Inside Bitcoin

751        assert_greater_than(large_tx_weight_without_inputs, min_tx_weight)
752        # Test for max_tx_weight less than Transaction weight without inputs
753        assert_raises_rpc_error(-4, "Maximum transaction weight is less than transaction weight without inputs", self.nodes[0].walletcreatefundedpsbt, [], dest_arg_large, 0, {"max_tx_weight": min_tx_weight})
754        assert_raises_rpc_error(-4, "Maximum transaction weight is less than transaction weight without inputs", self.nodes[0].walletcreatefundedpsbt, [], dest_arg_large, 0, {"max_tx_weight": large_tx_weight_without_inputs})
755
756        # Test for max_tx_weight just enough to include inputs but not change output
757        assert_raises_rpc_error(-4, "Maximum transaction weight is too low, can not accommodate change output", self.nodes[0].walletcreatefundedpsbt, [], dest_arg_large, 0, {"max_tx_weight": (large_tx_vsize_without_inputs + 1) * WITNESS_SCALE_FACTOR})
758        self.log.info("Test that a funded PSBT is always faithful to max_tx_weight option")
759        large_tx_vsize_with_change = large_tx_vsize_without_inputs + p2wpkh_output_vsize
760        # It's enough but won't accommodate selected input size
761        assert_raises_rpc_error(-4, "The inputs size exceeds the maximum weight", self.nodes[0].walletcreatefundedpsbt, [], dest_arg_large, 0, {"max_tx_weight": (large_tx_vsize_with_change) * WITNESS_SCALE_FACTOR})
762
763        max_tx_weight_sufficient = 1000 # 1k vbytes is enough
764        psbt = self.nodes[0].walletcreatefundedpsbt(outputs=dest_arg,locktime=0, options={"max_tx_weight": max_tx_weight_sufficient})["psbt"]
765        psbt = self.nodes[0].walletprocesspsbt(psbt)["psbt"]
766        final_tx = self.nodes[0].finalizepsbt(psbt)["hex"]
767        weight = self.nodes[0].decoderawtransaction(final_tx)["weight"]
768        # ensure the transaction's weight is below the specified max_tx_weight.
769        assert_greater_than_or_equal(max_tx_weight_sufficient, weight)
770
771        # If inputs are specified, do not automatically add more:
772        utxo1 = self.nodes[0].listunspent()[0]
773        assert_raises_rpc_error(-4, "The preselected coins total amount does not cover the transaction target. "
774                                    "Please allow other inputs to be automatically selected or include more coins manually",
775                                self.nodes[0].walletcreatefundedpsbt, [{"txid": utxo1['txid'], "vout": utxo1['vout']}], {self.nodes[2].getnewaddress():90})
776
777        psbtx1 = self.nodes[0].walletcreatefundedpsbt([{"txid": utxo1['txid'], "vout": utxo1['vout']}], {self.nodes[2].getnewaddress():90}, 0, {"add_inputs": True})['psbt']
778        assert_equal(len(self.nodes[0].decodepsbt(psbtx1)['inputs']), 2)
779
780        # Inputs argument can be null
781        self.nodes[0].walletcreatefundedpsbt(None, {self.nodes[2].getnewaddress():10})
782
783        # Node 1 should not be able to add anything to it but still return the psbtx same as before
784        psbtx = self.nodes[1].walletprocesspsbt(psbtx1)['psbt']
785        assert_equal(psbtx1, psbtx)
786
787        # Node 0 should not be able to sign the transaction with the wallet is locked
788        self.nodes[0].encryptwallet("password")
789        assert_raises_rpc_error(-13, "Please enter the wallet passphrase with walletpassphrase first", self.nodes[0].walletprocesspsbt, psbtx)
790
791        # Node 0 should be able to process without signing though
792        unsigned_tx = self.nodes[0].walletprocesspsbt(psbtx, False)
793        assert_equal(unsigned_tx['complete'], False)
794
795        self.nodes[0].walletpassphrase(passphrase="password", timeout=1000000)
796
797        # Sign the transaction but don't finalize
798        processed_psbt = self.nodes[0].walletprocesspsbt(psbt=psbtx, finalize=False)
799        assert "hex" not in processed_psbt
800        signed_psbt = processed_psbt['psbt']
801
802        # Finalize and send
803        finalized_hex = self.nodes[0].finalizepsbt(signed_psbt)['hex']
804        self.nodes[0].sendrawtransaction(finalized_hex)
805
806        # Alternative method: sign AND finalize in one command
807        processed_finalized_psbt = self.nodes[0].walletprocesspsbt(psbt=psbtx, finalize=True)
808        finalized_psbt = processed_finalized_psbt['psbt']
809        finalized_psbt_hex = processed_finalized_psbt['hex']
810        assert_not_equal(signed_psbt, finalized_psbt)
811        assert_equal(finalized_psbt_hex, finalized_hex)
812
813        # Manually selected inputs can be locked:
814        assert_equal(len(self.nodes[0].listlockunspent()), 0)
815        utxo1 = self.nodes[0].listunspent()[0]
816        psbtx1 = self.nodes[0].walletcreatefundedpsbt([{"txid": utxo1['txid'], "vout": utxo1['vout']}], {self.nodes[2].getnewaddress():1}, 0,{"lockUnspents": True})["psbt"]
817        assert_equal(len(self.nodes[0].listlockunspent()), 1)
818
819        # Locks are ignored for manually selected inputs
820        self.nodes[0].walletcreatefundedpsbt([{"txid": utxo1['txid'], "vout": utxo1['vout']}], {self.nodes[2].getnewaddress():1}, 0)
821
822        # Create p2sh, p2wpkh, and p2wsh addresses
823        pubkey0 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress())['pubkey']
824        pubkey1 = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())['pubkey']
825        pubkey2 = self.nodes[2].getaddressinfo(self.nodes[2].getnewaddress())['pubkey']
826
827        # Setup watchonly wallets
828        self.nodes[2].createwallet(wallet_name='wmulti', disable_private_keys=True)
829        wmulti = self.nodes[2].get_wallet_rpc('wmulti')
830
831        # Create all the addresses
832        p2sh_ms = wmulti.createmultisig(2, [pubkey0, pubkey1, pubkey2], address_type="legacy")
833        p2sh = p2sh_ms["address"]
834        p2wsh_ms = wmulti.createmultisig(2, [pubkey0, pubkey1, pubkey2], address_type="bech32")
835        p2wsh = p2wsh_ms["address"]
836        p2sh_p2wsh_ms = wmulti.createmultisig(2, [pubkey0, pubkey1, pubkey2], address_type="p2sh-segwit")
837        p2sh_p2wsh = p2sh_p2wsh_ms["address"]
838        import_res = wmulti.importdescriptors(
839            [
840                {"desc": p2sh_ms["descriptor"], "timestamp": "now"},
841                {"desc": p2wsh_ms["descriptor"], "timestamp": "now"},
842                {"desc": p2sh_p2wsh_ms["descriptor"], "timestamp": "now"},
843            ])
844        assert_equal(all([r["success"] for r in import_res]), True)
845        p2wpkh = self.nodes[1].getnewaddress("", "bech32")
846        p2pkh = self.nodes[1].getnewaddress("", "legacy")
847        p2sh_p2wpkh = self.nodes[1].getnewaddress("", "p2sh-segwit")
848
849        # fund those addresses
850        rawtx = self.nodes[0].createrawtransaction([], {p2sh:10, p2wsh:10, p2wpkh:10, p2sh_p2wsh:10, p2sh_p2wpkh:10, p2pkh:10})
851        rawtx = self.nodes[0].fundrawtransaction(rawtx, {"changePosition":3})
852        signed_tx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])['hex']
853        txid = self.nodes[0].sendrawtransaction(signed_tx)
854        self.generate(self.nodes[0], 6)
855
856        # Find the output pos
857        p2sh_pos = -1
858        p2wsh_pos = -1
859        p2wpkh_pos = -1
860        p2pkh_pos = -1
861        p2sh_p2wsh_pos = -1
862        p2sh_p2wpkh_pos = -1
863        decoded = self.nodes[0].decoderawtransaction(signed_tx)
864        for out in decoded['vout']:
865            if out['scriptPubKey']['address'] == p2sh:
866                p2sh_pos = out['n']
867            elif out['scriptPubKey']['address'] == p2wsh:
868                p2wsh_pos = out['n']
869            elif out['scriptPubKey']['address'] == p2wpkh:
870                p2wpkh_pos = out['n']
871            elif out['scriptPubKey']['address'] == p2sh_p2wsh:
872                p2sh_p2wsh_pos = out['n']
873            elif out['scriptPubKey']['address'] == p2sh_p2wpkh:
874                p2sh_p2wpkh_pos = out['n']
875            elif out['scriptPubKey']['address'] == p2pkh:
876                p2pkh_pos = out['n']
877
878        inputs = [{"txid": txid, "vout": p2wpkh_pos}, {"txid": txid, "vout": p2sh_p2wpkh_pos}, {"txid": txid, "vout": p2pkh_pos}]
879        outputs = [{self.nodes[1].getnewaddress(): 29.99}]
880
881        # spend single key from node 1
882        created_psbt = self.nodes[1].walletcreatefundedpsbt(inputs, outputs)
883        walletprocesspsbt_out = self.nodes[1].walletprocesspsbt(created_psbt['psbt'])
884        # Make sure it has both types of UTXOs
885        decoded = self.nodes[1].decodepsbt(walletprocesspsbt_out['psbt'])
886        assert 'non_witness_utxo' in decoded['inputs'][0]
887        assert 'witness_utxo' in decoded['inputs'][0]
888        # Check decodepsbt fee calculation (input values shall only be counted once per UTXO)
889        assert_equal(decoded['fee'], created_psbt['fee'])
890        assert_equal(walletprocesspsbt_out['complete'], True)
891        self.nodes[1].sendrawtransaction(walletprocesspsbt_out['hex'])
892
893        self.log.info("Test walletcreatefundedpsbt fee rate of 10000 sat/vB and 0.1 BTC/kvB produces a total fee at or slightly below -maxtxfee (~0.05290000)")
894        res1 = self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {"fee_rate": 10000, "add_inputs": True})
895        assert_approx(res1["fee"], 0.055, 0.005)
896        res2 = self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {"feeRate": "0.1", "add_inputs": True})
897        assert_approx(res2["fee"], 0.055, 0.005)
898
899        self.log.info("Test min fee rate checks with walletcreatefundedpsbt are bypassed, e.g. a fee_rate under 1 sat/vB is allowed")
900        res3 = self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {"fee_rate": "0.999", "add_inputs": True})
901        assert_approx(res3["fee"], 0.00000381, 0.0000001)
902        res4 = self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {"feeRate": 0.00000999, "add_inputs": True})
903        assert_approx(res4["fee"], 0.00000381, 0.0000001)
904
905        self.log.info("Test min fee rate checks with walletcreatefundedpsbt are bypassed and that funding non-standard 'zero-fee' transactions is valid")
906        for param, zero_value in product(["fee_rate", "feeRate"], [0, 0.000, 0.00000000, "0", "0.000", "0.00000000"]):
907            assert_equal(0, self.nodes[1].walletcreatefundedpsbt(inputs, outputs, 0, {param: zero_value, "add_inputs": True})["fee"])
908
909        self.log.info("Test invalid fee rate settings")
910        for param, value in {("fee_rate", 100000), ("feeRate", 1)}:
911            assert_raises_rpc_error(-4, "Fee exceeds maximum configured by user (e.g. -maxtxfee, maxfeerate)",
912                self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {param: value, "add_inputs": True})
913            assert_raises_rpc_error(-3, "Amount out of range",
914                self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {param: -1, "add_inputs": True})
915            assert_raises_rpc_error(-3, "Amount is not a number or string",
916                self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {param: {"foo": "bar"}, "add_inputs": True})
917            # Test fee rate values that don't pass fixed-point parsing checks.
918            for invalid_value in ["", 0.000000001, 1e-09, 1.111111111, 1111111111111111, "31.999999999999999999999"]:
919                assert_raises_rpc_error(-3, "Invalid amount",
920                    self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {param: invalid_value, "add_inputs": True})
921        # Test fee_rate values that cannot be represented in sat/vB.
922        for invalid_value in [0.0001, 0.00000001, 0.00099999, 31.99999999]:
923            assert_raises_rpc_error(-3, "Invalid amount",
924                self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"fee_rate": invalid_value, "add_inputs": True})
925
926        self.log.info("- raises RPC error if both feeRate and fee_rate are passed")
927        assert_raises_rpc_error(-8, "Cannot specify both fee_rate (sat/vB) and feeRate (BTC/kvB)",
928            self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"fee_rate": 0.1, "feeRate": 0.1, "add_inputs": True})
929
930        self.log.info("- raises RPC error if both feeRate and estimate_mode passed")
931        assert_raises_rpc_error(-8, "Cannot specify both estimate_mode and feeRate",
932            self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": "economical", "feeRate": 0.1, "add_inputs": True})
933
934        for param in ["feeRate", "fee_rate"]:
935            self.log.info("- raises RPC error if both {} and conf_target are passed".format(param))
936            assert_raises_rpc_error(-8, "Cannot specify both conf_target and {}. Please provide either a confirmation "
937                "target in blocks for automatic fee estimation, or an explicit fee rate.".format(param),
938                self.nodes[1].walletcreatefundedpsbt ,inputs, outputs, 0, {param: 1, "conf_target": 1, "add_inputs": True})
939
940        self.log.info("- raises RPC error if both fee_rate and estimate_mode are passed")
941        assert_raises_rpc_error(-8, "Cannot specify both estimate_mode and fee_rate",
942            self.nodes[1].walletcreatefundedpsbt ,inputs, outputs, 0, {"fee_rate": 1, "estimate_mode": "economical", "add_inputs": True})
943
944        self.log.info("- raises RPC error with invalid estimate_mode settings")
945        for k, v in {"number": 42, "object": {"foo": "bar"}}.items():
946            assert_raises_rpc_error(-3, f"JSON value of type {k} for field estimate_mode is not of expected type string",
947                self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": v, "conf_target": 0.1, "add_inputs": True})
948        for mode in ["", "foo", Decimal("3.141592")]:
949            assert_raises_rpc_error(-8, 'Invalid estimate_mode parameter, must be one of: "unset", "economical", "conservative"',
950                self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": mode, "conf_target": 0.1, "add_inputs": True})
951
952        self.log.info("- raises RPC error with invalid conf_target settings")
953        for mode in ["unset", "economical", "conservative"]:
954            self.log.debug("{}".format(mode))
955            for k, v in {"string": "", "object": {"foo": "bar"}}.items():
956                assert_raises_rpc_error(-3, f"JSON value of type {k} for field conf_target is not of expected type number",
957                    self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": mode, "conf_target": v, "add_inputs": True})
958            for n in [-1, 0, 1009]:
959                assert_raises_rpc_error(-8, "Invalid conf_target, must be between 1 and 1008",  # max value of 1008 per src/policy/fees/block_policy_estimator.h
960                    self.nodes[1].walletcreatefundedpsbt, inputs, outputs, 0, {"estimate_mode": mode, "conf_target": n, "add_inputs": True})
961
962        self.log.info("Test walletcreatefundedpsbt with too-high fee rate produces total fee well above -maxtxfee and raises RPC error")
963        # previously this was silently capped at -maxtxfee
964        for bool_add, outputs_array in {True: outputs, False: [{self.nodes[1].getnewaddress(): 1}]}.items():
965            msg = "Fee exceeds maximum configured by user (e.g. -maxtxfee, maxfeerate)"
966            assert_raises_rpc_error(-4, msg, self.nodes[1].walletcreatefundedpsbt, inputs, outputs_array, 0, {"fee_rate": 1000000, "add_inputs": bool_add})
967            assert_raises_rpc_error(-4, msg, self.nodes[1].walletcreatefundedpsbt, inputs, outputs_array, 0, {"feeRate": 1, "add_inputs": bool_add})
968
969        self.log.info("Test various PSBT operations")
970        # partially sign multisig things with node 1
971        psbtx = wmulti.walletcreatefundedpsbt(inputs=[{"txid":txid,"vout":p2wsh_pos},{"txid":txid,"vout":p2sh_pos},{"txid":txid,"vout":p2sh_p2wsh_pos}], outputs={self.nodes[1].getnewaddress():29.99}, changeAddress=self.nodes[1].getrawchangeaddress())['psbt']
972        walletprocesspsbt_out = self.nodes[1].walletprocesspsbt(psbtx)
973        psbtx = walletprocesspsbt_out['psbt']
974        assert_equal(walletprocesspsbt_out['complete'], False)
975
976        # Unload wmulti, we don't need it anymore
977        wmulti.unloadwallet()
978
979        # partially sign with node 2. This should be complete and sendable
980        walletprocesspsbt_out = self.nodes[2].walletprocesspsbt(psbtx)
981        assert_equal(walletprocesspsbt_out['complete'], True)
982        self.nodes[2].sendrawtransaction(walletprocesspsbt_out['hex'])
983
984        # check that walletprocesspsbt fails to decode a non-psbt
985        rawtx = self.nodes[1].createrawtransaction([{"txid":txid,"vout":p2wpkh_pos}], {self.nodes[1].getnewaddress():9.99})
986        assert_raises_rpc_error(-22, "TX decode failed", self.nodes[1].walletprocesspsbt, rawtx)
987
988        # Convert a non-psbt to psbt and make sure we can decode it
989        rawtx = self.nodes[0].createrawtransaction([], {self.nodes[1].getnewaddress():10})
990        rawtx = self.nodes[0].fundrawtransaction(rawtx)
991        new_psbt = self.nodes[0].converttopsbt(rawtx['hex'])
992        self.nodes[0].decodepsbt(new_psbt)
993
994        # Make sure that a non-psbt with signatures cannot be converted
995        signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])
996        assert_raises_rpc_error(-22, "Inputs must not have scriptSigs and scriptWitnesses",
997                                self.nodes[0].converttopsbt, hexstring=signedtx['hex'])  # permitsigdata=False by default
998        assert_raises_rpc_error(-22, "Inputs must not have scriptSigs and scriptWitnesses",
999                                self.nodes[0].converttopsbt, hexstring=signedtx['hex'], permitsigdata=False)
1000        assert_raises_rpc_error(-22, "Inputs must not have scriptSigs and scriptWitnesses",