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_attributes(reader: serialization.BinaryReader, max_count: int) -> List[TransactionAttribute]:
count = reader.read_var_int(max_count)
values: List[TransactionAttribute] = []
for _ in range(0, count):
attribute = TransactionAttribute.deserialize_from(reader)
if not attribute.allow_multiple and attribute in values:
raise ValueError("Deserialization error - duplicate transaction attribute")
values.append(attribute)
return values
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.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.
"""
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_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.
"""
self.magic = reader.read_uint32()
self.version = reader.read_uint32()
self.timestamp = reader.read_uint32()
self.nonce = reader.read_uint32()
self.user_agent = reader.read_var_string(max=1024)
capabilities_cnt = reader.read_var_int(self.MAX_CAPABILITIES)
capabilities_list = []
for _ in range(capabilities_cnt):
capabilities_list.append(capabilities.NodeCapability.deserialize_from(reader))
self.capabilities = capabilities_list
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 i > 0 and signer.scope == payloads.WitnessScope.FEE_ONLY:
raise ValueError(
"Deserialization error - only the first signer can be fee only"
)
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.
"""
self.timestamp = reader.read_uint32()
full_address_bytes = bytearray(reader.read_bytes(16))
ip_bytes = full_address_bytes[-4:]
host = '.'.join(map(lambda b: str(b), ip_bytes))
port = 0
capabilities_cnt = reader.read_var_int(VersionPayload.MAX_CAPABILITIES)
capabilities_list = []
for _ in range(capabilities_cnt):
capa = capabilities.NodeCapability.deserialize_from(reader)
if isinstance(capa, capabilities.ServerCapability):
port = capa.port
capabilities_list.append(capa)
self.capabilities = capabilities_list
self.address = f"{host}:{port}"
def deserialize(self, reader: serialization.BinaryReader) -> None:
for _ in range(reader.read_var_int()):
self.append(reader.read_var_string())
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:
count = reader.read_var_int()
for _ in range(count):
self.append(reader.read_uint64())
