Implement segwit

Author: veqtrus

p2pool/bitcoin/data.py

@@ -91,30 +91,87 @@ def write(self, file, item):
     ('port', pack.IntType(16, 'big')),
 ])
 
-tx_type = pack.ComposedType([
-    ('version', pack.IntType(32)),
-    ('tx_ins', pack.ListType(pack.ComposedType([
-        ('previous_output', pack.PossiblyNoneType(dict(hash=0, index=2**32 - 1), pack.ComposedType([
-            ('hash', pack.IntType(256)),
-            ('index', pack.IntType(32)),
-        ]))),
-        ('script', pack.VarStrType()),
-        ('sequence', pack.PossiblyNoneType(2**32 - 1, pack.IntType(32))),
-    ]))),
-    ('tx_outs', pack.ListType(pack.ComposedType([
-        ('value', pack.IntType(64)),
-        ('script', pack.VarStrType()),
+def is_segwit_tx(tx):
+    return tx.get('marker', -1) == 0 and tx.get('flag', -1) >= 1
+
+tx_in_type = pack.ComposedType([
+    ('previous_output', pack.PossiblyNoneType(dict(hash=0, index=2**32 - 1), pack.ComposedType([
+        ('hash', pack.IntType(256)),
+        ('index', pack.IntType(32)),
     ]))),
-    ('lock_time', pack.IntType(32)),
+    ('script', pack.VarStrType()),
+    ('sequence', pack.PossiblyNoneType(2**32 - 1, pack.IntType(32))),
 ])
 
+tx_out_type = pack.ComposedType([
+    ('value', pack.IntType(64)),
+    ('script', pack.VarStrType()),
+])
+
+tx_id_type = pack.ComposedType([
+    ('version', pack.IntType(32)),
+    ('tx_ins', pack.ListType(tx_in_type)),
+    ('tx_outs', pack.ListType(tx_out_type)),
+    ('lock_time', pack.IntType(32))
+])
+
+class TransactionType(pack.Type):
+    _int_type = pack.IntType(32)
+    _varint_type = pack.VarIntType()
+    _witness_type = pack.ListType(pack.VarStrType())
+    _wtx_type = pack.ComposedType([
+        ('flag', pack.IntType(8)),
+        ('tx_ins', pack.ListType(tx_in_type)),
+        ('tx_outs', pack.ListType(tx_out_type))
+    ])
+    _ntx_type = pack.ComposedType([
+        ('tx_outs', pack.ListType(tx_out_type)),
+        ('lock_time', _int_type)
+    ])
+    _write_type = pack.ComposedType([
+        ('version', _int_type),
+        ('marker', pack.IntType(8)),
+        ('flag', pack.IntType(8)),
+        ('tx_ins', pack.ListType(tx_in_type)),
+        ('tx_outs', pack.ListType(tx_out_type))
+    ])
+
+    def read(self, file):
+        version, file = self._int_type.read(file)
+        marker, file = self._varint_type.read(file)
+        if marker == 0:
+            next, file = self._wtx_type.read(file)
+            witness = [None]*len(next['tx_ins'])
+            for i in xrange(len(next['tx_ins'])):
+                witness[i], file = self._witness_type.read(file)
+            locktime, file = self._int_type.read(file)
+            return dict(version=version, marker=marker, flag=next['flag'], tx_ins=next['tx_ins'], tx_outs=next['tx_outs'], witness=witness, lock_time=locktime), file
+        else:
+            tx_ins = [None]*marker
+            for i in xrange(marker):
+                tx_ins[i], file = tx_in_type.read(file)
+            next, file = self._ntx_type.read(file)
+            return dict(version=version, tx_ins=tx_ins, tx_outs=next['tx_outs'], lock_time=next['lock_time']), file
+    
+    def write(self, file, item):
+        if is_segwit_tx(item):
+            assert len(item['tx_ins']) == len(item['witness'])
+            res = self._write_type.pack(item)
+            for w in item['witness']:
+                res += self._witness_type.pack(w)
+            res += self._int_type.pack(item['lock_time'])
+            return file, res
+        return tx_id_type.write(file, item)
+
+tx_type = TransactionType()
+
 merkle_link_type = pack.ComposedType([
     ('branch', pack.ListType(pack.IntType(256))),
     ('index', pack.IntType(32)),
 ])
 
 merkle_tx_type = pack.ComposedType([
-    ('tx', tx_type),
+    ('tx', tx_id_type), # used only in aux_pow_type
     ('block_hash', pack.IntType(256)),
     ('merkle_link', merkle_link_type),
 ])
@@ -133,6 +190,11 @@ def write(self, file, item):
     ('txs', pack.ListType(tx_type)),
 ])
 
+stripped_block_type = pack.ComposedType([
+    ('header', block_header_type),
+    ('txs', pack.ListType(tx_id_type)),
+])
+
 # merged mining
 
 aux_pow_type = pack.ComposedType([
@@ -264,6 +326,22 @@ def address_to_pubkey_hash(address, net):
 
 # transactions
 
+def get_witness_commitment_hash(witness_root_hash, witness_reserved_value):
+    return hash256(merkle_record_type.pack(dict(left=witness_root_hash, right=witness_reserved_value)))
+
+def get_wtxid(tx, txid=None, txhash=None):
+    has_witness = False
+    if is_segwit_tx(tx):
+        assert len(tx['tx_ins']) == len(tx['witness'])
+        has_witness = any(len(w) > 0 for w in tx['witness'])
+    if has_witness:
+        return hash256(tx_type.pack(tx)) if txhash is None else txhash
+    else:
+        return hash256(tx_id_type.pack(tx)) if txid is None else txid
+
+def get_txid(tx):
+    return hash256(tx_id_type.pack(tx))
+
 def pubkey_to_script2(pubkey):
     assert len(pubkey) <= 75
     return (chr(len(pubkey)) + pubkey) + '\xac'

p2pool/bitcoin/helper.py

@@ -39,7 +39,7 @@ def check(bitcoind, net):
 def getwork(bitcoind, use_getblocktemplate=False):
     def go():
         if use_getblocktemplate:
-            return bitcoind.rpc_getblocktemplate(dict(mode='template'))
+            return bitcoind.rpc_getblocktemplate(dict(mode='template', rules=['segwit']))
         else:
             return bitcoind.rpc_getmemorypool()
     try:
@@ -71,6 +71,7 @@ def go():
         bits=bitcoin_data.FloatingIntegerType().unpack(work['bits'].decode('hex')[::-1]) if isinstance(work['bits'], (str, unicode)) else bitcoin_data.FloatingInteger(work['bits']),
         coinbaseflags=work['coinbaseflags'].decode('hex') if 'coinbaseflags' in work else ''.join(x.decode('hex') for x in work['coinbaseaux'].itervalues()) if 'coinbaseaux' in work else '',
         height=work['height'],
+        rules=work.get('rules', []),
         last_update=time.time(),
         use_getblocktemplate=use_getblocktemplate,
         latency=end - start,
@@ -86,9 +87,11 @@ def submit_block_p2p(block, factory, net):
 @deferral.retry('Error submitting block: (will retry)', 10, 10)
 @defer.inlineCallbacks
 def submit_block_rpc(block, ignore_failure, bitcoind, bitcoind_work, net):
+    segwit_rules = set(['!segwit', 'segwit'])
+    segwit_activated = len(segwit_rules - set(bitcoind_work.value['rules'])) < len(segwit_rules)
     if bitcoind_work.value['use_getblocktemplate']:
         try:
-            result = yield bitcoind.rpc_submitblock(bitcoin_data.block_type.pack(block).encode('hex'))
+            result = yield bitcoind.rpc_submitblock((bitcoin_data.block_type if segwit_activated else bitcoin_data.stripped_block_type).pack(block).encode('hex'))
         except jsonrpc.Error_for_code(-32601): # Method not found, for older litecoin versions
             result = yield bitcoind.rpc_getblocktemplate(dict(mode='submit', data=bitcoin_data.block_type.pack(block).encode('hex')))
         success = result is None

p2pool/bitcoin/stratum.py

@@ -66,7 +66,7 @@ def rpc_submit(self, worker_name, job_id, extranonce2, ntime, nonce):
         header = dict(
             version=x['version'],
             previous_block=x['previous_block'],
-            merkle_root=bitcoin_data.check_merkle_link(bitcoin_data.hash256(new_packed_gentx), x['merkle_link']),
+            merkle_root=bitcoin_data.check_merkle_link(bitcoin_data.hash256(new_packed_gentx), x['merkle_link']), # new_packed_gentx has witness data stripped
             timestamp=pack.IntType(32).unpack(getwork._swap4(ntime.decode('hex'))),
             bits=x['bits'],
             nonce=pack.IntType(32).unpack(getwork._swap4(nonce.decode('hex'))),