def stream_deserialize(cls, f): self = super(Block, cls).stream_deserialize(f) txs = VectorSerializer.stream_deserialize(Transaction, f) stxs = VectorSerializer.stream_deserialize(Transaction, f) self.txs = list(txs) self.stxs = list(stxs) return self
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 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_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_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): self = super(Block, cls).stream_deserialize(f) vtx = VectorSerializer.stream_deserialize(Transaction, f) vMerkleTree = tuple(Block.build_merkle_tree_from_txs(vtx)) setattr(self, 'vMerkleTree', vMerkleTree) setattr(self, 'vtx', tuple(vtx)) return self
def stream_deserialize(cls, f): self = super(CAltcoinBlock, cls).stream_deserialize(f) vtx = VectorSerializer.stream_deserialize(CTransaction, f) vMerkleTree = tuple(bitcoin.core.CBlock.build_merkle_tree_from_txs(vtx)) object.__setattr__(self, 'vMerkleTree', vMerkleTree) object.__setattr__(self, 'vtx', tuple(vtx)) 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_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 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 stream_serialize(self, f): f.write(struct.pack(b"<i", self.nVersion)) VectorSerializer.stream_serialize(CInterested, self.vInterested, f)
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)
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_deserialize(cls, f, **kwargs): schema_obj = kwargs['schema_obj'] if 'schema_obj' in kwargs else None if not isinstance(schema_obj, Schema): raise ValueError( f'`schema_obj` parameter must be of Schema type; got `{schema_obj}` instead' ) # Deserialize proof header # - version with flag (ver, flag) = FlagVarIntSerializer.stream_deserialize(f) # - fields common for root and upgrade proofs if flag: schema = Hash256Id.stream_deserialize(f) network = VarIntSerializer.stream_deserialize(f) if network is 0x00: format = ProofFormat.upgrade # - root-specific fields else: network = Network(network) format = ProofFormat.root root = OutPoint.stream_deserialize(f, short=False) else: format = ProofFormat.ordinary # Deserialize proof body # - reading proof type type_no = ser_read(f, 1)[0] # - reading `seal_sequence` structure seals = [] seal_type_no = 0 # -- we iterate over the seals until 0xFF (=FlagVarIntSerializer.Separator.EOF) byte is met while True: try: # -- reading seal with the current type number seal = Seal.stream_deserialize(f, type_no=seal_type_no, schema_obj=schema_obj) 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_eol", None)): raise if ex.is_eol(): # -- met 0xFE separator byte, increasing current type number seal_type_no = seal_type_no + 1 elif ex.is_eof(): # -- end of `seal_sequence` structure break else: # -- otherwise append read seal to the list of seals seals.append(seal) # -- if we had zero seals implies proof of state destruction format if len(seals) is 0: format = ProofFormat.burn # - reading unparsed state and metadata bytes state = BytesSerializer.stream_deserialize(f) metadata = BytesSerializer.stream_deserialize(f) # Deserialize original public key pkcode = ser_read(f, 1) if pkcode is 0x00: pubkey = None else: buf = pkcode + ser_read(f, 32) pubkey = PubKey.deserialize(buf) # Deserialize prunable data try: pruned_flag = ser_read(f, 1) except: pruned_flag = 0x00 txid, parents = None, None if pruned_flag & 0x01 > 0: txid = Hash256Id.stream_deserialize(f) if pruned_flag & 0x02 > 0: parents = VectorSerializer.stream_deserialize(Hash256Id, f) proof = Proof(schema_obj=schema_obj, type_no=type_no, ver=ver, format=format, schema=schema, network=network, root=root, pubkey=pubkey, fields=None, seals=seals, txid=txid, parents=parents, metadata=metadata, state=state) # Parsing raw seals and metadata and resolving types against the provided Schema if 'schema_obj' in kwargs: schema_obj = kwargs['schema_obj'] if isinstance(schema_obj, Schema): proof.resolve_schema(schema_obj) return proof
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 msg_ser(self, f): VectorSerializer.stream_serialize(CInv, self.inv, 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 msg_deser(cls, f, protover=PROTO_VERSION): inv = VectorSerializer.stream_deserialize(CInv, f) return cls(inv)
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))