Inside Bitcoin

1001        utxo = self.create_outpoints(self.nodes[0], outputs=[{addr: 10}])[0]
1002
1003        rawtx = self.nodes[0].createrawtransaction([utxo], [{self.nodes[0].getnewaddress(): 5}])
1004        fundedtx = self.nodes[0].fundrawtransaction(rawtx, subtractFeeFromOutputs=[0], fee_rate=self.fee_rate_sats_per_vb)
1005        signedtx = self.nodes[0].signrawtransactionwithwallet(fundedtx['hex'])
1006        self.nodes[0].sendrawtransaction(signedtx['hex'])
1007
1008    def test_transaction_too_large(self):
1009        self.log.info("Test fundrawtx where BnB solution would result in a too large transaction, but Knapsack would not")
1010        self.nodes[0].createwallet("large")
1011        wallet = self.nodes[0].get_wallet_rpc(self.default_wallet_name)
1012        recipient = self.nodes[0].get_wallet_rpc("large")
1013        outputs = {}
1014        rawtx = recipient.createrawtransaction([], {wallet.getnewaddress(): 147.99899260})
1015
1016        # Make 1500 0.1 BTC outputs. The amount that we target for funding is in
1017        # the BnB range when these outputs are used.  However if these outputs
1018        # are selected, the transaction will end up being too large, so it
1019        # shouldn't use BnB and instead fall back to Knapsack but that behavior
1020        # is not implemented yet. For now we just check that we get an error.
1021        # First, force the wallet to bulk-generate the addresses we'll need.
1022        recipient.keypoolrefill(1500)
1023        for _ in range(1500):
1024            outputs[recipient.getnewaddress()] = 0.1
1025        wallet.sendmany("", outputs, fee_rate=self.fee_rate_sats_per_vb)
1026        self.generate(self.nodes[0], 10)
1027        assert_raises_rpc_error(-4, "The inputs size exceeds the maximum weight. "
1028                                    "Please try sending a smaller amount or manually consolidating your wallet's UTXOs",
1029                                recipient.fundrawtransaction, rawtx)
1030        self.nodes[0].unloadwallet("large")
1031
1032    def test_external_inputs(self):
1033        self.log.info("Test funding with external inputs")
1034        privkey, _ = generate_keypair(wif=True)
1035        self.nodes[2].createwallet("extfund")
1036        wallet = self.nodes[2].get_wallet_rpc("extfund")
1037
1038        # Make a weird but signable script. sh(pkh()) descriptor accomplishes this
1039        desc = descsum_create("sh(pkh({}))".format(privkey))
1040        res = self.nodes[0].importdescriptors([{"desc": desc, "timestamp": "now"}])
1041        assert res[0]["success"]
1042        addr = self.nodes[0].deriveaddresses(desc)[0]
1043        addr_info = self.nodes[0].getaddressinfo(addr)
1044
1045        self.nodes[0].sendtoaddress(addr, 10, fee_rate=self.fee_rate_sats_per_vb)
1046        self.nodes[0].sendtoaddress(wallet.getnewaddress(), 10, fee_rate=self.fee_rate_sats_per_vb)
1047        self.generate(self.nodes[0], 6)
1048        ext_utxo = self.nodes[0].listunspent(addresses=[addr])[0]
1049
1050        # An external input without solving data should result in an error
1051        raw_tx = wallet.createrawtransaction([ext_utxo], {self.nodes[0].getnewaddress(): ext_utxo["amount"] / 2})
1052        assert_raises_rpc_error(-4, "Not solvable pre-selected input COutPoint(%s, %s)" % (ext_utxo["txid"][0:10], ext_utxo["vout"]), wallet.fundrawtransaction, raw_tx)
1053
1054        # Error conditions
1055        assert_raises_rpc_error(-5, 'Pubkey "not a pubkey" must be a hex string', wallet.fundrawtransaction, raw_tx, solving_data={"pubkeys":["not a pubkey"]})
1056        assert_raises_rpc_error(-5, 'Pubkey "01234567890a0b0c0d0e0f" must have a length of either 33 or 65 bytes', wallet.fundrawtransaction, raw_tx, solving_data={"pubkeys":["01234567890a0b0c0d0e0f"]})
1057        assert_raises_rpc_error(-5, "'not a script' is not hex", wallet.fundrawtransaction, raw_tx, solving_data={"scripts":["not a script"]})
1058        assert_raises_rpc_error(-8, "Unable to parse descriptor 'not a descriptor'", wallet.fundrawtransaction, raw_tx, solving_data={"descriptors":["not a descriptor"]})
1059        assert_raises_rpc_error(-8, "Invalid parameter, missing vout key", wallet.fundrawtransaction, raw_tx, input_weights=[{"txid": ext_utxo["txid"]}])
1060        assert_raises_rpc_error(-8, "Invalid parameter, vout cannot be negative", wallet.fundrawtransaction, raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": -1}])
1061        assert_raises_rpc_error(-8, "Invalid parameter, missing weight key", wallet.fundrawtransaction, raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"]}])
1062        assert_raises_rpc_error(-8, "Invalid parameter, weight cannot be less than 165", wallet.fundrawtransaction, raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": 164}])
1063        assert_raises_rpc_error(-8, "Invalid parameter, weight cannot be less than 165", wallet.fundrawtransaction, raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": -1}])
1064        assert_raises_rpc_error(-8, "Invalid parameter, weight cannot be greater than", wallet.fundrawtransaction, raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": 400001}])
1065
1066        # But funding should work when the solving data is provided
1067        funded_tx = wallet.fundrawtransaction(raw_tx, solving_data={"pubkeys": [addr_info['pubkey']], "scripts": [addr_info["embedded"]["scriptPubKey"]]})
1068        signed_tx = wallet.signrawtransactionwithwallet(funded_tx['hex'])
1069        assert not signed_tx['complete']
1070        signed_tx = self.nodes[0].signrawtransactionwithwallet(signed_tx['hex'])
1071        assert signed_tx['complete']
1072
1073        funded_tx = wallet.fundrawtransaction(raw_tx, solving_data={"descriptors": [desc]}, fee_rate=self.fee_rate_sats_per_vb)
1074        signed_tx1 = wallet.signrawtransactionwithwallet(funded_tx['hex'])
1075        assert not signed_tx1['complete']
1076        signed_tx2 = self.nodes[0].signrawtransactionwithwallet(signed_tx1['hex'])
1077        assert signed_tx2['complete']
1078
1079        unsigned_weight = self.nodes[0].decoderawtransaction(signed_tx1["hex"])["weight"]
1080        signed_weight = self.nodes[0].decoderawtransaction(signed_tx2["hex"])["weight"]
1081        # Input's weight is difference between weight of signed and unsigned,
1082        # and the weight of stuff that didn't change (prevout, sequence, 1 byte of scriptSig)
1083        input_weight = signed_weight - unsigned_weight + (41 * 4)
1084        low_input_weight = input_weight // 2
1085        high_input_weight = input_weight * 2
1086
1087        # Funding should also work if the input weight is provided
1088        funded_tx = wallet.fundrawtransaction(raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": input_weight}], fee_rate=2)
1089        signed_tx = wallet.signrawtransactionwithwallet(funded_tx["hex"])
1090        signed_tx = self.nodes[0].signrawtransactionwithwallet(signed_tx["hex"])
1091        assert_equal(self.nodes[0].testmempoolaccept([signed_tx["hex"]])[0]["allowed"], True)
1092        assert_equal(signed_tx["complete"], True)
1093        # Reducing the weight should have a lower fee
1094        funded_tx2 = wallet.fundrawtransaction(raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": low_input_weight}], fee_rate=2)
1095        assert_greater_than(funded_tx["fee"], funded_tx2["fee"])
1096        # Increasing the weight should have a higher fee
1097        funded_tx2 = wallet.fundrawtransaction(raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}], fee_rate=2)
1098        assert_greater_than(funded_tx2["fee"], funded_tx["fee"])
1099        # The provided weight should override the calculated weight when solving data is provided
1100        funded_tx3 = wallet.fundrawtransaction(raw_tx, solving_data={"descriptors": [desc]}, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}], fee_rate=2)
1101        assert_equal(funded_tx2["fee"], funded_tx3["fee"])
1102        # The feerate should be met
1103        funded_tx4 = wallet.fundrawtransaction(raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": high_input_weight}], fee_rate=10)
1104        input_add_weight = high_input_weight - (41 * 4)
1105        tx4_weight = wallet.decoderawtransaction(funded_tx4["hex"])["weight"] + input_add_weight
1106        tx4_vsize = int(ceil(tx4_weight / 4))
1107        assert_fee_amount(funded_tx4["fee"], tx4_vsize, Decimal(0.0001))
1108
1109        # Funding with weight at csuint boundaries should not cause problems
1110        funded_tx = wallet.fundrawtransaction(raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": 255}], fee_rate=2)
1111        funded_tx = wallet.fundrawtransaction(raw_tx, input_weights=[{"txid": ext_utxo["txid"], "vout": ext_utxo["vout"], "weight": 65539}], fee_rate=2)
1112
1113        self.nodes[2].unloadwallet("extfund")
1114
1115    def test_add_inputs_default_value(self):
1116        self.log.info("Test 'add_inputs' default value")
1117
1118        # Create and fund the wallet with 5 BTC
1119        self.nodes[2].createwallet("test_preset_inputs")
1120        wallet = self.nodes[2].get_wallet_rpc("test_preset_inputs")
1121        addr1 = wallet.getnewaddress(address_type="bech32")
1122        self.nodes[0].sendtoaddress(addr1, 5, fee_rate=self.fee_rate_sats_per_vb)
1123        self.generate(self.nodes[0], 1)
1124
1125        # Covered cases:
1126        # 1. Default add_inputs value with no preset inputs (add_inputs=true):
1127        #       Expect: automatically add coins from the wallet to the tx.
1128        # 2. Default add_inputs value with preset inputs (add_inputs=false):
1129        #       Expect: disallow automatic coin selection.
1130        # 3. Explicit add_inputs=true and preset inputs (with preset inputs not-covering the target amount).
1131        #       Expect: include inputs from the wallet.
1132        # 4. Explicit add_inputs=true and preset inputs (with preset inputs covering the target amount).
1133        #       Expect: only preset inputs are used.
1134        # 5. Explicit add_inputs=true, no preset inputs (same as (1) but with an explicit set):
1135        #       Expect: include inputs from the wallet.
1136        # 6. Explicit add_inputs=false, no preset inputs:
1137        #       Expect: failure as we did not provide inputs and the process cannot automatically select coins.
1138
1139        # Case (1), 'send' command
1140        # 'add_inputs' value is true unless "inputs" are specified, in such case, add_inputs=false.
1141        # So, the wallet will automatically select coins and create the transaction if only the outputs are provided.
1142        tx = wallet.send(outputs=[{addr1: 3}], fee_rate=self.fee_rate_sats_per_vb)
1143        assert tx["complete"]
1144
1145        # Case (2), 'send' command
1146        # Select an input manually, which doesn't cover the entire output amount and
1147        # verify that the dynamically set 'add_inputs=false' value works.
1148
1149        # Fund wallet with 2 outputs, 5 BTC each.
1150        addr2 = wallet.getnewaddress(address_type="bech32")
1151        source_tx = self.nodes[0].send(outputs=[{addr1: 5}, {addr2: 5}], change_position=0, fee_rate=self.fee_rate_sats_per_vb)
1152        self.generate(self.nodes[0], 1)
1153
1154        # Select only one input.
1155        options = {
1156            "inputs": [
1157                {
1158                    "txid": source_tx["txid"],
1159                    "vout": 1  # change position was hardcoded to index 0
1160                }
1161            ]
1162        }
1163        assert_raises_rpc_error(-4, ERR_NOT_ENOUGH_PRESET_INPUTS, wallet.send, outputs=[{addr1: 8}], **options)
1164
1165        # Case (3), Explicit add_inputs=true and preset inputs (with preset inputs not-covering the target amount)
1166        options["add_inputs"] = True
1167        options["add_to_wallet"] = False
1168        options["fee_rate"] = self.fee_rate_sats_per_vb
1169        tx = wallet.send(outputs=[{addr1: 8}], **options)
1170        assert tx["complete"]
1171
1172        # Case (4), Explicit add_inputs=true and preset inputs (with preset inputs covering the target amount)
1173        options["inputs"].append({
1174            "txid": source_tx["txid"],
1175            "vout": 2  # change position was hardcoded to index 0
1176        })
1177        tx = wallet.send(outputs=[{addr1: 8}], **options)
1178        assert tx["complete"]
1179        # Check that only the preset inputs were added to the tx
1180        decoded_psbt_inputs = self.nodes[0].decodepsbt(tx["psbt"])["inputs"]
1181        assert_equal(len(decoded_psbt_inputs), 2)
1182        for input in decoded_psbt_inputs:
1183            assert_equal(input["previous_txid"], source_tx["txid"])
1184
1185        # Case (5), assert that inputs are added to the tx by explicitly setting add_inputs=true
1186        options = {"add_inputs": True, "add_to_wallet": True}
1187        tx = wallet.send(outputs=[{addr1: 8}], **options)
1188        assert tx["complete"]
1189
1190        # 6. Explicit add_inputs=false, no preset inputs:
1191        options = {"add_inputs": False}
1192        assert_raises_rpc_error(-4, ERR_NOT_ENOUGH_PRESET_INPUTS, wallet.send, outputs=[{addr1: 3}], **options)
1193
1194        ################################################
1195
1196        # Case (1), 'walletcreatefundedpsbt' command
1197        # Default add_inputs value with no preset inputs (add_inputs=true)
1198        inputs = []
1199        outputs = {self.nodes[1].getnewaddress(): 8}
1200        assert "psbt" in wallet.walletcreatefundedpsbt(inputs=inputs, outputs=outputs, options={'fee_rate': self.fee_rate_sats_per_vb})
1201
1202        # Case (2), 'walletcreatefundedpsbt' command
1203        # Default add_inputs value with preset inputs (add_inputs=false).
1204        inputs = [{
1205            "txid": source_tx["txid"],
1206            "vout": 1  # change position was hardcoded to index 0
1207        }]
1208        outputs = {self.nodes[1].getnewaddress(): 8}
1209        assert_raises_rpc_error(-4, ERR_NOT_ENOUGH_PRESET_INPUTS, wallet.walletcreatefundedpsbt, inputs=inputs, outputs=outputs, options={'fee_rate': self.fee_rate_sats_per_vb})
1210
1211        # Case (3), Explicit add_inputs=true and preset inputs (with preset inputs not-covering the target amount)
1212        options["add_inputs"] = True
1213        assert "psbt" in wallet.walletcreatefundedpsbt(outputs=[{addr1: 8}], inputs=inputs, **options)
1214
1215        # Case (4), Explicit add_inputs=true and preset inputs (with preset inputs covering the target amount)
1216        inputs.append({
1217            "txid": source_tx["txid"],
1218            "vout": 2  # change position was hardcoded to index 0
1219        })
1220        psbt_tx = wallet.walletcreatefundedpsbt(outputs=[{addr1: 8}], inputs=inputs, **options)
1221        # Check that only the preset inputs were added to the tx
1222        decoded_psbt_inputs = self.nodes[0].decodepsbt(psbt_tx["psbt"])["inputs"]
1223        assert_equal(len(decoded_psbt_inputs), 2)
1224        for input in decoded_psbt_inputs:
1225            assert_equal(input["previous_txid"], source_tx["txid"])
1226
1227        # Case (5), 'walletcreatefundedpsbt' command
1228        # Explicit add_inputs=true, no preset inputs
1229        options = {
1230            "add_inputs": True,
1231        }
1232        assert "psbt" in wallet.walletcreatefundedpsbt(inputs=[], outputs=outputs, **options)
1233
1234        # Case (6). Explicit add_inputs=false, no preset inputs:
1235        options = {"add_inputs": False}
1236        assert_raises_rpc_error(-4, ERR_NOT_ENOUGH_PRESET_INPUTS, wallet.walletcreatefundedpsbt, inputs=[], outputs=outputs, **options)
1237
1238        self.nodes[2].unloadwallet("test_preset_inputs")
1239
1240    def test_preset_inputs_selection(self):
1241        self.log.info('Test wallet preset inputs are not double-counted or reused in coin selection')
1242
1243        # Create and fund the wallet with 4 UTXO of 5 BTC each (20 BTC total)
1244        self.nodes[2].createwallet("test_preset_inputs_selection")
1245        wallet = self.nodes[2].get_wallet_rpc("test_preset_inputs_selection")
1246        outputs = {}
1247        for _ in range(4):
1248            outputs[wallet.getnewaddress(address_type="bech32")] = 5
1249        self.nodes[0].sendmany("", outputs, fee_rate=self.fee_rate_sats_per_vb)
1250        self.generate(self.nodes[0], 1)