Funding, signing and committing wallet transactions

501                    {"inputs", UniValueType(UniValue::VARR)},
502                    {"lockUnspents", UniValueType(UniValue::VBOOL)},
503                    {"lock_unspents", UniValueType(UniValue::VBOOL)},
504                    {"locktime", UniValueType(UniValue::VNUM)},
505                    {"fee_rate", UniValueType()}, // will be checked by AmountFromValue() in SetFeeEstimateMode()
506                    {"feeRate", UniValueType()}, // will be checked by AmountFromValue() below
507                    {"psbt", UniValueType(UniValue::VBOOL)},
508                    {"solving_data", UniValueType(UniValue::VOBJ)},
509                    {"subtractFeeFromOutputs", UniValueType(UniValue::VARR)},
510                    {"subtract_fee_from_outputs", UniValueType(UniValue::VARR)},
511                    {"replaceable", UniValueType(UniValue::VBOOL)},
512                    {"conf_target", UniValueType(UniValue::VNUM)},
513                    {"estimate_mode", UniValueType(UniValue::VSTR)},
514                    {"minconf", UniValueType(UniValue::VNUM)},
515                    {"maxconf", UniValueType(UniValue::VNUM)},
516                    {"input_weights", UniValueType(UniValue::VARR)},
517                    {"max_tx_weight", UniValueType(UniValue::VNUM)},
518                },
519                true, true);
520
521        if (options.exists("add_inputs")) {
522            coinControl.m_allow_other_inputs = options["add_inputs"].get_bool();
523        }
524
525        if (options.exists("changeAddress") || options.exists("change_address")) {
526            const std::string change_address_str = (options.exists("change_address") ? options["change_address"] : options["changeAddress"]).get_str();
527            CTxDestination dest = DecodeDestination(change_address_str);
528
529            if (!IsValidDestination(dest)) {
530                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Change address must be a valid bitcoin address");
531            }
532
533            coinControl.destChange = dest;
534        }
535
536        if (options.exists("changePosition") || options.exists("change_position")) {
537            int pos = (options.exists("change_position") ? options["change_position"] : options["changePosition"]).getInt<int>();
538            if (pos < 0 || (unsigned int)pos > recipients.size()) {
539                throw JSONRPCError(RPC_INVALID_PARAMETER, "changePosition out of bounds");
540            }
541            change_position = (unsigned int)pos;
542        }
543
544        if (options.exists("change_type")) {
545            if (options.exists("changeAddress") || options.exists("change_address")) {
546                throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both change address and address type options");
547            }
548            if (std::optional<OutputType> parsed = ParseOutputType(options["change_type"].get_str())) {
549                coinControl.m_change_type.emplace(parsed.value());
550            } else {
551                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("Unknown change type '%s'", options["change_type"].get_str()));
552            }
553        }
554
555        if (options.exists("lockUnspents") || options.exists("lock_unspents")) {
556            lockUnspents = (options.exists("lock_unspents") ? options["lock_unspents"] : options["lockUnspents"]).get_bool();
557        }
558
559        if (options.exists("include_unsafe")) {
560            coinControl.m_include_unsafe_inputs = options["include_unsafe"].get_bool();
561        }
562
563        if (options.exists("feeRate")) {
564            if (options.exists("fee_rate")) {
565                throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both fee_rate (" + CURRENCY_ATOM + "/vB) and feeRate (" + CURRENCY_UNIT + "/kvB)");
566            }
567            if (options.exists("conf_target")) {
568                throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both conf_target and feeRate. Please provide either a confirmation target in blocks for automatic fee estimation, or an explicit fee rate.");
569            }
570            if (options.exists("estimate_mode")) {
571                throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot specify both estimate_mode and feeRate");
572            }
573            coinControl.m_feerate = CFeeRate(AmountFromValue(options["feeRate"]));
574            coinControl.fOverrideFeeRate = true;
575        }
576
577        if (options.exists("replaceable")) {
578            coinControl.m_signal_bip125_rbf = options["replaceable"].get_bool();
579        }
580
581        if (options.exists("minconf")) {
582            coinControl.m_min_depth = options["minconf"].getInt<int>();
583
584            if (coinControl.m_min_depth < 0) {
585                throw JSONRPCError(RPC_INVALID_PARAMETER, "Negative minconf");
586            }
587        }
588
589        if (options.exists("maxconf")) {
590            coinControl.m_max_depth = options["maxconf"].getInt<int>();
591
592            if (coinControl.m_max_depth < coinControl.m_min_depth) {
593                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("maxconf can't be lower than minconf: %d < %d", coinControl.m_max_depth, coinControl.m_min_depth));
594            }
595        }
596        SetFeeEstimateMode(wallet, coinControl, options["conf_target"], options["estimate_mode"], options["fee_rate"], override_min_fee);
597    }
598
599    if (options.exists("solving_data")) {
600        const UniValue solving_data = options["solving_data"].get_obj();
601        if (solving_data.exists("pubkeys")) {
602            for (const UniValue& pk_univ : solving_data["pubkeys"].get_array().getValues()) {
603                const CPubKey pubkey = HexToPubKey(pk_univ.get_str());
604                coinControl.m_external_provider.pubkeys.emplace(pubkey.GetID(), pubkey);
605                // Add witness script for pubkeys
606                const CScript wit_script = GetScriptForDestination(WitnessV0KeyHash(pubkey));
607                coinControl.m_external_provider.scripts.emplace(CScriptID(wit_script), wit_script);
608            }
609        }
610
611        if (solving_data.exists("scripts")) {
612            for (const UniValue& script_univ : solving_data["scripts"].get_array().getValues()) {
613                const std::string& script_str = script_univ.get_str();
614                if (!IsHex(script_str)) {
615                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("'%s' is not hex", script_str));
616                }
617                std::vector<unsigned char> script_data(ParseHex(script_str));
618                const CScript script(script_data.begin(), script_data.end());
619                coinControl.m_external_provider.scripts.emplace(CScriptID(script), script);
620            }
621        }
622
623        if (solving_data.exists("descriptors")) {
624            for (const UniValue& desc_univ : solving_data["descriptors"].get_array().getValues()) {
625                const std::string& desc_str  = desc_univ.get_str();
626                FlatSigningProvider desc_out;
627                std::string error;
628                std::vector<CScript> scripts_temp;
629                auto descs = Parse(desc_str, desc_out, error, true);
630                if (descs.empty()) {
631                    throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Unable to parse descriptor '%s': %s", desc_str, error));
632                }
633                for (auto& desc : descs) {
634                    desc->Expand(0, desc_out, scripts_temp, desc_out);
635                }
636                coinControl.m_external_provider.Merge(std::move(desc_out));
637            }
638        }
639    }
640
641    if (options.exists("input_weights")) {
642        for (const UniValue& input : options["input_weights"].get_array().getValues()) {
643            Txid txid = Txid::FromUint256(ParseHashO(input, "txid"));
644
645            const UniValue& vout_v = input.find_value("vout");
646            if (!vout_v.isNum()) {
647                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing vout key");
648            }
649            int vout = vout_v.getInt<int>();
650            if (vout < 0) {
651                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
652            }
653
654            const UniValue& weight_v = input.find_value("weight");
655            if (!weight_v.isNum()) {
656                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing weight key");
657            }
658            int64_t weight = weight_v.getInt<int64_t>();
659            const int64_t min_input_weight = GetTransactionInputWeight(CTxIn());
660            CHECK_NONFATAL(min_input_weight == 165);
661            if (weight < min_input_weight) {
662                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, weight cannot be less than 165 (41 bytes (size of outpoint + sequence + empty scriptSig) * 4 (witness scaling factor)) + 1 (empty witness)");
663            }
664            if (weight > MAX_STANDARD_TX_WEIGHT) {
665                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter, weight cannot be greater than the maximum standard tx weight of %d", MAX_STANDARD_TX_WEIGHT));
666            }
667
668            coinControl.SetInputWeight(COutPoint(txid, vout), weight);
669        }
670    }
671
672    if (options.exists("max_tx_weight")) {
673        coinControl.m_max_tx_weight = options["max_tx_weight"].getInt<int>();
674    }
675
676    if (tx.version == TRUC_VERSION) {
677        if (!coinControl.m_max_tx_weight.has_value() || coinControl.m_max_tx_weight.value() > TRUC_MAX_WEIGHT) {
678            coinControl.m_max_tx_weight = TRUC_MAX_WEIGHT;
679        }
680    }
681
682    if (recipients.empty())
683        throw JSONRPCError(RPC_INVALID_PARAMETER, "TX must have at least one output");
684
685    auto txr = FundTransaction(wallet, tx, recipients, change_position, lockUnspents, coinControl);
686    if (!txr) {
687        throw JSONRPCError(RPC_WALLET_ERROR, ErrorString(txr).original);
688    }
689    return *txr;
690}
691
692static void SetOptionsInputWeights(const UniValue& inputs, UniValue& options)
693{
694    if (options.exists("input_weights")) {
695        throw JSONRPCError(RPC_INVALID_PARAMETER, "Input weights should be specified in inputs rather than in options.");
696    }
697    if (inputs.size() == 0) {
698        return;
699    }
700    UniValue weights(UniValue::VARR);
701    for (const UniValue& input : inputs.getValues()) {
702        if (input.exists("weight")) {
703            weights.push_back(input);
704        }
705    }
706    options.pushKV("input_weights", std::move(weights));
707}
708
709RPCMethod fundrawtransaction()
710{
711    return RPCMethod{
712        "fundrawtransaction",
713        "If the transaction has no inputs, they will be automatically selected to meet its out value.\n"
714                "It will add at most one change output to the outputs.\n"
715                "No existing outputs will be modified unless \"subtractFeeFromOutputs\" is specified.\n"
716                "Note that inputs which were signed may need to be resigned after completion since in/outputs have been added.\n"
717                "The inputs added will not be signed, use signrawtransactionwithkey\n"
718                "or signrawtransactionwithwallet for that.\n"
719                "All existing inputs must either have their previous output transaction be in the wallet\n"
720                "or be in the UTXO set. Solving data must be provided for non-wallet inputs.\n"
721                "Note that all inputs selected must be of standard form and P2SH scripts must be\n"
722                "in the wallet using importdescriptors (to calculate fees).\n"
723                "You can see whether this is the case by checking the \"solvable\" field in the listunspent output.\n"
724                "Note that if specifying an exact fee rate, the resulting transaction may have a higher fee rate\n"
725                "if the transaction has unconfirmed inputs. This is because the wallet will attempt to make the\n"
726                "entire package have the given fee rate, not the resulting transaction.\n",
727                {
728                    {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex string of the raw transaction"},
729                    {"options", RPCArg::Type::OBJ_NAMED_PARAMS, RPCArg::Optional::OMITTED, "",
730                        Cat<std::vector<RPCArg>>(
731                        {
732                            {"add_inputs", RPCArg::Type::BOOL, RPCArg::Default{true}, "For a transaction with existing inputs, automatically include more if they are not enough."},
733                            {"include_unsafe", RPCArg::Type::BOOL, RPCArg::Default{false}, "Include inputs that are not safe to spend (unconfirmed transactions from outside keys and unconfirmed replacement transactions).\n"
734                                                          "Warning: the resulting transaction may become invalid if one of the unsafe inputs disappears.\n"
735                                                          "If that happens, you will need to fund the transaction with different inputs and republish it."},
736                            {"minconf", RPCArg::Type::NUM, RPCArg::Default{0}, "If add_inputs is specified, require inputs with at least this many confirmations."},
737                            {"maxconf", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "If add_inputs is specified, require inputs with at most this many confirmations."},
738                            {"changeAddress", RPCArg::Type::STR, RPCArg::DefaultHint{"automatic"}, "The bitcoin address to receive the change"},
739                            {"changePosition", RPCArg::Type::NUM, RPCArg::DefaultHint{"random"}, "The index of the change output"},
740                            {"change_type", RPCArg::Type::STR, RPCArg::DefaultHint{"set by -changetype"}, "The output type to use. Only valid if changeAddress is not specified. Options are " + FormatAllOutputTypes() + "."},
741                            {"includeWatching", RPCArg::Type::BOOL, RPCArg::Default{false}, "(DEPRECATED) No longer used"},
742                            {"lockUnspents", RPCArg::Type::BOOL, RPCArg::Default{false}, "Lock selected unspent outputs"},
743                            {"fee_rate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_ATOM + "/vB."},
744                            {"feeRate", RPCArg::Type::AMOUNT, RPCArg::DefaultHint{"not set, fall back to wallet fee estimation"}, "Specify a fee rate in " + CURRENCY_UNIT + "/kvB."},
745                            {"subtractFeeFromOutputs", RPCArg::Type::ARR, RPCArg::Default{UniValue::VARR}, "The integers.\n"
746                                                          "The fee will be equally deducted from the amount of each specified output.\n"
747                                                          "Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"
748                                                          "If no outputs are specified here, the sender pays the fee.",
749                                {
750                                    {"vout_index", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "The zero-based output index, before a change output is added."},