Decoding, querying and submitting transactions

1251
1252        // Sighash
1253        if (input.sighash_type != std::nullopt) {
1254            in.pushKV("sighash", SighashToStr(*input.sighash_type));
1255        }
1256
1257        // Redeem script and witness script
1258        if (!input.redeem_script.empty()) {
1259            UniValue r(UniValue::VOBJ);
1260            ScriptToUniv(input.redeem_script, /*out=*/r);
1261            in.pushKV("redeem_script", std::move(r));
1262        }
1263        if (!input.witness_script.empty()) {
1264            UniValue r(UniValue::VOBJ);
1265            ScriptToUniv(input.witness_script, /*out=*/r);
1266            in.pushKV("witness_script", std::move(r));
1267        }
1268
1269        // keypaths
1270        if (!input.hd_keypaths.empty()) {
1271            UniValue keypaths(UniValue::VARR);
1272            for (auto entry : input.hd_keypaths) {
1273                UniValue keypath(UniValue::VOBJ);
1274                keypath.pushKV("pubkey", HexStr(entry.first));
1275
1276                keypath.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(entry.second.fingerprint.data())));
1277                keypath.pushKV("path", WriteHDKeypath(entry.second.path));
1278                keypaths.push_back(std::move(keypath));
1279            }
1280            in.pushKV("bip32_derivs", std::move(keypaths));
1281        }
1282
1283        // Final scriptSig and scriptwitness
1284        if (!input.final_script_sig.empty()) {
1285            UniValue scriptsig(UniValue::VOBJ);
1286            scriptsig.pushKV("asm", ScriptToAsmStr(input.final_script_sig, true));
1287            scriptsig.pushKV("hex", HexStr(input.final_script_sig));
1288            in.pushKV("final_scriptSig", std::move(scriptsig));
1289        }
1290        if (!input.final_script_witness.IsNull()) {
1291            UniValue txinwitness(UniValue::VARR);
1292            for (const auto& item : input.final_script_witness.stack) {
1293                txinwitness.push_back(HexStr(item));
1294            }
1295            in.pushKV("final_scriptwitness", std::move(txinwitness));
1296        }
1297
1298        // Ripemd160 hash preimages
1299        if (!input.ripemd160_preimages.empty()) {
1300            UniValue ripemd160_preimages(UniValue::VOBJ);
1301            for (const auto& [hash, preimage] : input.ripemd160_preimages) {
1302                ripemd160_preimages.pushKVEnd(HexStr(hash), HexStr(preimage));
1303            }
1304            in.pushKV("ripemd160_preimages", std::move(ripemd160_preimages));
1305        }
1306
1307        // Sha256 hash preimages
1308        if (!input.sha256_preimages.empty()) {
1309            UniValue sha256_preimages(UniValue::VOBJ);
1310            for (const auto& [hash, preimage] : input.sha256_preimages) {
1311                sha256_preimages.pushKVEnd(HexStr(hash), HexStr(preimage));
1312            }
1313            in.pushKV("sha256_preimages", std::move(sha256_preimages));
1314        }
1315
1316        // Hash160 hash preimages
1317        if (!input.hash160_preimages.empty()) {
1318            UniValue hash160_preimages(UniValue::VOBJ);
1319            for (const auto& [hash, preimage] : input.hash160_preimages) {
1320                hash160_preimages.pushKVEnd(HexStr(hash), HexStr(preimage));
1321            }
1322            in.pushKV("hash160_preimages", std::move(hash160_preimages));
1323        }
1324
1325        // Hash256 hash preimages
1326        if (!input.hash256_preimages.empty()) {
1327            UniValue hash256_preimages(UniValue::VOBJ);
1328            for (const auto& [hash, preimage] : input.hash256_preimages) {
1329                hash256_preimages.pushKVEnd(HexStr(hash), HexStr(preimage));
1330            }
1331            in.pushKV("hash256_preimages", std::move(hash256_preimages));
1332        }
1333
1334        // PSBTv2
1335        if (psbtx.GetVersion() >= 2) {
1336            in.pushKV("previous_txid", input.prev_txid.GetHex());
1337            in.pushKV("previous_vout", static_cast<uint64_t>(input.prev_out));
1338            if (input.sequence.has_value()) {
1339                in.pushKV("sequence", static_cast<uint64_t>(*input.sequence));
1340            }
1341            if (input.time_locktime.has_value()) {
1342                in.pushKV("time_locktime", static_cast<uint64_t>(*input.time_locktime));
1343            }
1344            if (input.height_locktime.has_value()) {
1345                in.pushKV("height_locktime", static_cast<uint64_t>(*input.height_locktime));
1346            }
1347        }
1348
1349        // Taproot key path signature
1350        if (!input.m_tap_key_sig.empty()) {
1351            in.pushKV("taproot_key_path_sig", HexStr(input.m_tap_key_sig));
1352        }
1353
1354        // Taproot script path signatures
1355        if (!input.m_tap_script_sigs.empty()) {
1356            UniValue script_sigs(UniValue::VARR);
1357            for (const auto& [pubkey_leaf, sig] : input.m_tap_script_sigs) {
1358                const auto& [xonly, leaf_hash] = pubkey_leaf;
1359                UniValue sigobj(UniValue::VOBJ);
1360                sigobj.pushKV("pubkey", HexStr(xonly));
1361                sigobj.pushKV("leaf_hash", HexStr(leaf_hash));
1362                sigobj.pushKV("sig", HexStr(sig));
1363                script_sigs.push_back(std::move(sigobj));
1364            }
1365            in.pushKV("taproot_script_path_sigs", std::move(script_sigs));
1366        }
1367
1368        // Taproot leaf scripts
1369        if (!input.m_tap_scripts.empty()) {
1370            UniValue tap_scripts(UniValue::VARR);
1371            for (const auto& [leaf, control_blocks] : input.m_tap_scripts) {
1372                const auto& [script, leaf_ver] = leaf;
1373                UniValue script_info(UniValue::VOBJ);
1374                script_info.pushKV("script", HexStr(script));
1375                script_info.pushKV("leaf_ver", leaf_ver);
1376                UniValue control_blocks_univ(UniValue::VARR);
1377                for (const auto& control_block : control_blocks) {
1378                    control_blocks_univ.push_back(HexStr(control_block));
1379                }
1380                script_info.pushKV("control_blocks", std::move(control_blocks_univ));
1381                tap_scripts.push_back(std::move(script_info));
1382            }
1383            in.pushKV("taproot_scripts", std::move(tap_scripts));
1384        }
1385
1386        // Taproot bip32 keypaths
1387        if (!input.m_tap_bip32_paths.empty()) {
1388            UniValue keypaths(UniValue::VARR);
1389            for (const auto& [xonly, leaf_origin] : input.m_tap_bip32_paths) {
1390                const auto& [leaf_hashes, origin] = leaf_origin;
1391                UniValue path_obj(UniValue::VOBJ);
1392                path_obj.pushKV("pubkey", HexStr(xonly));
1393                path_obj.pushKV("master_fingerprint", strprintf("%08x", ReadBE32(origin.fingerprint.data())));
1394                path_obj.pushKV("path", WriteHDKeypath(origin.path));
1395                UniValue leaf_hashes_arr(UniValue::VARR);
1396                for (const auto& leaf_hash : leaf_hashes) {
1397                    leaf_hashes_arr.push_back(HexStr(leaf_hash));
1398                }
1399                path_obj.pushKV("leaf_hashes", std::move(leaf_hashes_arr));
1400                keypaths.push_back(std::move(path_obj));
1401            }
1402            in.pushKV("taproot_bip32_derivs", std::move(keypaths));
1403        }
1404
1405        // Taproot internal key
1406        if (!input.m_tap_internal_key.IsNull()) {
1407            in.pushKV("taproot_internal_key", HexStr(input.m_tap_internal_key));
1408        }
1409
1410        // Write taproot merkle root
1411        if (!input.m_tap_merkle_root.IsNull()) {
1412            in.pushKV("taproot_merkle_root", HexStr(input.m_tap_merkle_root));
1413        }
1414
1415        // Write MuSig2 fields
1416        if (!input.m_musig2_participants.empty()) {
1417            UniValue musig_pubkeys(UniValue::VARR);
1418            for (const auto& [agg, parts] : input.m_musig2_participants) {
1419                UniValue musig_part(UniValue::VOBJ);
1420                musig_part.pushKV("aggregate_pubkey", HexStr(agg));
1421                UniValue part_pubkeys(UniValue::VARR);
1422                for (const auto& pub : parts) {
1423                    part_pubkeys.push_back(HexStr(pub));
1424                }
1425                musig_part.pushKV("participant_pubkeys", part_pubkeys);
1426                musig_pubkeys.push_back(musig_part);
1427            }
1428            in.pushKV("musig2_participant_pubkeys", musig_pubkeys);
1429        }
1430        if (!input.m_musig2_pubnonces.empty()) {
1431            UniValue musig_pubnonces(UniValue::VARR);
1432            for (const auto& [agg_lh, part_pubnonce] : input.m_musig2_pubnonces) {
1433                const auto& [agg, lh] = agg_lh;
1434                for (const auto& [part, pubnonce] : part_pubnonce) {
1435                    UniValue info(UniValue::VOBJ);
1436                    info.pushKV("participant_pubkey", HexStr(part));
1437                    info.pushKV("aggregate_pubkey", HexStr(agg));
1438                    if (!lh.IsNull()) info.pushKV("leaf_hash", HexStr(lh));
1439                    info.pushKV("pubnonce", HexStr(pubnonce));
1440                    musig_pubnonces.push_back(info);
1441                }
1442            }
1443            in.pushKV("musig2_pubnonces", musig_pubnonces);
1444        }
1445        if (!input.m_musig2_partial_sigs.empty()) {
1446            UniValue musig_partial_sigs(UniValue::VARR);
1447            for (const auto& [agg_lh, part_psig] : input.m_musig2_partial_sigs) {
1448                const auto& [agg, lh] = agg_lh;
1449                for (const auto& [part, psig] : part_psig) {
1450                    UniValue info(UniValue::VOBJ);
1451                    info.pushKV("participant_pubkey", HexStr(part));
1452                    info.pushKV("aggregate_pubkey", HexStr(agg));
1453                    if (!lh.IsNull()) info.pushKV("leaf_hash", HexStr(lh));
1454                    info.pushKV("partial_sig", HexStr(psig));
1455                    musig_partial_sigs.push_back(info);
1456                }
1457            }
1458            in.pushKV("musig2_partial_sigs", musig_partial_sigs);
1459        }
1460
1461        // Proprietary
1462        if (!input.m_proprietary.empty()) {
1463            UniValue proprietary(UniValue::VARR);
1464            for (const auto& entry : input.m_proprietary) {
1465                UniValue this_prop(UniValue::VOBJ);
1466                this_prop.pushKV("identifier", HexStr(entry.identifier));
1467                this_prop.pushKV("subtype", entry.subtype);
1468                this_prop.pushKV("key", HexStr(entry.key));
1469                this_prop.pushKV("value", HexStr(entry.value));
1470                proprietary.push_back(std::move(this_prop));
1471            }
1472            in.pushKV("proprietary", std::move(proprietary));
1473        }
1474
1475        // Unknown data
1476        if (input.unknown.size() > 0) {
1477            UniValue unknowns(UniValue::VOBJ);
1478            for (auto [key, value] : input.unknown) {
1479                unknowns.pushKVEnd(HexStr(key), HexStr(value));
1480            }
1481            in.pushKV("unknown", std::move(unknowns));
1482        }
1483
1484        inputs.push_back(std::move(in));
1485    }
1486    result.pushKV("inputs", std::move(inputs));
1487
1488    // outputs
1489    CAmount output_value = 0;
1490    UniValue outputs(UniValue::VARR);
1491    for (unsigned int i = 0; i < psbtx.outputs.size(); ++i) {
1492        const PSBTOutput& output = psbtx.outputs[i];
1493        UniValue out(UniValue::VOBJ);
1494        // Redeem script and witness script
1495        if (!output.redeem_script.empty()) {
1496            UniValue r(UniValue::VOBJ);
1497            ScriptToUniv(output.redeem_script, /*out=*/r);
1498            out.pushKV("redeem_script", std::move(r));
1499        }
1500        if (!output.witness_script.empty()) {