def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.invocation_script = reader.read_var_bytes(max=664)
self.verification_script = reader.read_var_bytes(max=360)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.config = MessageConfig(reader.read_uint8())
x = reader.read_uint8()
self.type = MessageType(x)
# self.type = MessageType(reader.read_uint8())
payload_data = reader.read_var_bytes(self.PAYLOAD_MAX_SIZE)
if len(payload_data) > 0:
if MessageConfig.COMPRESSED in self.config:
# From the lz4 documentation:
# "The uncompressed_size argument specifies an upper bound on the size of the uncompressed data size
# rather than an absolute value"
try:
payload_data = lz4.block.decompress(
payload_data, uncompressed_size=self.PAYLOAD_MAX_SIZE)
except lz4.block.LZ4BlockError:
raise ValueError(
"Invalid payload data - decompress failed")
self.payload = self._payload_from_data(self.type, payload_data)
if self.payload is None:
self.payload = payloads.EmptyPayload()
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.data = reader.read_var_bytes(520)
def deserialize_binary(reader: BinaryReader) -> Any:
deserialized_items = []
underserialized = 1
while underserialized > 0:
stack_type = reader.read_byte()
if stack_type == StackItemType.Any:
deserialized_items.append(None)
elif stack_type == StackItemType.Boolean:
deserialized_items.append(reader.read_bool())
elif stack_type == StackItemType.Integer:
value_in_bytes = reader.read_var_bytes()
deserialized_items.append(Integer.from_bytes(value_in_bytes))
elif stack_type in (StackItemType.ByteString, StackItemType.Buffer):
deserialized_items.append(reader.read_var_bytes())
elif stack_type in (StackItemType.Array, StackItemType.Struct):
count = reader.read_var_int()
deserialized_items.append(list(range(count)))
underserialized += count
elif stack_type == StackItemType.Map:
count = reader.read_var_int()
deserialized_items.append({key: None for key in range(count)})
underserialized += count * 2
else:
raise ValueError
underserialized -= 1
stack_temp = []
while len(deserialized_items) > 0:
item = deserialized_items.pop()
if isinstance(item, list):
new_item = []
for _ in range(len(item)):
new_item.append(stack_temp.pop())
item = new_item
elif isinstance(item, dict):
new_item = {}
for _ in range(0, len(item), 2):
key = stack_temp.pop()
value = stack_temp.pop()
new_item[key] = value
item = new_item
stack_temp.append(item)
return stack_temp.pop()
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.usage = TransactionAttributeUsage(reader.read_uint8())
self.data = reader.read_var_bytes(max=252)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
super(MerkleBlockPayload, self).deserialize(reader)
self.content_count = reader.read_var_int()
self.hashes = reader.read_serializable_list(types.UInt256)
self.flags = reader.read_var_bytes()
def deserialize_unsigned(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream excluding the validation byte + witness.
Args:
reader: instance.
"""
self.version = reader.read_uint32()
self.prev_hash = reader.read_serializable(types.UInt256)
self.block_index = reader.read_uint32()
self.validator_index = reader.read_uint16()
self.data = reader.read_var_bytes()
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.filter = reader.read_var_bytes(max=36000)
self.K = reader.read_uint8()
if self.K > 50:
raise ValueError("Deserialization error - K exceeds limit of 50")
self.tweak = reader.read_uint32()
def deserialize(self, reader: serialization.BinaryReader) -> None:
self.magic = reader.read_uint32()
self.compiler = reader.read_bytes(32).decode('utf-8')
self.version = Version.deserialize_from_bytes(reader.read_bytes(16))
self.script_hash = reader.read_serializable(types.UInt160)
self.checksum = reader.read_bytes(4)
if self.checksum != self.compute_checksum():
raise ValueError("Deserialization error - invalid checksum")
self.script = reader.read_var_bytes()
if self.script_hash != self.compute_script_hash():
raise ValueError("Deserialization error - invalid script_hash")
def deserialize(self, reader: serialization.BinaryReader) -> None:
self.magic = reader.read_uint32()
compiler_with_version = reader.read_bytes(64).decode('utf-8')
self.compiler, version = compiler_with_version.rsplit('-', maxsplit=1)
self.version = Version.deserialize_from_bytes(
version[:32].encode('utf-8'))
assert reader.read_uint16() == 0 # 2 reserved bytes
reader.read_var_int(128) # TODO: method tokens
assert reader.read_uint16() == 0 # 2 reserved bytes
self.script = reader.read_var_bytes()
self.checksum = reader.read_bytes(4)
if self.checksum != self.compute_checksum():
raise ValueError("Deserialization error - invalid checksum")
def deserialize_unsigned(self, reader: serialization.BinaryReader) -> None:
self.version = reader.read_uint8()
if self.version > 0:
raise ValueError("Deserialization error - invalid version")
self.nonce = reader.read_uint32()
self.sender = reader.read_serializable(types.UInt160)
self.system_fee = reader.read_int64()
if self.system_fee < 0:
raise ValueError("Deserialization error - negative system fee")
self.network_fee = reader.read_int64()
if self.network_fee < 0:
raise ValueError("Deserialization error - negative network fee")
# Impossible overflow, only applicable to the C# implementation where they use longs
# if (self.system_fee + self.network_fee < self.system_fee):
# raise ValueError("Deserialization error - overflow")
self.valid_until_block = reader.read_uint32()
self.attributes = reader.read_serializable_list(TransactionAttribute)
self.cosigners = reader.read_serializable_list(payloads.Cosigner)
self.script = reader.read_var_bytes(max=65535)
if len(self.script) == 0:
raise ValueError("Deserialization error - invalid script length 0")
def deserialize(self, reader: serialization.BinaryReader) -> None:
self.value = reader.read_var_bytes()
def deserialize(self, reader: BinaryReader) -> None:
self.script = reader.read_var_bytes()
self.manifest = reader.read_serializable(manifest.ContractManifest)