Decoding, querying and submitting transactions

2001                                {RPCResult::Type::STR_HEX, "witnessscript", /*optional=*/true, "SHA256 of the witness script that is missing"},
2002                            }},
2003                            {RPCResult::Type::STR, "next", /*optional=*/true, "Role of the next person that this input needs to go to"},
2004                        }},
2005                    }},
2006                    {RPCResult::Type::NUM, "estimated_vsize", /*optional=*/true, "Estimated vsize of the final signed transaction"},
2007                    {RPCResult::Type::STR_AMOUNT, "estimated_feerate", /*optional=*/true, "Estimated feerate of the final signed transaction in " + CURRENCY_UNIT + "/kvB. Shown only if all UTXO slots in the PSBT have been filled"},
2008                    {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The transaction fee paid. Shown only if all UTXO slots in the PSBT have been filled"},
2009                    {RPCResult::Type::STR, "next", "Role of the next person that this psbt needs to go to"},
2010                    {RPCResult::Type::STR, "error", /*optional=*/true, "Error message (if there is one)"},
2011                }
2012            },
2013            RPCExamples {
2014                HelpExampleCli("analyzepsbt", "\"psbt\"")
2015            },
2016        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
2017{
2018    // Unserialize the transaction
2019    util::Result<PartiallySignedTransaction> psbt_res = DecodeBase64PSBT(request.params[0].get_str());
2020    if (!psbt_res) {
2021        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", util::ErrorString(psbt_res).original));
2022    }
2023    const PartiallySignedTransaction& psbtx = *psbt_res;
2024
2025    PSBTAnalysis psbta = AnalyzePSBT(psbtx);
2026
2027    UniValue result(UniValue::VOBJ);
2028    UniValue inputs_result(UniValue::VARR);
2029    for (const auto& input : psbta.inputs) {
2030        UniValue input_univ(UniValue::VOBJ);
2031        UniValue missing(UniValue::VOBJ);
2032
2033        input_univ.pushKV("has_utxo", input.has_utxo);
2034        input_univ.pushKV("is_final", input.is_final);
2035        input_univ.pushKV("next", PSBTRoleName(input.next));
2036
2037        if (!input.missing_pubkeys.empty()) {
2038            UniValue missing_pubkeys_univ(UniValue::VARR);
2039            for (const CKeyID& pubkey : input.missing_pubkeys) {
2040                missing_pubkeys_univ.push_back(HexStr(pubkey));
2041            }
2042            missing.pushKV("pubkeys", std::move(missing_pubkeys_univ));
2043        }
2044        if (!input.missing_redeem_script.IsNull()) {
2045            missing.pushKV("redeemscript", HexStr(input.missing_redeem_script));
2046        }
2047        if (!input.missing_witness_script.IsNull()) {
2048            missing.pushKV("witnessscript", HexStr(input.missing_witness_script));
2049        }
2050        if (!input.missing_sigs.empty()) {
2051            UniValue missing_sigs_univ(UniValue::VARR);
2052            for (const CKeyID& pubkey : input.missing_sigs) {
2053                missing_sigs_univ.push_back(HexStr(pubkey));
2054            }
2055            missing.pushKV("signatures", std::move(missing_sigs_univ));
2056        }
2057        if (!missing.getKeys().empty()) {
2058            input_univ.pushKV("missing", std::move(missing));
2059        }
2060        inputs_result.push_back(std::move(input_univ));
2061    }
2062    if (!inputs_result.empty()) result.pushKV("inputs", std::move(inputs_result));
2063
2064    if (psbta.estimated_vsize != std::nullopt) {
2065        result.pushKV("estimated_vsize", *psbta.estimated_vsize);
2066    }
2067    if (psbta.estimated_feerate != std::nullopt) {
2068        result.pushKV("estimated_feerate", ValueFromAmount(psbta.estimated_feerate->GetFeePerK()));
2069    }
2070    if (psbta.fee != std::nullopt) {
2071        result.pushKV("fee", ValueFromAmount(*psbta.fee));
2072    }
2073    result.pushKV("next", PSBTRoleName(psbta.next));
2074    if (!psbta.error.empty()) {
2075        result.pushKV("error", psbta.error);
2076    }
2077
2078    return result;
2079},
2080    };
2081}
2082
2083RPCMethod descriptorprocesspsbt()
2084{
2085    return RPCMethod{
2086        "descriptorprocesspsbt",
2087        "Update all segwit inputs in a PSBT with information from output descriptors, the UTXO set or the mempool. \n"
2088                "Then, sign the inputs we are able to with information from the output descriptors. ",
2089                {
2090                    {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction base64 string"},
2091                    {"descriptors", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of either strings or objects", {
2092                        {"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "An output descriptor"},
2093                        {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "An object with an output descriptor and extra information", {
2094                             {"desc", RPCArg::Type::STR, RPCArg::Optional::NO, "An output descriptor"},
2095                             {"range", RPCArg::Type::RANGE, RPCArg::Default{1000}, "Up to what index HD chains should be explored (either end or [begin,end])"},
2096                        }},
2097                    }},
2098                    {"sighashtype", RPCArg::Type::STR, RPCArg::DefaultHint{"DEFAULT for Taproot, ALL otherwise"}, "The signature hash type to sign with if not specified by the PSBT. Must be one of\n"
2099            "       \"DEFAULT\"\n"
2100            "       \"ALL\"\n"
2101            "       \"NONE\"\n"
2102            "       \"SINGLE\"\n"
2103            "       \"ALL|ANYONECANPAY\"\n"
2104            "       \"NONE|ANYONECANPAY\"\n"
2105            "       \"SINGLE|ANYONECANPAY\""},
2106                    {"bip32derivs", RPCArg::Type::BOOL, RPCArg::Default{true}, "Include BIP 32 derivation paths for public keys if we know them"},
2107                    {"finalize", RPCArg::Type::BOOL, RPCArg::Default{true}, "Also finalize inputs if possible"},
2108                },
2109                RPCResult{
2110                    RPCResult::Type::OBJ, "", "",
2111                    {
2112                        {RPCResult::Type::STR, "psbt", "The base64-encoded partially signed transaction"},
2113                        {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"},
2114                        {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "The hex-encoded network transaction if complete"},
2115                    }
2116                },
2117                RPCExamples{
2118                    HelpExampleCli("descriptorprocesspsbt", "\"psbt\" \"[\\\"descriptor1\\\", \\\"descriptor2\\\"]\"") +
2119                    HelpExampleCli("descriptorprocesspsbt", "\"psbt\" \"[{\\\"desc\\\":\\\"mydescriptor\\\", \\\"range\\\":21}]\"")
2120                },
2121        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
2122{
2123    // Add descriptor information to a signing provider
2124    FlatSigningProvider provider;
2125
2126    auto descs = request.params[1].get_array();
2127    for (size_t i = 0; i < descs.size(); ++i) {
2128        EvalDescriptorStringOrObject(descs[i], provider, /*expand_priv=*/true);
2129    }
2130
2131    std::optional<int> sighash_type = ParseSighashString(request.params[2]);
2132    bool bip32derivs = request.params[3].isNull() ? true : request.params[3].get_bool();
2133    bool finalize = request.params[4].isNull() ? true : request.params[4].get_bool();
2134
2135    const PartiallySignedTransaction& psbtx = ProcessPSBT(
2136        request.params[0].get_str(),
2137        request.context,
2138        HidingSigningProvider(&provider, /*hide_secret=*/false, !bip32derivs),
2139        sighash_type,
2140        finalize);
2141
2142    // Check whether or not all of the inputs are now correctly signed
2143    bool complete = true;
2144    const std::optional<PrecomputedTransactionData> txdata_opt{PrecomputePSBTData(psbtx)};
2145    const PrecomputedTransactionData txdata{*CHECK_NONFATAL(txdata_opt)};
2146    for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) {
2147        complete = complete && PSBTInputSignedAndVerified(psbtx, i, &txdata);
2148    }
2149
2150    DataStream ssTx{};
2151    ssTx << psbtx;
2152
2153    UniValue result(UniValue::VOBJ);
2154
2155    result.pushKV("psbt", EncodeBase64(ssTx));
2156    result.pushKV("complete", complete);
2157    if (complete) {
2158        CMutableTransaction mtx;
2159        PartiallySignedTransaction psbtx_copy = psbtx;
2160        CHECK_NONFATAL(FinalizeAndExtractPSBT(psbtx_copy, mtx));
2161        DataStream ssTx_final;
2162        ssTx_final << TX_WITH_WITNESS(mtx);
2163        result.pushKV("hex", HexStr(ssTx_final));
2164    }
2165    return result;
2166},
2167    };
2168}
2169
2170void RegisterRawTransactionRPCCommands(CRPCTable& t)
2171{
2172    static const CRPCCommand commands[]{
2173        {"rawtransactions", &getrawtransaction},
2174        {"rawtransactions", &createrawtransaction},
2175        {"rawtransactions", &decoderawtransaction},
2176        {"rawtransactions", &decodescript},
2177        {"rawtransactions", &combinerawtransaction},
2178        {"rawtransactions", &signrawtransactionwithkey},
2179        {"rawtransactions", &decodepsbt},
2180        {"rawtransactions", &combinepsbt},
2181        {"rawtransactions", &finalizepsbt},
2182        {"rawtransactions", &createpsbt},
2183        {"rawtransactions", &converttopsbt},
2184        {"rawtransactions", &utxoupdatepsbt},
2185        {"rawtransactions", &descriptorprocesspsbt},
2186        {"rawtransactions", &joinpsbts},
2187        {"rawtransactions", &analyzepsbt},
2188    };
2189    for (const auto& c : commands) {
2190        t.appendCommand(c.name, &c);
2191    }
2192}
2193