def serialize_prefix(self, f):
VarIntSerializer.stream_serialize(len(self.txins), f)
for txin in self.txins:
txin.serialize_prefix(f)
VectorSerializer.stream_serialize(TxOut, self.txouts, f)
f.write(struct.pack(b'<I', self.locktime))
f.write(struct.pack(b'<I', self.expiry))
def serialize_field(self, tx, attr, fmt, num_bytes, f):
if fmt not in ['inputs', 'outputs', 'bytes']:
f.write(struct.pack(fmt, getattr(tx, attr)))
elif fmt == 'inputs':
VectorSerializer.stream_serialize(CMutableTxIn, tx.vin, f)
elif fmt == 'outputs':
VectorSerializer.stream_serialize(CMutableTxOut, tx.vout, f)
elif fmt == 'bytes':
BytesSerializer.stream_serialize(getattr(tx, attr), f)
def stream_serialize(self, f):
super(Block, self).stream_serialize(f)
for attr, fmt, num_bytes, _ in self.block_fields:
if fmt not in ['bytes', 'vectortx']:
f.write(struct.pack(fmt, getattr(self, attr)))
elif fmt == 'bytes':
BytesSerializer.stream_serialize(getattr(self, attr), f)
elif fmt == 'vectortx':
VectorSerializer.stream_serialize(Transaction, getattr(self, attr), f)
def stream_serialize(self, f):
for attr, fmt, num_bytes, _ in self.fields:
if fmt not in ['inputs', 'outputs', 'bytes']:
f.write(struct.pack(fmt, getattr(self, attr)))
elif fmt == 'inputs':
VectorSerializer.stream_serialize(CTxIn, self.vin, f)
elif fmt == 'outputs':
VectorSerializer.stream_serialize(CTxOut, self.vout, f)
elif fmt == 'bytes':
BytesSerializer.stream_serialize(getattr(self, attr), f)
def stream_serialize(self, f):
for attr, fmt, num_bytes, _ in self.fields:
if fmt not in ["inputs", "outputs", "bytes"]:
f.write(struct.pack(fmt, getattr(self, attr)))
elif fmt == "inputs":
VectorSerializer.stream_serialize(CTxIn, self.vin, f)
elif fmt == "outputs":
VectorSerializer.stream_serialize(CTxOut, self.vout, f)
elif fmt == "bytes":
BytesSerializer.stream_serialize(getattr(self, attr), f)
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 stream_serialize(self, f):
f.write(struct.pack(b"<i", self.nVersion))
VectorSerializer.stream_serialize(CInterested, self.vInterested, f)
def stream_serialize(self, f):
super(CAltcoinBlock, self).stream_serialize(f)
VectorSerializer.stream_serialize(CTransaction, self.vtx, f)
def stream_serialize(self, f):
super(Block, self).stream_serialize(f)
VectorSerializer.stream_serialize(Transaction, self.vtx, f)
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):
super(Block, self).stream_serialize(f)
VectorSerializer.stream_serialize(Transaction, self.txs, f)
VectorSerializer.stream_serialize(Transaction, self.stxs, f)
def stream_serialize(self, f, **kwargs):
# Serialize proof header
# - version with flag
ver = self.ver if self.ver is not None else 0
flag = self.format is ProofFormat.root or self.format is ProofFormat.upgrade
FlagVarIntSerializer.stream_serialize((ver, flag), f)
# - root proof fields
if self.format is ProofFormat.root:
self.schema.stream_serialize(f)
VarIntSerializer.stream_serialize(self.network.value, f)
self.root.stream_serialize(f, short_form=False)
# - version upgrade proof fields
elif self.format is ProofFormat.upgrade:
if self.schema is not None:
self.schema.stream_serialize(f)
else:
ZeroBytesSerializer.stream_serialize(32, f)
ZeroBytesSerializer.stream_serialize(1, f)
# Serialize proof body
# - serializing proof type
if self.type_no is None:
raise ValueError(
'proof consensus serialization requires `type_no` to be known')
f.write(bytes([self.type_no]))
# - writing `seal_sequence` structure
current_type_no = None
for seal in self.seals:
if current_type_no is None:
current_type_no = seal.type_no
elif seal.type_no is not current_type_no:
# -- writing EOL byte to signify the change of the type
[
f.write(bytes([0x7F]))
for n in range(current_type_no, seal.type_no)
]
current_type_no = seal.type_no
seal.stream_serialize(f, state=False)
f.write(bytes([0xFF]))
# - writing raw data for the sealed state
length = reduce(
(lambda acc, seal: acc + len(seal.serialize({'state': True}))),
[0] + self.seals)
VarIntSerializer.stream_serialize(length, f)
[seal.stream_serialize(f, state=True) for seal in self.seals]
# - writing raw data for all metafields
length = reduce((lambda acc, field: acc + len(field.serialize())),
[0] + self.fields)
VarIntSerializer.stream_serialize(length, f)
[field.stream_serialize(f) for field in self.fields]
# Serialize original public key
if self.pubkey is not None:
self.pubkey.stream_serialize(f)
else:
ZeroBytesSerializer.stream_serialize(1, f)
# Serialize prunable data
if self.txid is not None:
if self.parents is not None:
f.write(bytes(0x03))
self.txid.stream_serialize(f)
else:
f.write(bytes(0x01))
VectorSerializer.stream_serialize(Hash256Id, self.parents, f)
elif self.parents is not None:
f.write(bytes(0x02))
VectorSerializer.stream_serialize(Hash256Id, self.parents, f)
else:
f.write(bytes(0x00))
def msg_ser(self, f):
VectorSerializer.stream_serialize(CInv, self.inv, f)
