251
252            // if redeemScript and private keys were given, add redeemScript to the keystore so it can be signed
253            const bool is_p2sh = scriptPubKey.IsPayToScriptHash();
254            const bool is_p2wsh = scriptPubKey.IsPayToWitnessScriptHash();
255            if (keystore && (is_p2sh || is_p2wsh)) {
256                RPCTypeCheckObj(prevOut,
257                    {
258                        {"redeemScript", UniValueType(UniValue::VSTR)},
259                        {"witnessScript", UniValueType(UniValue::VSTR)},
260                    }, true);
261                const UniValue& rs{prevOut.find_value("redeemScript")};
262                const UniValue& ws{prevOut.find_value("witnessScript")};
263                if (rs.isNull() && ws.isNull()) {
264                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing redeemScript/witnessScript");
265                }
266
267                // work from witnessScript when possible
268                std::vector<unsigned char> scriptData(!ws.isNull() ? ParseHexV(ws, "witnessScript") : ParseHexV(rs, "redeemScript"));
269                CScript script(scriptData.begin(), scriptData.end());
270                keystore->scripts.emplace(CScriptID(script), script);
271                // Automatically also add the P2WSH wrapped version of the script (to deal with P2SH-P2WSH).
272                // This is done for redeemScript only for compatibility, it is encouraged to use the explicit witnessScript field instead.
273                CScript witness_output_script{GetScriptForDestination(WitnessV0ScriptHash(script))};
274                keystore->scripts.emplace(CScriptID(witness_output_script), witness_output_script);
275
276                if (!ws.isNull() && !rs.isNull()) {
277                    // if both witnessScript and redeemScript are provided,
278                    // they should either be the same (for backwards compat),
279                    // or the redeemScript should be the encoded form of
280                    // the witnessScript (ie, for p2sh-p2wsh)
281                    if (ws.get_str() != rs.get_str()) {
282                        std::vector<unsigned char> redeemScriptData(ParseHexV(rs, "redeemScript"));
283                        CScript redeemScript(redeemScriptData.begin(), redeemScriptData.end());
284                        if (redeemScript != witness_output_script) {
285                            throw JSONRPCError(RPC_INVALID_PARAMETER, "redeemScript does not correspond to witnessScript");
286                        }
287                    }
288                }
289
290                if (is_p2sh) {
291                    const CTxDestination p2sh{ScriptHash(script)};
292                    const CTxDestination p2sh_p2wsh{ScriptHash(witness_output_script)};
293                    if (scriptPubKey == GetScriptForDestination(p2sh)) {
294                        // traditional p2sh; arguably an error if
295                        // we got here with rs.IsNull(), because
296                        // that means the p2sh script was specified
297                        // via witnessScript param, but for now
298                        // we'll just quietly accept it
299                    } else if (scriptPubKey == GetScriptForDestination(p2sh_p2wsh)) {
300                        // p2wsh encoded as p2sh; ideally the witness
301                        // script was specified in the witnessScript
302                        // param, but also support specifying it via
303                        // redeemScript param for backwards compat
304                        // (in which case ws.IsNull() == true)
305                    } else {
306                        // otherwise, can't generate scriptPubKey from
307                        // either script, so we got unusable parameters
308                        throw JSONRPCError(RPC_INVALID_PARAMETER, "redeemScript/witnessScript does not match scriptPubKey");
309                    }
310                } else if (is_p2wsh) {
311                    // plain p2wsh; could throw an error if script
312                    // was specified by redeemScript rather than
313                    // witnessScript (ie, ws.IsNull() == true), but
314                    // accept it for backwards compat
315                    const CTxDestination p2wsh{WitnessV0ScriptHash(script)};
316                    if (scriptPubKey != GetScriptForDestination(p2wsh)) {
317                        throw JSONRPCError(RPC_INVALID_PARAMETER, "redeemScript/witnessScript does not match scriptPubKey");
318                    }
319                }
320            }
321        }
322    }
323}
324
325void SignTransaction(CMutableTransaction& mtx, const SigningProvider* keystore, const std::map<COutPoint, Coin>& coins, const UniValue& hashType, UniValue& result)
326{
327    std::optional<int> nHashType = ParseSighashString(hashType);
328    if (!nHashType) {
329        nHashType = SIGHASH_DEFAULT;
330    }
331
332    // Script verification errors
333    std::map<int, bilingual_str> input_errors;
334
335    bool complete = SignTransaction(mtx, keystore, coins, {.sighash_type = *nHashType}, input_errors);
336    SignTransactionResultToJSON(mtx, complete, coins, input_errors, result);
337}
338
339void SignTransactionResultToJSON(CMutableTransaction& mtx, bool complete, const std::map<COutPoint, Coin>& coins, const std::map<int, bilingual_str>& input_errors, UniValue& result)
340{
341    // Make errors UniValue
342    UniValue vErrors(UniValue::VARR);
343    for (const auto& err_pair : input_errors) {
344        if (err_pair.second.original == "Missing amount") {
345            // This particular error needs to be an exception for some reason
346            throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing amount for %s", coins.at(mtx.vin.at(err_pair.first).prevout).out.ToString()));
347        }
348        TxInErrorToJSON(mtx.vin.at(err_pair.first), vErrors, err_pair.second.original);
349    }
350
351    result.pushKV("hex", EncodeHexTx(CTransaction(mtx)));
352    result.pushKV("complete", complete);
353    if (!vErrors.empty()) {
354        if (result.exists("errors")) {
355            vErrors.push_backV(result["errors"].getValues());
356        }
357        result.pushKV("errors", std::move(vErrors));
358    }
359}
360
361std::vector<RPCResult> TxDoc(const TxDocOptions& opts)
362{
363    CHECK_NONFATAL(!opts.fee_doc || opts.fee);
364    CHECK_NONFATAL(!opts.prevout_doc || opts.prevout);
365    CHECK_NONFATAL(!opts.vin_item_doc || opts.vin_inner_elision);
366    CHECK_NONFATAL(opts.elision_mode != ElisionMode::WithSummary || opts.elision_summary.has_value());
367
368    const std::string fee_doc{opts.fee_doc.value_or(
369        "transaction fee in " + CURRENCY_UNIT + ", omitted if block undo data is not available")};
370    const std::string prevout_doc{opts.prevout_doc.value_or(
371        "The previous output, omitted if block undo data is not available")};
372    const std::string vin_item_doc{opts.vin_item_doc.value_or("utxo being spent")};
373
374    auto vin_inner = std::vector<RPCResult>{
375        {RPCResult::Type::STR_HEX, "coinbase", /*optional=*/true, "The coinbase value (only if coinbase transaction)"},
376        {RPCResult::Type::STR_HEX, "txid", /*optional=*/true, "The transaction id (if not coinbase transaction)"},
377        {RPCResult::Type::NUM, "vout", /*optional=*/true, "The output number (if not coinbase transaction)"},
378        {RPCResult::Type::OBJ, "scriptSig", /*optional=*/true, "The script (if not coinbase transaction)",
379        {
380            {RPCResult::Type::STR, "asm", "Disassembly of the signature script"},
381            {RPCResult::Type::STR_HEX, "hex", "The raw signature script bytes, hex-encoded"},
382        }},
383        {RPCResult::Type::ARR, "txinwitness", /*optional=*/true, "",
384        {
385            {RPCResult::Type::STR_HEX, "hex", "hex-encoded witness data (if any)"},
386        }},
387    };
388    if (opts.prevout) {
389        vin_inner.emplace_back(
390            RPCResult::Type::OBJ, "prevout", opts.prevout_optional, prevout_doc,
391            std::vector<RPCResult>{
392                {RPCResult::Type::BOOL, "generated", "Coinbase or not"},
393                {RPCResult::Type::NUM, "height", "The height of the prevout"},
394                {RPCResult::Type::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT},
395                {RPCResult::Type::OBJ, "scriptPubKey", "", ScriptPubKeyDoc()},
396            }
397        );
398    }
399    vin_inner.emplace_back(RPCResult::Type::NUM, "sequence", "The script sequence number");
400
401    if (opts.vin_inner_elision) {
402        vin_inner = ElideGroup(std::move(vin_inner), *opts.vin_inner_elision);
403        if (opts.prevout) {
404            // prevout remains visible even when other fields are elided
405            std::vector<RPCResult> new_vin;
406            new_vin.reserve(vin_inner.size());
407            for (const auto& r : vin_inner) {
408                if (r.m_key_name == "prevout") {
409                    RPCResultOptions unopts = r.m_opts;
410                    unopts.print_elision = HelpElisionNone{};
411                    new_vin.emplace_back(r, std::move(unopts));
412                } else {
413                    new_vin.push_back(r);
414                }
415            }
416            vin_inner = std::move(new_vin);
417        }
418    }
419
420    auto fields = std::vector<RPCResult>{
421        {RPCResult::Type::STR_HEX, "txid", opts.txid_field_doc},
422        {RPCResult::Type::STR_HEX, "hash", "The transaction hash (differs from txid for witness transactions)"},
423        {RPCResult::Type::NUM, "size", "The serialized transaction size"},
424        {RPCResult::Type::NUM, "vsize", "The virtual transaction size (differs from size for witness transactions)"},
425        {RPCResult::Type::NUM, "weight", "The transaction's weight (between vsize*4-3 and vsize*4)"},
426        {RPCResult::Type::NUM, "version", "The version"},
427        {RPCResult::Type::NUM_TIME, "locktime", "The lock time"},
428        {RPCResult::Type::ARR, "vin", "",
429        {
430            {RPCResult::Type::OBJ, "", opts.vin_inner_elision ? vin_item_doc : "", std::move(vin_inner)},
431        }},
432        {RPCResult::Type::ARR, "vout", "",
433        {
434            {RPCResult::Type::OBJ, "", "", Cat(
435                {
436                    {RPCResult::Type::STR_AMOUNT, "value", "The value in " + CURRENCY_UNIT},
437                    {RPCResult::Type::NUM, "n", "index"},
438                    {RPCResult::Type::OBJ, "scriptPubKey", "", ScriptPubKeyDoc()},
439                },
440                opts.wallet ?
441                    std::vector<RPCResult>{{RPCResult::Type::BOOL, "ischange", /*optional=*/true, "Output script is change (only present if true)"}} :
442                    std::vector<RPCResult>{}
443            )},
444        }},
445    };
446
447    if (opts.fee) fields.emplace_back(RPCResult::Type::NUM, "fee", /*optional=*/true, fee_doc);
448    if (opts.hex) fields.emplace_back(RPCResult::Type::STR_HEX, "hex", "The hex-encoded transaction data");
449
450    if (opts.elision_mode != ElisionMode::None) {
451        const bool silent = opts.elision_mode == ElisionMode::Silent;
452        std::vector<RPCResult> new_fields;
453        new_fields.reserve(fields.size());
454        bool first = true;
455        for (const auto& f : fields) {
456            if (!silent && f.m_key_name == "fee") {
457                new_fields.push_back(f);
458                continue;
459            }
460            if (f.m_key_name == "vin" && opts.vin_inner_elision) {
461                new_fields.push_back(f);
462                continue;
463            }
464            if (!silent && first) {
465                RPCResultOptions eopts = f.m_opts;
466                eopts.print_elision = opts.elision_summary.value_or("");
467                new_fields.emplace_back(f, std::move(eopts));
468                first = false;
469            } else {
470                RPCResultOptions eopts = f.m_opts;
471                eopts.print_elision = HelpElisionSkip{};
472                new_fields.emplace_back(f, std::move(eopts));
473            }
474        }
475        fields = std::move(new_fields);
476    }
477
478    return fields;
479}
480