Fix remaining RPC tests.

qa/rpc-tests/txn_doublespend.py

@@ -24,29 +24,28 @@ class TxnMallTest(BitcoinTestFramework):
         return super(TxnMallTest, self).setup_network(True)
 
     def run_test(self):
-        starting_balance = 1000
+        mining_reward = 40
+        starting_balance = mining_reward * 25
+
         for i in range(4):
             assert_equal(self.nodes[i].getbalance(), starting_balance)
             self.nodes[i].getnewaddress("")  # bug workaround, coins generated assigned to first getnewaddress!
         
         # Assign coins to foo and bar accounts:
-        amtfoo = 970
-        amtbar = starting_balance - amtfoo
-        self.nodes[0].move("", "foo", amtfoo)
-        self.nodes[0].move("", "bar", amtbar)
+        self.nodes[0].move("", "foo", (starting_balance - (mining_reward - 20)))
+        self.nodes[0].move("", "bar", (mining_reward - 20))
         assert_equal(self.nodes[0].getbalance(""), 0)
 
         # Coins are sent to node1_address
         node1_address = self.nodes[1].getnewaddress("from0")
 
-        # First: use raw transaction API to send amtqux BTC to node1_address,
+        # First: use raw transaction API to send (starting_balance - (mining_reward - 10)) BTC to node1_address,
         # but don't broadcast:
-        amtqux = 713
-        (total_in, inputs) = gather_inputs(self.nodes[0], amtqux)
+        (total_in, inputs) = gather_inputs(self.nodes[0], (starting_balance - (mining_reward - 10)))
         change_address = self.nodes[0].getnewaddress("foo")
         outputs = {}
-        outputs[change_address] = starting_balance - amtqux
-        outputs[node1_address] = amtqux
+        outputs[change_address] = (mining_reward - 10)
+        outputs[node1_address] = (starting_balance - (mining_reward - 10))
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
         doublespend = self.nodes[0].signrawtransaction(rawtx)
         assert_equal(doublespend["complete"], True)
@@ -54,9 +53,8 @@ class TxnMallTest(BitcoinTestFramework):
         # Create two transaction from node[0] to node[1]; the
         # second must spend change from the first because the first
         # spends all mature inputs:
-        txid1 = self.nodes[0].sendfrom("foo", node1_address, amtqux, 0)
-        amtbar2 = 20
-        txid2 = self.nodes[0].sendfrom("bar", node1_address, amtbar2, 0)
+        txid1 = self.nodes[0].sendfrom("foo", node1_address, (starting_balance - (mining_reward - 10)), 0)
+        txid2 = self.nodes[0].sendfrom("bar", node1_address, 20, 0)
         
         # Have node0 mine a block:
         if (self.options.mine_block):
@@ -66,17 +64,17 @@ class TxnMallTest(BitcoinTestFramework):
         tx1 = self.nodes[0].gettransaction(txid1)
         tx2 = self.nodes[0].gettransaction(txid2)
 
-        # Node0's balance should be starting balance, plus 40BTC for another
-        # matured block, minus amtqux, minus amtbar2, and minus transaction fees:
+        # Node0's balance should be starting balance, plus mining_reward for another
+        # matured block, minus (starting_balance - (mining_reward - 10)), minus 20, and minus transaction fees:
         expected = starting_balance
-        if self.options.mine_block: expected += 40
+        if self.options.mine_block: expected += mining_reward
         expected += tx1["amount"] + tx1["fee"]
         expected += tx2["amount"] + tx2["fee"]
         assert_equal(self.nodes[0].getbalance(), expected)
 
         # foo and bar accounts should be debited:
-        assert_equal(self.nodes[0].getbalance("foo"), amtfoo+tx1["amount"]+tx1["fee"])
-        assert_equal(self.nodes[0].getbalance("bar"), amtbar+tx2["amount"]+tx2["fee"])
+        assert_equal(self.nodes[0].getbalance("foo"), (starting_balance - (mining_reward - 20))+tx1["amount"]+tx1["fee"])
+        assert_equal(self.nodes[0].getbalance("bar"), (mining_reward - 20)+tx2["amount"]+tx2["fee"])
 
         if self.options.mine_block:
             assert_equal(tx1["confirmations"], 1)
@@ -105,18 +103,18 @@ class TxnMallTest(BitcoinTestFramework):
         assert_equal(tx1["confirmations"], -1)
         assert_equal(tx2["confirmations"], -1)
 
-        # Node0's total balance should be starting balance, plus 80BTC for
-        # two more matured blocks, minus amtqux for the double-spend:
-        expected = starting_balance + 80 - amtqux
+        # Node0's total balance should be starting balance, plus 100BTC for 
+        # two more matured blocks, minus (starting_balance - (mining_reward - 10)) for the double-spend:
+        expected = starting_balance + (mining_reward * 2) - (starting_balance - (mining_reward - 10))
         assert_equal(self.nodes[0].getbalance(), expected)
         assert_equal(self.nodes[0].getbalance("*"), expected)
 
         # foo account should be debited, but bar account should not:
-        assert_equal(self.nodes[0].getbalance("foo"), amtfoo-amtqux)
-        assert_equal(self.nodes[0].getbalance("bar"), amtbar)
+        assert_equal(self.nodes[0].getbalance("foo"), (starting_balance - (mining_reward - 20))-(starting_balance - (mining_reward - 10)))
+        assert_equal(self.nodes[0].getbalance("bar"), (mining_reward - 20))
 
         # Node1's "from" account balance should be just the mutated send:
-        assert_equal(self.nodes[1].getbalance("from0"), amtqux)
+        assert_equal(self.nodes[1].getbalance("from0"), (starting_balance - (mining_reward - 10)))
 
 if __name__ == '__main__':
     TxnMallTest().main()

qa/rpc-tests/zcpour.py

@@ -13,91 +13,38 @@ import sys
 
 class PourTxTest(BitcoinTestFramework):
     def setup_network(self):
-        # Start with split network:
-        return super(PourTxTest, self).setup_network(True)
+        self.nodes = []
+        self.is_network_split = False
+        self.nodes.append(start_node(0, self.options.tmpdir))
 
-    def send_pours_around(self):
-        zckeypair = self.nodes[1].zcrawkeygen()
+    def run_test(self):
+        zckeypair = self.nodes[0].zcrawkeygen()
         zcsecretkey = zckeypair["zcsecretkey"]
         zcaddress = zckeypair["zcaddress"]
 
-        (total_in, inputs) = gather_inputs(self.nodes[1], 40)
-        protect_tx = self.nodes[1].createrawtransaction(inputs, {})
-        pour_result = self.nodes[1].zcrawpour(protect_tx, {}, {zcaddress:49.9}, 40, 0.1)
+        (total_in, inputs) = gather_inputs(self.nodes[0], 40)
+        protect_tx = self.nodes[0].createrawtransaction(inputs, {})
+        pour_result = self.nodes[0].zcrawpour(protect_tx, {}, {zcaddress:39.9}, 40, 0.1)
 
-        receive_result = self.nodes[1].zcrawreceive(zcsecretkey, pour_result["encryptedbucket1"])
+        receive_result = self.nodes[0].zcrawreceive(zcsecretkey, pour_result["encryptedbucket1"])
         assert_equal(receive_result["exists"], False)
 
-        protect_tx = self.nodes[1].signrawtransaction(pour_result["rawtxn"])
-        self.nodes[1].sendrawtransaction(protect_tx["hex"])
-        self.nodes[1].generate(1)
+        protect_tx = self.nodes[0].signrawtransaction(pour_result["rawtxn"])
+        self.nodes[0].sendrawtransaction(protect_tx["hex"])
+        self.nodes[0].generate(1)
 
-        receive_result = self.nodes[1].zcrawreceive(zcsecretkey, pour_result["encryptedbucket1"])
+        receive_result = self.nodes[0].zcrawreceive(zcsecretkey, pour_result["encryptedbucket1"])
         assert_equal(receive_result["exists"], True)
 
-        pour_tx = self.nodes[1].createrawtransaction([], {})
-        pour_result = self.nodes[1].zcrawpour(pour_tx, {receive_result["bucket"] : zcsecretkey}, {zcaddress: 49.8}, 0, 0.1)
-
-        self.nodes[1].sendrawtransaction(pour_result["rawtxn"])
-        self.nodes[1].generate(1)
+        pour_tx = self.nodes[0].createrawtransaction([], {})
+        pour_result = self.nodes[0].zcrawpour(pour_tx, {receive_result["bucket"] : zcsecretkey}, {zcaddress: 39.8}, 0, 0.1)
 
-        print "Syncing blocks..."
-        connect_nodes(self.nodes[1], 0)
-        sync_blocks(self.nodes[0:2])
+        self.nodes[0].sendrawtransaction(pour_result["rawtxn"])
+        self.nodes[0].generate(1)
 
         print "Done!"
         receive_result = self.nodes[0].zcrawreceive(zcsecretkey, pour_result["encryptedbucket1"])
         assert_equal(receive_result["exists"], True)
 
-    def run_test(self):
-        starting_balance = 1000
-        for i in range(4):
-            assert_equal(self.nodes[i].getbalance(), starting_balance)
-            self.nodes[i].getnewaddress("")  # bug workaround, coins generated assigned to first getnewaddress!
-
-        # Generate zcaddress keypairs
-        zckeypair1 = self.nodes[0].zcrawkeygen()
-        zcsecretkey1 = zckeypair1["zcsecretkey"]
-        zcaddress1 = zckeypair1["zcaddress"]
-
-        zckeypair2 = self.nodes[0].zcrawkeygen()
-        zcsecretkey2 = zckeypair2["zcsecretkey"]
-        zcaddress2 = zckeypair2["zcaddress"]
-
-        self.nodes[0].move("", "foo", 970)
-        self.nodes[0].move("", "bar", 30)
-        assert_equal(self.nodes[0].getbalance(""), 0)
-
-        change_address = self.nodes[0].getnewaddress("foo")
-
-        # Pour some of our money into this address
-        (total_in, inputs) = gather_inputs(self.nodes[0], 960)
-        outputs = {}
-        outputs[change_address] = 78
-        rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
-
-        pour_inputs = {}
-        pour_outputs = {}
-        pour_outputs[zcaddress1] = 100
-        pour_outputs[zcaddress2] = 800
-        exception_triggered = False
-        try:
-            pour_result = self.nodes[0].zcrawpour(rawtx, pour_inputs, pour_outputs, 0, 0)
-        except JSONRPCException:
-            exception_triggered = True
-        
-        # We expect it to fail; the pour's balance equation isn't adding up.
-        assert_equal(exception_triggered, True)
-
-        pour_outputs[zcaddress1] = 370
-        pour_result = self.nodes[0].zcrawpour(rawtx, pour_inputs, pour_outputs, 1200, 30)
-        # This should succeed to construct a pour: the math adds up!
-
-        signed_tx_pour = self.nodes[0].signrawtransaction(pour_result["rawtxn"])
-
-        self.nodes[0].sendrawtransaction(signed_tx_pour["hex"])
-        
-        self.send_pours_around()
-
 if __name__ == '__main__':
-    PourTxTest().main()
+    PourTxTest().main()

qa/rpc-tests/zcpourdoublespend.py

@@ -41,6 +41,7 @@ class PourTxTest(BitcoinTestFramework):
         assert_equal(self.cannot_pour(node, txn), True)
 
     def run_test(self):
+        # All nodes should start with 1,250 BTC:
         starting_balance = 1000
         for i in range(4):
             assert_equal(self.nodes[i].getbalance(), starting_balance)
@@ -55,7 +56,7 @@ class PourTxTest(BitcoinTestFramework):
         for i in range(4):
             (total_in, inputs) = gather_inputs(self.nodes[i], 40)
             pool[i] = self.nodes[i].createrawtransaction(inputs, {})
-            pool[i] = self.nodes[i].zcrawpour(pool[i], {}, {zcaddress:49.9}, 40, 0.1)
+            pool[i] = self.nodes[i].zcrawpour(pool[i], {}, {zcaddress:39.9}, 40, 0.1)
             signed = self.nodes[i].signrawtransaction(pool[i]["rawtxn"])
 
             # send the tx to both halves of the network
@@ -89,25 +90,25 @@ class PourTxTest(BitcoinTestFramework):
         # Create pour {A, B}->{*}
         pour_AB = self.nodes[0].zcrawpour(blank_tx,
                                           {pool[0] : zcsecretkey, pool[1] : zcsecretkey},
-                                          {zcaddress:(49.9*2)-0.1},
+                                          {zcaddress:(39.9*2)-0.1},
                                           0, 0.1)
 
         # Create pour {B, C}->{*}
         pour_BC = self.nodes[0].zcrawpour(blank_tx,
                                           {pool[1] : zcsecretkey, pool[2] : zcsecretkey},
-                                          {zcaddress:(49.9*2)-0.1},
+                                          {zcaddress:(39.9*2)-0.1},
                                           0, 0.1)
 
         # Create pour {C, D}->{*}
         pour_CD = self.nodes[0].zcrawpour(blank_tx,
                                           {pool[2] : zcsecretkey, pool[3] : zcsecretkey},
-                                          {zcaddress:(49.9*2)-0.1},
+                                          {zcaddress:(39.9*2)-0.1},
                                           0, 0.1)
 
         # Create pour {A, D}->{*}
         pour_AD = self.nodes[0].zcrawpour(blank_tx,
                                           {pool[0] : zcsecretkey, pool[3] : zcsecretkey},
-                                          {zcaddress:(49.9*2)-0.1},
+                                          {zcaddress:(39.9*2)-0.1},
                                           0, 0.1)
 
         # (a)    Node 0 will spend pour AB, then attempt to
@@ -179,5 +180,4 @@ class PourTxTest(BitcoinTestFramework):
         sync_blocks(self.nodes)
 
 if __name__ == '__main__':
-    PourTxTest().main()
-
+    PourTxTest().main()