Inside Bitcoin

251        self.log.info("Don't broadcast...")
252        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, add_to_wallet=False)
253        assert res["hex"]
254
255        self.log.info("Return PSBT...")
256        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, psbt=True)
257        assert res["psbt"]
258
259        self.log.info("Create transaction that spends to address, but don't broadcast...")
260        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, add_to_wallet=False)
261        # conf_target & estimate_mode can be set as argument or option
262        res1 = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_conf_target=1, arg_estimate_mode="economical", add_to_wallet=False)
263        res2 = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, conf_target=1, estimate_mode="economical", add_to_wallet=False)
264        assert_equal(self.nodes[1].decodepsbt(res1["psbt"])["fee"],
265                     self.nodes[1].decodepsbt(res2["psbt"])["fee"])
266        # but not at the same time
267        for mode in ["unset", "economical", "conservative"]:
268            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_conf_target=1, arg_estimate_mode="economical",
269                conf_target=1, estimate_mode=mode, add_to_wallet=False,
270                expect_error=(-8, "Pass conf_target and estimate_mode either as arguments or in the options object, but not both"))
271
272        self.log.info("Create PSBT from watch-only wallet w3, sign with w2...")
273        res = self.test_send(from_wallet=w3, to_wallet=w1, amount=1)
274        res = w2.walletprocesspsbt(res["psbt"])
275        assert res["complete"]
276
277        self.log.info("Create OP_RETURN...")
278        self.test_send(from_wallet=w0, to_wallet=w1, amount=1)
279        self.test_send(from_wallet=w0, data="Hello World", expect_error=(-8, "Data must be hexadecimal string (not 'Hello World')"))
280        self.test_send(from_wallet=w0, data="23")
281        res = self.test_send(from_wallet=w3, data="23")
282        res = w2.walletprocesspsbt(res["psbt"])
283        assert res["complete"]
284
285        self.log.info("Create mempool-invalid tx (due to large OP_RETURN)...")
286        self.test_send(from_wallet=w0, data=b"The quick brown fox jumps over the lazy dog".hex(), nonmempool=True)
287
288        self.log.info("Test setting explicit fee rate")
289        res1 = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate="1", add_to_wallet=False)
290        res2 = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate="1", add_to_wallet=False)
291        assert_equal(self.nodes[1].decodepsbt(res1["psbt"])["fee"], self.nodes[1].decodepsbt(res2["psbt"])["fee"])
292
293        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate=7, add_to_wallet=False)
294        fee = self.nodes[1].decodepsbt(res["psbt"])["fee"]
295        assert_fee_amount(fee, count_bytes(res["hex"]), Decimal("0.00007"))
296
297        # "unset" and None are treated the same for estimate_mode
298        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate=2, estimate_mode="unset", add_to_wallet=False)
299        fee = self.nodes[1].decodepsbt(res["psbt"])["fee"]
300        assert_fee_amount(fee, count_bytes(res["hex"]), Decimal("0.00002"))
301
302        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=4.531, add_to_wallet=False)
303        fee = self.nodes[1].decodepsbt(res["psbt"])["fee"]
304        assert_fee_amount(fee, count_bytes(res["hex"]), Decimal("0.00004531"))
305
306        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=3, add_to_wallet=False)
307        fee = self.nodes[1].decodepsbt(res["psbt"])["fee"]
308        assert_fee_amount(fee, count_bytes(res["hex"]), Decimal("0.00003"))
309
310        # Test that passing fee_rate as both an argument and an option raises.
311        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=1, fee_rate=1, add_to_wallet=False,
312                       expect_error=(-8, "Pass the fee_rate either as an argument, or in the options object, but not both"))
313
314        assert_raises_rpc_error(-8, "Use fee_rate (sat/vB) instead of feeRate", w0.send, {w1.getnewaddress(): 1}, 6, "conservative", 1, {"feeRate": 0.01})
315
316        assert_raises_rpc_error(-3, "Unexpected key totalFee", w0.send, {w1.getnewaddress(): 1}, 6, "conservative", 1, {"totalFee": 0.01})
317
318        for target, mode in product([-1, 0, 1009], ["economical", "conservative"]):
319            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, conf_target=target, estimate_mode=mode,
320                expect_error=(-8, "Invalid conf_target, must be between 1 and 1008"))  # max value of 1008 per src/policy/fees/block_policy_estimator.h
321        msg = 'Invalid estimate_mode parameter, must be one of: "unset", "economical", "conservative"'
322        for target, mode in product([-1, 0], ["btc/kb", "sat/b"]):
323            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, conf_target=target, estimate_mode=mode, expect_error=(-8, msg))
324        for mode in ["", "foo", Decimal("3.141592")]:
325            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, conf_target=0.1, estimate_mode=mode, expect_error=(-8, msg))
326            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_conf_target=0.1, arg_estimate_mode=mode, expect_error=(-8, msg))
327            assert_raises_rpc_error(-8, msg, w0.send, {w1.getnewaddress(): 1}, 0.1, mode)
328
329        for mode in ["economical", "conservative"]:
330            for k, v in {"string": "true", "bool": True, "object": {"foo": "bar"}}.items():
331                self.test_send(from_wallet=w0, to_wallet=w1, amount=1, conf_target=v, estimate_mode=mode,
332                    expect_error=(-3, f"JSON value of type {k} for field conf_target is not of expected type number"))
333
334        # Test setting explicit fee rate just below the minimum of 1 sat/vB.
335        self.log.info("Explicit fee rate raises RPC error 'fee rate too low' if fee_rate of 0.99999999 is passed")
336        msg = "Fee rate (0.999 sat/vB) is lower than the minimum fee rate setting (1.000 sat/vB)"
337        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate=0.999, expect_error=(-4, msg))
338        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=0.999, expect_error=(-4, msg))
339
340        self.log.info("Explicit fee rate raises if invalid fee_rate is passed")
341        # Test fee_rate with zero values.
342        msg = "Fee rate (0.000 sat/vB) is lower than the minimum fee rate setting (1.000 sat/vB)"
343        for zero_value in [0, 0.000, 0.00000000, "0", "0.000", "0.00000000"]:
344            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate=zero_value, expect_error=(-4, msg))
345            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=zero_value, expect_error=(-4, msg))
346        msg = "Invalid amount"
347        # Test fee_rate values that don't pass fixed-point parsing checks.
348        for invalid_value in ["", 0.000000001, 1e-09, 1.111111111, 1111111111111111, "31.999999999999999999999"]:
349            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate=invalid_value, expect_error=(-3, msg))
350            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=invalid_value, expect_error=(-3, msg))
351        # Test fee_rate values that cannot be represented in sat/vB.
352        for invalid_value in [0.0001, 0.00000001, 0.00099999, 31.99999999]:
353            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate=invalid_value, expect_error=(-3, msg))
354            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=invalid_value, expect_error=(-3, msg))
355        # Test fee_rate out of range (negative number).
356        msg = "Amount out of range"
357        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate=-1, expect_error=(-3, msg))
358        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=-1, expect_error=(-3, msg))
359        # Test type error.
360        msg = "Amount is not a number or string"
361        for invalid_value in [True, {"foo": "bar"}]:
362            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, fee_rate=invalid_value, expect_error=(-3, msg))
363            self.test_send(from_wallet=w0, to_wallet=w1, amount=1, arg_fee_rate=invalid_value, expect_error=(-3, msg))
364
365        # TODO: Return hex if fee rate is below -maxmempool
366        # res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, conf_target=0.1, estimate_mode="sat/b", add_to_wallet=False)
367        # assert res["hex"]
368        # hex = res["hex"]
369        # res = self.nodes[0].testmempoolaccept([hex])
370        # assert not res[0]["allowed"]
371        # assert_equal(res[0]["reject-reason"], "...") # low fee
372        # assert_fee_amount(fee, Decimal(len(res["hex"]) / 2), Decimal("0.000001"))
373
374        self.log.info("If inputs are specified, do not automatically add more...")
375        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=51, inputs=[], add_to_wallet=False)
376        assert res["complete"]
377        utxo1 = w0.listunspent()[0]
378        assert_equal(utxo1["amount"], 50)
379        ERR_NOT_ENOUGH_PRESET_INPUTS = "The preselected coins total amount does not cover the transaction target. " \
380                                       "Please allow other inputs to be automatically selected or include more coins manually"
381        self.test_send(from_wallet=w0, to_wallet=w1, amount=51, inputs=[utxo1],
382                       expect_error=(-4, ERR_NOT_ENOUGH_PRESET_INPUTS))
383        self.test_send(from_wallet=w0, to_wallet=w1, amount=51, inputs=[utxo1], add_inputs=False,
384                       expect_error=(-4, ERR_NOT_ENOUGH_PRESET_INPUTS))
385        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=51, inputs=[utxo1], add_inputs=True, add_to_wallet=False)
386        assert res["complete"]
387
388        self.log.info("Manual change address and position...")
389        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, change_address="not an address",
390                       expect_error=(-5, "Change address must be a valid bitcoin address"))
391        change_address = w0.getnewaddress()
392        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, add_to_wallet=False, change_address=change_address)
393        assert res["complete"]
394        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, add_to_wallet=False, change_address=change_address, change_position=0)
395        assert res["complete"]
396        assert_equal(self.nodes[0].decodepsbt(res["psbt"])["outputs"][0]["script"]["address"], change_address)
397        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, add_to_wallet=False, change_type="legacy", change_position=0)
398        assert res["complete"]
399        change_address = self.nodes[0].decodepsbt(res["psbt"])["outputs"][0]["script"]["address"]
400        assert change_address[0] in ("m", "n")
401
402        self.log.info("Set lock time...")
403        height = self.nodes[0].getblockchaininfo()["blocks"]
404        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, locktime=height + 1)
405        assert res["complete"]
406        assert res["txid"]
407        txid = res["txid"]
408        # Although the wallet finishes the transaction, it can't be added to the mempool yet:
409        hex = self.nodes[0].gettransaction(res["txid"])["hex"]
410        res = self.nodes[0].testmempoolaccept([hex])
411        assert not res[0]["allowed"]
412        assert_equal(res[0]["reject-reason"], "non-final")
413        # It shouldn't be confirmed in the next block
414        self.generate(self.nodes[0], 1)
415        assert_equal(self.nodes[0].gettransaction(txid)["confirmations"], 0)
416        # The mempool should allow it now:
417        res = self.nodes[0].testmempoolaccept([hex])
418        assert res[0]["allowed"]
419        # Don't wait for wallet to add it to the mempool:
420        res = self.nodes[0].sendrawtransaction(hex)
421        self.generate(self.nodes[0], 1)
422        assert_equal(self.nodes[0].gettransaction(txid)["confirmations"], 1)
423
424        self.log.info("Lock unspents...")
425        utxo1 = w0.listunspent()[0]
426        assert_greater_than(utxo1["amount"], 1)
427        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, inputs=[utxo1], add_to_wallet=False, lock_unspents=True)
428        assert res["complete"]
429        locked_coins = w0.listlockunspent()
430        assert_equal(len(locked_coins), 1)
431        # Locked coins are automatically unlocked when manually selected
432        res = self.test_send(from_wallet=w0, to_wallet=w1, amount=1, inputs=[utxo1], add_to_wallet=False)
433        assert res["complete"]
434
435        self.log.info("Subtract fee from output")
436        self.test_send(from_wallet=w0, to_wallet=w1, amount=1, subtract_fee_from_outputs=[0])
437
438        self.log.info("Include unsafe inputs")
439        self.nodes[1].createwallet(wallet_name="w5")
440        w5 = self.nodes[1].get_wallet_rpc("w5")
441        self.test_send(from_wallet=w0, to_wallet=w5, amount=2)
442        self.test_send(from_wallet=w5, to_wallet=w0, amount=1, expect_error=(-4, "Insufficient funds"))
443        res = self.test_send(from_wallet=w5, to_wallet=w0, amount=1, include_unsafe=True)
444        assert res["complete"]
445
446        self.log.info("Minconf")
447        self.nodes[1].createwallet(wallet_name="minconfw")
448        minconfw= self.nodes[1].get_wallet_rpc("minconfw")
449        self.test_send(from_wallet=w0, to_wallet=minconfw, amount=2)
450        self.generate(self.nodes[0], 3)
451        self.test_send(from_wallet=minconfw, to_wallet=w0, amount=1, minconf=4, expect_error=(-4, "Insufficient funds"))
452        self.test_send(from_wallet=minconfw, to_wallet=w0, amount=1, minconf=-4, expect_error=(-8, "Negative minconf"))
453        res = self.test_send(from_wallet=minconfw, to_wallet=w0, amount=1, minconf=3)
454        assert res["complete"]
455
456        self.log.info("External outputs")
457        privkey, _ = generate_keypair(wif=True)
458
459        self.nodes[1].createwallet("extsend")
460        ext_wallet = self.nodes[1].get_wallet_rpc("extsend")
461        self.nodes[1].createwallet("extfund")
462        ext_fund = self.nodes[1].get_wallet_rpc("extfund")
463
464        # Make a weird but signable script. sh(wsh(pkh())) descriptor accomplishes this
465        desc = descsum_create("sh(wsh(pkh({})))".format(privkey))
466        res = ext_fund.importdescriptors([{"desc": desc, "timestamp": "now"}])
467        assert res[0]["success"]
468        addr = self.nodes[0].deriveaddresses(desc)[0]
469        addr_info = ext_fund.getaddressinfo(addr)
470
471        self.nodes[0].sendtoaddress(addr, 10)
472        self.nodes[0].sendtoaddress(ext_wallet.getnewaddress(), 10)
473        self.generate(self.nodes[0], 6)
474        ext_utxo = ext_fund.listunspent(addresses=[addr])[0]
475
476        # An external input without solving data should result in an error
477        self.test_send(from_wallet=ext_wallet, to_wallet=self.nodes[0], amount=15, inputs=[ext_utxo], add_inputs=True, psbt=True, expect_error=(-4, "Not solvable pre-selected input COutPoint(%s, %s)" % (ext_utxo["txid"][0:10], ext_utxo["vout"])))
478
479        # But funding should work when the solving data is provided
480        res = self.test_send(from_wallet=ext_wallet, to_wallet=self.nodes[0], amount=15, inputs=[ext_utxo], add_inputs=True, psbt=True, solving_data={"pubkeys": [addr_info['pubkey']], "scripts": [addr_info["embedded"]["scriptPubKey"], addr_info["embedded"]["embedded"]["scriptPubKey"]]})
481        signed = ext_wallet.walletprocesspsbt(res["psbt"])
482        signed = ext_fund.walletprocesspsbt(res["psbt"])
483        assert signed["complete"]
484
485        res = self.test_send(from_wallet=ext_wallet, to_wallet=self.nodes[0], amount=15, inputs=[ext_utxo], add_inputs=True, psbt=True, solving_data={"descriptors": [desc]})
486        signed = ext_wallet.walletprocesspsbt(res["psbt"])
487        signed = ext_fund.walletprocesspsbt(res["psbt"])
488        assert signed["complete"]
489
490        dec = self.nodes[0].decodepsbt(signed["psbt"])
491        for psbt_in in dec["inputs"]:
492            if psbt_in["previous_txid"] == ext_utxo["txid"] and psbt_in["previous_vout"] == ext_utxo["vout"]:
493                break
494        scriptsig_hex = psbt_in["final_scriptSig"]["hex"] if "final_scriptSig" in psbt_in else ""
495        witness_stack_hex = psbt_in["final_scriptwitness"] if "final_scriptwitness" in psbt_in else None
496        input_weight = calculate_input_weight(scriptsig_hex, witness_stack_hex)
497
498        # Input weight error conditions
499        assert_raises_rpc_error(
500            -8,