add Secp256k1 signature

Author: b00f

pactus/crypto/address.py

@@ -16,6 +16,7 @@ class AddressType(Enum):
     VALIDATOR = 1
     BLS_ACCOUNT = 2
     ED25519_ACCOUNT = 3
+    SECP256K1_ACCOUNT = 4
 
 
 class Address:

pactus/crypto/bls/__init__.py

@@ -3,4 +3,3 @@
 from .signature import DST, SIGNATURE_TYPE_BLS, Signature
 
 __all__ = ["DST", "SIGNATURE_TYPE_BLS", "PrivateKey", "PublicKey", "Signature"]
-

pactus/crypto/bls/bls12_381/consts.py

@@ -12,8 +12,8 @@
 k_final = (p**4 - p**2 + 1) // q
 
 # ciphersuite numbers
-_gsuite = (
-    lambda stype, group, stag: b"BLS_"
+_gsuite = lambda stype, group, stag: (
+    b"BLS_"
     + stype
     + b"_BLS12381G"
     + group

pactus/crypto/ed25519/__init__.py

@@ -3,4 +3,3 @@
 from .signature import SIGNATURE_TYPE_ED25519, Signature
 
 __all__ = ["SIGNATURE_TYPE_ED25519", "PrivateKey", "PublicKey", "Signature"]
-

pactus/crypto/secp256k1/__init__.py

@@ -0,0 +1,5 @@
+from .private_key import PrivateKey
+from .public_key import PublicKey
+from .signature import SIGNATURE_TYPE_SECP256K1, Signature
+
+__all__ = ["SIGNATURE_TYPE_SECP256K1", "PrivateKey", "PublicKey", "Signature"]

pactus/crypto/secp256k1/private_key.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import secp256k1
+
+from pactus.crypto.hrp import HRP
+from pactus.utils import utils
+
+from .public_key import PublicKey
+from .signature import SIGNATURE_TYPE_SECP256K1, Signature
+
+PRIVATE_KEY_SIZE = 32
+
+
+class PrivateKey:
+    def __init__(self, scalar: secp256k1.PrivateKey) -> None:
+        self.scalar = scalar
+
+    @classmethod
+    def from_bytes(cls, buffer: bytes) -> PrivateKey:
+        sk = secp256k1.PrivateKey()
+        sk.set_raw_privkey(buffer)
+        return cls(sk)
+
+    @classmethod
+    def random(cls) -> PrivateKey:
+        sk = secp256k1.PrivateKey()
+        return cls(sk)
+
+    @classmethod
+    def from_string(cls, text: str) -> PrivateKey:
+        hrp, typ, data = utils.decode_to_base256_with_type(text)
+
+        if hrp != HRP.PRIVATE_KEY_HRP:
+            msg = f"Invalid hrp: {hrp}"
+            raise ValueError(msg)
+
+        if typ != SIGNATURE_TYPE_SECP256K1:
+            msg = f"Invalid Private key type: {typ}"
+            raise ValueError(msg)
+
+        if len(data) != PRIVATE_KEY_SIZE:
+            msg = "Private key data must be 32 bytes long"
+            raise ValueError(msg)
+
+        sk = secp256k1.PrivateKey()
+        sk.set_raw_privkey(bytes(data))
+        return cls(sk)
+
+    def raw_bytes(self) -> bytes:
+        # serialize() returns a hex string, convert to bytes
+        hex_str = self.scalar.serialize()
+        return bytes.fromhex(hex_str)
+
+    def string(self) -> str:
+        return utils.encode_from_base256_with_type(
+            HRP.PRIVATE_KEY_HRP,
+            SIGNATURE_TYPE_SECP256K1,
+            self.raw_bytes(),
+        )
+
+    def public_key(self) -> PublicKey:
+        return PublicKey(self.scalar.pubkey)
+
+    def sign(self, msg: bytes) -> Signature:
+        sig = self.scalar.ecdsa_sign(msg)
+        sig_compact = self.scalar.ecdsa_serialize_compact(sig)
+        return Signature(sig_compact)

pactus/crypto/secp256k1/public_key.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import hashlib
+
+import secp256k1
+from ripemd.ripemd160 import ripemd160
+
+from pactus.crypto.address import Address, AddressType
+from pactus.crypto.hrp import HRP
+from pactus.utils import utils
+
+from .signature import SIGNATURE_TYPE_SECP256K1, Signature
+
+PUBLIC_KEY_SIZE = 33  # Compressed public key
+
+
+class PublicKey:
+    def __init__(self, pub: secp256k1.PublicKey) -> None:
+        self.pub = pub
+
+    @classmethod
+    def from_string(cls, text: str) -> PublicKey:
+        hrp, typ, data = utils.decode_to_base256_with_type(text)
+
+        if hrp != HRP.PUBLIC_KEY_HRP:
+            msg = f"Invalid hrp: {hrp}"
+            raise ValueError(msg)
+
+        if typ != SIGNATURE_TYPE_SECP256K1:
+            msg = f"Invalid Public key type: {typ}"
+            raise ValueError(msg)
+
+        if len(data) != PUBLIC_KEY_SIZE:
+            msg = "Public key data must be 33 bytes long"
+            raise ValueError(msg)
+
+        pub_key = secp256k1.PublicKey(bytes(data), raw=True)
+
+        return cls(pub_key)
+
+    def raw_bytes(self) -> bytes:
+        return self.pub.serialize(compressed=True)
+
+    def string(self) -> str:
+        return utils.encode_from_base256_with_type(
+            HRP.PUBLIC_KEY_HRP,
+            SIGNATURE_TYPE_SECP256K1,
+            self.raw_bytes(),
+        )
+
+    def account_address(self) -> Address:
+        blake2b = hashlib.blake2b(digest_size=32)
+        blake2b.update(self.raw_bytes())
+        hash_256 = blake2b.digest()
+        hash_160 = ripemd160(hash_256)
+
+        return Address(AddressType.SECP256K1_ACCOUNT, hash_160)
+
+    def verify(self, msg: bytes, sig: Signature) -> bool:
+        try:
+            sig_compact = sig.raw_bytes()
+            sig_deserialized = self.pub.ecdsa_deserialize_compact(sig_compact)
+            return self.pub.ecdsa_verify(msg, sig_deserialized)
+        except Exception:
+            return False

pactus/crypto/secp256k1/signature.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+SIGNATURE_SIZE = 64
+SIGNATURE_TYPE_SECP256K1 = 4
+
+
+class Signature:
+    def __init__(self, sig: bytes) -> None:
+        self.sig = sig
+
+    @classmethod
+    def from_string(cls, text: str) -> Signature:
+        data = bytes.fromhex(text)
+
+        if len(data) != SIGNATURE_SIZE:
+            msg = "Signature data must be 64 bytes long"
+            raise ValueError(msg)
+
+        return cls(data)
+
+    def raw_bytes(self) -> bytes:
+        return self.sig
+
+    def string(self) -> str:
+        return self.sig.hex()

pactus/crypto/sss/sss.py

@@ -6,6 +6,7 @@
 
 See the bottom few lines for usage. Tested on Python 2 and 3.
 """
+
 from __future__ import annotations
 
 import functools
@@ -100,7 +101,6 @@ def make_random_shares(secret: int, minimum: int, shares: int, prime: int) -> li
     return [(i, _eval_at(poly, i, prime)) for i in range(1, shares + 1)]
 
 
-
 def recover_secret(shares: list[tuple[int, int]], prime: int) -> int:
     """
     Recover the secret from share points

pactus/types/amount.py

@@ -89,4 +89,3 @@ def round(self: float) -> float:
             return self - 0.5
 
         return self + 0.5
-