def test_set_network():
# test main net
set_network(Mainnet)
result = get_network()
assert result['version'] == 23
assert result['wif'] == 170
# test test net
set_network(Testnet)
result = get_network()
assert result['version'] == 23
assert result['wif'] == 186
set_network(Devnet) # set back to devnet so other tests don't fail
def serialize(self):
"""Perform AIP11 compliant serialization
Returns:
bytes: bytes string
"""
network_config = get_network()
bytes_data = bytes()
bytes_data += write_bit8(0xff)
bytes_data += write_low(self.transaction.get('version') or 0x01)
bytes_data += write_bit8(self.transaction.get('network') or network_config['version'])
bytes_data += write_low(self.transaction['type'])
bytes_data += write_bit32(self.transaction['timestamp'])
bytes_data += write_high(self.transaction['senderPublicKey'])
bytes_data += write_bit64(self.transaction['fee'])
if self.transaction.get('vendorField'):
vendorFieldLength = len(self.transaction['vendorField'])
bytes_data += write_bit8(vendorFieldLength)
bytes_data += self.transaction['vendorField']
elif self.transaction.get('vendorFieldHex'):
vendorField_hex_length = len(self.transaction['vendorFieldHex'])
bytes_data += write_bit8(vendorField_hex_length / 2)
bytes_data += self.transaction['vendorFieldHex']
else:
bytes_data += write_bit8(0x00)
bytes_data = self._handle_transaction_type(bytes_data)
bytes_data = self._handle_signature(bytes_data)
return hexlify(bytes_data).decode()
def test_set_custom_network():
epoch_time = datetime(2017, 1, 1, 13, 00, 00)
set_custom_network(epoch_time, 11, 130)
result = get_network()
assert result['version'] == 11
assert result['wif'] == 130
assert result['epoch'] == epoch_time
set_network(Devnet) # set back to devnet so other tests don't fail
def get_time():
"""Get the time difference between now and network start.
Returns:
int: difference in seconds
"""
now = datetime.utcnow()
network = get_network()
seconds = int((now - network['epoch']).total_seconds())
return seconds
def validate_address(address, network_version=None):
"""Validate a given address
Args:
address (str): address you wish to validate
network_version (None, optional): integer, version of the network
Returns:
bool:
"""
if not network_version:
network = get_network()
network_version = network['version']
return network_version == b58decode_check(address)[0]
def wif_from_passphrase(passphrase, network_wif=None):
"""Get wif from passphrase
Args:
passphrase (bytes):
network_wif (int, optional):
Returns:
string: wif
"""
if not network_wif:
network = get_network()
network_wif = network['wif']
private_key = hashlib.sha256(passphrase.encode())
seed = write_bit8(network_wif) + private_key.digest() + write_bit8(0x01)
return b58encode_check(seed).decode()
def address_from_passphrase(passphrase, network_version=None):
"""Get an address from passphrase
Args:
passphrase (str):
network_version (int, optional):
Returns:
string: address
"""
if not network_version:
network = get_network()
network_version = network['version']
private_key = hashlib.sha256(passphrase.encode()).hexdigest()
address = address_from_private_key(private_key, network_version)
return address
def address_from_public_key(public_key, network_version=None):
"""Get an address from a public key
Args:
public_key (str):
network_version (int, optional):
Returns:
bytes:
"""
if not network_version:
network = get_network()
network_version = network['version']
ripemd160 = hashlib.new('ripemd160', unhexlify(public_key.encode()))
seed = write_bit8(network_version) + ripemd160.digest()
return b58encode_check(seed).decode()
def address_from_private_key(private_key, network_version=None):
"""Get an address from private key
Args:
private_key (string):
network_version (int, optional):
Returns:
TYPE: Description
"""
if not network_version:
network = get_network()
network_version = network['version']
private_key = PrivateKey.from_hex(private_key)
ripemd160 = hashlib.new('ripemd160', unhexlify(private_key.public_key))
seed = write_bit8(network_version) + ripemd160.digest()
return b58encode_check(seed).decode()
def serialize(self,
skip_signature=True,
skip_second_signature=True,
skip_multi_signature=True,
raw=False):
"""Perform AIP11 compliant serialization
Returns:
bytes: bytes string
"""
network_config = get_network()
bytes_data = bytes()
bytes_data += write_bit8(0xff)
bytes_data += write_bit8(self.transaction.get('version') or 0x02)
bytes_data += write_bit8(
self.transaction.get('network') or network_config['version'])
bytes_data += write_bit32(self.transaction.get('typeGroup') or 0x01)
bytes_data += write_bit16(self.transaction.get('type'))
bytes_data += write_bit64(self.transaction.get('nonce') or 0x01)
bytes_data += write_high(self.transaction.get('senderPublicKey'))
bytes_data += write_bit64(self.transaction.get('fee'))
if self.transaction.get('vendorField'):
vendorFieldLength = len(self.transaction.get('vendorField'))
bytes_data += write_bit8(vendorFieldLength)
bytes_data += self.transaction['vendorField'].encode()
elif self.transaction.get('vendorFieldHex'):
vendorField_hex_length = len(self.transaction['vendorFieldHex'])
bytes_data += write_bit8(vendorField_hex_length / 2)
bytes_data += self.transaction['vendorFieldHex']
else:
bytes_data += write_bit8(0x00)
bytes_data = self._handle_transaction_type(bytes_data)
bytes_data = self._handle_signature(bytes_data, skip_signature,
skip_second_signature,
skip_multi_signature)
return bytes_data if raw else hexlify(bytes_data).decode()
def get_epoch():
network = get_network()
return network['epoch']
def test_get_network():
result = get_network()
assert result['version'] == 30
def test_set_network():
set_network(Mainnet)
result = get_network()
assert result['version'] == 23
set_network(Devnet) # set back to devnet so other tests don't fail
