def stream_serialize(self, f):
OutPoint.stream_serialize(self.prev_out, f)
f.write(struct.pack(b'<I', self.sequence))
f.write(struct.pack(b'<q', self.value))
f.write(struct.pack(b'<I', self.block_height))
f.write(struct.pack(b'<I', self.block_index))
BytesSerializer.stream_serialize(self.sig_script, f)
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, **kwargs):
state = kwargs['state'] if 'state' in kwargs else False
if state is True:
if self.seal_type is not None:
self.seal_type.stream_serialize_state(self.state, f)
elif self.state is not None:
BytesSerializer.stream_serialize(self.state, f)
else:
raise SchemaError(
f'''Unable to consensus-serialize sealed state: no binary state and no schema seal type are
provided for the value `{self.dict_state}`
''')
else:
self.outpoint.stream_serialize(f, short=True)
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):
f.write(struct.pack(b'<q', self.value))
f.write(struct.pack(b'<H', self.version))
BytesSerializer.stream_serialize(self.pk_script, f)
def serialize_witness_value_signing(self, f):
f.write(struct.pack(b'<q', self.value))
BytesSerializer.stream_serialize(self.sig_script, f)
def serialize_witness_signing(self, f):
BytesSerializer.stream_serialize(self.sig_script, f)
def serialize_witness(self, f):
f.write(struct.pack(b'<q', self.value))
f.write(struct.pack(b'<I', self.block_height))
f.write(struct.pack(b'<I', self.block_index))
BytesSerializer.stream_serialize(self.sig_script, f)
def stream_serialize(self, f):
f.write(self.hash)
f.write(self.vin.stream_serialize())
BytesSerializer.stream_serialize(self.sig, f)
f.write(struct.pack(b"<I", self.height))
def stream_serialize(self, f):
f.write(self.hash)
f.write(self.vin.stream_serialize())
BytesSerializer.stream_serialize(self.sig, f)
f.write(struct.pack(b"<I", self.height))
