Decoding, querying and submitting transactions

1001                {RPCResult::Type::OBJ, "witness_script", /*optional=*/true, "",
1002                {
1003                    {RPCResult::Type::STR, "asm", "Disassembly of the witness script"},
1004                    {RPCResult::Type::STR_HEX, "hex", "The raw witness script bytes, hex-encoded"},
1005                    {RPCResult::Type::STR, "type", "The type, eg 'pubkeyhash'"},
1006                }},
1007                {RPCResult::Type::ARR, "bip32_derivs", /*optional=*/true, "",
1008                {
1009                    {RPCResult::Type::OBJ, "", "",
1010                    {
1011                        {RPCResult::Type::STR, "pubkey", "The public key this path corresponds to"},
1012                        {RPCResult::Type::STR, "master_fingerprint", "The fingerprint of the master key"},
1013                        {RPCResult::Type::STR, "path", "The path"},
1014                    }},
1015                }},
1016                {RPCResult::Type::NUM, "amount", /* optional=*/ true, "The amount (nValue) for this output"},
1017                {RPCResult::Type::OBJ, "script", /* optional=*/ true, "The output script (scriptPubKey) for this output",
1018                    ElideGroup(ScriptPubKeyDoc(), "The layout is the same as the output of scriptPubKeys in decoderawtransaction."),
1019                },
1020                {RPCResult::Type::STR_HEX, "taproot_internal_key", /*optional=*/ true, "The hex-encoded Taproot x-only internal key"},
1021                {RPCResult::Type::ARR, "taproot_tree", /*optional=*/ true, "The tuples that make up the Taproot tree, in depth first search order",
1022                {
1023                    {RPCResult::Type::OBJ, "tuple", /*optional=*/ true, "A single leaf script in the taproot tree",
1024                    {
1025                        {RPCResult::Type::NUM, "depth", "The depth of this element in the tree"},
1026                        {RPCResult::Type::NUM, "leaf_ver", "The version of this leaf"},
1027                        {RPCResult::Type::STR, "script", "The hex-encoded script itself"},
1028                    }},
1029                }},
1030                {RPCResult::Type::ARR, "taproot_bip32_derivs", /*optional=*/ true, "",
1031                {
1032                    {RPCResult::Type::OBJ, "", "",
1033                    {
1034                        {RPCResult::Type::STR, "pubkey", "The x-only public key this path corresponds to"},
1035                        {RPCResult::Type::STR, "master_fingerprint", "The fingerprint of the master key"},
1036                        {RPCResult::Type::STR, "path", "The path"},
1037                        {RPCResult::Type::ARR, "leaf_hashes", "The hashes of the leaves this pubkey appears in",
1038                        {
1039                            {RPCResult::Type::STR_HEX, "hash", "The hash of a leaf this pubkey appears in"},
1040                        }},
1041                    }},
1042                }},
1043                {RPCResult::Type::ARR, "musig2_participant_pubkeys", /*optional=*/true, "",
1044                {
1045                    {RPCResult::Type::OBJ, "", "",
1046                    {
1047                        {RPCResult::Type::STR_HEX, "aggregate_pubkey", "The compressed aggregate public key for which the participants create."},
1048                        {RPCResult::Type::ARR, "participant_pubkeys", "",
1049                        {
1050                            {RPCResult::Type::STR_HEX, "pubkey", "The compressed public keys that are aggregated for aggregate_pubkey."},
1051                        }},
1052                    }},
1053                }},
1054                {RPCResult::Type::OBJ_DYN, "unknown", /*optional=*/true, "The unknown output fields",
1055                {
1056                    {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"},
1057                }},
1058                {RPCResult::Type::ARR, "proprietary", /*optional=*/true, "The output proprietary map",
1059                {
1060                    {RPCResult::Type::OBJ, "", "",
1061                    {
1062                        {RPCResult::Type::STR_HEX, "identifier", "The hex string for the proprietary identifier"},
1063                        {RPCResult::Type::NUM, "subtype", "The number for the subtype"},
1064                        {RPCResult::Type::STR_HEX, "key", "The hex for the key"},
1065                        {RPCResult::Type::STR_HEX, "value", "The hex for the value"},
1066                    }},
1067                }},
1068            }},
1069        }
1070    };
1071    return decodepsbt_outputs;
1072}
1073
1074static RPCMethod decodepsbt()
1075{
1076    return RPCMethod{
1077        "decodepsbt",
1078        "Return a JSON object representing the serialized, base64-encoded partially signed Bitcoin transaction.",
1079                {
1080                    {"psbt", RPCArg::Type::STR, RPCArg::Optional::NO, "The PSBT base64 string"},
1081                },
1082                RPCResult{
1083                    RPCResult::Type::OBJ, "", "",
1084                    {
1085                        {RPCResult::Type::OBJ, "tx", /*optional=*/true, "The decoded network-serialized unsigned transaction.",
1086                            TxDoc({.elision_mode = ElisionMode::WithSummary, .elision_summary = "The layout is the same as the output of decoderawtransaction."})
1087                        },
1088                        {RPCResult::Type::ARR, "global_xpubs", "",
1089                        {
1090                            {RPCResult::Type::OBJ, "", "",
1091                            {
1092                                {RPCResult::Type::STR, "xpub", "The extended public key this path corresponds to"},
1093                                {RPCResult::Type::STR_HEX, "master_fingerprint", "The fingerprint of the master key"},
1094                                {RPCResult::Type::STR, "path", "The path"},
1095                            }},
1096                        }},
1097                        {RPCResult::Type::NUM, "tx_version", /* optional */ true, "The version number of the unsigned transaction. Not to be confused with PSBT version"},
1098                        {RPCResult::Type::NUM, "fallback_locktime", /* optional */ true, "The locktime to fallback to if no inputs specify a required locktime."},
1099                        {RPCResult::Type::NUM, "input_count", /* optional */ true, "The number of inputs in this psbt"},
1100                        {RPCResult::Type::NUM, "output_count", /* optional */ true, "The number of outputs in this psbt."},
1101                        {RPCResult::Type::BOOL, "inputs_modifiable", /* optional */ true, "Whether inputs can be modified"},
1102                        {RPCResult::Type::BOOL, "outputs_modifiable", /* optional */ true, "Whether outputs can be modified"},
1103                        {RPCResult::Type::BOOL, "has_sighash_single", /* optional */ true, "Whether this PSBT has SIGHASH_SINGLE inputs"},
1104                        {RPCResult::Type::NUM, "psbt_version", /* optional */ true, "The PSBT version number. Not to be confused with the unsigned transaction version"},
1105                        {RPCResult::Type::ARR, "proprietary", "The global proprietary map",
1106                        {
1107                            {RPCResult::Type::OBJ, "", "",
1108                            {
1109                                {RPCResult::Type::STR_HEX, "identifier", "The hex string for the proprietary identifier"},
1110                                {RPCResult::Type::NUM, "subtype", "The number for the subtype"},
1111                                {RPCResult::Type::STR_HEX, "key", "The hex for the key"},
1112                                {RPCResult::Type::STR_HEX, "value", "The hex for the value"},
1113                            }},
1114                        }},
1115                        {RPCResult::Type::OBJ_DYN, "unknown", "The unknown global fields",
1116                        {
1117                             {RPCResult::Type::STR_HEX, "key", "(key-value pair) An unknown key-value pair"},
1118                        }},
1119                        DecodePSBTInputs(),
1120                        DecodePSBTOutputs(),
1121                        {RPCResult::Type::STR_AMOUNT, "fee", /*optional=*/true, "The transaction fee paid if all UTXOs slots in the PSBT have been filled."},
1122                    }
1123                },
1124                RPCExamples{
1125                    HelpExampleCli("decodepsbt", "\"psbt\"")
1126                },
1127        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
1128{
1129    // Unserialize the transactions
1130    util::Result<PartiallySignedTransaction> psbt_res = DecodeBase64PSBT(request.params[0].get_str());
1131    if (!psbt_res) {
1132        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", util::ErrorString(psbt_res).original));
1133    }
1134    PartiallySignedTransaction psbtx = *psbt_res;
1135
1136    UniValue result(UniValue::VOBJ);
1137
1138    if (psbtx.GetVersion() < 2) {
1139        // Add the decoded tx
1140        UniValue tx_univ(UniValue::VOBJ);
1141        TxToUniv(CTransaction(*CHECK_NONFATAL(psbtx.GetUnsignedTx())), /*block_hash=*/uint256(), /*entry=*/tx_univ, /*include_hex=*/false);
1142        result.pushKV("tx", std::move(tx_univ));
1143    }
1144
1145    // Add the global xpubs
1146    UniValue global_xpubs(UniValue::VARR);
1147    for (std::pair<KeyOriginInfo, std::set<CExtPubKey>> xpub_pair : psbtx.m_xpubs) {
1148        for (auto& xpub : xpub_pair.second) {
1149            std::vector<unsigned char> ser_xpub;
1150            ser_xpub.assign(BIP32_EXTKEY_WITH_VERSION_SIZE, 0);
1151            xpub.EncodeWithVersion(ser_xpub.data());
1152
1153            UniValue keypath(UniValue::VOBJ);
1154            keypath.pushKV("xpub", EncodeBase58Check(ser_xpub));
1155            keypath.pushKV("master_fingerprint", HexStr(xpub_pair.first.fingerprint));
1156            keypath.pushKV("path", WriteHDKeypath(xpub_pair.first.path));
1157            global_xpubs.push_back(std::move(keypath));
1158        }
1159    }
1160    result.pushKV("global_xpubs", std::move(global_xpubs));
1161
1162    // Add PSBTv2 stuff
1163    if (psbtx.GetVersion() >= 2) {
1164        result.pushKV("tx_version", psbtx.tx_version);
1165        if (psbtx.fallback_locktime.has_value()) {
1166            result.pushKV("fallback_locktime", static_cast<uint64_t>(*psbtx.fallback_locktime));
1167        }
1168        result.pushKV("input_count", (uint64_t)psbtx.inputs.size());
1169        result.pushKV("output_count", (uint64_t)psbtx.outputs.size());
1170        if (psbtx.m_tx_modifiable.has_value()) {
1171            result.pushKV("inputs_modifiable", psbtx.m_tx_modifiable->test(0));
1172            result.pushKV("outputs_modifiable", psbtx.m_tx_modifiable->test(1));
1173            result.pushKV("has_sighash_single", psbtx.m_tx_modifiable->test(2));
1174        }
1175    }
1176
1177    // PSBT version
1178    result.pushKV("psbt_version", psbtx.GetVersion());
1179
1180    // Proprietary
1181    UniValue proprietary(UniValue::VARR);
1182    for (const auto& entry : psbtx.m_proprietary) {
1183        UniValue this_prop(UniValue::VOBJ);
1184        this_prop.pushKV("identifier", HexStr(entry.identifier));
1185        this_prop.pushKV("subtype", entry.subtype);
1186        this_prop.pushKV("key", HexStr(entry.key));
1187        this_prop.pushKV("value", HexStr(entry.value));
1188        proprietary.push_back(std::move(this_prop));
1189    }
1190    result.pushKV("proprietary", std::move(proprietary));
1191
1192    // Unknown data
1193    UniValue unknowns(UniValue::VOBJ);
1194    for (auto [key, value] : psbtx.unknown) {
1195        unknowns.pushKVEnd(HexStr(key), HexStr(value));
1196    }
1197    result.pushKV("unknown", std::move(unknowns));
1198
1199    // inputs
1200    CAmount total_in = 0;
1201    bool have_all_utxos = true;
1202    UniValue inputs(UniValue::VARR);
1203    for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) {
1204        const PSBTInput& input = psbtx.inputs[i];
1205        UniValue in(UniValue::VOBJ);
1206        // UTXOs
1207        bool have_a_utxo = false;
1208        CTxOut txout;
1209        if (!input.witness_utxo.IsNull()) {
1210            txout = input.witness_utxo;
1211
1212            UniValue o(UniValue::VOBJ);
1213            ScriptToUniv(txout.scriptPubKey, /*out=*/o, /*include_hex=*/true, /*include_address=*/true);
1214
1215            UniValue out(UniValue::VOBJ);
1216            out.pushKV("amount", ValueFromAmount(txout.nValue));
1217            out.pushKV("scriptPubKey", std::move(o));
1218
1219            in.pushKV("witness_utxo", std::move(out));
1220
1221            have_a_utxo = true;
1222        }
1223        if (input.non_witness_utxo) {
1224            txout = input.non_witness_utxo->vout[input.prev_out];
1225
1226            UniValue non_wit(UniValue::VOBJ);
1227            TxToUniv(*input.non_witness_utxo, /*block_hash=*/uint256(), /*entry=*/non_wit, /*include_hex=*/false);
1228            in.pushKV("non_witness_utxo", std::move(non_wit));
1229
1230            have_a_utxo = true;
1231        }
1232        if (have_a_utxo) {
1233            if (MoneyRange(txout.nValue) && MoneyRange(total_in + txout.nValue)) {
1234                total_in += txout.nValue;
1235            } else {
1236                // Hack to just not show fee later
1237                have_all_utxos = false;
1238            }
1239        } else {
1240            have_all_utxos = false;
1241        }
1242
1243        // Partial sigs
1244        if (!input.partial_sigs.empty()) {
1245            UniValue partial_sigs(UniValue::VOBJ);
1246            for (const auto& sig : input.partial_sigs) {
1247                partial_sigs.pushKV(HexStr(sig.second.first), HexStr(sig.second.second));
1248            }
1249            in.pushKV("partial_signatures", std::move(partial_sigs));
1250        }