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.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.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(self, reader: serialization.BinaryReader) -> None: """ Deserialize the object from a binary stream. Args: reader: instance. """ if reader.read_uint32() != self.magic: raise ValueError("Deserialization error - Incorrect magic") self.compiler = reader.read_bytes(64).decode('utf-8') if reader.read_uint16() != 0: raise ValueError("Reserved bytes must be 0") self.tokens = reader.read_serializable_list(MethodToken) if reader.read_uint16() != 0: raise ValueError("Reserved bytes must be 0") self.script = reader.read_var_bytes(max=512 * 1024) if len(self.script) == 0: raise ValueError("Deserialization error - Script can't be empty") checksum = int.from_bytes(reader.read_bytes(4), 'little') if checksum != self.compute_checksum(): raise ValueError("Deserialization error - Invalid checksum") else: self._checksum = checksum
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: 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_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.data = reader.read_var_bytes(520)
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_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: """ 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. """ 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_unsigned(self, reader: serialization.BinaryReader) -> None: (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.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_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_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_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.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.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: self.index = reader.read_uint32() self.gas_per_block = vm.BigInteger(reader.read_var_bytes())
def deserialize(self, reader: serialization.BinaryReader) -> None: self.registered = reader.read_bool() self.votes = vm.BigInteger(reader.read_var_bytes())
def deserialize(self, reader: serialization.BinaryReader) -> None: self.balance = vm.BigInteger(reader.read_var_bytes())
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: self.value = reader.read_var_bytes() self.is_constant = reader.read_bool()
def deserialize(self, reader: serialization.BinaryReader) -> None: self.value = reader.read_var_bytes()
def deserialize(self, reader: BinaryReader) -> None: self.script = reader.read_var_bytes() self.manifest = reader.read_serializable(manifest.ContractManifest)