Inside Bitcoin

501    def __init__(self, outpoint=None, scriptSig=b"", nSequence=0):
502        if outpoint is None:
503            self.prevout = COutPoint()
504        else:
505            self.prevout = outpoint
506        self.scriptSig = scriptSig
507        self.nSequence = nSequence
508
509    def deserialize(self, f):
510        self.prevout = COutPoint()
511        self.prevout.deserialize(f)
512        self.scriptSig = deser_string(f)
513        self.nSequence = int.from_bytes(f.read(4), "little")
514
515    def serialize(self):
516        r = b""
517        r += self.prevout.serialize()
518        r += ser_string(self.scriptSig)
519        r += self.nSequence.to_bytes(4, "little")
520        return r
521
522    def __repr__(self):
523        return "CTxIn(prevout=%s scriptSig=%s nSequence=%i)" \
524            % (repr(self.prevout), self.scriptSig.hex(),
525               self.nSequence)
526
527
528class CTxOut:
529    __slots__ = ("nValue", "scriptPubKey")
530
531    def __init__(self, nValue=0, scriptPubKey=b""):
532        self.nValue = nValue
533        self.scriptPubKey = scriptPubKey
534
535    def deserialize(self, f):
536        self.nValue = int.from_bytes(f.read(8), "little", signed=True)
537        self.scriptPubKey = deser_string(f)
538
539    def serialize(self):
540        r = b""
541        r += self.nValue.to_bytes(8, "little", signed=True)
542        r += ser_string(self.scriptPubKey)
543        return r
544
545    def __repr__(self):
546        return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" \
547            % (self.nValue // COIN, self.nValue % COIN,
548               self.scriptPubKey.hex())
549
550
551class CScriptWitness:
552    __slots__ = ("stack",)
553
554    def __init__(self):
555        # stack is a vector of strings
556        self.stack = []
557
558    def __repr__(self):
559        return "CScriptWitness(%s)" % \
560               (",".join([x.hex() for x in self.stack]))
561
562    def is_null(self):
563        if self.stack:
564            return False
565        return True
566
567
568class CTxInWitness:
569    __slots__ = ("scriptWitness",)
570
571    def __init__(self):
572        self.scriptWitness = CScriptWitness()
573
574    def deserialize(self, f):
575        self.scriptWitness.stack = deser_string_vector(f)
576
577    def serialize(self):
578        return ser_string_vector(self.scriptWitness.stack)
579
580    def __repr__(self):
581        return repr(self.scriptWitness)
582
583    def is_null(self):
584        return self.scriptWitness.is_null()
585
586
587class CTxWitness:
588    __slots__ = ("vtxinwit",)
589
590    def __init__(self):
591        self.vtxinwit = []
592
593    def deserialize(self, f):
594        for i in range(len(self.vtxinwit)):
595            self.vtxinwit[i].deserialize(f)
596
597    def serialize(self):
598        r = b""
599        # This is different than the usual vector serialization --
600        # we omit the length of the vector, which is required to be
601        # the same length as the transaction's vin vector.
602        for x in self.vtxinwit:
603            r += x.serialize()
604        return r
605
606    def __repr__(self):
607        return "CTxWitness(%s)" % \
608               (';'.join([repr(x) for x in self.vtxinwit]))
609
610    def is_null(self):
611        for x in self.vtxinwit:
612            if not x.is_null():
613                return False
614        return True
615
616
617class CTransaction:
618    __slots__ = ("nLockTime", "version", "vin", "vout", "wit")
619
620    def __init__(self, tx=None):
621        if tx is None:
622            self.version = 2
623            self.vin = []
624            self.vout = []
625            self.wit = CTxWitness()
626            self.nLockTime = 0
627        else:
628            self.version = tx.version
629            self.vin = copy.deepcopy(tx.vin)
630            self.vout = copy.deepcopy(tx.vout)
631            self.nLockTime = tx.nLockTime
632            self.wit = copy.deepcopy(tx.wit)
633
634    def deserialize(self, f):
635        self.version = int.from_bytes(f.read(4), "little")
636        self.vin = deser_vector(f, CTxIn)
637        flags = 0
638        if len(self.vin) == 0:
639            flags = int.from_bytes(f.read(1), "little")
640            # Not sure why flags can't be zero, but this
641            # matches the implementation in bitcoind
642            if (flags != 0):
643                self.vin = deser_vector(f, CTxIn)
644                self.vout = deser_vector(f, CTxOut)
645        else:
646            self.vout = deser_vector(f, CTxOut)
647        if flags != 0:
648            self.wit.vtxinwit = [CTxInWitness() for _ in range(len(self.vin))]
649            self.wit.deserialize(f)
650        else:
651            self.wit = CTxWitness()
652        self.nLockTime = int.from_bytes(f.read(4), "little")
653
654    def serialize_without_witness(self):
655        r = b""
656        r += self.version.to_bytes(4, "little")
657        r += ser_vector(self.vin)
658        r += ser_vector(self.vout)
659        r += self.nLockTime.to_bytes(4, "little")
660        return r
661
662    # Only serialize with witness when explicitly called for
663    def serialize_with_witness(self):
664        flags = 0
665        if not self.wit.is_null():
666            flags |= 1
667        r = b""
668        r += self.version.to_bytes(4, "little")
669        if flags:
670            dummy = []
671            r += ser_vector(dummy)
672            r += flags.to_bytes(1, "little")
673        r += ser_vector(self.vin)
674        r += ser_vector(self.vout)
675        if flags & 1:
676            if (len(self.wit.vtxinwit) != len(self.vin)):
677                # vtxinwit must have the same length as vin
678                self.wit.vtxinwit = self.wit.vtxinwit[:len(self.vin)]
679                for _ in range(len(self.wit.vtxinwit), len(self.vin)):
680                    self.wit.vtxinwit.append(CTxInWitness())
681            r += self.wit.serialize()
682        r += self.nLockTime.to_bytes(4, "little")
683        return r
684
685    # Regular serialization is with witness -- must explicitly
686    # call serialize_without_witness to exclude witness data.
687    def serialize(self):
688        return self.serialize_with_witness()
689
690    @property
691    def wtxid(self):
692        """Return wtxid (transaction hash with witness) as little-endian bytes."""
693        return hash256(self.serialize_with_witness())
694
695    @property
696    def wtxid_hex(self):
697        """Return wtxid (transaction hash with witness) as hex string."""
698        return self.wtxid[::-1].hex()
699
700    @property
701    def wtxid_int(self):
702        """Return wtxid (transaction hash with witness) as integer."""
703        return uint256_from_str(self.wtxid)
704
705    @property
706    def txid(self):
707        """Return txid (transaction hash without witness) as little-endian bytes."""
708        return hash256(self.serialize_without_witness())
709
710    @property
711    def txid_hex(self):
712        """Return txid (transaction hash without witness) as hex string."""
713        return self.txid[::-1].hex()
714
715    @property
716    def txid_int(self):
717        """Return txid (transaction hash without witness) as integer."""
718        return uint256_from_str(self.txid)
719
720    def is_valid(self):
721        for tout in self.vout:
722            if tout.nValue < 0 or tout.nValue > 21000000 * COIN:
723                return False
724        return True
725
726    # Calculate the transaction weight using witness and non-witness
727    # serialization size (does NOT use sigops).
728    def get_weight(self):
729        with_witness_size = len(self.serialize_with_witness())
730        without_witness_size = len(self.serialize_without_witness())
731        return (WITNESS_SCALE_FACTOR - 1) * without_witness_size + with_witness_size
732
733    def get_vsize(self):
734        return math.ceil(self.get_weight() / WITNESS_SCALE_FACTOR)
735
736    def __repr__(self):
737        return "CTransaction(version=%i vin=%s vout=%s wit=%s nLockTime=%i)" \
738            % (self.version, repr(self.vin), repr(self.vout), repr(self.wit), self.nLockTime)
739
740
741class CBlockHeader:
742    __slots__ = ("hashMerkleRoot", "hashPrevBlock", "nBits", "nNonce",
743                 "nTime", "nVersion")
744
745    def __init__(self, header=None):
746        if header is None:
747            self.set_null()
748        else:
749            self.nVersion = header.nVersion
750            self.hashPrevBlock = header.hashPrevBlock