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")