def stream_deserialize(cls, f: BinaryIO) -> HelloMessage:
# type_indicator has been read already by the superclass at this point.
# version is ignored... we parse everything as version 0, since that's the only thing we ourselves speak.
# once other versions get introduced we should start paying attention to what's in here, and parse as much as we
# know about.
(version, ) = struct.unpack(b"B", safe_read(f, 1))
your_ip_address = IPv6Address(safe_read(f, 16))
(your_port, ) = struct.unpack(b">H", safe_read(f, 2))
my_ip_address = IPv6Address(safe_read(f, 16))
(my_port, ) = struct.unpack(b">H", safe_read(f, 2))
(nonce, ) = struct.unpack(b">I", safe_read(f, 4))
(ua_length, ) = struct.unpack(b"B", safe_read(f, 1))
user_agent = safe_read(f, ua_length)
supported_versions = stream_deserialize_list(f, SupportedVersion)
safe_read(f, 256) # reserved space for later versions
return cls(supported_versions, your_ip_address, your_port,
my_ip_address, my_port, nonce, user_agent)
def stream_deserialize(cls, f: BinaryIO) -> GetDataMessage:
# type_indicator has been read already by the superclass at this point.
if safe_read(f, 1) != b'\x00':
raise ValueError(
"Current version supports only version 0 GetDataMessage")
data_type = safe_read(f, 2)
hash = safe_read(f, 32)
return cls(data_type, hash)
def stream_deserialize(cls, f: BinaryIO) -> DataMessage:
# type_indicator has been read already by the superclass at this point.
if safe_read(f, 1) != b'\x00':
raise ValueError(
"Current version supports only version 0 DataMessage")
data_type = safe_read(f, 2)
clz = DATATYPES[data_type]
data = clz.stream_deserialize(f)
return cls(data_type, data)
def stream_deserialize(cls, f: BinaryIO) -> GetBlocksMessage:
# type_indicator has been read already by the superclass at this point.
if safe_read(f, 1) != b'\x00':
raise ValueError(
"Current version supports only version 0 GetBlocksMessage")
potential_start_hashes = []
length = stream_deserialize_vlq(f)
for i in range(length):
potential_start_hashes.append(safe_read(f, 32))
stop_hash = safe_read(f, 32)
return cls(potential_start_hashes, stop_hash)
def stream_deserialize(cls, f: BinaryIO) -> Message:
type_indicator = safe_read(f, 2)
if type_indicator == MSG_HELLO:
return HelloMessage.stream_deserialize(f)
if type_indicator == MSG_GET_BLOCKS:
return GetBlocksMessage.stream_deserialize(f)
if type_indicator == MSG_INVENTORY:
return InventoryMessage.stream_deserialize(f)
if type_indicator == MSG_GET_DATA:
return GetDataMessage.stream_deserialize(f)
if type_indicator == MSG_DATA:
return DataMessage.stream_deserialize(f)
if type_indicator == MSG_GET_PEERS:
return GetPeersMessage.stream_deserialize(f)
if type_indicator == MSG_PEERS:
return PeersMessage.stream_deserialize(f)
raise DeserializationError("Non-supported message type")
def stream_deserialize(cls, f: BinaryIO) -> InventoryMessage:
# type_indicator has been read already by the superclass at this point.
if safe_read(f, 1) != b'\x00':
raise ValueError(
"Current version supports only version 0 InventoryMessage")
items = stream_deserialize_list(f, InventoryItem)
return cls(items)
def stream_deserialize(cls, f: BinaryIO) -> PeersMessage:
# type_indicator has been read already by the superclass at this point.
if safe_read(f, 1) != b'\x00':
raise ValueError(
"Current version supports only version 0 GetPeersMessage")
peers = stream_deserialize_list(f, Peer)
return cls(peers)
def stream_deserialize(cls, f: BinaryIO) -> MessageHeader:
# version is ignored... we parse everything as version 0, since that's the only thing we ourselves speak.
# once other versions get introduced we should start paying attention to what's in here, and parse as much as we
# know about
(version, ) = struct.unpack(b"B", safe_read(f, 1))
(timestamp, ) = struct.unpack(b">I", safe_read(f, 4))
(id, ) = struct.unpack(b">I", safe_read(f, 4))
(in_response_to, ) = struct.unpack(b">I", safe_read(f, 4))
(context, ) = struct.unpack(b">Q", safe_read(f, 8))
safe_read(f, 32) # reserved space for later versions
return cls(timestamp, id, in_response_to, context)
def stream_deserialize(cls, f: BinaryIO) -> Peer:
(last_seen_at, ) = struct.unpack(b">I", safe_read(f, 4))
ip_address = IPv6Address(safe_read(f, 16))
(port, ) = struct.unpack(b">H", safe_read(f, 2))
return cls(last_seen_at, ip_address, port)
def stream_deserialize(cls, f: BinaryIO) -> InventoryItem:
data_type = safe_read(f, 2)
hash = safe_read(f, 32)
return cls(data_type, hash)
def stream_deserialize(cls, f: BinaryIO) -> SupportedVersion:
(version, ) = struct.unpack(b"B", safe_read(f, 1))
return cls(version)
