Inside Bitcoin

1251
1252        # Select the preset inputs
1253        coins = wallet.listunspent()
1254        preset_inputs = [coins[0], coins[1], coins[2]]
1255
1256        # Now let's create the tx creation options
1257        options = {
1258            "inputs": preset_inputs,
1259            "add_inputs": True,  # automatically add coins from the wallet to fulfill the target
1260            "subtract_fee_from_outputs": [0],  # deduct fee from first output
1261            "add_to_wallet": False,
1262            "fee_rate": self.fee_rate_sats_per_vb
1263        }
1264
1265        # Attempt to send 29 BTC from a wallet that only has 20 BTC. The wallet should exclude
1266        # the preset inputs from the pool of available coins, realize that there is not enough
1267        # money to fund the 29 BTC payment, and fail with "Insufficient funds".
1268        #
1269        # Even with SFFO, the wallet can only afford to send 20 BTC.
1270        # If the wallet does not properly exclude preset inputs from the pool of available coins
1271        # prior to coin selection, it may create a transaction that does not fund the full payment
1272        # amount or, through SFFO, incorrectly reduce the recipient's amount by the difference
1273        # between the original target and the wrongly counted inputs (in this case 9 BTC)
1274        # so that the recipient's amount is no longer equal to the user's selected target of 29 BTC.
1275
1276        # First case, use 'subtract_fee_from_outputs = true'
1277        assert_raises_rpc_error(-4, "Insufficient funds", wallet.send, outputs=[{wallet.getnewaddress(address_type="bech32"): 29}], options=options)
1278
1279        # Second case, don't use 'subtract_fee_from_outputs'
1280        del options["subtract_fee_from_outputs"]
1281        assert_raises_rpc_error(-4, "Insufficient funds", wallet.send, outputs=[{wallet.getnewaddress(address_type="bech32"): 29}], options=options)
1282
1283        self.nodes[2].unloadwallet("test_preset_inputs_selection")
1284
1285    def test_weight_calculation(self):
1286        self.log.info("Test weight calculation with external inputs")
1287
1288        self.nodes[2].createwallet("test_weight_calculation")
1289        wallet = self.nodes[2].get_wallet_rpc("test_weight_calculation")
1290
1291        addr = wallet.getnewaddress(address_type="bech32")
1292        ext_addr = self.nodes[0].getnewaddress(address_type="bech32")
1293        utxo, ext_utxo = self.create_outpoints(self.nodes[0], outputs=[{addr: 5}, {ext_addr: 5}])
1294
1295        self.nodes[0].sendtoaddress(wallet.getnewaddress(address_type="bech32"), 5, fee_rate=self.fee_rate_sats_per_vb)
1296        self.generate(self.nodes[0], 1)
1297
1298        rawtx = wallet.createrawtransaction([utxo], [{self.nodes[0].getnewaddress(address_type="bech32"): 8}])
1299        fundedtx = wallet.fundrawtransaction(rawtx, fee_rate=10, change_type="bech32")
1300        # with 71-byte signatures we should expect following tx size
1301        # tx overhead (10) + 2 inputs (41 each) + 2 p2wpkh (31 each) + (segwit marker and flag (2) + 2 p2wpkh 71 byte sig witnesses (107 each)) / witness scaling factor (4)
1302        tx_size = ceil(10 + 41*2 + 31*2 + (2 + 107*2)/4)
1303        assert_equal(fundedtx['fee'] * COIN, tx_size * 10)
1304
1305        # Using the other output should have 72 byte sigs
1306        rawtx = wallet.createrawtransaction([ext_utxo], [{self.nodes[0].getnewaddress(): 13}])
1307        ext_desc = self.nodes[0].getaddressinfo(ext_addr)["desc"]
1308        fundedtx = wallet.fundrawtransaction(rawtx, fee_rate=10, change_type="bech32", solving_data={"descriptors": [ext_desc]})
1309        # tx overhead (10) + 3 inputs (41 each) + 2 p2wpkh(31 each) + (segwit marker and flag (2) + 2 p2wpkh 71 bytes sig witnesses (107 each) + p2wpkh 72 byte sig witness (108)) / witness scaling factor (4)
1310        tx_size = ceil(10 + 41*3 + 31*2 + (2 + 107*2 + 108)/4)
1311        assert_equal(fundedtx['fee'] * COIN, tx_size * 10)
1312
1313        self.nodes[2].unloadwallet("test_weight_calculation")
1314
1315    def test_weight_limits(self):
1316        self.log.info("Test weight limits")
1317
1318        self.nodes[2].createwallet("test_weight_limits")
1319        wallet = self.nodes[2].get_wallet_rpc("test_weight_limits")
1320
1321        outputs = []
1322        for _ in range(1472):
1323            outputs.append({wallet.getnewaddress(address_type="legacy"): 0.1})
1324        txid = self.nodes[0].send(outputs=outputs, change_position=0, fee_rate=self.fee_rate_sats_per_vb)["txid"]
1325        self.generate(self.nodes[0], 1)
1326
1327        # 272 WU per input (273 when high-s); picking 1471 inputs will exceed the max standard tx weight.
1328        rawtx = wallet.createrawtransaction([], [{wallet.getnewaddress(): 0.1 * 1471}])
1329
1330        # 1) Try to fund transaction only using the preset inputs (pick all 1472 inputs to cover the fee)
1331        input_weights = []
1332        for i in range(1, 1473):  # skip first output as it is the parent tx change output
1333            input_weights.append({"txid": txid, "vout": i, "weight": 273})
1334        assert_raises_rpc_error(-4, "Transaction too large", wallet.fundrawtransaction, hexstring=rawtx, input_weights=input_weights)
1335
1336        # 2) Let the wallet fund the transaction
1337        assert_raises_rpc_error(-4, "The inputs size exceeds the maximum weight. Please try sending a smaller amount or manually consolidating your wallet's UTXOs",
1338                                wallet.fundrawtransaction, hexstring=rawtx)
1339
1340        # 3) Pre-select some inputs and let the wallet fill-up the remaining amount
1341        inputs = input_weights[0:1000]
1342        assert_raises_rpc_error(-4, "The combination of the pre-selected inputs and the wallet automatic inputs selection exceeds the transaction maximum weight. Please try sending a smaller amount or manually consolidating your wallet's UTXOs",
1343                                wallet.fundrawtransaction, hexstring=rawtx, input_weights=inputs)
1344
1345        self.nodes[2].unloadwallet("test_weight_limits")
1346
1347    def test_include_unsafe(self):
1348        self.log.info("Test fundrawtxn with unsafe inputs")
1349
1350        self.nodes[0].createwallet("unsafe")
1351        wallet = self.nodes[0].get_wallet_rpc("unsafe")
1352
1353        # We receive unconfirmed funds from external keys (unsafe outputs).
1354        addr = wallet.getnewaddress()
1355        inputs = []
1356        for i in range(0, 2):
1357            utxo = self.create_outpoints(self.nodes[2], outputs=[{addr: 5}])[0]
1358            inputs.append((utxo['txid'], utxo['vout']))
1359        self.sync_mempools()
1360
1361        # Unsafe inputs are ignored by default.
1362        rawtx = wallet.createrawtransaction([], [{self.nodes[2].getnewaddress(): 7.5}])
1363        assert_raises_rpc_error(-4, "Insufficient funds", wallet.fundrawtransaction, rawtx)
1364
1365        # But we can opt-in to use them for funding.
1366        fundedtx = wallet.fundrawtransaction(rawtx, include_unsafe=True, fee_rate=self.fee_rate_sats_per_vb)
1367        tx_dec = wallet.decoderawtransaction(fundedtx['hex'])
1368        assert all((txin["txid"], txin["vout"]) in inputs for txin in tx_dec["vin"])
1369        signedtx = wallet.signrawtransactionwithwallet(fundedtx['hex'])
1370        assert wallet.testmempoolaccept([signedtx['hex']])[0]["allowed"]
1371
1372        # And we can also use them once they're confirmed.
1373        self.generate(self.nodes[0], 1)
1374        fundedtx = wallet.fundrawtransaction(rawtx, include_unsafe=False, fee_rate=self.fee_rate_sats_per_vb)
1375        tx_dec = wallet.decoderawtransaction(fundedtx['hex'])
1376        assert all((txin["txid"], txin["vout"]) in inputs for txin in tx_dec["vin"])
1377        signedtx = wallet.signrawtransactionwithwallet(fundedtx['hex'])
1378        assert wallet.testmempoolaccept([signedtx['hex']])[0]["allowed"]
1379        self.nodes[0].unloadwallet("unsafe")
1380
1381    def test_22670(self):
1382        # In issue #22670, it was observed that ApproximateBestSubset may
1383        # choose enough value to cover the target amount but not enough to cover the transaction fees.
1384        # This leads to a transaction whose actual transaction feerate is lower than expected.
1385        # However at normal feerates, the difference between the effective value and the real value
1386        # that this bug is not detected because the transaction fee must be at least 0.01 BTC (the minimum change value).
1387        # Otherwise the targeted minimum change value will be enough to cover the transaction fees that were not
1388        # being accounted for. So the minimum relay fee is set to 0.1 BTC/kvB in this test.
1389        self.log.info("Test issue 22670 ApproximateBestSubset bug")
1390        # Make sure the default wallet will not be loaded when restarted with a high minrelaytxfee
1391        self.nodes[0].unloadwallet(self.default_wallet_name, False)
1392        feerate = Decimal("0.1")
1393        self.restart_node(0, [f"-minrelaytxfee={feerate}", "-discardfee=0"]) # Set high minrelayfee, set discardfee to 0 for easier calculation
1394
1395        self.nodes[0].loadwallet(self.default_wallet_name, True)
1396        funds = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
1397        self.nodes[0].createwallet(wallet_name="tester")
1398        tester = self.nodes[0].get_wallet_rpc("tester")
1399
1400        # Because this test is specifically for ApproximateBestSubset, the target value must be greater
1401        # than any single input available, and require more than 1 input. So we make 3 outputs
1402        for i in range(0, 3):
1403            funds.sendtoaddress(tester.getnewaddress(address_type="bech32"), 1)
1404        self.generate(self.nodes[0], 1, sync_fun=self.no_op)
1405
1406        # Create transactions in order to calculate fees for the target bounds that can trigger this bug
1407        change_tx = tester.fundrawtransaction(tester.createrawtransaction([], [{funds.getnewaddress(): 1.5}]))
1408        tx = tester.createrawtransaction([], [{funds.getnewaddress(): 2}])
1409        no_change_tx = tester.fundrawtransaction(tx, subtractFeeFromOutputs=[0])
1410
1411        overhead_fees = feerate * len(tx) / 2 / 1000
1412        cost_of_change = change_tx["fee"] - no_change_tx["fee"]
1413        fees = no_change_tx["fee"]
1414        assert_greater_than(fees, 0.01)
1415
1416        def do_fund_send(target):
1417            create_tx = tester.createrawtransaction([], [{funds.getnewaddress(): target}])
1418            funded_tx = tester.fundrawtransaction(create_tx)
1419            signed_tx = tester.signrawtransactionwithwallet(funded_tx["hex"])
1420            assert signed_tx["complete"]
1421            decoded_tx = tester.decoderawtransaction(signed_tx["hex"])
1422            assert_equal(len(decoded_tx["vin"]), 3)
1423            assert tester.testmempoolaccept([signed_tx["hex"]])[0]["allowed"]
1424
1425        # We want to choose more value than is available in 2 inputs when considering the fee,
1426        # but not enough to need 3 inputs when not considering the fee.
1427        # So the target value must be at least 2.00000001 - fee.
1428        lower_bound = Decimal("2.00000001") - fees
1429        # The target value must be at most 2 - cost_of_change - not_input_fees - min_change (these are all
1430        # included in the target before ApproximateBestSubset).
1431        upper_bound = Decimal("2.0") - cost_of_change - overhead_fees - Decimal("0.01")
1432        assert_greater_than_or_equal(upper_bound, lower_bound)
1433        do_fund_send(lower_bound)
1434        do_fund_send(upper_bound)
1435
1436        self.restart_node(0)
1437        self.connect_nodes(0, 1)
1438        self.connect_nodes(0, 2)
1439        self.connect_nodes(0, 3)
1440
1441    def test_feerate_rounding(self):
1442        self.log.info("Test that rounding of GetFee does not result in an assertion")
1443
1444        self.nodes[1].createwallet("roundtest")
1445        w = self.nodes[1].get_wallet_rpc("roundtest")
1446
1447        addr = w.getnewaddress(address_type="bech32")
1448        self.nodes[0].sendtoaddress(addr, 1, fee_rate=self.fee_rate_sats_per_vb)
1449        self.generate(self.nodes[0], 1)
1450
1451        # A P2WPKH input costs 68 vbytes; With a single P2WPKH output, the rest of the tx is 42 vbytes for a total of 110 vbytes.
1452        # At a feerate of 1.85 sat/vb, the input will need a fee of 125.8 sats and the rest 77.7 sats
1453        # The entire tx fee should be 203.5 sats.
1454        # Coin selection rounds the fee individually instead of at the end (due to how CFeeRate::GetFee works).
1455        # If rounding down (which is the incorrect behavior), then the calculated fee will be 125 + 77 = 202.
1456        # If rounding up, then the calculated fee will be 126 + 78 = 204.
1457        # In the former case, the calculated needed fee is higher than the actual fee being paid, so an assertion is reached
1458        # To test this does not happen, we subtract 202 sats from the input value. If working correctly, this should
1459        # fail with insufficient funds rather than bitcoind asserting.
1460        rawtx = w.createrawtransaction(inputs=[], outputs=[{self.nodes[0].getnewaddress(address_type="bech32"): 1 - 0.00000202}])
1461        expected_err_msg = "The total exceeds your balance when the 0.00000078 transaction fee is included."
1462        assert_raises_rpc_error(-4, expected_err_msg, w.fundrawtransaction, rawtx, fee_rate=1.85)
1463
1464    def test_input_confs_control(self):
1465        self.nodes[0].createwallet("minconf")
1466        wallet = self.nodes[0].get_wallet_rpc("minconf")
1467
1468        # Fund the wallet with different chain heights
1469        for _ in range(2):
1470            self.nodes[2].sendmany("", {wallet.getnewaddress():1, wallet.getnewaddress():1}, fee_rate=self.fee_rate_sats_per_vb)
1471            self.generate(self.nodes[2], 1)
1472
1473        unconfirmed_txid = wallet.sendtoaddress(wallet.getnewaddress(), 0.5, fee_rate=self.fee_rate_sats_per_vb)
1474
1475        self.log.info("Crafting TX using an unconfirmed input")
1476        target_address = self.nodes[2].getnewaddress()
1477        raw_tx1 = wallet.createrawtransaction([], {target_address: 0.1}, 0, True)
1478        funded_tx1 = wallet.fundrawtransaction(raw_tx1, {'fee_rate': 1, 'maxconf': 0})['hex']
1479
1480        # Make sure we only had the one input
1481        tx1_inputs = self.nodes[0].decoderawtransaction(funded_tx1)['vin']
1482        assert_equal(len(tx1_inputs), 1)
1483
1484        utxo1 = tx1_inputs[0]
1485        assert_equal(unconfirmed_txid, utxo1['txid'])
1486
1487        final_tx1 = wallet.signrawtransactionwithwallet(funded_tx1)['hex']
1488        txid1 = self.nodes[0].sendrawtransaction(final_tx1)
1489
1490        mempool = self.nodes[0].getrawmempool()
1491        assert txid1 in mempool
1492
1493        self.log.info("Fail to craft a new TX with minconf above highest one")
1494        # Create a replacement tx to 'final_tx1' that has 1 BTC target instead of 0.1.
1495        raw_tx2 = wallet.createrawtransaction([{'txid': utxo1['txid'], 'vout': utxo1['vout']}], {target_address: 1})
1496        assert_raises_rpc_error(-4, "Insufficient funds", wallet.fundrawtransaction, raw_tx2, {'add_inputs': True, 'minconf': 3, 'fee_rate': 10})
1497
1498        self.log.info("Fail to broadcast a new TX with maxconf 0 due to BIP125 rules to verify it actually chose unconfirmed outputs")
1499        # Now fund 'raw_tx2' to fulfill the total target (1 BTC) by using all the wallet unconfirmed outputs.
1500        # As it was created with the first unconfirmed output, 'raw_tx2' only has 0.1 BTC covered (need to fund 0.9 BTC more).