1501            UniValue r(UniValue::VOBJ);
1502            ScriptToUniv(output.witness_script, /*out=*/r);
1503            out.pushKV("witness_script", std::move(r));
1504        }
1505
1506        // keypaths
1507        if (!output.hd_keypaths.empty()) {
1508            UniValue keypaths(UniValue::VARR);
1509            for (auto entry : output.hd_keypaths) {
1510                UniValue keypath(UniValue::VOBJ);
1511                keypath.pushKV("pubkey", HexStr(entry.first));
1512                keypath.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(entry.second.fingerprint.data())));
1513                keypath.pushKV("path", WriteHDKeypath(entry.second.path));
1514                keypaths.push_back(std::move(keypath));
1515            }
1516            out.pushKV("bip32_derivs", std::move(keypaths));
1517        }
1518
1519        // PSBTv2 stuff
1520        if (psbtx.GetVersion() >= 2) {
1521            out.pushKV("amount", ValueFromAmount(output.amount));
1522            UniValue spk(UniValue::VOBJ);
1523            ScriptToUniv(output.script, spk, /*include_hex=*/true, /*include_address=*/true);
1524            out.pushKV("script", spk);
1525        }
1526
1527        // Taproot internal key
1528        if (!output.m_tap_internal_key.IsNull()) {
1529            out.pushKV("taproot_internal_key", HexStr(output.m_tap_internal_key));
1530        }
1531
1532        // Taproot tree
1533        if (!output.m_tap_tree.empty()) {
1534            UniValue tree(UniValue::VARR);
1535            for (const auto& [depth, leaf_ver, script] : output.m_tap_tree) {
1536                UniValue elem(UniValue::VOBJ);
1537                elem.pushKV("depth", depth);
1538                elem.pushKV("leaf_ver", leaf_ver);
1539                elem.pushKV("script", HexStr(script));
1540                tree.push_back(std::move(elem));
1541            }
1542            out.pushKV("taproot_tree", std::move(tree));
1543        }
1544
1545        // Taproot bip32 keypaths
1546        if (!output.m_tap_bip32_paths.empty()) {
1547            UniValue keypaths(UniValue::VARR);
1548            for (const auto& [xonly, leaf_origin] : output.m_tap_bip32_paths) {
1549                const auto& [leaf_hashes, origin] = leaf_origin;
1550                UniValue path_obj(UniValue::VOBJ);
1551                path_obj.pushKV("pubkey", HexStr(xonly));
1552                path_obj.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(origin.fingerprint.data())));
1553                path_obj.pushKV("path", WriteHDKeypath(origin.path));
1554                UniValue leaf_hashes_arr(UniValue::VARR);
1555                for (const auto& leaf_hash : leaf_hashes) {
1556                    leaf_hashes_arr.push_back(HexStr(leaf_hash));
1557                }
1558                path_obj.pushKV("leaf_hashes", std::move(leaf_hashes_arr));
1559                keypaths.push_back(std::move(path_obj));
1560            }
1561            out.pushKV("taproot_bip32_derivs", std::move(keypaths));
1562        }
1563
1564        // Write MuSig2 fields
1565        if (!output.m_musig2_participants.empty()) {
1566            UniValue musig_pubkeys(UniValue::VARR);
1567            for (const auto& [agg, parts] : output.m_musig2_participants) {
1568                UniValue musig_part(UniValue::VOBJ);
1569                musig_part.pushKV("aggregate_pubkey", HexStr(agg));
1570                UniValue part_pubkeys(UniValue::VARR);
1571                for (const auto& pub : parts) {
1572                    part_pubkeys.push_back(HexStr(pub));
1573                }
1574                musig_part.pushKV("participant_pubkeys", part_pubkeys);
1575                musig_pubkeys.push_back(musig_part);
1576            }
1577            out.pushKV("musig2_participant_pubkeys", musig_pubkeys);
1578        }
1579
1580        // Proprietary
1581        if (!output.m_proprietary.empty()) {
1582            UniValue proprietary(UniValue::VARR);
1583            for (const auto& entry : output.m_proprietary) {
1584                UniValue this_prop(UniValue::VOBJ);
1585                this_prop.pushKV("identifier", HexStr(entry.identifier));
1586                this_prop.pushKV("subtype", entry.subtype);
1587                this_prop.pushKV("key", HexStr(entry.key));
1588                this_prop.pushKV("value", HexStr(entry.value));
1589                proprietary.push_back(std::move(this_prop));
1590            }
1591            out.pushKV("proprietary", std::move(proprietary));
1592        }
1593
1594        // Unknown data
1595        if (output.unknown.size() > 0) {
1596            UniValue unknowns(UniValue::VOBJ);
1597            for (auto [key, value] : output.unknown) {
1598                unknowns.pushKVEnd(HexStr(key), HexStr(value));
1599            }
1600            out.pushKV("unknown", std::move(unknowns));
1601        }
1602
1603        outputs.push_back(std::move(out));
1604
1605        // Fee calculation
1606        if (MoneyRange(output.amount) && MoneyRange(output_value + output.amount)) {
1607            output_value += output.amount;
1608        } else {
1609            // Hack to just not show fee later
1610            have_all_utxos = false;
1611        }
1612    }
1613    result.pushKV("outputs", std::move(outputs));
1614    if (have_all_utxos) {
1615        result.pushKV("fee", ValueFromAmount(total_in - output_value));
1616    }
1617
1618    return result;
1619},
1620    };
1621}
1622
1623static RPCMethod combinepsbt()
1624{
1625    return RPCMethod{
1626        "combinepsbt",
1627        "Combine multiple partially signed Bitcoin transactions into one transaction.\n"
1628                "Implements the Combiner role.\n",
1629                {
1630                    {"txs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The base64 strings of partially signed transactions",
1631                        {
1632                            {"psbt", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "A base64 string of a PSBT"},
1633                        },
1634                        },
1635                },
1636                RPCResult{
1637                    RPCResult::Type::STR, "", "The base64-encoded partially signed transaction"
1638                },
1639                RPCExamples{
1640                    HelpExampleCli("combinepsbt", R"('["mybase64_1", "mybase64_2", "mybase64_3"]')")
1641                },
1642        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1643{
1644    // Unserialize the transactions
1645    std::vector<PartiallySignedTransaction> psbtxs;
1646    UniValue txs = request.params[0].get_array();
1647    if (txs.empty()) {
1648        throw JSONRPCError(RPC_INVALID_PARAMETER, "Parameter 'txs' cannot be empty");
1649    }
1650    for (unsigned int i = 0; i < txs.size(); ++i) {
1651        util::Result<PartiallySignedTransaction> psbt_res = DecodeBase64PSBT(txs[i].get_str());
1652        if (!psbt_res) {
1653            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", util::ErrorString(psbt_res).original));
1654        }
1655        psbtxs.push_back(*psbt_res);
1656    }
1657
1658    std::optional<PartiallySignedTransaction> merged_psbt = CombinePSBTs(psbtxs);
1659    if (!merged_psbt) {
1660        throw JSONRPCError(RPC_INVALID_PARAMETER, "PSBTs not compatible (different transactions)");
1661    }
1662
1663    DataStream ssTx{};
1664    ssTx << *merged_psbt;
1665    return EncodeBase64(ssTx);
1666},
1667    };
1668}
1669
1670static RPCMethod finalizepsbt()
1671{
1672    return RPCMethod{"finalizepsbt",
1673                "Finalize the inputs of a PSBT. If the transaction is fully signed, it will produce a\n"
1674                "network serialized transaction which can be broadcast with sendrawtransaction. Otherwise a PSBT will be\n"
1675                "created which has the final_scriptSig and final_scriptwitness fields filled for inputs that are complete.\n"
1676                "Implements the Finalizer and Extractor roles.\n",
1677                {
1678                    {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "A base64 string of a PSBT"},
1679                    {"extract", RPCArg::Type::BOOL, RPCArg::Default{true}, "If true and the transaction is complete,\n"
1680            "                             extract and return the complete transaction in normal network serialization instead of the PSBT."},
1681                },
1682                RPCResult{
1683                    RPCResult::Type::OBJ, "", "",
1684                    {
1685                        {RPCResult::Type::STR, "psbt", /*optional=*/true, "The base64-encoded partially signed transaction if not extracted"},
1686                        {RPCResult::Type::STR_HEX, "hex", /*optional=*/true, "The hex-encoded network transaction if extracted"},
1687                        {RPCResult::Type::BOOL, "complete", "If the transaction has a complete set of signatures"},
1688                    }
1689                },
1690                RPCExamples{
1691                    HelpExampleCli("finalizepsbt", "\"psbt\"")
1692                },
1693        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1694{
1695    // Unserialize the transactions
1696    util::Result<PartiallySignedTransaction> psbt_res = DecodeBase64PSBT(request.params[0].get_str());
1697    if (!psbt_res) {
1698        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", util::ErrorString(psbt_res).original));
1699    }
1700    PartiallySignedTransaction psbtx = *psbt_res;
1701
1702    bool extract = request.params[1].isNull() || (!request.params[1].isNull() && request.params[1].get_bool());
1703
1704    CMutableTransaction mtx;
1705    bool complete = FinalizeAndExtractPSBT(psbtx, mtx);
1706
1707    UniValue result(UniValue::VOBJ);
1708    DataStream ssTx{};
1709    std::string result_str;
1710
1711    if (complete && extract) {
1712        ssTx << TX_WITH_WITNESS(mtx);
1713        result_str = HexStr(ssTx);
1714        result.pushKV("hex", result_str);
1715    } else {
1716        ssTx << psbtx;
1717        result_str = EncodeBase64(ssTx.str());
1718        result.pushKV("psbt", result_str);
1719    }
1720    result.pushKV("complete", complete);
1721
1722    return result;
1723},
1724    };
1725}
1726
1727static RPCMethod createpsbt()
1728{
1729    return RPCMethod{
1730        "createpsbt",
1731        "Creates a transaction in the Partially Signed Transaction format.\n"
1732                "Implements the Creator role.\n"
1733                "Note that the transaction's inputs are not signed, and\n"
1734                "it is not stored in the wallet or transmitted to the network.\n",
1735                Cat<std::vector<RPCArg>>(
1736                    CreateTxDoc(),
1737                    {
1738                        {"psbt_version", RPCArg::Type::NUM, RPCArg::Default{2}, "The PSBT version number to use."},
1739                    }
1740                ),
1741                RPCResult{
1742                    RPCResult::Type::STR, "", "The resulting raw transaction (base64-encoded string)"
1743                },
1744                RPCExamples{
1745                    HelpExampleCli("createpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":0.01}]\"")
1746                },
1747        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1748{
1749    std::optional<bool> rbf;
1750    if (!request.params[3].isNull()) {