def sign(message, private_key_hex):
private_key = PrivateKey(bytes(bytearray.fromhex(private_key_hex)),
raw=True)
signature = private_key.ecdsa_sign(message)
signature = private_key.ecdsa_serialize_compact(signature).hex()
return signature
class Wallet:
def __init__(self, address, private_key):
self._address = address
self._private_key = private_key
self._pk = PrivateKey(bytes(bytearray.fromhex(private_key)))
self._public_key = self._pk.pubkey.serialize(compressed=True)
@property
def address(self):
return self._address
@property
def private_key(self):
return self._private_key
@property
def public_key(self):
return self._public_key
def sign_message(self, msg_bytes):
sig = self._pk.ecdsa_sign(msg_bytes)
return self._pk.ecdsa_serialize_compact(sig)
def sign(self, msg):
"""
Sign a message with private key, Return signature
"""
priv = PrivateKey(self.key.private_byte, raw=True)
sig = priv.ecdsa_sign(msg)
h = priv.ecdsa_serialize_compact(sig)
return self.key.public_hex, encoding.to_hexstring(h)
def _sign(self) -> str:
message_str = json.dumps(self._get_sign_message(),
separators=(",", ":"),
sort_keys=True)
message_bytes = message_str.encode("utf-8")
privkey = PrivateKey(bytes.fromhex(self.privkey))
signature = privkey.ecdsa_sign(message_bytes)
signature_compact = privkey.ecdsa_serialize_compact(signature)
signature_base64_str = base64.b64encode(signature_compact).decode(
"utf-8")
return signature_base64_str
def generate_sig(secret, hash_digest):
"""
Given a secret (privkey) scalar and hash_digets,
returns a valid signature (64-bytes compact)
inputs:
privkey: a hex-string private key scalar
hash_digest: a hex-string hash message to sign
returns: 64-byte compact ecdsa sig
"""
privkey = PrivateKey(bytes(bytearray.fromhex(secret)), raw=True)
sig = privkey.ecdsa_sign(bytes(bytearray.fromhex(hash_digest)), raw=True)
return privkey.ecdsa_serialize_compact(sig)
class Wallet(BaseWallet):
HD_PATH = "44'/714'/0'/0/0"
def __init__(self, private_key, env: Optional[BinanceEnvironment] = None):
super().__init__(env)
self._private_key = private_key
self._pk = PrivateKey(bytes(bytearray.fromhex(self._private_key)))
self._public_key = self._pk.pubkey.serialize(compressed=True)
self._address = address_from_public_key(self._public_key,
self._env.hrp)
@classmethod
def create_random_wallet(
cls,
language: MnemonicLanguage = MnemonicLanguage.ENGLISH,
env: Optional[BinanceEnvironment] = None):
"""Create wallet with random mnemonic code
:return:
"""
m = Mnemonic(language.value)
phrase = m.generate()
return cls.create_wallet_from_mnemonic(phrase, env=env)
@classmethod
def create_wallet_from_mnemonic(cls,
mnemonic: str,
env: Optional[BinanceEnvironment] = None):
"""Create wallet with random mnemonic code
:return:
"""
seed = Mnemonic.to_seed(mnemonic)
parent_wallet = network.keys.bip32_seed(seed)
child_wallet = parent_wallet.subkey_for_path(Wallet.HD_PATH)
# convert secret exponent (private key) int to hex
key_hex = format(child_wallet.secret_exponent(), 'x')
return cls(key_hex, env=env)
@property
def private_key(self):
return self._private_key
def sign_message(self, msg_bytes):
# check if ledger wallet
sig = self._pk.ecdsa_sign(msg_bytes)
return self._pk.ecdsa_serialize_compact(sig)
class Wallet(BaseWallet):
"""
Usage example:
m = Wallet.create_random_mnemonic() # 12 words
p = 'my secret passphrase' # bip39 passphrase
# Store <m> and <p> somewhere safe
wallet1 = Wallet.create_wallet_from_mnemonic(m, passphrase=p, child=0, env=testnet_env)
wallet2 = Wallet.create_wallet_from_mnemonic(m, passphrase=p, child=1, env=testnet_env)
...
"""
HD_PATH = "44'/714'/0'/0/{id}"
def __init__(self, private_key, env: Optional[BinanceEnvironment] = None):
super().__init__(env)
self._private_key = private_key
self._pk = PrivateKey(bytes(bytearray.fromhex(self._private_key)))
self._public_key = self._pk.pubkey.serialize(compressed=True)
self._address = address_from_public_key(self._public_key,
self._env.hrp)
@classmethod
def create_random_wallet(
cls,
language: MnemonicLanguage = MnemonicLanguage.ENGLISH,
env: Optional[BinanceEnvironment] = None):
"""Create wallet with random mnemonic code
:return: initialised Wallet
"""
phrase = cls.create_random_mnemonic(language)
return cls.create_wallet_from_mnemonic(phrase, env=env)
@classmethod
def create_wallet_from_mnemonic(cls,
mnemonic: str,
passphrase: Optional[str] = '',
child: Optional[int] = 0,
env: Optional[BinanceEnvironment] = None):
"""Create wallet from mnemonic, passphrase and child wallet id
:return: initialised Wallet
"""
if type(child) != int:
raise TypeError("Child wallet id should be of type int")
seed = Mnemonic.to_seed(mnemonic, passphrase)
new_wallet = network.keys.bip32_seed(seed)
child_wallet = new_wallet.subkey_for_path(Wallet.HD_PATH)
# convert secret exponent (private key) int to hex
key_hex = format(child_wallet.secret_exponent(), 'x')
return cls(key_hex, env=env)
@classmethod
def create_random_mnemonic(
cls, language: MnemonicLanguage = MnemonicLanguage.ENGLISH):
"""Create random mnemonic code
:return: str, mnemonic phrase
"""
m = Mnemonic(language.value)
phrase = m.generate()
return phrase
@property
def private_key(self):
return self._private_key
def sign_message(self, msg_bytes):
# check if ledger wallet
sig = self._pk.ecdsa_sign(msg_bytes)
return self._pk.ecdsa_serialize_compact(sig)
