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: """ 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: 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(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.hash_start = reader.read_serializable(types.UInt256) self.count = reader.read_int16()
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: 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_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. """ 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_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.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: """ 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.GLOBAL in self.scope and self.scope != payloads.WitnessScope.GLOBAL: raise ValueError("Deserialization error - invalid scope. GLOBAL scope not allowed with other scope types") 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.ECPoint, # type: ignore max=self.MAX_SUB_ITEMS)
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(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. """ self.header = reader.read_serializable(Header) self.transactions = reader.read_serializable_list(payloads.Transaction, max=0xFFFF) if len(set(self.transactions)) != len(self.transactions): raise ValueError("Deserialization error - block contains duplicate transaction") hashes = [t.hash() for t in self.transactions] if crypto.MerkleTree.compute_root(hashes) != self.header.merkle_root: raise ValueError("Deserialization error - merkle root mismatch")
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.header = reader.read_serializable(Header) self.hashes = reader.read_serializable_list(types.UInt256, max=0xFFFF)
def deserialize(self, reader: serialization.BinaryReader) -> None: super(_NeoTokenStorageState, self).deserialize(reader) self.vote_to = reader.read_serializable( cryptography.ECPoint) # type: ignore self.balance_height = reader.read_uint32()
def deserialize(self, reader: serialization.BinaryReader) -> None: super(TrimmedBlock, self).deserialize(reader) self.hashes = reader.read_serializable_list(types.UInt256) if len(self.hashes) > 0: self.consensus_data = reader.read_serializable(payloads.ConsensusData)
def deserialize(self, reader: serialization.BinaryReader) -> None: self.owner = reader.read_serializable(types.UInt160) self.name = reader.read_var_string()
def deserialize(self, reader: serialization.BinaryReader) -> None: super(NameState, self).deserialize(reader) self.expiration = reader.read_uint32() self.admin = reader.read_serializable(types.UInt160)
def deserialize(self, reader: serialization.BinaryReader) -> None: 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: BinaryReader) -> None: self.script = reader.read_var_bytes() self.manifest = reader.read_serializable(manifest.ContractManifest)
def deserialize(self, reader: serialization.BinaryReader) -> None: self.id = reader.read_int32() self.nef = reader.read_serializable(contracts.NEF) self.manifest = reader.read_serializable(contracts.ContractManifest) self.update_counter = reader.read_uint16() self.hash = reader.read_serializable(types.UInt160)
def deserialize(self, reader: serialization.BinaryReader) -> None: self.deserialize_unsigned(reader) if reader.read_uint8() != 1: raise ValueError("Deserialization error - check byte incorrect") self.witness = reader.read_serializable(payloads.Witness)
def deserialize(self, reader: serialization.BinaryReader) -> None: self.contract = reader.read_serializable(types.UInt160) self.key = reader.read_bytes_with_grouping(group_size=16)