def decode_from_reader(
self, reader: serialization.BinaryReader) -> EllipticCurve.ECPoint:
"""
Raises:
NotImplementedError: if an unsupported point encoding is used
TypeError: if unexpected encoding is read
"""
try:
f = reader.read_byte()
except ValueError:
return self.Infinity
f = int.from_bytes(f, "little")
if f == 0:
return self.Infinity
# these are compressed
if f == 2 or f == 3:
yTilde = f & 1
data = bytearray(reader.read_bytes(32))
data.reverse()
data.append(0)
X1 = int.from_bytes(data, 'little')
return self.decompress_from_curve(X1, yTilde)
# uncompressed or hybrid
elif f == 4 or f == 6 or f == 7:
raise NotImplementedError()
raise ValueError(f"Invalid point encoding: {f}")
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
Raises:
ValueError: if the content count of the block is zero, or if there is a duplicate transaction in the list,
or if the merkle root does not included the calculated root.
"""
super(Block, self).deserialize(reader)
content_count = reader.read_var_int(max=self.MAX_CONTENTS_PER_BLOCK)
if content_count == 0:
raise ValueError("Deserialization error - no contents")
self.consensus_data = reader.read_serializable(payloads.ConsensusData)
tx_count = content_count - 1
for _ in range(tx_count):
self.transactions.append(reader.read_serializable(payloads.Transaction))
if len(set(self.transactions)) != tx_count:
raise ValueError("Deserialization error - block contains duplicate transaction")
hashes = [t.hash() for t in self.transactions]
if Block.calculate_merkle_root(self.consensus_data.hash(), hashes) != self.merkle_root:
raise ValueError("Deserialization error - merkle root mismatch")
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_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.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.header = reader.read_serializable(Header)
self.hashes = reader.read_serializable_list(types.UInt256, max=0xFFFF)
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.
"""
self.type = ConsensusMessageType(reader.read_uint8())
self.view_number = reader.read_uint8()
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.hash_start = reader.read_serializable(types.UInt256)
self.count = reader.read_int16()
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.type = InventoryType(reader.read_uint8())
self.hashes = reader.read_serializable_list(types.UInt256)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.current_height = reader.read_uint32()
self.timestamp = reader.read_uint32()
self.nonce = reader.read_uint32()
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.primary_index = reader.read_var_int(
max=1024) # comes from C#'s Clockchain.MaxValidators
self.nonce = reader.read_uint64()
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.id = reader.read_int32()
remaining_stream_size = len(reader) - reader._stream.tell()
self.key = reader.read_bytes(remaining_stream_size)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.major = reader.read_int32()
self.minor = reader.read_int32()
self.build = reader.read_int32()
self.revision = reader.read_int32()
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_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.hash = reader.read_serializable(types.UInt160)
self.method = reader.read_var_string(32)
self.parameters_count = reader.read_uint16()
self.has_return_value = bool(reader.read_uint8())
self.call_flags = contracts.CallFlags(reader.read_uint8())
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_signers(reader: serialization.BinaryReader, max_count: int) -> List[payloads.Signer]:
count = reader.read_var_int(max_count)
if count == 0:
raise ValueError("Deserialization error - signers can't be empty")
values: List[payloads.Signer] = []
for i in range(0, count):
signer = reader.read_serializable(payloads.Signer)
if signer in values:
raise ValueError("Deserialization error - duplicate signer")
values.append(signer)
return values
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
Raises:
ValueError: if the validation byte is not 1
"""
self.deserialize_unsigned(reader)
if reader.read_uint8() != 1:
raise ValueError("Deserialization error - validation byte not 1")
self.witness = reader.read_serializable(payloads.Witness)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
Raises:
ValueError: if no witnesses are found.
"""
self.deserialize_unsigned(reader)
witness_obj_count = reader.read_uint8()
if witness_obj_count != 1:
raise ValueError(f"Deserialization error - Witness object count is {witness_obj_count} must be 1")
self.witness = reader.read_serializable(payloads.Witness)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
Raises:
ValueError: if `count` is zero or exceeds
:const:`~neo3.network.payloads.getblocks.GetBlockByIndexPayload.MAX_BLOCKS_COUNT`.
"""
self.index_start = reader.read_uint32()
self.count = reader.read_int16()
if self.count < 1 or self.count == 0 or self.count > HeadersPayload.MAX_HEADERS_COUNT:
raise ValueError("Deserialization error - invalid count")
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:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.headers = reader.read_serializable_list(Header)
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._data = bytes(reader.read_bytes(self._BYTE_LEN))
