def stream_serialize(self, f):
VarStringSerializer.stream_serialize(self.name.encode('utf-8'), f)
self.schema_ver.stream_serialize(f)
self.prev_schema.stream_serialize(f)
VectorSerializer.stream_serialize(FieldType, self.field_types, f)
VectorSerializer.stream_serialize(SealType, self.seal_types, f)
VectorSerializer.stream_serialize(ProofType, self.proof_types, f)
def msg_ser(self, f):
f.write(struct.pack(b"<i", self.nVersion))
f.write(struct.pack(b"<Q", self.nServices))
f.write(struct.pack(b"<q", self.nTime))
self.addrTo.stream_serialize(f, True)
self.addrFrom.stream_serialize(f, True)
f.write(struct.pack(b"<Q", self.nNonce))
VarStringSerializer.stream_serialize(self.strSubVer, f)
f.write(struct.pack(b"<i", self.nStartingHeight))
f.write(struct.pack('?', self.relay))
def msg_ser(self, f):
f.write(struct.pack(b"<i", self.nVersion))
f.write(struct.pack(b"<Q", self.nServices))
f.write(struct.pack(b"<q", self.nTime))
self.addrTo.stream_serialize(f, True)
self.addrFrom.stream_serialize(f, True)
f.write(struct.pack(b"<Q", self.nNonce))
VarStringSerializer.stream_serialize(self.strSubVer, f)
f.write(struct.pack(b"<i", self.nStartingHeight))
f.write(struct.pack('?', self.relay))
def stream_serialize(self, f):
f.write(struct.pack(b"<i", self.nVersion))
f.write(struct.pack(b"<q", self.nRelayUntil))
f.write(struct.pack(b"<q", self.nExpiration))
f.write(struct.pack(b"<i", self.nID))
f.write(struct.pack(b"<i", self.nCancel))
f.write(intVectorSerializer.serialize(self.setCancel))
f.write(struct.pack(b"<i", self.nMinVer))
f.write(struct.pack(b"<i", self.nMaxVer))
f.write(intVectorSerializer.serialize(self.setSubVer))
f.write(struct.pack(b"<i", self.nPriority))
f.write(VarStringSerializer.serialize(self.strComment))
f.write(VarStringSerializer.serialize(self.strStatusBar))
f.write(VarStringSerializer.serialize(self.strReserved))
def stream_serialize(self, f):
f.write(struct.pack(b"<i", self.nVersion))
f.write(struct.pack(b"<q", self.nRelayUntil))
f.write(struct.pack(b"<q", self.nExpiration))
f.write(struct.pack(b"<i", self.nID))
f.write(struct.pack(b"<i", self.nCancel))
f.write(intVectorSerializer.serialize(self.setCancel))
f.write(struct.pack(b"<i", self.nMinVer))
f.write(struct.pack(b"<i", self.nMaxVer))
f.write(intVectorSerializer.serialize(self.setSubVer))
f.write(struct.pack(b"<i", self.nPriority))
f.write(VarStringSerializer.serialize(self.strComment))
f.write(VarStringSerializer.serialize(self.strStatusBar))
f.write(VarStringSerializer.serialize(self.strReserved))
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):
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):
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_serialize_value(self, value, f):
if value is None:
if self.type is FieldType.Type.str or self.type is FieldType.Type.bytes:
f.write(bytes([0x00]))
elif self.type is FieldType.Type.fvi:
f.write(bytes([0xFF]))
elif self.type in [FieldType.Type.sha256, FieldType.Type.sha256d]:
f.write(bytes([0]*32))
elif self.type in [FieldType.Type.ripmd160, FieldType.Type.hash160]:
f.write(bytes([0]*20))
elif self.type is FieldType.Type.pubkey:
f.write(bytes([0x00]))
elif self.type is FieldType.Type.ecdsa:
f.write(bytes([0x00]))
return
lut = {
FieldType.Type.u8: lambda x: f.write(bytes([x])),
FieldType.Type.u16: lambda x: f.write(struct.pack(b'<H', x)),
FieldType.Type.u32: lambda x: f.write(struct.pack(b'<I', x)),
FieldType.Type.u64: lambda x: f.write(struct.pack(b'<Q', x)),
FieldType.Type.i8: lambda x: f.write(bytes([x])),
FieldType.Type.i16: lambda x: f.write(struct.pack(b'<h', x)),
FieldType.Type.i32: lambda x: f.write(struct.pack(b'<i', x)),
FieldType.Type.i64: lambda x: f.write(struct.pack(b'<q', x)),
FieldType.Type.vi: lambda x: VarIntSerializer.stream_serialize(x, f),
FieldType.Type.fvi: lambda x: FlagVarIntSerializer.stream_serialize((x, False), f),
FieldType.Type.str: lambda x: VarStringSerializer.stream_serialize(x.encode('utf-8'), f),
FieldType.Type.bytes: lambda x: BytesSerializer.stream_serialize(x, f),
FieldType.Type.sha256: lambda x: x.stream_serealize(f),
FieldType.Type.sha256d: lambda x: x.stream_serealize(f),
FieldType.Type.ripmd160: lambda x: x.stream_serealize(f),
FieldType.Type.hash160: lambda x: x.stream_serealize(f),
FieldType.Type.pubkey: lambda x: x.stream_serealize(f),
FieldType.Type.ecdsa: lambda _: None,
}
if self.type in lut.keys():
if self.type in [FieldType.Type.sha256, FieldType.Type.sha256d,
FieldType.Type.ripmd160, FieldType.Type.hash160] and not issubclass(value, HashId):
raise ValueError('in order to serialize hash value you need to provide an instance of HashId class')
lut[self.type](value)
else:
raise NotImplementedError('ECDSA serialization is not implemented')
def stream_serialize(self, f):
VarStringSerializer.stream_serialize(self.vchMsg, f)
VarStringSerializer.stream_serialize(self.vchSig, f)
def stream_deserialize(cls, f):
c = cls()
c.vchMsg = VarStringSerializer.stream_deserialize(f)
c.vchSig = VarStringSerializer.stream_deserialize(f)
return c
def stream_serialize(self, f):
VarStringSerializer.stream_serialize(self.name.encode('utf-8'), f)
VectorSerializer.stream_serialize(TypeRef, self.fields, f)
VectorSerializer.stream_serialize(
TypeRef, [] if self.unseals is None else self.unseals, f)
VectorSerializer.stream_serialize(TypeRef, self.seals, f)
def stream_serialize(self, f):
VarStringSerializer.stream_serialize(self.vchMsg, f)
VarStringSerializer.stream_serialize(self.vchSig, f)
def stream_deserialize(cls, f):
c = cls()
c.vchMsg = VarStringSerializer.stream_deserialize(f)
c.vchSig = VarStringSerializer.stream_deserialize(f)
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_serialize(self, f, **kwargs):
VarStringSerializer.stream_serialize(self.name.encode('utf-8'), f)
f.write(bytes([self.type]))
def stream_deserialize(cls, f, **kwargs):
name = VarStringSerializer.stream_deserialize(f)
type_val = ser_read(f, 1)
return FieldType(name, FieldType.Type(type_val))
def stream_serialize(self, f):
assert len(self.nonce) == HASH_LENGTH
f.write(self.nonce)
VarStringSerializer.stream_serialize(self.strPaymentInfo, f)
VarStringSerializer.stream_serialize(self.host, f)
f.write(struct.pack(b">H", self.port))
def stream_deserialize(cls, f):
name = VarStringSerializer.deserialize(f)
