def decode_base58(string_base58,
hex=False,
checksum=False,
verify_checksum=False):
"""Decode a base58-encoding string
:param string_base58: base58 string.
:param hex: (optional) return result as HEX encoded string, by default is False.
:param checksum: (optional) boolean, by default is False.
:param verify_checksum: (optional) boolean, by default is False.
:return: HEX or bytes string format.
"""
if verify_checksum:
checksum = True
if not string_base58:
return b''
if not isinstance(string_base58, str):
raise ValueError("base58 string required")
b = __decode_base58__(string_base58)
if checksum:
if verify_checksum:
if double_sha256(b[:-4])[:4] != b[-4:]:
raise Exception("invalid checksum")
return b[:-4].hex() if hex else b[:-4]
return b.hex() if hex else b
def merkle_tree(tx_hash_list, return_hex=False, receive_hex=False):
if receive_hex:
tx_hash_deque = deque()
tx_hash_deque_append = tx_hash_deque.append
for h in tx_hash_list:
tx_hash_deque_append(h if isinstance(h, bytes) else s2rh(h))
else:
tx_hash_deque = deque(tx_hash_list)
c = merkle_tree_depth(len(tx_hash_deque))
m = {c: deque(tx_hash_deque)}
while len(tx_hash_deque) > 1:
new_deque = deque()
new_deque_append = new_deque.append
while tx_hash_deque:
h1 = tx_hash_deque.popleft()
try: h2 = tx_hash_deque.popleft()
except: h2 = h1
hs = double_sha256(b"".join((h1, h2)))
new_deque_append(hs)
tx_hash_deque = new_deque
c -= 1
m[c] = deque(tx_hash_deque)
if return_hex:
for i in m:
for k in range(len(m[i])):
m[i][k] = rh2s(m[i][k])
return m
def is_wif_valid(wif):
"""
Check is private key in WIF format string is valid.
:param wif: private key in WIF format string.
:return: boolean.
"""
if not isinstance(wif, str):
return False
if wif[0] not in PRIVATE_KEY_PREFIX_LIST:
return False
try:
h = decode_base58(wif)
except:
return False
checksum = h[-4:]
if wif[0] in (MAINNET_PRIVATE_KEY_UNCOMPRESSED_PREFIX,
TESTNET_PRIVATE_KEY_UNCOMPRESSED_PREFIX):
if len(h) != 37:
return False
elif len(h) != 38:
return False
if double_sha256(h[:-4])[:4] != checksum:
return False
return True
def private_to_public_key(private_key, compressed=True, hex=True):
"""
Get public key from private key using ECDSA secp256k1
:param private_key: private key in WIF, HEX or bytes.
:param compressed: (optional) flag of public key compressed format, by default is True.
In case private_key in WIF format, this flag is set in accordance with
the key format specified in WIF string.
:param hex: (optional) if set to True return key in HEX format, by default is True.
:return: 33/65 bytes public key in HEX or bytes string.
"""
if not isinstance(private_key, bytes):
if isinstance(private_key, bytearray):
private_key = bytes(private_key)
elif isinstance(private_key, str):
try:
if private_key[0] in (MAINNET_PRIVATE_KEY_UNCOMPRESSED_PREFIX,
TESTNET_PRIVATE_KEY_UNCOMPRESSED_PREFIX):
compressed = False
h = decode_base58(private_key)
if double_sha256(h[:-4])[:4] != h[-4:]:
raise Exception()
private_key = h[1:33]
except:
try:
private_key = bytes_from_hex(private_key)
except:
raise ValueError("private key HEX or WIF invalid")
else:
raise ValueError(
"private key must be a bytes or WIF or hex encoded string")
if len(private_key) != 32:
raise ValueError("private key length invalid")
pub = __secp256k1_ec_pubkey_create__(private_key, bool(compressed))
return pub.hex() if hex else pub
def wif_to_private_key(h, hex=True):
"""
Decode WIF private key to bytes string or HEX encoded string
:param h: private key in WIF format string.
:param hex: (optional) if set to True return key in HEX format, by default is True.
:return: Private key HEX encoded string or raw bytes string.
"""
h = decode_base58(h)
if double_sha256(h[:-4])[:4] != h[-4:]:
raise TypeError("invalid wif key")
return h[1:33].hex() if hex else h[1:33]
def encode_base58(bytes, checksum=False):
"""Encode bytes to a base58-encoded string
:param bytes: bytes string.
:param checksum: (optional) boolean, by default is False.
:return: base58 string format.
"""
# Convert big-endian bytes to integer
if not bytes:
return ''
b = get_bytes(bytes)
if checksum:
return __encode_base58__(b"%s%s" % (b, double_sha256(b)[:4]))
return __encode_base58__(b)
def merkle_root_from_proof(merkle_proof, tx_id, index, return_hex=True, receive_hex=True):
if isinstance(merkle_proof, str):
merkle_proof = bytes_from_hex(merkle_proof)
if isinstance(merkle_proof, bytes):
merkle_proof = [merkle_proof[y - 32:y] for y in range(32, len(merkle_proof) + 32, 32)]
if receive_hex:
_merkle_proof = deque()
_merkle_proof_append = _merkle_proof.append
for h in merkle_proof:
_merkle_proof_append(s2rh(h) if isinstance(h, str) else h)
merkle_proof = _merkle_proof
tx_id = s2rh(tx_id) if isinstance(tx_id, str) else tx_id
root = tx_id
for h in merkle_proof:
root = double_sha256(b"".join((h, root) if index % 2 else (root, h)))
index = index // 2
if return_hex:
return rh2s(root)
return root
def private_key_to_wif(h, compressed=True, testnet=False):
"""
Encode private key in HEX or RAW bytes format to WIF format.
:param h: private key 32 byte string or HEX encoded string.
:param compressed: (optional) flag of public key compressed format, by default is True.
:param testnet: (optional) flag for testnet network, by default is False.
:return: Private key in WIF format.
"""
# uncompressed: 0x80 + [32-byte secret] + [4 bytes of Hash() of previous 33 bytes], base58 encoded.
# compressed: 0x80 + [32-byte secret] + 0x01 + [4 bytes of Hash() previous 34 bytes], base58 encoded.
if isinstance(h, str):
h = bytes_from_hex(h)
if len(h) != 32 and isinstance(h, bytes):
raise TypeError("private key must be a 32 bytes or hex encoded string")
if testnet:
h = TESTNET_PRIVATE_KEY_BYTE_PREFIX + h
else:
h = MAINNET_PRIVATE_KEY_BYTE_PREFIX + h
if compressed:
h += b'\x01'
h += double_sha256(h)[:4]
return encode_base58(h)
