class BlockheaderSerializer(Serializer):
def __init__(self, flags=0):
self.BLOCKHEADER = Structure([
Field("<I", "version"),
Uint256Serializer("hash_prev"),
Uint256Serializer("hash_merkle"),
Field("<I", "time"),
Field("<I", "bits"),
Field("<I", "nonce")
], "txindex")
def get_size(self, blockheader):
return (self.BLOCKHEADER.get_size([
blockheader.version, blockheader.hash_prev,
blockheader.hash_merkle, blockheader.time, blockheader.bits,
blockheader.nonce
]))
def serialize(self, blockheader):
return (self.BLOCKHEADER.serialize([
blockheader.version, blockheader.hash_prev,
blockheader.hash_merkle, blockheader.time, blockheader.bits,
blockheader.nonce
]))
def deserialize(self, data, cursor=0):
(version, hash_prev, hash_merkle, time, bits,
nonce), new_cursor = self.BLOCKHEADER.deserialize(data, cursor)
blockheader = BlockHeader(version, hash_prev, hash_merkle, time, bits,
nonce)
blockheader.rawdata = data[cursor:new_cursor]
return (blockheader, new_cursor)
class BlockheaderSerializer(Serializer):
def __init__(self, flags=0):
self.BLOCKHEADER = Structure([Field("<I", "version"),
Uint256Serializer("hash_prev"),
Uint256Serializer("hash_merkle"),
Field("<I", "time"),
Field("<I", "bits"),
Field("<I", "nonce")], "txindex")
def get_size(self, blockheader):
return (self.BLOCKHEADER.get_size([blockheader.version,
blockheader.hash_prev,
blockheader.hash_merkle,
blockheader.time,
blockheader.bits,
blockheader.nonce]))
def serialize(self, blockheader):
return (self.BLOCKHEADER.serialize([blockheader.version,
blockheader.hash_prev,
blockheader.hash_merkle,
blockheader.time,
blockheader.bits,
blockheader.nonce]))
def deserialize(self, data, cursor=0):
(version, hash_prev, hash_merkle, time, bits, nonce), new_cursor = self.BLOCKHEADER.deserialize(data, cursor)
blockheader = BlockHeader(version, hash_prev, hash_merkle, time, bits, nonce)
blockheader.rawdata = data[cursor:new_cursor]
return (blockheader, new_cursor)
def __init__(self, flags=0):
self.BLOCKHEADER = Structure([
Field("<I", "version"),
Uint256Serializer("hash_prev"),
Uint256Serializer("hash_merkle"),
Field("<I", "time"),
Field("<I", "bits"),
Field("<I", "nonce")
], "txindex")
class NetAddrSerializer(Serializer):
def __init__(self, desc=""):
self.NETADDR = Structure([Field("<Q", "services"),
IPAddrSerializer("ip"),
Field(">H", "port")], "netaddr")
def serialize(self, a_netaddr):
data = self.NETADDR.serialize([a_netaddr.services, a_netaddr.ip, a_netaddr.port])
return (data)
def deserialize(self, data, cursor=0):
(services, ip, port), cursor = self.NETADDR.deserialize(data, cursor)
return (Netaddr(services, ip, port), cursor)
def __init__(self, flags=0):
self.BLOCKHEADER = Structure([Field("<I", "version"),
Uint256Serializer("hash_prev"),
Uint256Serializer("hash_merkle"),
Field("<I", "time"),
Field("<I", "bits"),
Field("<I", "nonce")], "txindex")
class NetAddrSerializer(Serializer):
def __init__(self, desc=""):
self.NETADDR = Structure([
Field("<Q", "services"),
IPAddrSerializer("ip"),
Field(">H", "port")
], "netaddr")
def serialize(self, a_netaddr):
data = self.NETADDR.serialize(
[a_netaddr.services, a_netaddr.ip, a_netaddr.port])
return (data)
def deserialize(self, data, cursor=0):
(services, ip, port), cursor = self.NETADDR.deserialize(data, cursor)
return (Netaddr(services, ip, port), cursor)
class BlockLocatorSerializer(Serializer):
def __init__(self, flags=0):
self.BLOCKLOCATOR = Structure([Field("<I", "version"),
VarsizelistSerializer(VarintSerializer("count"), Uint256Serializer("locator"))])
def get_size(self, blocklocator):
return (self.BLOCKLOCATOR.get_size([blocklocator.version, blocklocator.blockhashlist]))
def serialize(self, blocklocator):
return (self.BLOCKLOCATOR.serialize([blocklocator.version, blocklocator.blockhashlist]))
def deserialize(self, data, cursor=0):
(version, blockhashlist), cursor = self.BLOCKLOCATOR.deserialize(data, cursor)
return (BlockLocator(version, blockhashlist), cursor)
class BlockIndexSerializer():
BLOCKINDEX = Structure([Field("<I", "version"),
Uint256Serializer("hash_next"),
Field("<I", "file"),
Field("<I", "blockpos"),
Field("<I", "height"),
BlockheaderSerializer()], "txindex")
def __init__(self):
pass
def serialize(self, blockindex_obj):
return (self.BLOCKINDEX.serialize([blockindex_obj.version,
blockindex_obj.hash_next,
blockindex_obj.file,
blockindex_obj.blockpos,
blockindex_obj.height,
blockindex_obj.blockheader]))
def deserialize(self, data, cursor=0):
result, cursor = self.BLOCKINDEX.deserialize(data, cursor)
(version, hash_next, file, blockpos, height, blockheader) = result
return (DbBlockIndex(version, hash_next, file, blockpos, height, blockheader), cursor)
class MessageSerializer(Serializer):
MESSAGE_HEADER = Structure(
[Field("<I", "magic"),
Field("12s", "command"),
Field("<I", "length")], "message")
def __init__(self, runmode):
self.runmode = runmode
def serialize(self, msg):
if (msg.type not in ENCODERS):
raise FormatErrorException("Encoder not found for type: %d" %
(msg.type))
payload = ENCODERS[msg.type].serialize(msg)
result = self.MESSAGE_HEADER.serialize(
[MAGICS[self.runmode], COMMANDS[msg.type],
len(payload)])
result += sha256checksum(payload)
result += payload
return (result)
def deserialize(self, data, cursor=0):
result, cursor = self.MESSAGE_HEADER.deserialize(data, cursor)
magic, command, length = result
pos = string.find(command, "\0")
if (pos != -1):
command = command[0:pos]
if (command not in COMMANDS_TYPES):
raise FormatErrorException("Error: unknown command : %s" %
(command))
if (ENCODERS[COMMANDS_TYPES[command]] == None):
raise FormatErrorException("Error: Unsupported command : %s" %
(command))
msg_type = COMMANDS_TYPES[command]
#if (msg_type != MSG_VERSION and msg_type != MSG_VERACK):
checksum = data[cursor:cursor + 4]
cursor += 4
startplayload = cursor
#raise FormatErrorException("Checksum error in command: %s %s != %s" % (command, hexdump1(checksum,""), hexdump1(verify,"")))
if (magic != MAGICS[self.runmode]):
raise FormatErrorException(
"Error: wrong magic : expected:%s received:%s" %
(MAGICS[self.runmode], magic))
if (len(data) - cursor < length):
raise MissingDataException("Command incomplete: %s" % (command))
#self.log.debug("Decoding: %s" % (command))
res, cursor = ENCODERS[COMMANDS_TYPES[command]].deserialize(
data, cursor)
#verify checksum after decoding (required to identify message boundaries)
#if (msg_type != MSG_VERSION and msg_type != MSG_VERACK):
verify = sha256checksum(data[startplayload:cursor])
if (checksum != verify):
#raise FormatErrorException("Checksum error in command: %s %s != %s" % (command, hexdump1(checksum,""), hexdump1(verify,"")))
raise FormatErrorException(
"Checksum error in command: %s %s != %s" %
(command, hexstr(checksum), hexstr(verify)))
return (res, cursor)
class BlockSerializer(Serializer):
def __init__(self, flags=0):
self.BLOCK = Structure([BlockheaderSerializer(flags),
VarsizelistSerializer(VarintSerializer("txn_count"), TxSerializer())], "block")
def get_size(self, block):
return (self.BLOCK.get_size([block.blockheader,
block.transactions]))
def serialize(self, block):
return (self.BLOCK.serialize([block.blockheader,
block.transactions]))
def deserialize(self, data, cursor=0):
(blockheader, transactions), new_cursor = self.BLOCK.deserialize(data, cursor)
block = Block(blockheader, transactions)
block.rawdata = data[cursor:new_cursor]
return (block, new_cursor)
class TimenetaddrSerializer(Serializer):
TIME_NETADDR = Structure([Field("<I", "timestamp"),
NetAddrSerializer("addr")], "timestamped_netaddr")
def serialize(self, timenetaddr):
return (self.TIME_NETADDR.serialize([timenetaddr.timestamp, timenetaddr.netaddr]))
def deserialize(self, data, cursor=0):
(timestamp, netaddr), cursor = self.TIME_NETADDR.deserialize(data, cursor)
return (Timenetaddr(timestamp, netaddr), cursor)
class GetheadersMessageSerializer(Serializer):
GETHEADERS = Structure([BlockLocatorSerializer(), Uint256Serializer()])
def serialize(self, getheaders_msg):
return (self.GETHEADERS.serialize(
[getheaders_msg.blocklocator, getheaders_msg.hash_stop]))
def deserialize(self, data, cursor=0):
(blocklocator,
hash_stop), cursor = self.GETHEADERS.deserialize(data, cursor)
return (GetheadersMessage(blocklocator, hash_stop), cursor)
class BlockSerializer(Serializer):
def __init__(self, flags=0):
self.BLOCK = Structure([
BlockheaderSerializer(flags),
VarsizelistSerializer(VarintSerializer("txn_count"),
TxSerializer())
], "block")
def get_size(self, block):
return (self.BLOCK.get_size([block.blockheader, block.transactions]))
def serialize(self, block):
return (self.BLOCK.serialize([block.blockheader, block.transactions]))
def deserialize(self, data, cursor=0):
(blockheader,
transactions), new_cursor = self.BLOCK.deserialize(data, cursor)
block = Block(blockheader, transactions)
block.rawdata = data[cursor:new_cursor]
return (block, new_cursor)
class GetblocksMessageSerializer(Serializer):
GETBLOCKS = Structure([BlockLocatorSerializer(),
Uint256Serializer("stop")], "getblocks")
def serialize(self, getblocks_msg):
return (self.GETBLOCKS.serialize([getblocks_msg.block_locator,
getblocks_msg.hash_stop]))
def deserialize(self, data, cursor=0):
(block_locator, hash_stop), cursor = self.GETBLOCKS.deserialize(data, cursor)
return (GetblocksMessage(block_locator, hash_stop), cursor)
class AlertMessageSerializer(Serializer):
ALERT = Structure([VarstrSerializer("payload"),
VarstrSerializer("signature")])
PAYLOAD = AlertPayloadSerializer()
def serialize(self, alert_msg):
payload_data = AlertPayloadSerializer().serialize(alert_msg.payload)
return (self.ALERT.serialize([payload_data, alert_msg.signature]))
def deserialize(self, data, cursor=0):
(payload_data, signature), cursor = self.ALERT.deserialize(data, cursor)
payload, _ = AlertPayloadSerializer().deserialize(payload_data)
return (AlertMessage(payload, signature), cursor)
class TxoutSerializer(Serializer):
TXOUT = Structure(
[Field("<q", "value"), VarstrScriptSerializer()], "outpoint")
def get_size(self, txout):
return (self.TXOUT.get_size([txout.value, txout.script]))
def serialize(self, outpoint):
return (self.TXOUT.serialize([outpoint.value, outpoint.script]))
def deserialize(self, data, cursor=0):
(value, script), cursor = self.TXOUT.deserialize(data, cursor)
return (TxOut(value, script), cursor)
class OutpointSerializer(Serializer):
OUTPOINT = Structure([Uint256Serializer("hash"),
Field("<I","index")], "outpoint")
def get_size(self, outpoint):
return (self.OUTPOINT.get_size([outpoint.hash, outpoint.index]))
def serialize(self, outpoint):
return (self.OUTPOINT.serialize([outpoint.hash, outpoint.index]))
def deserialize(self, data, cursor=0):
(hash, index), cursor = self.OUTPOINT.deserialize(data, cursor)
return (Outpoint(hash, index), cursor)
class DiskTxPosSerializer():
DISKTXPOS = Structure([Field("<I", "file"),
Field("<I", "blockpos"),
Field("<I", "txpos")], "disktxpos")
def serialize(self, disktxpos_obj):
return (self.DISKTXPOS.serialize([disktxpos_obj.file,
disktxpos_obj.blockpos,
disktxpos_obj.txpos]))
def deserialize(self, data, cursor=0):
(file, nblockpos, ntxpos), cursor = self.DISKTXPOS.deserialize(data, cursor)
return (DiskTxPos(file, nblockpos, ntxpos), cursor)
class InvitemSerializer(Serializer):
INVITEM_ENC = Structure(
[Field("<I", "type"), Uint256Serializer("hash")], "getblocks")
def get_size(self, invitem):
return (self.INVITEM_ENC.get_size(invitem.type, invitem.hash))
def serialize(self, invitem):
return (self.INVITEM_ENC.serialize([invitem.type, invitem.hash]))
def deserialize(self, data, cursor=0):
(type, hash), cursor = self.INVITEM_ENC.deserialize(data, cursor)
if (type not in INV_ITEMS):
raise FormatErrorException("Unknown inventory item")
return (Invitem(type, hash), cursor)
class TxIndexSerializer():
TXINDEX = Structure([
Field("<I", "version"),
DiskTxPosSerializer(),
VarsizelistSerializer(VarintSerializer(), DiskTxPosSerializer())
], "txindex")
def __init__(self):
pass
def serialize(self, txindex_obj):
return (self.TXINDEX.serialize(
[txindex_obj.version, txindex_obj.pos, txindex_obj.spent]))
def deserialize(self, data, cursor=0):
(version, pos, spent), cursor = self.TXINDEX.deserialize(data, cursor)
return (DbTxIndex(version, pos, spent), cursor)
class TxinSerializer(Serializer):
TXIN = Structure([
OutpointSerializer(),
VarstrScriptSerializer(),
Field("<I", "sequence")
], "outpoint")
def get_size(self, txin):
return (self.TXIN.get_size(
[txin.previous_output, txin.script, txin.sequence]))
def serialize(self, txin):
return (self.TXIN.serialize(
[txin.previous_output, txin.script, txin.sequence]))
def deserialize(self, data, cursor=0):
(previous_output, script,
sequence), cursor = self.TXIN.deserialize(data, cursor)
return (TxIn(previous_output, script, sequence), cursor)
class MerkleTxSerializer(Serializer):
MERKLE_TX = Structure([
TxSerializer(),
Uint256Serializer(),
VarsizelistSerializer(VarintSerializer(), Uint256Serializer()),
Field("<I", "nindex")
], "tx")
def get_size(self, tx):
return (self.MERKLE_TX.get_size(
[tx.tx, tx.blockhash, tx.merkle_branch, tx.nindex]))
def serialize(self, tx):
return (self.MERKLE_TX.serialize(
[tx.tx, tx.blockhash, tx.merkle_branch, tx.nindex]))
def deserialize(self, data, cursor=0):
(tx, blockhash, merkle_branch,
nindex), cursor = self.MERKLE_TX.deserialize(data, cursor)
return (MerkleTx(tx, blockhash, merkle_branch, nindex), cursor)
class VersionMessageSerializer(Serializer):
VERSION_STRUCT = Structure([
Field("<I", "version"),
Field("<Q", "services"),
Field("<Q", "timestamp"),
NetAddrSerializer("addr_me"),
NetAddrSerializer("addr_you"),
Field("<Q", "nonce"),
VarstrSerializer("sub_version_num"),
Field("<I", "start_height")
], "version_message")
def serialize(self, version_msg):
return (self.VERSION_STRUCT.serialize([
version_msg.version, version_msg.services, version_msg.timestamp,
version_msg.addr_me, version_msg.addr_you, version_msg.nonce,
version_msg.sub_version_num, version_msg.start_height
]))
def deserialize(self, data, cursor=0):
result, cursor = self.VERSION_STRUCT.deserialize(data, cursor)
return (VersionMessage(*result), cursor)
class MasterKeySerializer():
MASTER_KEY = Structure([
VarstrSerializer(),
VarstrSerializer(),
Field("<I"),
Field("<I"),
VarstrSerializer()
])
def serialize(self, master_key):
return (self.MASTER_KEY.serialize([
master_key.crypted_key, master_key.salt,
master_key.derivation_method, master_key.derive_iterations,
master_key.other_derivation_parameters
]))
def deserialize(self, data, cursor):
master_key_fields, cursor = self.MASTER_KEY.deserialize(data, cursor)
(crypted_key, salt, derivation_method, derive_iterations,
other_derivation_parameters) = master_key_fields
return (MasterKey(crypted_key, salt, derivation_method,
derive_iterations,
other_derivation_parameters), cursor)
class AlertPayloadSerializer(Serializer):
PAYLOAD = Structure([Field("<I", "version"),
Field("<Q", "relay_until"),
Field("<Q", "expiration"),
Field("<I", "id"),
Field("<I", "cancel"),
VarsizelistSerializer(VarintSerializer("count"), VarintSerializer("set_cancel")),
Field("<I", "min_ver"),
Field("<I", "max_ver"),
VarsizelistSerializer(VarintSerializer("count"), VarstrSerializer("set_sub_ver")),
Field("<I", "priority"),
VarstrSerializer("comment"),
VarstrSerializer("statusbar"),
VarstrSerializer("reserved")])
def serialize(self, alert_payload):
return (self.PAYLOAD.serialize([alert_payload.version,
alert_payload.relay_until,
alert_payload.expiration,
alert_payload.id,
alert_payload.cancel,
alert_payload.set_cancel,
alert_payload.min_ver,
alert_payload.max_ver,
alert_payload.set_sub_ver,
alert_payload.priority,
alert_payload.comment,
alert_payload.statusbar,
alert_payload.reserved]))
def deserialize(self, data, cursor=0):
payload_fields, cursor = self.PAYLOAD.deserialize(data, cursor)
(version, relay_until, expiration, id, cancel, set_cancel, min_ver, max_ver, \
set_sub_ver, priority, comment, statusbar, reserved) = payload_fields
return (AlertPayload(version, relay_until, expiration, id, cancel,
set(set_cancel), min_ver, max_ver, set(set_sub_ver), priority,
comment, statusbar, reserved), cursor)
class TxSerializer(Serializer):
TX = Structure([
Field("<I", "version"),
VarsizelistSerializer(VarintSerializer("txin_count"),
TxinSerializer()),
VarsizelistSerializer(VarintSerializer("txout_count"),
TxoutSerializer()),
Field("<I", "lock_time")
], "tx")
def get_size(self, tx):
return (self.TX.get_size(
[tx.version, tx.in_list, tx.out_list, tx.locktime]))
def serialize(self, tx):
return (self.TX.serialize(
[tx.version, tx.in_list, tx.out_list, tx.locktime]))
def deserialize(self, data, cursor=0):
(version, in_list, out_list,
locktime), new_cursor = self.TX.deserialize(data, cursor)
tx = Tx(version, in_list, out_list, locktime)
tx.rawdata = data[cursor:new_cursor]
return (tx, new_cursor)
def __init__(self, flags=0):
self.BLOCK = Structure([BlockheaderSerializer(flags),
VarsizelistSerializer(VarintSerializer("txn_count"), TxSerializer())], "block")
def __init__(self, desc=""):
self.NETADDR = Structure([Field("<Q", "services"),
IPAddrSerializer("ip"),
Field(">H", "port")], "netaddr")
def __init__(self, flags=0):
self.BLOCKLOCATOR = Structure([Field("<I", "version"),
VarsizelistSerializer(VarintSerializer("count"), Uint256Serializer("locator"))])
def __init__(self, flags=0):
self.BLOCK = Structure([
BlockheaderSerializer(flags),
VarsizelistSerializer(VarintSerializer("txn_count"),
TxSerializer())
], "block")
def __init__(self, desc=""):
self.NETADDR = Structure([
Field("<Q", "services"),
IPAddrSerializer("ip"),
Field(">H", "port")
], "netaddr")
