def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
message = stream.read(varint.decode(stream)).decode()
code = RejectCode.from_bytes(stream.read(1), "little")
reason = stream.read(varint.decode(stream)).decode()
data = stream.read(32).hex()
return cls(message, code, reason, data)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
blockhash = stream.read(32)[::-1].hex()
num_indexes = varint.decode(stream)
indexes = []
for x in range(num_indexes):
indexes.append(varint.decode(stream))
return cls(blockhash=blockhash, indexes=indexes)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
hash = stream.read(32).hex()
to_add = []
for x in range(varint.decode(stream)):
out_point = OutPoint.deserialize(stream)
tx_out = TxOut.deserialize(stream)
to_add.append([out_point, tx_out])
to_remove = []
for x in range(varint.decode(stream)):
out_point = OutPoint.deserialize(stream)
to_remove.append(out_point)
return cls(hash, to_add, to_remove)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
header = BlockHeader.deserialize(stream)
index = varint.decode(stream)
status = BlockStatus.from_bytes(stream.read(1), "little")
downloaded = bool(int.from_bytes(stream.read(1), "little"))
return cls(header, index, status, downloaded)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
len_addresses = varint.decode(stream)
addresses = []
for x in range(len_addresses):
addresses.append(NetworkAddress.deserialize(stream))
return cls(addresses=addresses)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
blockhash = stream.read(32)[::-1].hex()
num_transactions = varint.decode(stream)
transactions = []
for x in range(num_transactions):
transactions.append(TxData.deserialize(stream))
return cls(blockhash=blockhash, transactions=transactions)
def test_conversion(self):
i = 0xfc
b = varint.encode(i)
self.assertEqual(len(b), 1)
self.assertEqual(varint.decode(b), i)
i += 1
b = varint.encode(i)
self.assertEqual(len(b), 3)
self.assertEqual(varint.decode(b), i)
i = 0xffff
b = varint.encode(i)
self.assertEqual(len(b), 3)
self.assertEqual(varint.decode(b), i)
i += 1
b = varint.encode(i)
self.assertEqual(len(b), 5)
self.assertEqual(varint.decode(b), i)
i = 0xffffffff
b = varint.encode(i)
self.assertEqual(len(b), 5)
self.assertEqual(varint.decode(b), i)
i += 1
b = varint.encode(i)
self.assertEqual(len(b), 9)
self.assertEqual(varint.decode(b), i)
i = 0xffffffffffffffff
b = varint.encode(i)
self.assertEqual(len(b), 9)
self.assertEqual(varint.decode(b), i)
# integer too large (0x10000000000000000) for varint encoding
i += 1
self.assertRaises(ValueError, varint.encode, i)
#varint.encode(i)
self.assertEqual(varint.decode('6a'), 106)
self.assertEqual(varint.decode('fd2602'), 550)
self.assertEqual(varint.decode('fe703a0f00'), 998000)
def test_varint_conversion():
i = 0xFC
b = varint.encode(i)
assert len(b) == 1
assert varint.decode(b) == i
i += 1
b = varint.encode(i)
assert len(b) == 3
assert varint.decode(b) == i
i = 0xFFFF
b = varint.encode(i)
assert len(b) == 3
assert varint.decode(b) == i
i += 1
b = varint.encode(i)
assert len(b) == 5
assert varint.decode(b) == i
i = 0xFFFFFFFF
b = varint.encode(i)
assert len(b) == 5
assert varint.decode(b) == i
i += 1
b = varint.encode(i)
assert len(b) == 9
assert varint.decode(b) == i
i = 0xFFFFFFFFFFFFFFFF
b = varint.encode(i)
assert len(b) == 9
assert varint.decode(b) == i
i += 1
with pytest.raises(ValueError,
match="integer too big for varint encoding: "):
varint.encode(i)
assert varint.decode("6a") == 106
assert varint.decode("fd2602") == 550
assert varint.decode("fe703a0f00") == 998000
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
inventory_length = varint.decode(stream)
inventory = []
for x in range(inventory_length):
item_type = int.from_bytes(stream.read(4), "little")
item_hash = stream.read(32)[::-1].hex()
inventory.append((item_type, item_hash))
return cls(inventory)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
headers_num = varint.decode(stream)
headers = []
for x in range(headers_num):
header = BlockHeader.deserialize(stream)
stream.read(1)
headers.append(header)
return cls(headers)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
version = int.from_bytes(stream.read(4), "little")
block_hashes = []
for x in range(varint.decode(stream)):
block_hash = stream.read(32)[::-1].hex()
block_hashes.append(block_hash)
hash_stop = stream.read(32)[::-1].hex()
return cls(version=version,
block_hashes=block_hashes,
hash_stop=hash_stop)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
header = BlockHeader.deserialize(stream)
nonce = int.from_bytes(stream.read(8), "little")
short_ids = []
short_ids_length = varint.decode(stream)
for x in range(short_ids_length):
short_ids.append(stream.read(6)[::-1].hex())
prefilled_tx_list = []
prefilled_tx_num = varint.decode(stream)
for x in range(prefilled_tx_num):
tx_index = varint.decode(stream)
tx = Tx.deserialize(stream)
prefilled_tx_list.append((tx_index, tx))
return cls(
header=header,
nonce=nonce,
short_ids=short_ids,
prefilled_tx_list=prefilled_tx_list,
)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
version = int.from_bytes(stream.read(4), "little")
services = int.from_bytes(stream.read(8), "little")
timestamp = int.from_bytes(stream.read(8), "little")
addr_recv = NetworkAddress.deserialize(stream, version_msg=True)
addr_from = NetworkAddress.deserialize(stream, version_msg=True)
nonce = int.from_bytes(stream.read(8), "little")
user_agent_len = varint.decode(stream)
user_agent = stream.read(user_agent_len).decode()
start_height = int.from_bytes(stream.read(4), "little")
relay = bool(int.from_bytes(stream.read(1), "little"))
return cls(
version=version,
services=services,
timestamp=timestamp,
addr_recv=addr_recv,
addr_from=addr_from,
nonce=nonce,
user_agent=user_agent,
start_height=start_height,
relay=relay,
)
def deserialize(cls, data):
stream = bytesio_from_binarydata(data)
filename = stream.read(10).decode()
size = varint.decode(stream)
return cls(filename, size)