def stream_deserialize(cls, f):
self = super(CSqueak, cls).stream_deserialize(f)
encContent = ser_read(f, ENC_CONTENT_LENGTH)
object.__setattr__(self, 'encContent', encContent)
sig = ser_read(f, SIGNATURE_LENGTH)
object.__setattr__(self, 'sig', sig)
return self
def stream_deserialize(cls, f, protover=PROTO_VERSION):
recvbuf = ser_read(f, 4 + 12 + 4 + 4)
# check magic
if recvbuf[:4] != squeak.params.params.MESSAGE_START:
raise ValueError(
"Invalid message start '%s', expected '%s'" %
(b2x(recvbuf[:4]), b2x(squeak.params.params.MESSAGE_START)))
# remaining header fields: command, msg length, checksum
command = recvbuf[4:4 + 12].split(b"\x00", 1)[0]
msglen = struct.unpack(b"<i", recvbuf[4 + 12:4 + 12 + 4])[0]
checksum = recvbuf[4 + 12 + 4:4 + 12 + 4 + 4]
# read message body
recvbuf += ser_read(f, msglen)
msg = recvbuf[4 + 12 + 4 + 4:4 + 12 + 4 + 4 + msglen]
th = hashlib.sha256(msg).digest()
h = hashlib.sha256(th).digest()
if checksum != h[:4]:
raise ValueError("got bad checksum %s" % repr(recvbuf))
recvbuf = recvbuf[4 + 12 + 4 + 4 + msglen:]
if command in messagemap:
cls = messagemap[command]
return cls.msg_deser(_BytesIO(msg))
else:
print("Command '%s' not in messagemap" % repr(command))
return None
def stream_deserialize(cls, f):
self = cls()
for attr, fmt, num_bytes, _ in self.fields:
if fmt not in ['bytes']:
setattr(self, attr, struct.unpack(fmt, ser_read(f, num_bytes))[0])
elif fmt == 'bytes':
setattr(self, attr, ser_read(f, num_bytes))
return self
def tx_version_to_vars(version):
"""Converts an int32 representation into serialization type and version."""
f = BytesIO()
f.write(struct.pack(b'<I', version))
f.seek(0)
version_value = struct.unpack(b'<H', ser_read(f, 2))[0]
serialization_type = struct.unpack(b'<H', ser_read(f, 2))[0]
return (version_value, serialization_type)
def stream_deserialize(cls, f, without_time=False):
c = cls()
if c.protover >= CADDR_TIME_VERSION and not without_time:
c.nTime = struct.unpack(b"<I", ser_read(f, 4))[0]
c.nServices = struct.unpack(b"<Q", ser_read(f, 8))[0]
c.pchReserved = ser_read(f, 12)
c.ip = socket.inet_ntoa(ser_read(f, 4))
c.port = struct.unpack(b">H", ser_read(f, 2))[0]
return c
def stream_deserialize(cls, f):
n = VarIntSerializer.stream_deserialize(f)
pubkeys = tuple(
SqueakPublicKey.from_bytes(ser_read(f, PUB_KEY_LENGTH))
for i in range(n))
nMinBlockHeight = struct.unpack(b"<i", ser_read(f, 4))[0]
nMaxBlockHeight = struct.unpack(b"<i", ser_read(f, 4))[0]
hashReplySqk = ser_read(f, HASH_LENGTH)
return cls(pubkeys, nMinBlockHeight, nMaxBlockHeight, hashReplySqk)
def stream_deserialize(cls, f):
self = cls()
for attr, fmt, num_bytes, _ in self.fields:
if fmt not in ['bytes']:
setattr(self, attr,
struct.unpack(fmt, ser_read(f, num_bytes))[0])
elif fmt == 'bytes':
setattr(self, attr, ser_read(f, num_bytes))
return self
def stream_deserialize(cls, f):
prev_out = OutPoint.stream_deserialize(f)
sequence = struct.unpack(b'<I', ser_read(f, 4))[0]
value = struct.unpack(b'<q', ser_read(f, 8))[0]
block_height = struct.unpack(b'<I', ser_read(f, 4))[0]
block_index = struct.unpack(b'<I', ser_read(f, 4))[0]
sig_script = BytesSerializer.stream_deserialize(f)
return cls(prev_out, sequence, value, block_height, block_index, sig_script)
def stream_deserialize(cls, f, without_time=False):
c = cls()
if c.protover >= CADDR_TIME_VERSION and not without_time:
c.nTime = struct.unpack(b"<I", ser_read(f, 4))[0]
c.nServices = struct.unpack(b"<Q", ser_read(f, 8))[0]
c.pchReserved = ser_read(f, 12)
c.ip = socket.inet_ntoa(ser_read(f, 4))
c.port = struct.unpack(b">H", ser_read(f, 2))[0]
return c
def stream_deserialize(cls, f):
self = cls()
if not hasattr(self, 'fields'):
setattr(self, 'fields', list(block_header_fields))
for attr, fmt, num_bytes, _ in self.fields:
if fmt not in ['bytes']:
setattr(self, attr, struct.unpack(fmt, ser_read(f, num_bytes))[0])
elif fmt == 'bytes':
setattr(self, attr, ser_read(f, num_bytes))
return self
def msg_deser(cls, f, protover=PROTO_VERSION):
hashSqk = ser_read(f, HASH_LENGTH)
secretKey = ser_read(f, SECRET_KEY_LENGTH)
markerbyte = struct.unpack(b'B', ser_read(f, 1))[0]
flagbyte = struct.unpack(b'B', ser_read(f, 1))[0]
if markerbyte == 0 and flagbyte == 1:
offer = COffer.stream_deserialize(f)
else:
offer = None
return cls(hashSqk, secretKey, offer)
def deserialize_witness(self, f):
value = struct.unpack(b'<q', ser_read(f, 8))[0]
block_height = struct.unpack(b'<I', ser_read(f, 4))[0]
block_index = struct.unpack(b'<I', ser_read(f, 4))[0]
sig_script = BytesSerializer.stream_deserialize(f)
self.value = value
self.block_height = block_height
self.block_index = block_index
self.sig_script = sig_script
def stream_deserialize_value(self, f):
if self.bounds is TypeRef.Usage.single:
value = self.type.stream_deserialize_value(f)
elif self.bounds.is_fixed():
value = [self.type.stream_deserialize_value(f) for n in range(0, self.bounds.min())]
elif self.bounds is TypeRef.Usage.optional:
if self.type.type is FieldType.Type.pubkey:
key = ser_read(f, 1)
if key[0] is 0:
return None
data = key + ser_read(f, 32)
return PubKey.deserialize(data)
elif self.type.type is FieldType.Type.ecdsa:
key = ser_read(f, 1)
if key[0] is 0:
return None
raise NotImplementedError('ECDSA deserealization is not implemented')
try:
value = self.type.stream_deserialize_value(f)
except BaseException as ex:
# due to some strange bug, python 3 is unable to capture SeparatorByteSignal exception by its type,
# and `isinstance(ex, SeparatorByteSignal)` returns False as well :(
# so we have to capture generic exception and re-raise if it is not SeparatorByteSignal, which
# can be determined only by the presence of its method
if not callable(getattr(ex, "is_eof", None)):
raise
if ex.is_eof():
# -- met 0xFF separator byte, indicating absent value
value = None
else:
raise
if self.type.type is FieldType.Type.fvi:
pass
elif self.type.type is FieldType.Type.str:
value = None if value is b'\x00' or len(value) is 0 else value
elif self.type.type is FieldType.Type.bytes:
value = None if len(value) is 0 else value
elif self.type.type in [FieldType.Type.sha256, FieldType.Type.sha256d]:
value = None if value is bytes([0] * 32) else value
elif self.type.type in [FieldType.Type.ripmd160, FieldType.Type.hash160]:
value = None if value is bytes([0] * 20) else value
else:
raise SchemaError(f'optional fields can be only of `str`, `fvi`, `bytes` and complex types')
else:
no = VarIntSerializer.stream_deserialize(f)
value = [self.type.stream_deserialize_value(f) for n in range(0, no)]
return value
def stream_deserialize_value(self, f):
lut = {
FieldType.Type.u8: lambda: ser_read(f, 1),
FieldType.Type.u16: lambda: struct.unpack(b'<H', ser_read(f, 2))[0],
FieldType.Type.u32: lambda: struct.unpack(b'<I', ser_read(f, 4))[0],
FieldType.Type.u64: lambda: struct.unpack(b'<Q', ser_read(f, 8))[0],
FieldType.Type.i8: lambda: ser_read(f, 1),
FieldType.Type.i16: lambda: struct.unpack(b'<h', ser_read(f, 2))[0],
FieldType.Type.i32: lambda: struct.unpack(b'<i', ser_read(f, 4))[0],
FieldType.Type.i64: lambda: struct.unpack(b'<q', ser_read(f, 8))[0],
FieldType.Type.vi: lambda: VarIntSerializer.stream_deserialize(f),
FieldType.Type.fvi: lambda: FlagVarIntSerializer.stream_deserialize(f),
FieldType.Type.str: lambda: VarStringSerializer.stream_deserialize(f).decode('utf-8'),
FieldType.Type.bytes: lambda: BytesSerializer.stream_deserialize(f),
FieldType.Type.sha256: lambda: Hash256Id.stream_deserialize(f),
FieldType.Type.sha256d: lambda: Hash256Id.stream_deserialize(f),
FieldType.Type.ripmd160: lambda: Hash160Id.stream_deserialize(f),
FieldType.Type.hash160: lambda: Hash160Id.stream_deserialize(f),
FieldType.Type.pubkey: lambda: PubKey.stream_deserialize(f),
FieldType.Type.ecdsa: lambda: None,
}
if self.type in lut.keys():
return lut[self.type]()
else:
raise NotImplementedError()
def stream_deserialize(cls, f, without_time=False):
c = cls()
if c.protover >= CADDR_TIME_VERSION and not without_time:
c.nTime = struct.unpack(b"<I", ser_read(f, 4))[0]
c.nServices = struct.unpack(b"<Q", ser_read(f, 8))[0]
packedIP = ser_read(f, 16)
if bytes(packedIP[0:12]) == IPV4_COMPAT: # IPv4
c.ip = socket.inet_ntop(socket.AF_INET, packedIP[12:16])
else: #IPv6
c.ip = socket.inet_ntop(socket.AF_INET6, packedIP)
c.port = struct.unpack(b">H", ser_read(f, 2))[0]
return c
def stream_deserialize(cls, f, without_time=False):
c = cls()
if c.protover >= CADDR_TIME_VERSION and not without_time:
c.nTime = struct.unpack(b"<I", ser_read(f, 4))[0]
c.nServices = struct.unpack(b"<Q", ser_read(f, 8))[0]
packedIP = ser_read(f, 16)
if bytes(packedIP[0:12]) == IPV4_COMPAT: # IPv4
c.ip = socket.inet_ntop(socket.AF_INET, packedIP[12:16])
else: #IPv6
c.ip = socket.inet_ntop(socket.AF_INET6, packedIP)
c.port = struct.unpack(b">H", ser_read(f, 2))[0]
return c
def deserialize_prefix(self, f):
"""Deserialize the transaction prefix."""
txin_count = VarIntSerializer.stream_deserialize(f)
txins = []
for i in range(txin_count):
txin = TxIn()
txin.deserialize_prefix(f)
txins.append(txin)
txouts = VectorSerializer.stream_deserialize(TxOut, f)
locktime = struct.unpack(b'<I', ser_read(f, 4))[0]
expiry = struct.unpack(b'<I', ser_read(f, 4))[0]
self.txins = list(txins)
self.txouts = list(txouts)
self.locktime = locktime
self.expiry = expiry
def vars_to_tx_version(version_value, serialization_type):
"""Converts serialization type and tx version into a 32 bit int."""
f = BytesIO()
f.write(struct.pack(b'<H', version_value))
f.write(struct.pack(b'<H', serialization_type))
f.seek(0)
version = struct.unpack(b'<i', ser_read(f, 4))[0]
return version
def stream_deserialize(cls, f):
val = ser_read(f, 1)[0]
mask = 0x80 & val
flag = True if mask is 0x80 else False
r = val & 0x7f
if r < 0x7c:
val = r
elif r == 0x7c:
val = ser_read(f, 1)[0]
elif r == 0x7d:
val = struct.unpack(b'<H', ser_read(f, 2))[0]
elif r == 0x7e:
val = struct.unpack(b'<I', ser_read(f, 4))[0]
elif val == 0x7f:
raise SeparatorByteSignal(FlagVarIntSerializer.Separator.EOL)
elif val == 0xff:
raise SeparatorByteSignal(FlagVarIntSerializer.Separator.EOF)
return val, flag
def stream_deserialize(cls, f):
self = super(CAuxPow, cls).stream_deserialize(f)
hashBlock = ser_read(f, 32)
vMerkleBranch = uint256VectorSerializer.stream_deserialize(f)
nIndex = struct.unpack(b"<I", ser_read(f, 4))[0]
vChainMerkleBranch = uint256VectorSerializer.stream_deserialize(f)
nChainIndex = struct.unpack(b"<I", ser_read(f, 4))[0]
parentBlockHeader = CAltcoinBlockHeader.stream_deserialize(f)
object.__setattr__(self, 'hashBlock', hashBlock)
object.__setattr__(self, 'vMerkleBranch', vMerkleBranch)
object.__setattr__(self, 'nIndex', nIndex)
object.__setattr__(self, 'vChainMerkleBranch', vChainMerkleBranch)
object.__setattr__(self, 'nChainIndex', nChainIndex)
object.__setattr__(self, 'parentBlockHeader', parentBlockHeader)
return self
def deserialize_field(self, tx, kwargs, attr, fmt, num_bytes, f):
if fmt not in ['inputs', 'outputs', 'bytes']:
kwargs[attr] = struct.unpack(fmt, ser_read(f, num_bytes))[0]
elif fmt == 'inputs':
kwargs[attr] = VectorSerializer.stream_deserialize(CMutableTxIn, f)
elif fmt == 'outputs':
kwargs[attr] = VectorSerializer.stream_deserialize(CMutableTxOut, f)
elif fmt == 'bytes':
kwargs[attr] = BytesSerializer.stream_deserialize(f)
def stream_deserialize(cls, f):
self = super(CAuxPow, cls).stream_deserialize(f)
hashBlock = ser_read(f, 32)
vMerkleBranch = uint256VectorSerializer.stream_deserialize(f)
nIndex = struct.unpack(b"<I", ser_read(f, 4))[0]
vChainMerkleBranch = uint256VectorSerializer.stream_deserialize(f)
nChainIndex = struct.unpack(b"<I", ser_read(f, 4))[0]
parentBlockHeader = CAltcoinBlockHeader.stream_deserialize(f)
object.__setattr__(self, 'hashBlock', hashBlock)
object.__setattr__(self, 'vMerkleBranch', vMerkleBranch)
object.__setattr__(self, 'nIndex', nIndex)
object.__setattr__(self, 'vChainMerkleBranch', vChainMerkleBranch)
object.__setattr__(self, 'nChainIndex', nChainIndex)
object.__setattr__(self, 'parentBlockHeader', parentBlockHeader)
return self
def stream_deserialize(cls, f):
self = super(Block, cls).stream_deserialize(f)
for attr, fmt, num_bytes, _ in self.block_fields:
if fmt not in ['bytes', 'vectortx']:
setattr(self, attr, struct.unpack(fmt, ser_read(f, num_bytes))[0])
elif fmt == 'bytes':
setattr(self, attr, BytesSerializer.stream_deserialize(f))
elif fmt == 'vectortx':
setattr(self, attr, VectorSerializer.stream_deserialize(Transaction, f))
setattr(self, 'vMerkleTree', tuple(Block.build_merkle_tree_from_txs(getattr(self, 'vtx'))))
return self
def stream_deserialize(cls, f):
self = cls()
for attr, fmt, num_bytes, _ in self.fields:
if fmt not in ['inputs', 'outputs', 'bytes']:
setattr(self, attr, struct.unpack(fmt, ser_read(f, num_bytes))[0])
elif fmt == 'inputs':
setattr(self, attr, VectorSerializer.stream_deserialize(CTxIn, f))
elif fmt == 'outputs':
setattr(self, attr, VectorSerializer.stream_deserialize(CTxOut, f))
elif fmt == 'bytes':
setattr(self, attr, BytesSerializer.stream_deserialize(f))
return self
def stream_deserialize(cls, f, protover=PROTO_VERSION):
recvbuf = ser_read(f, 4 + 12 + 4 + 4)
# check magic
if recvbuf[:4] != bitcoin.params.MESSAGE_START:
raise ValueError("Invalid message start '%s', expected '%s'" %
(b2x(recvbuf[:4]), b2x(bitcoin.params.MESSAGE_START)))
# remaining header fields: command, msg length, checksum
command = recvbuf[4:4+12].split(b"\x00", 1)[0]
msglen = struct.unpack(b"<i", recvbuf[4+12:4+12+4])[0]
checksum = recvbuf[4+12+4:4+12+4+4]
return MsgHeader(command, msglen, checksum)
def stream_deserialize(cls, f):
c = cls()
c.nVersion = struct.unpack(b"<i", ser_read(f,4))[0]
c.nRelayUntil = struct.unpack(b"<q", ser_read(f,8))[0]
c.nExpiration = struct.unpack(b"<q", ser_read(f,8))[0]
c.nID = struct.unpack(b"<i", ser_read(f,4))[0]
c.nCancel = struct.unpack(b"<i", ser_read(f,4))[0]
c.setCancel = intVectorSerializer.deserialize(f)
c.nMinVer = struct.unpack(b"<i", ser_read(f,4))[0]
c.nMaxVer = struct.unpack(b"<i", ser_read(f,4))[0]
c.setSubVer = intVectorSerializer.deserialize(f)
c.nPriority = struct.unpack(b"<i", ser_read(f,4))[0]
c.strComment = VarStringSerializer.deserialize(f)
c.strStatusBar = VarStringSerializer.deserialize(f)
c.strReserved = VarStringSerializer.deserialize(f)
return c
def stream_deserialize(cls, f, protover=PROTO_VERSION):
recvbuf = ser_read(f, 4 + 12 + 4 + 4)
# check magic
if recvbuf[:4] != bitcoin.params.MESSAGE_START:
raise ValueError(
"Invalid message start '%s', expected '%s'" %
(b2x(recvbuf[:4]), b2x(bitcoin.params.MESSAGE_START)))
# remaining header fields: command, msg length, checksum
command = recvbuf[4:4 + 12].split(b"\x00", 1)[0]
msglen = struct.unpack(b"<i", recvbuf[4 + 12:4 + 12 + 4])[0]
checksum = recvbuf[4 + 12 + 4:4 + 12 + 4 + 4]
return MsgHeader(command, msglen, checksum)
def stream_deserialize(cls, f):
def bits(f, n):
ret = []
bytes = (ord(b) for b in f.read(n))
for b in bytes:
for i in xrange(8):
ret.append((b >> i) & 1)
return ret
self = super(CMerkleBlock, cls).stream_deserialize(f)
nTX = struct.unpack('<L', ser_read(f, 4))[0]
nHashes = VarIntSerializer.stream_deserialize(f)
vHashes = []
for i in range(nHashes):
vHashes.append(ser_read(f, 32))
nFlags = VarIntSerializer.stream_deserialize(f)
vFlags = bits(f, nFlags)
object.__setattr__(self, 'nTX', nTX)
object.__setattr__(self, 'vHashes', vHashes)
object.__setattr__(self, 'vFlags', vFlags)
return self
def stream_deserialize(cls, f):
c = cls()
c.nVersion = struct.unpack(b"<i", ser_read(f, 4))[0]
c.nRelayUntil = struct.unpack(b"<q", ser_read(f, 8))[0]
c.nExpiration = struct.unpack(b"<q", ser_read(f, 8))[0]
c.nID = struct.unpack(b"<i", ser_read(f, 4))[0]
c.nCancel = struct.unpack(b"<i", ser_read(f, 4))[0]
c.setCancel = intVectorSerialzer.deserialize(f)
c.nMinVer = struct.unpack(b"<i", ser_read(f, 4))[0]
c.nMaxVer = struct.unpack(b"<i", ser_read(f, 4))[0]
c.setSubVer = VarStringSerializer.deserialize(f)
c.nPriority = struct.unpack(b"<i", ser_read(f, 4))[0]
c.strComment = VarStringSerializer.deserialize(f)
c.strStatusBar = VarStringSerializer.deserialize(f)
c.strReserved = VarStringSerializer.deserialize(f)
return c
def stream_deserialize(cls, f):
def bits(f, n):
ret = []
bytes = (ord(b) for b in f.read(n))
for b in bytes:
for i in xrange(8):
ret.append((b >> i) & 1)
return ret
self = super(CMerkleBlock, cls).stream_deserialize(f)
nTX = struct.unpack('<L', ser_read(f, 4))[0]
nHashes = VarIntSerializer.stream_deserialize(f)
vHashes = []
for i in range(nHashes):
vHashes.append(ser_read(f, 32))
nFlags = VarIntSerializer.stream_deserialize(f)
vFlags = bits(f, nFlags)
object.__setattr__(self, 'nTX', nTX)
object.__setattr__(self, 'vHashes', vHashes)
object.__setattr__(self, 'vFlags', vFlags)
return self
def stream_deserialize(cls, f):
self = cls()
self.version = struct.unpack(b'<i', ser_read(f, 4))[0]
_, ser_type = tx_version_to_vars(self.version)
if ser_type == TX_SERIALIZE_NO_WITNESS:
self.deserialize_prefix(f)
elif ser_type == TX_SERIALIZE_ONLY_WITNESS:
self.deserialize_witness(f, False)
elif ser_type == TX_SERIALIZE_WITNESS_SIGNING:
self.deserialize_witness_signing(f)
elif ser_type == TX_SERIALIZE_WITNESS_VALUE_SIGNING:
self.deserialize_witness_value_signing(f)
elif ser_type == TX_SERIALIZE_FULL:
self.deserialize_prefix(f)
self.deserialize_witness(f, True)
else:
raise Exception('Unsupported transaction type.')
return self
def deserialize_prefix(self, f):
prev_out = OutPoint.stream_deserialize(f)
sequence = struct.unpack(b'<I', ser_read(f, 4))[0]
self.prev_out = prev_out
self.sequence = sequence
def stream_deserialize(cls, f):
hash = ser_read(f, 32)
vin = CTxIn.stream_deserialize(f)
sig = BytesSerializer.stream_deserialize(f)
height = struct.unpack(b"<I", ser_read(f, 4))[0]
return cls(hash, vin, sig, height)
def stream_deserialize(cls, f):
hash = ser_read(f, 32)
index = struct.unpack(b'<I', ser_read(f, 4))[0]
tree = struct.unpack(b'<b', ser_read(f, 1))[0]
return cls(hash, index, tree)
def stream_deserialize(cls, f):
merkleHash = ser_read(f, 32)
return cls(merkleHash)
def stream_deserialize(cls, f):
version = struct.unpack(b'<i', ser_read(f, 4))[0]
prev_block = ser_read(f, 32)
merkle_root = ser_read(f, 32)
stake_root = ser_read(f, 32)
vote_bits = struct.unpack(b'<H', ser_read(f, 2))[0]
final_state = ser_read(f, 6)
voters = struct.unpack(b'<H', ser_read(f, 2))[0]
fresh_stake = struct.unpack(b'<B', ser_read(f, 1))[0]
revocations = struct.unpack(b'<B', ser_read(f, 1))[0]
pool_size = struct.unpack(b'<I', ser_read(f, 4))[0]
bits = struct.unpack(b'<I', ser_read(f, 4))[0]
sbits = struct.unpack(b'<q', ser_read(f, 8))[0]
height = struct.unpack(b'<I', ser_read(f, 4))[0]
size = struct.unpack(b'<I', ser_read(f, 4))[0]
timestamp = struct.unpack(b'<I', ser_read(f, 4))[0]
nonce = struct.unpack(b'<I', ser_read(f, 4))[0]
extra_data = ser_read(f, 36)
return cls(version, prev_block, merkle_root, stake_root, vote_bits, final_state,
voters, fresh_stake, revocations, pool_size, bits, sbits, height,
size, timestamp, nonce, extra_data)
def stream_deserialize(cls, f):
value = struct.unpack(b'<q', ser_read(f, 8))[0]
version = struct.unpack(b'<H', ser_read(f, 2))[0]
pk_script = BytesSerializer.stream_deserialize(f)
return cls(value, version, pk_script)
def stream_deserialize(cls, f):
c = cls()
c.nVersion = struct.unpack(b"<i", ser_read(f, 4))[0]
c.vHave = uint256VectorSerializer.stream_deserialize(f)
return c
def deserialize_witness_value_signing(self, f):
value = struct.unpack(b'<q', ser_read(f, 8))[0]
sig_script = BytesSerializer.stream_deserialize(f)
self.value = value
self.sig_script = sig_script
def stream_deserialize(cls, f):
c = cls()
c.type = struct.unpack(b"<i", ser_read(f, 4))[0]
c.hash = ser_read(f, 32)
return c
def stream_deserialize(cls, f):
nonce = ser_read(f, HASH_LENGTH)
strPaymentInfo = VarStringSerializer.stream_deserialize(f)
host = VarStringSerializer.stream_deserialize(f)
port = struct.unpack(b">H", ser_read(f, 2))[0]
return cls(nonce, strPaymentInfo, host, port)
def stream_deserialize(cls, f):
nVersion = struct.unpack(b"<i", ser_read(f, 4))[0]
vInterested = VectorSerializer.stream_deserialize(CInterested, f)
return cls(vInterested=vInterested, protover=nVersion)
