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 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.
"""
self._data = bytes(reader.read_bytes(self._BYTE_LEN))
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.
"""
remaining_stream_size = len(reader) - reader._stream.tell()
self.value = reader.read_bytes(remaining_stream_size)
def deserialize(self, reader: serialization.BinaryReader, curve=ECCCurve.SECP256R1) -> None:
try:
f0 = reader.read_byte()
except ValueError:
# infinity
self.from_bytes(b'\x00', curve, True)
return
f1 = int.from_bytes(f0, 'little')
if f1 == 0:
# infinity
self.from_bytes(b'\x00', curve, True)
return
elif f1 == 2 or f1 == 3:
data = reader.read_bytes(32)
self.from_bytes(f0 + data, curve, True)
return
else:
raise ValueError(f"Unsupported point encoding: {str(f0)}")
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:
self.id = reader.read_int32()
remaining_stream_size = len(reader) - reader._stream.tell()
self.key = reader.read_bytes(remaining_stream_size)
def deserialize(self, reader: serialization.BinaryReader) -> None:
remaining_stream_size = len(reader) - reader._stream.tell()
self.value = reader.read_bytes(remaining_stream_size)
