Inside Bitcoin

1#!/usr/bin/env python3
2# Copyright (c) 2014-present The Bitcoin Core developers
3# Distributed under the MIT software license, see the accompanying
4# file COPYING or http://www.opensource.org/licenses/mit-license.php.
5"""Test the wallet."""
6from decimal import Decimal
7from itertools import product
8
9from test_framework.blocktools import COINBASE_MATURITY
10from test_framework.descriptors import descsum_create
11from test_framework.messages import (
12    COIN,
13    DEFAULT_ANCESTOR_LIMIT,
14)
15from test_framework.test_framework import BitcoinTestFramework
16from test_framework.util import (
17    assert_array_result,
18    assert_equal,
19    assert_fee_amount,
20    assert_raises_rpc_error,
21)
22from test_framework.wallet_util import test_address
23from test_framework.wallet import MiniWallet
24
25NOT_A_NUMBER_OR_STRING = "Amount is not a number or string"
26OUT_OF_RANGE = "Amount out of range"
27
28
29class WalletTest(BitcoinTestFramework):
30    def set_test_params(self):
31        self.num_nodes = 4
32        # whitelist peers to speed up tx relay / mempool sync
33        self.noban_tx_relay = True
34        self.extra_args = [[
35            "-dustrelayfee=0", "-walletrejectlongchains=0"
36        ]] * self.num_nodes
37        self.setup_clean_chain = True
38        self.supports_cli = False
39
40    def skip_test_if_missing_module(self):
41        self.skip_if_no_wallet()
42
43    def setup_network(self):
44        self.setup_nodes()
45        # Only need nodes 0-2 running at start of test
46        self.stop_node(3)
47        self.connect_nodes(0, 1)
48        self.connect_nodes(1, 2)
49        self.connect_nodes(0, 2)
50        self.sync_all(self.nodes[0:3])
51
52    def check_fee_amount(self, curr_balance, balance_with_fee, fee_per_byte, tx_size):
53        """Return curr_balance after asserting the fee was in range"""
54        fee = balance_with_fee - curr_balance
55        assert_fee_amount(fee, tx_size, fee_per_byte * 1000)
56        return curr_balance
57
58    def get_vsize(self, txn):
59        return self.nodes[0].decoderawtransaction(txn)['vsize']
60
61    def run_test(self):
62
63        # Check that there's no UTXO on none of the nodes
64        assert_equal(len(self.nodes[0].listunspent()), 0)
65        assert_equal(len(self.nodes[1].listunspent()), 0)
66        assert_equal(len(self.nodes[2].listunspent()), 0)
67
68        self.log.info("Mining blocks...")
69
70        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
71
72        balances = self.nodes[0].getbalances()
73        assert_equal(balances["mine"]["immature"], 50)
74        assert_equal(balances["mine"]["trusted"], 0)
75
76        self.sync_all(self.nodes[0:3])
77        self.generate(self.nodes[1], COINBASE_MATURITY + 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
78
79        assert_equal(self.nodes[0].getbalance(), 50)
80        assert_equal(self.nodes[1].getbalance(), 50)
81        assert_equal(self.nodes[2].getbalance(), 0)
82
83        # Check that only first and second nodes have UTXOs
84        utxos = self.nodes[0].listunspent()
85        assert_equal(len(utxos), 1)
86        assert_equal(len(self.nodes[1].listunspent()), 1)
87        assert_equal(len(self.nodes[2].listunspent()), 0)
88
89        self.log.info("Test gettxout")
90        confirmed_txid, confirmed_index = utxos[0]["txid"], utxos[0]["vout"]
91        # First, outputs that are unspent both in the chain and in the
92        # mempool should appear with or without include_mempool
93        txout = self.nodes[0].gettxout(txid=confirmed_txid, n=confirmed_index, include_mempool=False)
94        assert_equal(txout['value'], 50)
95        txout = self.nodes[0].gettxout(txid=confirmed_txid, n=confirmed_index, include_mempool=True)
96        assert_equal(txout['value'], 50)
97
98        # Send 21 BTC from 0 to 2 using sendtoaddress call.
99        self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
100        mempool_txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
101
102        self.log.info("Test gettxout (second part)")
103        # utxo spent in mempool should be visible if you exclude mempool
104        # but invisible if you include mempool
105        txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index, False)
106        assert_equal(txout['value'], 50)
107        txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index)  # by default include_mempool=True
108        assert txout is None
109        txout = self.nodes[0].gettxout(confirmed_txid, confirmed_index, True)
110        assert txout is None
111        # new utxo from mempool should be invisible if you exclude mempool
112        # but visible if you include mempool
113        txout = self.nodes[0].gettxout(mempool_txid, 0, False)
114        assert txout is None
115        txout1 = self.nodes[0].gettxout(mempool_txid, 0, True)
116        txout2 = self.nodes[0].gettxout(mempool_txid, 1, True)
117        # note the mempool tx will have randomly assigned indices
118        # but 10 will go to node2 and the rest will go to node0
119        balance = self.nodes[0].getbalance()
120        assert_equal(set([txout1['value'], txout2['value']]), set([10, balance]))
121        assert_equal(self.nodes[0].getbalances()["mine"]["immature"], 0)
122
123        # Have node0 mine a block, thus it will collect its own fee.
124        self.generate(self.nodes[0], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
125
126        # Exercise locking of unspent outputs
127        unspent_0 = self.nodes[2].listunspent()[0]
128        unspent_0 = {"txid": unspent_0["txid"], "vout": unspent_0["vout"]}
129        # Trying to unlock an output which isn't locked should error
130        assert_raises_rpc_error(-8, "Invalid parameter, expected locked output", self.nodes[2].lockunspent, True, [unspent_0])
131
132        # Locking an already-locked output should error
133        self.nodes[2].lockunspent(False, [unspent_0])
134        assert_raises_rpc_error(-8, "Invalid parameter, output already locked", self.nodes[2].lockunspent, False, [unspent_0])
135
136        # Restarting the node should clear the lock
137        self.restart_node(2)
138        self.nodes[2].lockunspent(False, [unspent_0])
139
140        # Unloading and reloating the wallet should clear the lock
141        assert_equal(self.nodes[0].listwallets(), [self.default_wallet_name])
142        self.nodes[2].unloadwallet(self.default_wallet_name)
143        self.nodes[2].loadwallet(self.default_wallet_name)
144        assert_equal(len(self.nodes[2].listlockunspent()), 0)
145
146        # Locking non-persistently, then re-locking persistently, is allowed
147        self.nodes[2].lockunspent(False, [unspent_0])
148        self.nodes[2].lockunspent(False, [unspent_0], True)
149
150        # Restarting the node with the lock written to the wallet should keep the lock
151        self.restart_node(2, ["-walletrejectlongchains=0"])
152        assert_raises_rpc_error(-8, "Invalid parameter, output already locked", self.nodes[2].lockunspent, False, [unspent_0])
153
154        # Unloading and reloading the wallet with a persistent lock should keep the lock
155        self.nodes[2].unloadwallet(self.default_wallet_name)
156        self.nodes[2].loadwallet(self.default_wallet_name)
157        assert_raises_rpc_error(-8, "Invalid parameter, output already locked", self.nodes[2].lockunspent, False, [unspent_0])
158
159        # Locked outputs should not be used, even if they are the only available funds
160        assert_raises_rpc_error(-6, "Insufficient funds", self.nodes[2].sendtoaddress, self.nodes[2].getnewaddress(), 20)
161        assert_equal([unspent_0], self.nodes[2].listlockunspent())
162
163        # Unlocking should remove the persistent lock
164        self.nodes[2].lockunspent(True, [unspent_0])
165        self.restart_node(2)
166        assert_equal(len(self.nodes[2].listlockunspent()), 0)
167
168        # Reconnect node 2 after restarts
169        self.connect_nodes(1, 2)
170        self.connect_nodes(0, 2)
171
172        assert_raises_rpc_error(-8, "txid must be of length 64 (not 34, for '0000000000000000000000000000000000')",
173                                self.nodes[2].lockunspent, False,
174                                [{"txid": "0000000000000000000000000000000000", "vout": 0}])
175        assert_raises_rpc_error(-8, "txid must be hexadecimal string (not 'ZZZ0000000000000000000000000000000000000000000000000000000000000')",
176                                self.nodes[2].lockunspent, False,
177                                [{"txid": "ZZZ0000000000000000000000000000000000000000000000000000000000000", "vout": 0}])
178        assert_raises_rpc_error(-8, "Invalid parameter, unknown transaction",
179                                self.nodes[2].lockunspent, False,
180                                [{"txid": "0000000000000000000000000000000000000000000000000000000000000000", "vout": 0}])
181        assert_raises_rpc_error(-8, "Invalid parameter, vout index out of bounds",
182                                self.nodes[2].lockunspent, False,
183                                [{"txid": unspent_0["txid"], "vout": 999}])
184
185        # The lock on a manually selected output is ignored
186        unspent_0 = self.nodes[1].listunspent()[0]
187        self.nodes[1].lockunspent(False, [unspent_0])
188        tx = self.nodes[1].createrawtransaction([unspent_0], { self.nodes[1].getnewaddress() : 1 })
189        self.nodes[1].fundrawtransaction(tx,{"lockUnspents": True})
190
191        # fundrawtransaction can lock an input
192        self.nodes[1].lockunspent(True, [unspent_0])
193        assert_equal(len(self.nodes[1].listlockunspent()), 0)
194        tx = self.nodes[1].fundrawtransaction(tx,{"lockUnspents": True})['hex']
195        assert_equal(len(self.nodes[1].listlockunspent()), 1)
196
197        # Send transaction
198        tx = self.nodes[1].signrawtransactionwithwallet(tx)["hex"]
199        self.nodes[1].sendrawtransaction(tx)
200        assert_equal(len(self.nodes[1].listlockunspent()), 0)
201
202        # Have node1 generate 100 blocks (so node0 can recover the fee)
203        self.generate(self.nodes[1], COINBASE_MATURITY, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
204
205        # node0 should end up with 100 btc in block rewards plus fees, but
206        # minus the 21 plus fees sent to node2
207        assert_equal(self.nodes[0].getbalance(), 100 - 21)
208        assert_equal(self.nodes[2].getbalance(), 21)
209
210        # Node0 should have two unspent outputs.
211        # Create a couple of transactions to send them to node2, submit them through
212        # node1, and make sure both node0 and node2 pick them up properly:
213        node0utxos = self.nodes[0].listunspent(1)
214        assert_equal(len(node0utxos), 2)
215
216        # create both transactions
217        txns_to_send = []
218        for utxo in node0utxos:
219            inputs = []
220            outputs = {}
221            inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
222            outputs[self.nodes[2].getnewaddress()] = utxo["amount"] - 3
223            raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
224            txns_to_send.append(self.nodes[0].signrawtransactionwithwallet(raw_tx))
225
226        # Have node 1 (miner) send the transactions
227        self.nodes[1].sendrawtransaction(hexstring=txns_to_send[0]["hex"], maxfeerate=0)
228        self.nodes[1].sendrawtransaction(hexstring=txns_to_send[1]["hex"], maxfeerate=0)
229
230        # Have node1 mine a block to confirm transactions:
231        self.generate(self.nodes[1], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
232
233        assert_equal(self.nodes[0].getbalance(), 0)
234        assert_equal(self.nodes[2].getbalance(), 94)
235
236        # Verify that a spent output cannot be locked anymore
237        spent_0 = {"txid": node0utxos[0]["txid"], "vout": node0utxos[0]["vout"]}
238        assert_raises_rpc_error(-8, "Invalid parameter, expected unspent output", self.nodes[0].lockunspent, False, [spent_0])
239
240        # Send 10 BTC normal
241        address = self.nodes[0].getnewaddress("test")
242        fee_per_byte = Decimal('0.001') / 1000
243        fee_rate_sat_vb = fee_per_byte * Decimal(1e8)
244        txid = self.nodes[2].sendtoaddress(address, 10, "", "", False, fee_rate=fee_rate_sat_vb)
245        self.generate(self.nodes[2], 1, sync_fun=lambda: self.sync_all(self.nodes[0:3]))
246        node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), Decimal('84'), fee_per_byte, self.get_vsize(self.nodes[2].gettransaction(txid)['hex']))
247        assert_equal(self.nodes[0].getbalance(), Decimal('10'))
248
249        # Send 10 BTC with subtract fee from amount
250        txid = self.nodes[2].sendtoaddress(address, 10, "", "", True, fee_rate=fee_rate_sat_vb)