def deserialize(self):
starting_position = int(self.asset_offset / 2)
hash_function = read_bit8(self.serialized, starting_position) & 0xff
ipfs_hash_length = read_bit8(self.serialized, starting_position + 1) & 0xff
start_index = (starting_position + 2) * 2
end_index = start_index + (ipfs_hash_length * 2)
ipfs_hash = hexlify(self.serialized)[start_index:end_index]
temp_buffer = bytes()
temp_buffer += write_bit8(hash_function)
temp_buffer += write_bit8(ipfs_hash_length)
temp_buffer += unhexlify(ipfs_hash)
self.transaction.asset = {
'ipfs': b58encode(temp_buffer).decode()
}
self.transaction.parse_signatures(
hexlify(self.serialized).decode(),
self.asset_offset + (ipfs_hash_length + 2) * 2
)
return self.transaction
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 serialize(self):
public_keys_length = len(
self.transaction['asset']['multiSignature']['publicKeys'])
self.bytes_data += write_bit8(
self.transaction['asset']['multiSignature']['min'])
self.bytes_data += write_bit8(public_keys_length)
for key in self.transaction['asset']['multiSignature']['publicKeys']:
self.bytes_data += unhexlify(key.encode())
return self.bytes_data
def serialize(self):
keysgroup = []
if self.transaction.get('version') is None or self.transaction['version'] == 1:
for key in self.transaction['asset']['multisignature']['keysgroup']:
keysgroup.append(key[1::] if key.startswith('+') else key)
else:
keysgroup = self.transaction['asset']['multisignature']['keysgroup']
self.bytes_data += write_bit8(self.transaction['asset']['multisignature']['min'])
self.bytes_data += write_bit8(len(self.transaction['asset']['multisignature']['keysgroup']))
self.bytes_data += write_bit8(self.transaction['asset']['multisignature']['lifetime'])
self.bytes_data += unhexlify(''.join(keysgroup))
return self.bytes_data
def to_bytes(self, skip_signature=True, skip_second_signature=True):
"""Convert the transaction to its byte representation
Args:
skip_signature (bool, optional): do you want to skip the signature
skip_second_signature (bool, optional): do you want to skip the 2nd signature
Returns:
bytes: bytes representation of the transaction
"""
bytes_data = bytes()
bytes_data += write_bit8(self.type)
bytes_data += write_bit32(self.timestamp)
bytes_data += write_high(self.senderPublicKey)
if self.recipientId:
bytes_data += b58decode_check(self.recipientId)
else:
bytes_data += pack('21x')
if self.vendorField and len(self.vendorField) < 64:
bytes_data += self.vendorField
bytes_data += pack('{}x'.format(64 - len(self.vendorField)))
else:
bytes_data += pack('64x')
bytes_data += write_bit64(self.amount)
bytes_data += write_bit64(self.fee)
bytes_data = self._handle_transaction_type(bytes_data)
bytes_data = self._handle_signature(bytes_data, skip_signature,
skip_second_signature)
return bytes_data
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 serialize(self):
delegate_bytes = hexlify(
self.transaction['asset']['delegate']['username'].encode())
self.bytes_data += write_bit8(len(delegate_bytes) // 2)
self.bytes_data += unhexlify(delegate_bytes)
return self.bytes_data
def serialize(self):
vote_bytes = []
for vote in self.transaction['asset']['votes']:
if vote.startswith('+'):
vote_bytes.append('01{}'.format(vote[1::]))
else:
vote_bytes.append('00{}'.format(vote[1::]))
self.bytes_data += write_bit8(len(self.transaction['asset']['votes']))
self.bytes_data += unhexlify(''.join(vote_bytes))
return self.bytes_data
def serialize(self):
self.bytes_data += write_bit64(self.transaction['amount'])
self.bytes_data += unhexlify(
self.transaction['asset']['lock']['secretHash'].encode())
self.bytes_data += write_bit8(
self.transaction['asset']['lock']['expiration']['type'])
self.bytes_data += write_bit32(
self.transaction['asset']['lock']['expiration']['value'])
recipientId = hexlify(b58decode_check(self.transaction['recipientId']))
self.bytes_data += write_high(recipientId)
return self.bytes_data
def _handle_transaction_type(self, bytes_data):
"""Handled each transaction type differently
Args:
bytes_data (bytes): input the bytes data to which you want to append new bytes
Raises:
NotImplementedError: raised only if the child transaction doesn't implement this
required method
"""
if self.type == TRANSACTION_SECOND_SIGNATURE_REGISTRATION:
public_key = self.asset['signature']['publicKey']
bytes_data += unhexlify(public_key)
elif self.type == TRANSACTION_DELEGATE_REGISTRATION:
bytes_data += self.asset['delegate']['username'].encode()
elif self.type == TRANSACTION_VOTE:
bytes_data += ''.join(self.asset['votes']).encode()
elif self.type == TRANSACTION_MULTI_SIGNATURE_REGISTRATION:
bytes_data += write_bit8(self.asset['multisignature']['min'])
bytes_data += write_bit8(self.asset['multisignature']['lifetime'])
bytes_data += ''.join(
self.asset['multisignature']['keysgroup']).encode()
return bytes_data
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 _handle_signature(self, bytes_data):
"""Serialize signature data of the transaction
Args:
bytes_data (bytes): already serialized data
Returns:
bytes: bytes string
"""
if self.transaction.get('signature'):
bytes_data += unhexlify(self.transaction['signature'])
if self.transaction.get('secondSignature'):
bytes_data += unhexlify(self.transaction['secondSignature'])
elif self.transaction.get('signSignature'):
bytes_data += unhexlify(self.transaction['signSignature'])
if self.transaction.get('signatures'):
bytes_data += write_bit8(0xff)
bytes_data += unhexlify(''.join(self.transaction['signatures']))
return bytes_data
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 serialize(self):
dag = self.transaction['asset']['ipfs']['dag']
self.bytes_data += write_bit8(len(dag) // 2)
self.bytes_data += unhexlify(dag)
return self.bytes_data
