Inside Bitcoin

751            self.hashMerkleRoot = header.hashMerkleRoot
752            self.nTime = header.nTime
753            self.nBits = header.nBits
754            self.nNonce = header.nNonce
755
756    def set_null(self):
757        self.nVersion = 4
758        self.hashPrevBlock = 0
759        self.hashMerkleRoot = 0
760        self.nTime = 0
761        self.nBits = 0
762        self.nNonce = 0
763
764    def deserialize(self, f):
765        self.nVersion = int.from_bytes(f.read(4), "little", signed=True)
766        self.hashPrevBlock = deser_uint256(f)
767        self.hashMerkleRoot = deser_uint256(f)
768        self.nTime = int.from_bytes(f.read(4), "little")
769        self.nBits = int.from_bytes(f.read(4), "little")
770        self.nNonce = int.from_bytes(f.read(4), "little")
771
772    def serialize(self):
773        return self._serialize_header()
774
775    def _serialize_header(self):
776        r = b""
777        r += self.nVersion.to_bytes(4, "little", signed=True)
778        r += ser_uint256(self.hashPrevBlock)
779        r += ser_uint256(self.hashMerkleRoot)
780        r += self.nTime.to_bytes(4, "little")
781        r += self.nBits.to_bytes(4, "little")
782        r += self.nNonce.to_bytes(4, "little")
783        return r
784
785    @property
786    def hash_hex(self):
787        """Return block header hash as hex string."""
788        return hash256(self._serialize_header())[::-1].hex()
789
790    @property
791    def hash_int(self):
792        """Return block header hash as integer."""
793        return uint256_from_str(hash256(self._serialize_header()))
794
795    def __repr__(self):
796        return "CBlockHeader(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x)" \
797            % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
798               time.ctime(self.nTime), self.nBits, self.nNonce)
799
800BLOCK_HEADER_SIZE = len(CBlockHeader().serialize())
801assert_equal(BLOCK_HEADER_SIZE, 80)
802
803class CBlock(CBlockHeader):
804    __slots__ = ("vtx",)
805
806    def __init__(self, header=None):
807        super().__init__(header)
808        self.vtx = []
809
810    def deserialize(self, f):
811        super().deserialize(f)
812        self.vtx = deser_vector(f, CTransaction)
813
814    def serialize(self, with_witness=True):
815        r = b""
816        r += super().serialize()
817        if with_witness:
818            r += ser_vector(self.vtx, "serialize_with_witness")
819        else:
820            r += ser_vector(self.vtx, "serialize_without_witness")
821        return r
822
823    # Calculate the merkle root given a vector of transaction hashes
824    @classmethod
825    def get_merkle_root(cls, hashes):
826        while len(hashes) > 1:
827            newhashes = []
828            for i in range(0, len(hashes), 2):
829                i2 = min(i+1, len(hashes)-1)
830                newhashes.append(hash256(hashes[i] + hashes[i2]))
831            hashes = newhashes
832        return uint256_from_str(hashes[0])
833
834    def calc_merkle_root(self):
835        hashes = []
836        for tx in self.vtx:
837            hashes.append(ser_uint256(tx.txid_int))
838        return self.get_merkle_root(hashes)
839
840    def calc_witness_merkle_root(self):
841        # For witness root purposes, the hash of the
842        # coinbase, with witness, is defined to be 0...0
843        hashes = [ser_uint256(0)]
844
845        for tx in self.vtx[1:]:
846            # Calculate the hashes with witness data
847            hashes.append(ser_uint256(tx.wtxid_int))
848
849        return self.get_merkle_root(hashes)
850
851    def is_valid(self):
852        target = uint256_from_compact(self.nBits)
853        if self.hash_int > target:
854            return False
855        for tx in self.vtx:
856            if not tx.is_valid():
857                return False
858        if self.calc_merkle_root() != self.hashMerkleRoot:
859            return False
860        return True
861
862    def solve(self):
863        target = uint256_from_compact(self.nBits)
864        while self.hash_int > target:
865            self.nNonce += 1
866
867    # Calculate the block weight using witness and non-witness
868    # serialization size (does NOT use sigops).
869    def get_weight(self):
870        with_witness_size = len(self.serialize(with_witness=True))
871        without_witness_size = len(self.serialize(with_witness=False))
872        return (WITNESS_SCALE_FACTOR - 1) * without_witness_size + with_witness_size
873
874    def __repr__(self):
875        return "CBlock(nVersion=%i hashPrevBlock=%064x hashMerkleRoot=%064x nTime=%s nBits=%08x nNonce=%08x vtx=%s)" \
876            % (self.nVersion, self.hashPrevBlock, self.hashMerkleRoot,
877               time.ctime(self.nTime), self.nBits, self.nNonce, repr(self.vtx))
878
879
880class PrefilledTransaction:
881    __slots__ = ("index", "tx")
882
883    def __init__(self, index=0, tx = None):
884        self.index = index
885        self.tx = tx
886
887    def deserialize(self, f):
888        self.index = deser_compact_size(f)
889        self.tx = CTransaction()
890        self.tx.deserialize(f)
891
892    def serialize(self, with_witness=True):
893        r = b""
894        r += ser_compact_size(self.index)
895        if with_witness:
896            r += self.tx.serialize_with_witness()
897        else:
898            r += self.tx.serialize_without_witness()
899        return r
900
901    def serialize_without_witness(self):
902        return self.serialize(with_witness=False)
903
904    def serialize_with_witness(self):
905        return self.serialize(with_witness=True)
906
907    def __repr__(self):
908        return "PrefilledTransaction(index=%d, tx=%s)" % (self.index, repr(self.tx))
909
910
911# This is what we send on the wire, in a cmpctblock message.
912class P2PHeaderAndShortIDs:
913    __slots__ = ("header", "nonce", "prefilled_txn", "prefilled_txn_length",
914                 "shortids", "shortids_length")
915
916    def __init__(self):
917        self.header = CBlockHeader()
918        self.nonce = 0
919        self.shortids_length = 0
920        self.shortids = []
921        self.prefilled_txn_length = 0
922        self.prefilled_txn = []
923
924    def deserialize(self, f):
925        self.header.deserialize(f)
926        self.nonce = int.from_bytes(f.read(8), "little")
927        self.shortids_length = deser_compact_size(f)
928        for _ in range(self.shortids_length):
929            # shortids are defined to be 6 bytes in the spec, so append
930            # two zero bytes and read it in as an 8-byte number
931            self.shortids.append(int.from_bytes(f.read(6) + b'\x00\x00', "little"))
932        self.prefilled_txn = deser_vector(f, PrefilledTransaction)
933        self.prefilled_txn_length = len(self.prefilled_txn)
934
935    # When using version 2 compact blocks, we must serialize with_witness.
936    def serialize(self, with_witness=False):
937        r = b""
938        r += self.header.serialize()
939        r += self.nonce.to_bytes(8, "little")
940        r += ser_compact_size(self.shortids_length)
941        for x in self.shortids:
942            # We only want the first 6 bytes
943            r += x.to_bytes(8, "little")[0:6]
944        if with_witness:
945            r += ser_vector(self.prefilled_txn, "serialize_with_witness")
946        else:
947            r += ser_vector(self.prefilled_txn, "serialize_without_witness")
948        return r
949
950    def __repr__(self):
951        return "P2PHeaderAndShortIDs(header=%s, nonce=%d, shortids_length=%d, shortids=%s, prefilled_txn_length=%d, prefilledtxn=%s" % (repr(self.header), self.nonce, self.shortids_length, repr(self.shortids), self.prefilled_txn_length, repr(self.prefilled_txn))
952
953
954# P2P version of the above that will use witness serialization (for compact
955# block version 2)
956class P2PHeaderAndShortWitnessIDs(P2PHeaderAndShortIDs):
957    __slots__ = ()
958    def serialize(self):
959        return super().serialize(with_witness=True)
960
961# Calculate the BIP 152-compact blocks shortid for a given transaction hash
962def calculate_shortid(k0, k1, tx_hash):
963    expected_shortid = siphash256(k0, k1, tx_hash)
964    expected_shortid &= 0x0000ffffffffffff
965    return expected_shortid
966
967
968# This version gets rid of the array lengths, and reinterprets the differential
969# encoding into indices that can be used for lookup.
970class HeaderAndShortIDs:
971    __slots__ = ("header", "nonce", "prefilled_txn", "shortids", "use_witness")
972
973    def __init__(self, p2pheaders_and_shortids = None):
974        self.header = CBlockHeader()
975        self.nonce = 0
976        self.shortids = []
977        self.prefilled_txn = []
978        self.use_witness = False
979
980        if p2pheaders_and_shortids is not None:
981            self.header = p2pheaders_and_shortids.header
982            self.nonce = p2pheaders_and_shortids.nonce
983            self.shortids = p2pheaders_and_shortids.shortids
984            last_index = -1
985            for x in p2pheaders_and_shortids.prefilled_txn:
986                self.prefilled_txn.append(PrefilledTransaction(x.index + last_index + 1, x.tx))
987                last_index = self.prefilled_txn[-1].index
988
989    def to_p2p(self):
990        if self.use_witness:
991            ret = P2PHeaderAndShortWitnessIDs()
992        else:
993            ret = P2PHeaderAndShortIDs()
994        ret.header = self.header
995        ret.nonce = self.nonce
996        ret.shortids_length = len(self.shortids)
997        ret.shortids = self.shortids
998        ret.prefilled_txn_length = len(self.prefilled_txn)
999        ret.prefilled_txn = []
1000        last_index = -1