CTxWitness class, new message types

Author: Bob McElrath

bitcoin/core/__init__.py

@@ -306,12 +306,15 @@ def from_txout(cls, txout):
 
 
 class CTxInWitness(ImmutableSerializable):
-    """Witness data for a transaction input. """
+    """Witness data for a single transaction input. """
     __slots__ = ['scriptWitness']
 
     def __init__(self, scriptWitness=CScriptWitness()):
         object.__setattr__(self, 'scriptWitness', scriptWitness)
 
+    def is_null(self):
+        return self.scriptWitness.is_null()
+
     @classmethod
     def stream_deserialize(cls, f):
         scriptWitness = CScriptWitness.stream_deserialize(f)
@@ -336,12 +339,50 @@ def from_txinwitness(cls, txinwitness):
         else:
             return cls(txinwitness.scriptWitness)
 
+class CTxWitness(ImmutableSerializable):
+    """Witness data for all inputs to a transaction."""
+    __slots__ = ['vtxinwit']
+
+    def __init__(self, vtxinwit=()):
+        object.__setattr__(self, 'vtxinwit', vtxinwit)
+
+    def is_null(self):
+        for n in range(len(self.vtxinwit)):
+            if not self.vtxinwit[n].is_null(): return False
+        return True
+
+    # FIXME this cannot be a @classmethod like the others because we need to
+    # know how many items to deserialize, which comes from len(vin)
+    def stream_deserialize(self, f):
+        vtxinwit = tuple(CTxInWitness.stream_deserialize(f) for dummy in
+                range(len(self.vtxinwit)))
+        return CTxWitness(vtxinwit)
+
+    def stream_serialize(self, f):
+        for i in range(len(self.vtxinwit)):
+            self.vtxinwit[i].stream_serialize(f)
+
+    def __repr__(self):
+        return "CTxWitness(%s)" % (','.join(repr(w) for w in self.vtxinwit))
+
+    @classmethod
+    def from_txwitness(cls, txwitness):
+        """Create an immutable copy of an existing TxWitness
+
+        If txwitness is already immutable (txwitness.__class__ is CTxWitness) it is returned
+        directly.
+        """
+        if txwitness.__class__ is CTxWitness:
+            return txwitness
+        else:
+            return cls(txwitness.vtxinwit)
+
 
 class CTransaction(ImmutableSerializable):
     """A transaction"""
     __slots__ = ['nVersion', 'vin', 'vout', 'nLockTime', 'wit']
 
-    def __init__(self, vin=(), vout=(), nLockTime=0, nVersion=1, witness=()):
+    def __init__(self, vin=(), vout=(), nLockTime=0, nVersion=1, witness=CTxWitness()):
         """Create a new transaction
 
         vin and vout are iterables of transaction inputs and outputs
@@ -351,13 +392,10 @@ def __init__(self, vin=(), vout=(), nLockTime=0, nVersion=1, witness=()):
         if not (0 <= nLockTime <= 0xffffffff):
             raise ValueError('CTransaction: nLockTime must be in range 0x0 to 0xffffffff; got %x' % nLockTime)
         object.__setattr__(self, 'nLockTime', nLockTime)
-
         object.__setattr__(self, 'nVersion', nVersion)
         object.__setattr__(self, 'vin', tuple(CTxIn.from_txin(txin) for txin in vin))
         object.__setattr__(self, 'vout', tuple(CTxOut.from_txout(txout) for txout in vout))
-        object.__setattr__(self, 'wit',
-                tuple(CTxInWitness.from_txinwitness(witness) for txinwitness in
-                    witness))
+        object.__setattr__(self, 'wit', CTxWitness.from_txwitness(witness))
 
     @classmethod
     def stream_deserialize(cls, f):
@@ -370,7 +408,8 @@ def stream_deserialize(cls, f):
                 raise DeserializationFormatError
             vin = VectorSerializer.stream_deserialize(CTxIn, f)
             vout = VectorSerializer.stream_deserialize(CTxOut, f)
-            wit = VectorSerializer.stream_deserialize(CTxInWitness, f)
+            wit = CTxWitness(tuple(0 for dummy in range(len(vin))))
+            wit = wit.stream_deserialize(f)
             nLockTime = struct.unpack(b"<I", ser_read(f,4))[0]
             return cls(vin, vout, nLockTime, nVersion, wit)
         else:
@@ -382,15 +421,15 @@ def stream_deserialize(cls, f):
 
 
     def stream_serialize(self, f):
-        if self.wit:
-            if len(self.wit) != len(self.vin):
+        if not self.wit.is_null():
+            if len(self.wit.vtxinwit) != len(self.vin):
                 raise SerializationMissingWitnessError
             f.write(struct.pack(b"<i", self.nVersion))
             f.write(b'\x00') # Marker
             f.write(b'\x01') # Flag
             VectorSerializer.stream_serialize(CTxIn, self.vin, f)
             VectorSerializer.stream_serialize(CTxOut, self.vout, f)
-            for w in self.wit: w.stream_serialize(f)
+            self.wit.stream_serialize(f)
             f.write(struct.pack(b"<I", self.nLockTime))
         else:
             f.write(struct.pack(b"<i", self.nVersion))
@@ -422,11 +461,9 @@ def GetTxid(self):
         """Get the transaction ID.  This differs from the transactions hash as
             given by GetHash.  GetTxid excludes witness data, while GetHash
             includes it. """
-        if self.wit:
-            wit = self.wit
-            self.wit = b''
-            txid = Hash(self.serialize())
-            self.wit = wit
+        if self.wit != CTxWitness():
+            txid = Hash(CTransaction(self.vin, self.vout, self.nLockTime,
+                self.nVersion).serialize())
         else:
             txid = Hash(self.serialize())
         return txid
@@ -452,6 +489,9 @@ def __init__(self, vin=None, vout=None, nLockTime=0, nVersion=1, witness=None):
             vout = []
         self.vout = vout
         self.nVersion = nVersion
+
+        if witness is None:
+            witness = CTxWitness([CTxInWitness() for dummy in range(len(vin))])
         self.wit = witness
 
     @classmethod

bitcoin/core/script.py

@@ -678,21 +678,28 @@ def is_p2sh(self):
                 _bord(self[22]) == OP_EQUAL)
 
     def is_witness_scriptpubkey(self):
+        """Returns true if this is a scriptpubkey signaling segregated witness
+        data. """
         return 3 <= len(self) <= 42 and CScriptOp(self[0]).is_small_int()
 
     def witness_version(self):
+        """Returns the witness version on [0,16]. """
         return next(iter(self))
 
     def is_witness_v0_keyhash(self):
+        """Returns true if this is a scriptpubkey for V0 P2WPKH. """
         return len(self) == 22 and self[0:2] == b'\x00\x14'
 
     def is_witness_v0_nested_keyhash(self):
+        """Returns true if this is a scriptpubkey for V0 P2WPKH embedded in P2SH. """
         return len(self) == 23 and self[0:3] == b'\x16\x00\x14'
 
     def is_witness_v0_scripthash(self):
+        """Returns true if this is a scriptpubkey for V0 P2WSH. """
         return len(self) == 34 and self[0:2] == b'\x00\x20'
 
     def is_witness_v0_nested_scripthash(self):
+        """Returns true if this is a scriptpubkey for V0 P2WSH embedded in P2SH. """
         return len(self) == 23 and self[0:2] == b'\xa9\x14' and self[-1] == b'\x87'
 
     def is_push_only(self):
@@ -812,15 +819,16 @@ def __iter__(self):
         return iter(self.stack)
 
     def __repr__(self):
-
         return 'CScriptWitness(' + ','.join("x('%s')" % bitcoin.core.b2x(s) for s in self.stack) + ')'
 
+    def is_null(self):
+        return len(self.stack) == 0
+
     @classmethod
     def stream_deserialize(cls, f):
         n = VarIntSerializer.stream_deserialize(f)
-        self.stack = []
-        for i in range(n):
-            self.stack.append(BytesSerializer.stream_deserialize(f))
+        stack = tuple(BytesSerializer.stream_deserialize(f) for i in range(n))
+        return cls(stack)
 
     def stream_serialize(self, f):
         VarIntSerializer.stream_serialize(len(self.stack), f)
@@ -948,7 +956,7 @@ def RawSignatureHash(script, txTo, inIdx, hashtype):
         txtmp.vin = []
         txtmp.vin.append(tmp)
 
-    txtmp.wit = ()
+    txtmp.wit = bitcoin.core.CTxWitness()
     s = txtmp.serialize()
     s += struct.pack(b"<I", hashtype)
 

bitcoin/messages.py

@@ -35,9 +35,16 @@
 from bitcoin.net import *
 import bitcoin
 
+MSG_WITNESS_FLAG = 1 << 30
+MSG_TYPE_MASK = 0xffffffff >> 2
+
 MSG_TX = 1
 MSG_BLOCK = 2
 MSG_FILTERED_BLOCK = 3
+MSG_CMPCT_BLOCK = 4
+MSG_WITNESS_BLOCK = MSG_BLOCK | MSG_WITNESS_FLAG,
+MSG_WITNESS_TX = MSG_TX | MSG_WITNESS_FLAG,
+MSG_FILTERED_WITNESS_BLOCK = MSG_FILTERED_BLOCK | MSG_WITNESS_FLAG,
 
 
 class MsgSerializable(Serializable):
@@ -499,6 +506,12 @@ def __repr__(self):
         'MSG_TX',
         'MSG_BLOCK',
         'MSG_FILTERED_BLOCK',
+        'MSG_CMPCT_BLOCK',
+        'MSG_TYPE_MASK',
+        'MSG_WITNESS_TX',
+        'MSG_WITNESS_BLOCK',
+        'MSG_WITNESS_FLAG',
+        'MSG_FILTERED_WITNESS_BLOCK',
         'MsgSerializable',
         'msg_version',
         'msg_verack',

bitcoin/net.py

@@ -76,7 +76,8 @@ class CInv(Serializable):
         0: "Error",
         1: "TX",
         2: "Block",
-        3: "FilteredBlock"}
+        3: "FilteredBlock",
+        4: "CompactBlock"}
 
     def __init__(self):
         self.type = 0