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:
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.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.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.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.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.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.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.current_height = reader.read_uint32()
self.timestamp = reader.read_uint32()
self.nonce = reader.read_uint32()
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:
"""
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(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 `count` is zero or exceeds
:const:`~neo3.network.payloads.getblocks.GetBlockDataPayload.MAX_BLOCKS_COUNT`.
"""
self.index_start = reader.read_uint32()
self.count = reader.read_uint16()
if self.count == 0 or self.count > self.MAX_BLOCKS_COUNT:
raise ValueError("Deserialization error - invalid count")
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self._data = bytearray(reader.read_bytes(self._BYTE_LEN))
def deserialize(self, reader: BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self._deserialize_from_json(json.loads(reader.read_var_string(self.MAX_LENGTH)))
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.headers = reader.read_serializable_list(Header)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.account = reader.read_serializable(types.UInt160)
self.scope = payloads.WitnessScope(reader.read_uint8())
if payloads.WitnessScope.CUSTOM_CONTRACTS in self.scope:
self.allowed_contracts = reader.read_serializable_list(
types.UInt160)
if payloads.WitnessScope.CUSTOM_GROUPS in self.scope:
self.allowed_groups = reader.read_serializable_list(
cryptography.EllipticCurve.ECPoint)
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_without_type(self,
reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream without deserializing the base class `type` property.
Args:
reader: instance.
"""
self.start_height = reader.read_uint32()
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.type = NodeCapabilityType(reader.read_uint8())
self.deserialize_without_type(reader)
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
self.deserialize_unsigned(reader)
self.witnesses = reader.read_serializable_list(payloads.Witness)
def deserialize(self, reader: serialization.BinaryReader) -> None:
version_str = reader.read_bytes(s.uint64 * 4).decode('utf-8')
import re
version_str = re.sub(r'\x00+', '', version_str)
major, minor, build, revision = version_str.split('.')
self.major = int(major)
self.minor = int(minor)
self.build = int(build)
self.revision = int(revision)
def deserialize_from(reader: serialization.BinaryReader) -> NodeCapability:
capability_type = NodeCapabilityType(reader.read_uint8())
if capability_type in [
NodeCapabilityType.TCPSERVER, NodeCapabilityType.WSSERVER
]:
capability = ServerCapability(
capability_type) # type: NodeCapability
elif capability_type == NodeCapabilityType.FULLNODE:
capability = FullNodeCapability()
capability.deserialize_without_type(reader)
return capability # a type of Nodecapbility or inherited
def deserialize(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
"""
addr_list_len = reader.read_var_int()
for i in range(0, addr_list_len):
nawt = NetworkAddress()
nawt.deserialize(reader)
self.addresses.append(nawt)
def deserialize_unsigned(self, reader: serialization.BinaryReader) -> None:
self.version = reader.read_uint32()
self.prev_hash = reader.read_serializable(types.UInt256)
self.merkle_root = reader.read_serializable(types.UInt256)
self.timestamp = reader.read_uint64()
self.index = reader.read_uint32()
self.next_consensus = reader.read_serializable(types.UInt160)
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(self, reader: serialization.BinaryReader) -> None:
"""
Deserialize the object from a binary stream.
Args:
reader: instance.
Raises:
ValueError: if the check byte does not equal.
"""
super(Header, self).deserialize(reader)
tmp = reader.read_uint8()
if tmp != 0:
raise ValueError("Deserialization error")
