Initial segwit implementation, works with P2WPKH addresses

Author: Bob McElrath

.gitignore

@@ -1,4 +1,4 @@
-
+*.sw?
 *.pyc
 
 local*.cfg
@@ -8,3 +8,4 @@ local*.cfg
 build/
 htmlcov/
 python_bitcoinlib.egg-info/
+dist/

bitcoin/core/__init__.py

@@ -16,7 +16,7 @@
 import sys
 import time
 
-from .script import CScript
+from .script import CScript, CScriptWitness
 
 from .serialize import *
 
@@ -304,11 +304,44 @@ def from_txout(cls, txout):
         """Create a fullly mutable copy of an existing TxOut"""
         return cls(txout.nValue, txout.scriptPubKey)
 
+
+class CTxInWitness(ImmutableSerializable):
+    """Witness data for a transaction input. """
+    __slots__ = ['scriptWitness']
+
+    def __init__(self, scriptWitness=CScriptWitness()):
+        object.__setattr__(self, 'scriptWitness', scriptWitness)
+
+    @classmethod
+    def stream_deserialize(cls, f):
+        scriptWitness = CScriptWitness.stream_deserialize(f)
+        return cls(scriptWitness)
+
+    def stream_serialize(self, f):
+        self.scriptWitness.stream_serialize(f)
+
+    def __repr__(self):
+        return "CTxInWitness(%s)" % (repr(self.scriptWitness))
+
+    @classmethod
+    def from_txinwitness(cls, txinwitness):
+        """Create an immutable copy of an existing TxInWitness
+
+        If txin is already immutable (txin.__class__ is CTxIn) it is returned
+        directly.
+        """
+        if txinwitness.__class__ is CTxInWitness:
+            return txinwitness
+
+        else:
+            return cls(txinwitness.scriptWitness)
+
+
 class CTransaction(ImmutableSerializable):
     """A transaction"""
-    __slots__ = ['nVersion', 'vin', 'vout', 'nLockTime']
+    __slots__ = ['nVersion', 'vin', 'vout', 'nLockTime', 'wit']
 
-    def __init__(self, vin=(), vout=(), nLockTime=0, nVersion=1):
+    def __init__(self, vin=(), vout=(), nLockTime=0, nVersion=1, witness=()):
         """Create a new transaction
 
         vin and vout are iterables of transaction inputs and outputs
@@ -322,26 +355,55 @@ def __init__(self, vin=(), vout=(), nLockTime=0, nVersion=1):
         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))
 
     @classmethod
     def stream_deserialize(cls, f):
         nVersion = struct.unpack(b"<i", ser_read(f,4))[0]
-        vin = VectorSerializer.stream_deserialize(CTxIn, f)
-        vout = VectorSerializer.stream_deserialize(CTxOut, f)
-        nLockTime = struct.unpack(b"<I", ser_read(f,4))[0]
-        return cls(vin, vout, nLockTime, nVersion)
+        pos = f.tell()
+        markerbyte = struct.unpack(b'B', ser_read(f, 1))[0]
+        if markerbyte == 0:
+            flagbyte = struct.unpack(b'B', ser_read(f, 1))[0]
+            if flagbyte != 1:
+                raise DeserializationFormatError
+            vin = VectorSerializer.stream_deserialize(CTxIn, f)
+            vout = VectorSerializer.stream_deserialize(CTxOut, f)
+            wit = VectorSerializer.stream_deserialize(CTxInWitness, f)
+            nLockTime = struct.unpack(b"<I", ser_read(f,4))[0]
+            return cls(vin, vout, nLockTime, nVersion, wit)
+        else:
+            f.seek(pos) # put marker byte back, since we don't have peek
+            vin = VectorSerializer.stream_deserialize(CTxIn, f)
+            vout = VectorSerializer.stream_deserialize(CTxOut, f)
+            nLockTime = struct.unpack(b"<I", ser_read(f,4))[0]
+            return cls(vin, vout, nLockTime, nVersion)
+
 
     def stream_serialize(self, f):
-        f.write(struct.pack(b"<i", self.nVersion))
-        VectorSerializer.stream_serialize(CTxIn, self.vin, f)
-        VectorSerializer.stream_serialize(CTxOut, self.vout, f)
-        f.write(struct.pack(b"<I", self.nLockTime))
+        if self.wit:
+            if len(self.wit) != 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)
+            f.write(struct.pack(b"<I", self.nLockTime))
+        else:
+            f.write(struct.pack(b"<i", self.nVersion))
+            VectorSerializer.stream_serialize(CTxIn, self.vin, f)
+            VectorSerializer.stream_serialize(CTxOut, self.vout, f)
+            f.write(struct.pack(b"<I", self.nLockTime))
 
     def is_coinbase(self):
         return len(self.vin) == 1 and self.vin[0].prevout.is_null()
 
     def __repr__(self):
-        return "CTransaction(%r, %r, %i, %i)" % (self.vin, self.vout, self.nLockTime, self.nVersion)
+        return "CTransaction(%r, %r, %i, %i, %r)" % (self.vin, self.vout,
+                self.nLockTime, self.nVersion, self.wit)
 
     @classmethod
     def from_tx(cls, tx):
@@ -354,15 +416,30 @@ def from_tx(cls, tx):
             return tx
 
         else:
-            return cls(tx.vin, tx.vout, tx.nLockTime, tx.nVersion)
+            return cls(tx.vin, tx.vout, tx.nLockTime, tx.nVersion, tx.wit)
+
+    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
+        else:
+            txid = Hash(self.serialize())
+        return txid
+
+
 
 
 @__make_mutable
 class CMutableTransaction(CTransaction):
     """A mutable transaction"""
     __slots__ = []
 
-    def __init__(self, vin=None, vout=None, nLockTime=0, nVersion=1):
+    def __init__(self, vin=None, vout=None, nLockTime=0, nVersion=1, witness=CScriptWitness([])):
         if not (0 <= nLockTime <= 0xffffffff):
             raise ValueError('CTransaction: nLockTime must be in range 0x0 to 0xffffffff; got %x' % nLockTime)
         self.nLockTime = nLockTime
@@ -375,14 +452,15 @@ def __init__(self, vin=None, vout=None, nLockTime=0, nVersion=1):
             vout = []
         self.vout = vout
         self.nVersion = nVersion
+        self.wit = witness
 
     @classmethod
     def from_tx(cls, tx):
         """Create a fully mutable copy of a pre-existing transaction"""
         vin = [CMutableTxIn.from_txin(txin) for txin in tx.vin]
         vout = [CMutableTxOut.from_txout(txout) for txout in tx.vout]
 
-        return cls(vin, vout, tx.nLockTime, tx.nVersion)
+        return cls(vin, vout, tx.nLockTime, tx.nVersion, tx.wit)
 
 
 
@@ -478,7 +556,7 @@ def build_merkle_tree_from_txids(txids):
     @staticmethod
     def build_merkle_tree_from_txs(txs):
         """Build a full merkle tree from transactions"""
-        txids = [tx.GetHash() for tx in txs]
+        txids = [tx.GetTxid() for tx in txs]
         return CBlock.build_merkle_tree_from_txids(txids)
 
     def calc_merkle_root(self):
@@ -730,7 +808,7 @@ def CheckBlock(block, fCheckPoW = True, fCheckMerkleRoot = True, cur_time=None):
 
         CheckTransaction(tx)
 
-        txid = tx.GetHash()
+        txid = tx.GetTxid()
         if txid in unique_txids:
             raise CheckBlockError("CheckBlock() : duplicate transaction")
         unique_txids.add(txid)

bitcoin/core/script.py

@@ -30,6 +30,8 @@
 import bitcoin.core
 import bitcoin.core._bignum
 
+from .serialize import *
+
 MAX_SCRIPT_SIZE = 10000
 MAX_SCRIPT_ELEMENT_SIZE = 520
 MAX_SCRIPT_OPCODES = 201
@@ -773,6 +775,37 @@ def GetSigOpCount(self, fAccurate):
             lastOpcode = opcode
         return n
 
+class CScriptWitness(ImmutableSerializable):
+    """An encoding of the data elements on the initial stack for (segregated
+        witness)
+    """
+    __slots__ = ['stack']
+
+    def __init__(self, stack=()):
+        object.__setattr__(self, 'stack', stack)
+
+    def __len__(self):
+        return len(self.stack)
+
+    def __iter__(self):
+        return iter(self.stack)
+
+    def __repr__(self):
+
+        return 'CScriptWitness(' + ','.join("x('%s')" % bitcoin.core.b2x(s) for s in self.stack) + ')'
+
+    @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))
+
+    def stream_serialize(self, f):
+        VarIntSerializer.stream_serialize(len(self.stack), f)
+        for s in self.stack:
+            BytesSerializer.stream_serialize(s, f)
+
 
 SIGHASH_ALL = 1
 SIGHASH_NONE = 2
@@ -894,6 +927,7 @@ def RawSignatureHash(script, txTo, inIdx, hashtype):
         txtmp.vin = []
         txtmp.vin.append(tmp)
 
+    txtmp.wit = ()
     s = txtmp.serialize()
     s += struct.pack(b"<I", hashtype)
 
@@ -1048,6 +1082,7 @@ def SignatureHash(script, txTo, inIdx, hashtype):
         'CScriptInvalidError',
         'CScriptTruncatedPushDataError',
         'CScript',
+        'CScriptWitness',
         'SIGHASH_ALL',
         'SIGHASH_NONE',
         'SIGHASH_SINGLE',

bitcoin/core/serialize.py

@@ -55,6 +55,10 @@ class SerializationTruncationError(SerializationError):
     Thrown by deserialize() and stream_deserialize()
     """
 
+class SerializationMissingWitnessError(SerializationError):
+    """Missing witness data when serializing a segregated witness transaction
+    """
+
 class DeserializationExtraDataError(SerializationError):
     """Deserialized data had extra data at the end
 
@@ -67,6 +71,11 @@ def __init__(self, msg, obj, padding):
         self.obj = obj
         self.padding = padding
 
+class DeserializationFormatError(SerializationError):
+    """Deserialized data does not have the correct marker or flag bytes for a
+        segwit serialization
+    """
+
 def ser_read(f, n):
     """Read from a stream safely