Decoding, querying and submitting transactions

501                     {RPCResult::Type::STR, "p2sh-segwit", "address of the P2SH script wrapping this witness redeem script"},
502                 }},
503            },
504        },
505        RPCExamples{
506            HelpExampleCli("decodescript", "\"hexstring\"")
507          + HelpExampleRpc("decodescript", "\"hexstring\"")
508        },
509        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
510{
511    UniValue r(UniValue::VOBJ);
512    CScript script;
513    if (request.params[0].get_str().size() > 0){
514        std::vector<unsigned char> scriptData(ParseHexV(request.params[0], "argument"));
515        script = CScript(scriptData.begin(), scriptData.end());
516    } else {
517        // Empty scripts are valid
518    }
519    ScriptToUniv(script, /*out=*/r, /*include_hex=*/false, /*include_address=*/true);
520
521    std::vector<std::vector<unsigned char>> solutions_data;
522    const TxoutType which_type{Solver(script, solutions_data)};
523
524    const bool can_wrap{[&] {
525        switch (which_type) {
526        case TxoutType::MULTISIG:
527        case TxoutType::NONSTANDARD:
528        case TxoutType::PUBKEY:
529        case TxoutType::PUBKEYHASH:
530        case TxoutType::WITNESS_V0_KEYHASH:
531        case TxoutType::WITNESS_V0_SCRIPTHASH:
532            // Can be wrapped if the checks below pass
533            break;
534        case TxoutType::NULL_DATA:
535        case TxoutType::SCRIPTHASH:
536        case TxoutType::WITNESS_UNKNOWN:
537        case TxoutType::WITNESS_V1_TAPROOT:
538        case TxoutType::ANCHOR:
539            // Should not be wrapped
540            return false;
541        } // no default case, so the compiler can warn about missing cases
542        if (!script.HasValidOps() || script.IsUnspendable()) {
543            return false;
544        }
545        for (CScript::const_iterator it{script.begin()}; it != script.end();) {
546            opcodetype op;
547            CHECK_NONFATAL(script.GetOp(it, op));
548            if (op == OP_CHECKSIGADD || IsOpSuccess(op)) {
549                return false;
550            }
551        }
552        return true;
553    }()};
554
555    if (can_wrap) {
556        r.pushKV("p2sh", EncodeDestination(ScriptHash(script)));
557        // P2SH and witness programs cannot be wrapped in P2WSH, if this script
558        // is a witness program, don't return addresses for a segwit programs.
559        const bool can_wrap_P2WSH{[&] {
560            switch (which_type) {
561            case TxoutType::MULTISIG:
562            case TxoutType::PUBKEY:
563            // Uncompressed pubkeys cannot be used with segwit checksigs.
564            // If the script contains an uncompressed pubkey, skip encoding of a segwit program.
565                for (const auto& solution : solutions_data) {
566                    if ((solution.size() != 1) && !CPubKey(solution).IsCompressed()) {
567                        return false;
568                    }
569                }
570                return true;
571            case TxoutType::NONSTANDARD:
572            case TxoutType::PUBKEYHASH:
573                // Can be P2WSH wrapped
574                return true;
575            case TxoutType::NULL_DATA:
576            case TxoutType::SCRIPTHASH:
577            case TxoutType::WITNESS_UNKNOWN:
578            case TxoutType::WITNESS_V0_KEYHASH:
579            case TxoutType::WITNESS_V0_SCRIPTHASH:
580            case TxoutType::WITNESS_V1_TAPROOT:
581            case TxoutType::ANCHOR:
582                // Should not be wrapped
583                return false;
584            } // no default case, so the compiler can warn about missing cases
585            NONFATAL_UNREACHABLE();
586        }()};
587        if (can_wrap_P2WSH) {
588            UniValue sr(UniValue::VOBJ);
589            CScript segwitScr;
590            FlatSigningProvider provider;
591            if (which_type == TxoutType::PUBKEY) {
592                segwitScr = GetScriptForDestination(WitnessV0KeyHash(Hash160(solutions_data[0])));
593            } else if (which_type == TxoutType::PUBKEYHASH) {
594                segwitScr = GetScriptForDestination(WitnessV0KeyHash(uint160{solutions_data[0]}));
595            } else {
596                // Scripts that are not fit for P2WPKH are encoded as P2WSH.
597                provider.scripts[CScriptID(script)] = script;
598                segwitScr = GetScriptForDestination(WitnessV0ScriptHash(script));
599            }
600            ScriptToUniv(segwitScr, /*out=*/sr, /*include_hex=*/true, /*include_address=*/true, /*provider=*/&provider);
601            sr.pushKV("p2sh-segwit", EncodeDestination(ScriptHash(segwitScr)));
602            r.pushKV("segwit", std::move(sr));
603        }
604    }
605
606    return r;
607},
608    };
609}
610
611static RPCMethod combinerawtransaction()
612{
613    return RPCMethod{
614        "combinerawtransaction",
615        "Combine multiple partially signed transactions into one transaction.\n"
616                "The combined transaction may be another partially signed transaction or a \n"
617                "fully signed transaction.",
618                {
619                    {"txs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The hex strings of partially signed transactions",
620                        {
621                            {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A hex-encoded raw transaction"},
622                        },
623                        },
624                },
625                RPCResult{
626                    RPCResult::Type::STR, "", "The hex-encoded raw transaction with signature(s)"
627                },
628                RPCExamples{
629                    HelpExampleCli("combinerawtransaction", R"('["myhex1", "myhex2", "myhex3"]')")
630                },
631        [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue
632{
633
634    UniValue txs = request.params[0].get_array();
635
636    // Can't merge < 2 items
637    if (txs.size() < 2) {
638        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transactions. At least two transactions required.");
639    }
640
641    std::vector<CMutableTransaction> txVariants(txs.size());
642
643    for (unsigned int idx = 0; idx < txs.size(); idx++) {
644        if (!DecodeHexTx(txVariants[idx], txs[idx].get_str())) {
645            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed for tx %d. Make sure the tx has at least one input.", idx));
646        }
647    }
648
649    { // Test Tx relation for mergeability. Strip scriptSigs and scriptWitnesses to facilitate txId comparison
650        std::vector<CMutableTransaction> tx_variants_copy(txVariants);
651        Txid first_txid{};
652        for (unsigned int k{0}; k < tx_variants_copy.size(); ++k) {
653            // Remove all scriptSigs and scriptWitnesses from inputs
654            for (CTxIn& input : tx_variants_copy[k].vin) {
655                input.scriptSig.clear();
656                input.scriptWitness.SetNull();
657            }
658            if (k == 0) {
659                first_txid = tx_variants_copy[k].GetHash();
660            } else if (first_txid != tx_variants_copy[k].GetHash()) {
661                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Transaction number %d not compatible with first transaction", k+1));
662            }
663        }
664    }
665
666    // mergedTx will end up with all the signatures; it
667    // starts as a clone of the rawtx:
668    CMutableTransaction mergedTx(txVariants[0]);
669
670    // Fetch previous transactions (inputs):
671    CCoinsViewCache view{&CoinsViewEmpty::Get()};
672    {
673        NodeContext& node = EnsureAnyNodeContext(request.context);
674        const CTxMemPool& mempool = EnsureMemPool(node);
675        ChainstateManager& chainman = EnsureChainman(node);
676        LOCK2(cs_main, mempool.cs);
677        CCoinsViewCache &viewChain = chainman.ActiveChainstate().CoinsTip();
678        CCoinsViewMemPool viewMempool(&viewChain, mempool);
679        view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view
680
681        for (const CTxIn& txin : mergedTx.vin) {
682            view.AccessCoin(txin.prevout); // Load entries from viewChain into view; can fail.
683        }
684
685        view.SetBackend(CoinsViewEmpty::Get()); // switch back to avoid locking mempool for too long
686    }
687
688    // Use CTransaction for the constant parts of the
689    // transaction to avoid rehashing.
690    const CTransaction txConst(mergedTx);
691    // Sign what we can:
692    for (unsigned int i = 0; i < mergedTx.vin.size(); i++) {
693        CTxIn& txin = mergedTx.vin[i];
694        const Coin& coin = view.AccessCoin(txin.prevout);
695        if (coin.IsSpent()) {
696            throw JSONRPCError(RPC_VERIFY_ERROR, "Input not found or already spent");
697        }
698        SignatureData sigdata;
699
700        // ... and merge in other signatures:
701        for (const CMutableTransaction& txv : txVariants) {
702            if (txv.vin.size() > i) {
703                sigdata.MergeSignatureData(DataFromTransaction(txv, i, coin.out));
704            }
705        }
706        ProduceSignature(DUMMY_SIGNING_PROVIDER, MutableTransactionSignatureCreator(mergedTx, i, coin.out.nValue, {.sighash_type = SIGHASH_ALL}), coin.out.scriptPubKey, sigdata);
707
708        UpdateInput(txin, sigdata);
709    }
710
711    return EncodeHexTx(CTransaction(mergedTx));
712},
713    };
714}
715
716static RPCMethod signrawtransactionwithkey()
717{
718    return RPCMethod{
719        "signrawtransactionwithkey",
720        "Sign inputs for raw transaction (serialized, hex-encoded).\n"
721                "The second argument is an array of base58-encoded private\n"
722                "keys that will be the only keys used to sign the transaction.\n"
723                "The third optional argument (may be null) is an array of previous transaction outputs that\n"
724                "this transaction depends on but may not yet be in the block chain.\n",
725                {
726                    {"hexstring", RPCArg::Type::STR, RPCArg::Optional::NO, "The transaction hex string"},
727                    {"privkeys", RPCArg::Type::ARR, RPCArg::Optional::NO, "The base58-encoded private keys for signing",
728                        {
729                            {"privatekey", RPCArg::Type::STR, RPCArg::Optional::OMITTED, "private key in base58-encoding"},
730                        },
731                        },
732                    {"prevtxs", RPCArg::Type::ARR, RPCArg::Optional::OMITTED, "The previous dependent transaction outputs",
733                        {
734                            {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
735                                {
736                                    {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
737                                    {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
738                                    {"scriptPubKey", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "output script"},
739                                    {"redeemScript", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(required for P2SH) redeem script"},
740                                    {"witnessScript", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "(required for P2WSH or P2SH-P2WSH) witness script"},
741                                    {"amount", RPCArg::Type::AMOUNT, RPCArg::Optional::OMITTED, "(required for Segwit inputs) the amount spent"},
742                                },
743                                },
744                        },
745                        },
746                    {"sighashtype", RPCArg::Type::STR, RPCArg::DefaultHint{"DEFAULT for Taproot, ALL otherwise"}, "The signature hash type. Must be one of:\n"
747            "       \"DEFAULT\"\n"
748            "       \"ALL\"\n"
749            "       \"NONE\"\n"
750            "       \"SINGLE\"\n"