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.invocation_script = reader.read_var_bytes(max=self._MAX_INVOCATION_SCRIPT)
self.verification_script = reader.read_var_bytes(max=self._MAX_VERIFICATION_SCRIPT)
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:
size = int.from_bytes(payload_data[:4], 'little')
payload_data = lz4.block.decompress(payload_data[4:],
uncompressed_size=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.
"""
if reader.read_uint32() != self.magic:
raise ValueError("Deserialization error - Incorrect magic")
self.compiler = reader.read_bytes(64).decode('utf-8')
if reader.read_uint16() != 0:
raise ValueError("Reserved bytes must be 0")
self.tokens = reader.read_serializable_list(MethodToken)
if reader.read_uint16() != 0:
raise ValueError("Reserved bytes must be 0")
self.script = reader.read_var_bytes(max=512 * 1024)
if len(self.script) == 0:
raise ValueError("Deserialization error - Script can't be empty")
checksum = int.from_bytes(reader.read_bytes(4), 'little')
if checksum != self.compute_checksum():
raise ValueError("Deserialization error - Invalid checksum")
else:
self._checksum = checksum
def deserialize_unsigned(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the unsigned data part of the object from a binary stream.
Args:
reader: instance.
Raises:
ValueError: The version is not zero.
ValueError: If the system of network fee is negative.
ValueError: If there is no script
"""
(self.version,
self.nonce,
self.system_fee,
self.network_fee,
self.valid_until_block) = struct.unpack("<BIqqI", reader._stream.read(25))
if self.version > 0:
raise ValueError("Deserialization error - invalid version")
if self.system_fee < 0:
raise ValueError("Deserialization error - negative system fee")
if self.network_fee < 0:
raise ValueError("Deserialization error - negative network fee")
self.signers = Transaction._deserialize_signers(reader, self.MAX_TRANSACTION_ATTRIBUTES)
self.attributes = Transaction._deserialize_attributes(reader,
self.MAX_TRANSACTION_ATTRIBUTES - len(self.signers))
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.original_tx_id = reader.read_serializable(types.UInt256)
self.gas_for_response = reader.read_uint64()
self.url = reader.read_var_string()
self.filter = reader.read_var_string()
self.callback_contract = reader.read_serializable(types.UInt160)
self.callback_method = reader.read_var_string()
self.user_data = reader.read_var_bytes()
def _deserialize_without_type(self,
reader: serialization.BinaryReader) -> None:
self.id = reader.read_uint64()
self.code = OracleReponseCode(reader.read_uint8())
self.result = reader.read_var_bytes(self._MAX_RESULT_SIZE)
if self.code != OracleReponseCode.SUCCESS and len(self.result) > 0:
raise ValueError(
f"Deserialization error - oracle response: {self.code}")
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(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_unsigned(self, reader: serialization.BinaryReader) -> None:
self.category = reader.read_var_string(32)
self.valid_block_start = reader.read_uint32()
self.valid_block_end = reader.read_uint32()
if self.valid_block_start >= self.valid_block_end:
raise ValueError(
"Deserialization error - valid_block_starts is bigger than valid_block_end"
)
self.sender = reader.read_serializable(types.UInt160)
self.data = reader.read_var_bytes(message.Message.PAYLOAD_MAX_SIZE)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.header = reader.read_serializable(Header)
self.tx_count = reader.read_var_int(max=0xFFFF)
self.hashes = reader.read_serializable_list(types.UInt256, max=self.tx_count)
self.flags = reader.read_var_bytes(max=(max(self.tx_count, 1) + 7) // 8)
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(self, reader: serialization.BinaryReader) -> None:
length = reader.read_var_int()
if self._validators is None:
self._validators = {}
else:
self._validators.clear()
for _ in range(length):
public_key = reader.read_serializable(
cryptography.ECPoint) # type: ignore
self._validators.update(
{public_key: vm.BigInteger(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_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_unsigned(self, reader: serialization.BinaryReader) -> None:
(self.version, self.nonce, self.system_fee, self.network_fee,
self.valid_until_block) = struct.unpack("<BIqqI",
reader._stream.read(25))
if self.version > 0:
raise ValueError("Deserialization error - invalid version")
if self.system_fee < 0:
raise ValueError("Deserialization error - negative system fee")
if self.network_fee < 0:
raise ValueError("Deserialization error - negative network fee")
self.signers = Transaction._deserialize_signers(
reader, self.MAX_TRANSACTION_ATTRIBUTES)
self.attributes = Transaction._deserialize_attributes(
reader, self.MAX_TRANSACTION_ATTRIBUTES - len(self.signers))
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:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
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_unsigned(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the unsigned data part of the object from a binary stream.
Args:
reader: instance.
Raises:
ValueError: if the valid_block_start exceeds the valid_block_end field.
"""
self.category = reader.read_var_string(32)
self.valid_block_start = reader.read_uint32()
self.valid_block_end = reader.read_uint32()
if self.valid_block_start >= self.valid_block_end:
raise ValueError(
"Deserialization error - valid_block_start is bigger than valid_block_end"
)
self.sender = reader.read_serializable(types.UInt160)
self.data = reader.read_var_bytes(message.Message.PAYLOAD_MAX_SIZE)
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_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.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.signers = Transaction._deserialize_signers(
reader, self.MAX_TRANSACTION_ATTRIBUTES)
self.attributes = Transaction._deserialize_attributes(
reader, self.MAX_TRANSACTION_ATTRIBUTES - len(self.signers))
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.index = reader.read_uint32()
self.gas_per_block = vm.BigInteger(reader.read_var_bytes())
def deserialize(self, reader: serialization.BinaryReader) -> None:
self.registered = reader.read_bool()
self.votes = vm.BigInteger(reader.read_var_bytes())
def deserialize(self, reader: serialization.BinaryReader) -> None:
self.balance = vm.BigInteger(reader.read_var_bytes())
def deserialize(self, reader: serialization.BinaryReader) -> None:
super(NFTAccountState, self).deserialize(reader)
for _ in range(reader.read_var_int()):
self.tokens.append(reader.read_var_bytes())
def deserialize(self, reader: serialization.BinaryReader) -> None:
self.value = reader.read_var_bytes()
self.is_constant = reader.read_bool()
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)
