[Tests] Refactor some shared functions

qa/rpc-tests/mempool_limit.py

@@ -10,9 +10,6 @@ from test_framework.util import *
 
 class MempoolLimitTest(BitcoinTestFramework):
 
-    def satoshi_round(self, amount):
-        return  Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
-
     def __init__(self):
         # Some pre-processing to create a bunch of OP_RETURN txouts to insert into transactions we create
         # So we have big transactions (and therefore can't fit very many into each block)
@@ -30,58 +27,9 @@ class MempoolLimitTest(BitcoinTestFramework):
             # add script_pubkey
             self.txouts = self.txouts + script_pubkey
                     
-    def create_confirmed_utxos(self, count):
-        self.nodes[0].generate(int(0.5*90)+102)
-        utxos = self.nodes[0].listunspent()
-        iterations = count - len(utxos)
-        addr1 = self.nodes[0].getnewaddress()
-        addr2 = self.nodes[0].getnewaddress()
-        if iterations <= 0:
-            return utxos
-        for i in xrange(iterations):
-            t = utxos.pop()
-            fee = self.relayfee
-            inputs = []
-            inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
-            outputs = {}
-            send_value = t['amount'] - fee
-            outputs[addr1] = self.satoshi_round(send_value/2)
-            outputs[addr2] = self.satoshi_round(send_value/2)
-            raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
-            signed_tx = self.nodes[0].signrawtransaction(raw_tx)["hex"]
-            txid = self.nodes[0].sendrawtransaction(signed_tx)
-
-        while (self.nodes[0].getmempoolinfo()['size'] > 0):
-            self.nodes[0].generate(1)
-
-        utxos = self.nodes[0].listunspent()
-        assert(len(utxos) >= count)
-        return utxos
-
-    def create_lots_of_big_transactions(self, utxos, fee):
-        addr = self.nodes[0].getnewaddress()
-        txids = []
-        for i in xrange(len(utxos)):
-            t = utxos.pop()
-            inputs = []
-            inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
-            outputs = {}
-            send_value = t['amount'] - fee
-            outputs[addr] = self.satoshi_round(send_value)
-            rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
-            newtx = rawtx[0:92]
-            newtx = newtx + self.txouts
-            newtx = newtx + rawtx[94:]
-            signresult = self.nodes[0].signrawtransaction(newtx, None, None, "NONE")
-            txid = self.nodes[0].sendrawtransaction(signresult["hex"], True)
-            txids.append(txid)
-        return txids
-                    
     def setup_network(self):
         self.nodes = []
         self.nodes.append(start_node(0, self.options.tmpdir, ["-maxmempool=5", "-spendzeroconfchange=0", "-debug"]))
-        self.nodes.append(start_node(1, self.options.tmpdir, []))
-        connect_nodes(self.nodes[0], 1)
         self.is_network_split = False
         self.sync_all()
         self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']
@@ -92,12 +40,12 @@ class MempoolLimitTest(BitcoinTestFramework):
 
     def run_test(self):
         txids = []
-        utxos = self.create_confirmed_utxos(90)
+        utxos = create_confirmed_utxos(self.relayfee, self.nodes[0], 90)
 
         #create a mempool tx that will be evicted
         us0 = utxos.pop()
         inputs = [{ "txid" : us0["txid"], "vout" : us0["vout"]}]
-        outputs = {self.nodes[1].getnewaddress() : 0.0001}
+        outputs = {self.nodes[0].getnewaddress() : 0.0001}
         tx = self.nodes[0].createrawtransaction(inputs, outputs)
         txF = self.nodes[0].fundrawtransaction(tx)
         txFS = self.nodes[0].signrawtransaction(txF['hex'])
@@ -108,7 +56,7 @@ class MempoolLimitTest(BitcoinTestFramework):
         base_fee = relayfee*100
         for i in xrange (4):
             txids.append([])
-            txids[i] = self.create_lots_of_big_transactions(utxos[30*i:30*i+30], (i+1)*base_fee)
+            txids[i] = create_lots_of_big_transactions(self.nodes[0], self.txouts, utxos[30*i:30*i+30], (i+1)*base_fee)
 
         # by now, the tx should be evicted, check confirmation state
         assert(txid not in self.nodes[0].getrawmempool())

qa/rpc-tests/prioritise_transaction.py

@@ -42,62 +42,15 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
         self.nodes.append(start_node(0, self.options.tmpdir, ["-debug", "-printpriority=1"]))
         self.relayfee = self.nodes[0].getnetworkinfo()['relayfee']
 
-    def create_confirmed_utxos(self, count):
-        self.nodes[0].generate(int(0.5*count)+101)
-        utxos = self.nodes[0].listunspent()
-        iterations = count - len(utxos)
-        addr1 = self.nodes[0].getnewaddress()
-        addr2 = self.nodes[0].getnewaddress()
-        if iterations <= 0:
-            return utxos
-        for i in xrange(iterations):
-            t = utxos.pop()
-            fee = self.relayfee
-            inputs = []
-            inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
-            outputs = {}
-            send_value = t['amount'] - fee
-            outputs[addr1] = satoshi_round(send_value/2)
-            outputs[addr2] = satoshi_round(send_value/2)
-            raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
-            signed_tx = self.nodes[0].signrawtransaction(raw_tx)["hex"]
-            txid = self.nodes[0].sendrawtransaction(signed_tx)
-
-        while (self.nodes[0].getmempoolinfo()['size'] > 0):
-            self.nodes[0].generate(1)
-
-        utxos = self.nodes[0].listunspent()
-        assert(len(utxos) >= count)
-        return utxos
-
-    def create_lots_of_big_transactions(self, utxos, fee):
-        addr = self.nodes[0].getnewaddress()
-        txids = []
-        for i in xrange(len(utxos)):
-            t = utxos.pop()
-            inputs = []
-            inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
-            outputs = {}
-            send_value = t['amount'] - fee
-            outputs[addr] = satoshi_round(send_value)
-            rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
-            newtx = rawtx[0:92]
-            newtx = newtx + self.txouts
-            newtx = newtx + rawtx[94:]
-            signresult = self.nodes[0].signrawtransaction(newtx, None, None, "NONE")
-            txid = self.nodes[0].sendrawtransaction(signresult["hex"], True)
-            txids.append(txid)
-        return txids
-
     def run_test(self):
-        utxos = self.create_confirmed_utxos(90)
+        utxos = create_confirmed_utxos(self.relayfee, self.nodes[0], 90)
         base_fee = self.relayfee*100 # our transactions are smaller than 100kb
         txids = []
 
         # Create 3 batches of transactions at 3 different fee rate levels
         for i in xrange(3):
             txids.append([])
-            txids[i] = self.create_lots_of_big_transactions(utxos[30*i:30*i+30], (i+1)*base_fee)
+            txids[i] = create_lots_of_big_transactions(self.nodes[0], self.txouts, utxos[30*i:30*i+30], (i+1)*base_fee)
 
         # add a fee delta to something in the cheapest bucket and make sure it gets mined
         # also check that a different entry in the cheapest bucket is NOT mined (lower

qa/rpc-tests/test_framework/util.py

@@ -408,3 +408,49 @@ def assert_raises(exc, fun, *args, **kwds):
 
 def satoshi_round(amount):
     return  Decimal(amount).quantize(Decimal('0.00000001'), rounding=ROUND_DOWN)
+
+def create_confirmed_utxos(fee, node, count):
+    node.generate(int(0.5*count)+101)
+    utxos = node.listunspent()
+    iterations = count - len(utxos)
+    addr1 = node.getnewaddress()
+    addr2 = node.getnewaddress()
+    if iterations <= 0:
+        return utxos
+    for i in xrange(iterations):
+        t = utxos.pop()
+        inputs = []
+        inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
+        outputs = {}
+        send_value = t['amount'] - fee
+        outputs[addr1] = satoshi_round(send_value/2)
+        outputs[addr2] = satoshi_round(send_value/2)
+        raw_tx = node.createrawtransaction(inputs, outputs)
+        signed_tx = node.signrawtransaction(raw_tx)["hex"]
+        txid = node.sendrawtransaction(signed_tx)
+
+    while (node.getmempoolinfo()['size'] > 0):
+        node.generate(1)
+
+    utxos = node.listunspent()
+    assert(len(utxos) >= count)
+    return utxos
+
+def create_lots_of_big_transactions(node, txouts, utxos, fee):
+    addr = node.getnewaddress()
+    txids = []
+    for i in xrange(len(utxos)):
+        t = utxos.pop()
+        inputs = []
+        inputs.append({ "txid" : t["txid"], "vout" : t["vout"]})
+        outputs = {}
+        send_value = t['amount'] - fee
+        outputs[addr] = satoshi_round(send_value)
+        rawtx = node.createrawtransaction(inputs, outputs)
+        newtx = rawtx[0:92]
+        newtx = newtx + txouts
+        newtx = newtx + rawtx[94:]
+        signresult = node.signrawtransaction(newtx, None, None, "NONE")
+        txid = node.sendrawtransaction(signresult["hex"], True)
+        txids.append(txid)
+    return txids