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 stream_serialize(self, f):
VarIntSerializer.stream_serialize(len(self.pubkeys), f)
for pubkey in self.pubkeys:
pubkey_bytes = pubkey.to_bytes()
assert len(pubkey_bytes) == PUB_KEY_LENGTH
f.write(pubkey_bytes)
# BytesSerializer.stream_serialize(pubkey, f)
f.write(struct.pack(b"<i", self.nMinBlockHeight))
f.write(struct.pack(b"<i", self.nMaxBlockHeight))
assert len(self.hashReplySqk) == HASH_LENGTH
f.write(self.hashReplySqk)
def stream_serialize(self, f):
super(CMerkleBlock, self).stream_serialize(f)
f.write(struct.pack('<L', self.nTX))
VarIntSerializer.stream_serialize(len(self.vHashes), f)
for hash in self.vHashes:
f.write(hash)
VarIntSerializer.stream_serialize(len(self.vFlags)/8, f)
bin_string = ""
for bit in self.vFlags:
bin_string += str(bit)
if len(bin_string) == 8:
f.write(struct.pack('B', int(bin_string[::-1], 2)))
bin_string = ""
def stream_serialize(self, f):
super(CMerkleBlock, self).stream_serialize(f)
f.write(struct.pack('<L', self.nTX))
VarIntSerializer.stream_serialize(len(self.vHashes), f)
for hash in self.vHashes:
f.write(hash)
VarIntSerializer.stream_serialize(len(self.vFlags) / 8, f)
bin_string = ""
for bit in self.vFlags:
bin_string += str(bit)
if len(bin_string) == 8:
f.write(struct.pack('B', int(bin_string[::-1], 2)))
bin_string = ""
def on_tx_selection(self, selected, deselected):
if not self.block or not len(selected.indexes()):
return
index = selected.indexes()[0]
row = index.row()
def tx_len(i):
return len(self.block.vtx[i].serialize()) * 2
start = BlockHeader.header_length() * 2 + sum(tx_len(i) for i in range(row))
# Account for VarInt.
_buf = BytesIO()
VarIntSerializer.stream_serialize(len(self.block.vtx), _buf)
start += len(_buf.getvalue()) * 2
length = len(self.block.vtx[row].serialize()) * 2
self.select_block_text(start, length)
def on_tx_selection(self, selected, deselected):
if not self.block or not len(selected.indexes()):
return
index = selected.indexes()[0]
row = index.row()
def tx_len(i):
return len(self.block.vtx[i].serialize()) * 2
start = BlockHeader.header_length() * 2 + sum(
tx_len(i) for i in range(row))
# Account for VarInt.
_buf = BytesIO()
VarIntSerializer.stream_serialize(len(self.block.vtx), _buf)
start += len(_buf.getvalue()) * 2
length = len(self.block.vtx[row].serialize()) * 2
self.select_block_text(start, length)
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 serialize_witness_value_signing(self, f):
VarIntSerializer.stream_serialize(len(self.txins), f)
for txin in self.txins:
txin.serialize_witness_value_signing(f)
def serialize_witness(self, f):
VarIntSerializer.stream_serialize(len(self.txins), f)
for txin in self.txins:
txin.serialize_witness(f)
def stream_serialize_state(self, state, f):
if self.type is SealType.Type.balance:
VarIntSerializer.stream_serialize(state, 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 stream_serialize(self, f):
VarIntSerializer.stream_serialize(self.type_pos, f)
f.write(bytes([self.bounds.min()]))
f.write(bytes([self.bounds.max()]))
