diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index 677c226200..a004d0be28 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -1,886 +1,881 @@
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#if defined(HAVE_CONFIG_H)
#include <config/bitcoin-config.h>
#endif
#include <chainparams.h>
#include <clientversion.h>
#include <coins.h>
#include <consensus/consensus.h>
#include <core_io.h>
#include <key_io.h>
#include <keystore.h>
#include <policy/policy.h>
#include <primitives/transaction.h>
#include <script/script.h>
#include <script/sign.h>
#include <util/moneystr.h>
#include <util/strencodings.h>
#include <util/system.h>
#include <boost/algorithm/string.hpp>
#include <univalue.h>
#include <cstdio>
static bool fCreateBlank;
static std::map<std::string, UniValue> registers;
static const int CONTINUE_EXECUTION = -1;
const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;
static void SetupBitcoinTxArgs() {
gArgs.AddArg("-?", _("This help message"), false, OptionsCategory::OPTIONS);
gArgs.AddArg("-create", _("Create new, empty TX."), false,
OptionsCategory::OPTIONS);
gArgs.AddArg("-json", _("Select JSON output"), false,
OptionsCategory::OPTIONS);
gArgs.AddArg("-txid",
_("Output only the hex-encoded transaction id of the "
"resultant transaction."),
false, OptionsCategory::OPTIONS);
SetupChainParamsBaseOptions();
gArgs.AddArg("delin=N", _("Delete input N from TX"), false,
OptionsCategory::COMMANDS);
gArgs.AddArg("delout=N", _("Delete output N from TX"), false,
OptionsCategory::COMMANDS);
gArgs.AddArg("in=TXID:VOUT(:SEQUENCE_NUMBER)", _("Add input to TX"), false,
OptionsCategory::COMMANDS);
gArgs.AddArg("locktime=N", _("Set TX lock time to N"), false,
OptionsCategory::COMMANDS);
gArgs.AddArg("nversion=N", _("Set TX version to N"), false,
OptionsCategory::COMMANDS);
gArgs.AddArg("outaddr=VALUE:ADDRESS", _("Add address-based output to TX"),
false, OptionsCategory::COMMANDS);
gArgs.AddArg("outpubkey=VALUE:PUBKEY[:FLAGS]",
_("Add pay-to-pubkey output to TX") + ". " +
_("Optionally add the \"S\" flag to wrap the output in a "
"pay-to-script-hash."),
false, OptionsCategory::COMMANDS);
gArgs.AddArg("outdata=[VALUE:]DATA", _("Add data-based output to TX"),
false, OptionsCategory::COMMANDS);
gArgs.AddArg("outscript=VALUE:SCRIPT[:FLAGS]",
_("Add raw script output to TX") + ". " +
_("Optionally add the \"S\" flag to wrap the output in a "
"pay-to-script-hash."),
false, OptionsCategory::COMMANDS);
gArgs.AddArg(
"outmultisig=VALUE:REQUIRED:PUBKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]",
_("Add Pay To n-of-m Multi-sig output to TX. n = REQUIRED, m = "
"PUBKEYS") +
". " +
_("Optionally add the \"S\" flag to wrap the output in a "
"pay-to-script-hash."),
false, OptionsCategory::COMMANDS);
gArgs.AddArg("sign=SIGHASH-FLAGS",
_("Add zero or more signatures to transaction") + ". " +
_("This command requires JSON registers:") +
_("prevtxs=JSON object") + ", " +
_("privatekeys=JSON object") + ". " +
_("See signrawtransactionwithkey docs for format of "
"sighash flags, JSON objects."),
false, OptionsCategory::COMMANDS);
gArgs.AddArg("load=NAME:FILENAME",
_("Load JSON file FILENAME into register NAME"), false,
OptionsCategory::REGISTER_COMMANDS);
gArgs.AddArg("set=NAME:JSON-STRING",
_("Set register NAME to given JSON-STRING"), false,
OptionsCategory::REGISTER_COMMANDS);
// Hidden
gArgs.AddArg("-h", "", false, OptionsCategory::HIDDEN);
gArgs.AddArg("-help", "", false, OptionsCategory::HIDDEN);
}
//
// This function returns either one of EXIT_ codes when it's expected to stop
// the process or CONTINUE_EXECUTION when it's expected to continue further.
//
static int AppInitRawTx(int argc, char *argv[]) {
//
// Parameters
//
SetupBitcoinTxArgs();
std::string error;
if (!gArgs.ParseParameters(argc, argv, error)) {
fprintf(stderr, "Error parsing command line arguments: %s\n",
error.c_str());
return EXIT_FAILURE;
}
// Check for -testnet or -regtest parameter (Params() calls are only valid
// after this clause)
try {
SelectParams(gArgs.GetChainName());
} catch (const std::exception &e) {
fprintf(stderr, "Error: %s\n", e.what());
return EXIT_FAILURE;
}
fCreateBlank = gArgs.GetBoolArg("-create", false);
if (argc < 2 || HelpRequested(gArgs)) {
// First part of help message is specific to this utility
std::string strUsage =
PACKAGE_NAME " bitcoin-tx utility version " + FormatFullVersion() +
"\n\n" +
"Usage: bitcoin-tx [options] <hex-tx> [commands] Update "
"hex-encoded bitcoin transaction\n" +
"or: bitcoin-tx [options] -create [commands] Create "
"hex-encoded bitcoin transaction\n" +
"\n";
strUsage += gArgs.GetHelpMessage();
fprintf(stdout, "%s", strUsage.c_str());
if (argc < 2) {
fprintf(stderr, "Error: too few parameters\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
return CONTINUE_EXECUTION;
}
static void RegisterSetJson(const std::string &key,
const std::string &rawJson) {
UniValue val;
if (!val.read(rawJson)) {
std::string strErr = "Cannot parse JSON for key " + key;
throw std::runtime_error(strErr);
}
registers[key] = val;
}
static void RegisterSet(const std::string &strInput) {
// separate NAME:VALUE in string
size_t pos = strInput.find(':');
if ((pos == std::string::npos) || (pos == 0) ||
(pos == (strInput.size() - 1))) {
throw std::runtime_error("Register input requires NAME:VALUE");
}
std::string key = strInput.substr(0, pos);
std::string valStr = strInput.substr(pos + 1, std::string::npos);
RegisterSetJson(key, valStr);
}
static void RegisterLoad(const std::string &strInput) {
// separate NAME:FILENAME in string
size_t pos = strInput.find(':');
if ((pos == std::string::npos) || (pos == 0) ||
(pos == (strInput.size() - 1))) {
throw std::runtime_error("Register load requires NAME:FILENAME");
}
std::string key = strInput.substr(0, pos);
std::string filename = strInput.substr(pos + 1, std::string::npos);
FILE *f = fopen(filename.c_str(), "r");
if (!f) {
std::string strErr = "Cannot open file " + filename;
throw std::runtime_error(strErr);
}
// load file chunks into one big buffer
std::string valStr;
while ((!feof(f)) && (!ferror(f))) {
char buf[4096];
int bread = fread(buf, 1, sizeof(buf), f);
if (bread <= 0) {
break;
}
valStr.insert(valStr.size(), buf, bread);
}
int error = ferror(f);
fclose(f);
if (error) {
std::string strErr = "Error reading file " + filename;
throw std::runtime_error(strErr);
}
// evaluate as JSON buffer register
RegisterSetJson(key, valStr);
}
static Amount ExtractAndValidateValue(const std::string &strValue) {
Amount value;
if (!ParseMoney(strValue, value)) {
throw std::runtime_error("invalid TX output value");
}
return value;
}
static void MutateTxVersion(CMutableTransaction &tx,
const std::string &cmdVal) {
int64_t newVersion = atoi64(cmdVal);
if (newVersion < 1 || newVersion > CTransaction::MAX_STANDARD_VERSION) {
throw std::runtime_error("Invalid TX version requested");
}
tx.nVersion = int(newVersion);
}
static void MutateTxLocktime(CMutableTransaction &tx,
const std::string &cmdVal) {
int64_t newLocktime = atoi64(cmdVal);
if (newLocktime < 0LL || newLocktime > 0xffffffffLL) {
throw std::runtime_error("Invalid TX locktime requested");
}
tx.nLockTime = (unsigned int)newLocktime;
}
static void MutateTxAddInput(CMutableTransaction &tx,
const std::string &strInput) {
std::vector<std::string> vStrInputParts;
boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
// separate TXID:VOUT in string
if (vStrInputParts.size() < 2) {
throw std::runtime_error("TX input missing separator");
}
// extract and validate TXID
std::string strTxid = vStrInputParts[0];
if ((strTxid.size() != 64) || !IsHex(strTxid)) {
throw std::runtime_error("invalid TX input txid");
}
TxId txid(uint256S(strTxid));
static const unsigned int minTxOutSz = 9;
static const unsigned int maxVout = MAX_TX_SIZE / minTxOutSz;
// extract and validate vout
std::string strVout = vStrInputParts[1];
int vout = atoi(strVout);
if ((vout < 0) || (vout > (int)maxVout)) {
throw std::runtime_error("invalid TX input vout");
}
// extract the optional sequence number
uint32_t nSequenceIn = std::numeric_limits<unsigned int>::max();
if (vStrInputParts.size() > 2) {
nSequenceIn = std::stoul(vStrInputParts[2]);
}
// append to transaction input list
CTxIn txin(txid, vout, CScript(), nSequenceIn);
tx.vin.push_back(txin);
}
static void MutateTxAddOutAddr(CMutableTransaction &tx,
const std::string &strInput,
const CChainParams &chainParams) {
// Separate into VALUE:ADDRESS
std::vector<std::string> vStrInputParts;
boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
if (vStrInputParts.size() != 2) {
throw std::runtime_error("TX output missing or too many separators");
}
// Extract and validate VALUE
Amount value = ExtractAndValidateValue(vStrInputParts[0]);
// extract and validate ADDRESS
std::string strAddr = vStrInputParts[1];
CTxDestination destination = DecodeDestination(strAddr, chainParams);
if (!IsValidDestination(destination)) {
throw std::runtime_error("invalid TX output address");
}
CScript scriptPubKey = GetScriptForDestination(destination);
// construct TxOut, append to transaction output list
CTxOut txout(value, scriptPubKey);
tx.vout.push_back(txout);
}
static void MutateTxAddOutPubKey(CMutableTransaction &tx,
const std::string &strInput) {
// Separate into VALUE:PUBKEY[:FLAGS]
std::vector<std::string> vStrInputParts;
boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
if (vStrInputParts.size() < 2 || vStrInputParts.size() > 3) {
throw std::runtime_error("TX output missing or too many separators");
}
// Extract and validate VALUE
Amount value = ExtractAndValidateValue(vStrInputParts[0]);
// Extract and validate PUBKEY
CPubKey pubkey(ParseHex(vStrInputParts[1]));
if (!pubkey.IsFullyValid()) {
throw std::runtime_error("invalid TX output pubkey");
}
CScript scriptPubKey = GetScriptForRawPubKey(pubkey);
// Extract and validate FLAGS
bool bScriptHash = false;
if (vStrInputParts.size() == 3) {
std::string flags = vStrInputParts[2];
bScriptHash = (flags.find('S') != std::string::npos);
}
if (bScriptHash) {
// Get the ID for the script, and then construct a P2SH destination for
// it.
scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
}
// construct TxOut, append to transaction output list
CTxOut txout(value, scriptPubKey);
tx.vout.push_back(txout);
}
static void MutateTxAddOutMultiSig(CMutableTransaction &tx,
const std::string &strInput) {
// Separate into VALUE:REQUIRED:NUMKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]
std::vector<std::string> vStrInputParts;
boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
// Check that there are enough parameters
if (vStrInputParts.size() < 3) {
throw std::runtime_error("Not enough multisig parameters");
}
// Extract and validate VALUE
Amount value = ExtractAndValidateValue(vStrInputParts[0]);
// Extract REQUIRED
uint32_t required = stoul(vStrInputParts[1]);
// Extract NUMKEYS
uint32_t numkeys = stoul(vStrInputParts[2]);
// Validate there are the correct number of pubkeys
if (vStrInputParts.size() < numkeys + 3) {
throw std::runtime_error("incorrect number of multisig pubkeys");
}
if (required < 1 || required > 20 || numkeys < 1 || numkeys > 20 ||
numkeys < required) {
throw std::runtime_error("multisig parameter mismatch. Required " +
std::to_string(required) + " of " +
std::to_string(numkeys) + "signatures.");
}
// extract and validate PUBKEYs
std::vector<CPubKey> pubkeys;
for (int pos = 1; pos <= int(numkeys); pos++) {
CPubKey pubkey(ParseHex(vStrInputParts[pos + 2]));
if (!pubkey.IsFullyValid()) {
throw std::runtime_error("invalid TX output pubkey");
}
pubkeys.push_back(pubkey);
}
// Extract FLAGS
bool bScriptHash = false;
if (vStrInputParts.size() == numkeys + 4) {
std::string flags = vStrInputParts.back();
bScriptHash = (flags.find('S') != std::string::npos);
} else if (vStrInputParts.size() > numkeys + 4) {
// Validate that there were no more parameters passed
throw std::runtime_error("Too many parameters");
}
CScript scriptPubKey = GetScriptForMultisig(required, pubkeys);
if (bScriptHash) {
// Get the ID for the script, and then construct a P2SH destination for
// it.
scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
}
// construct TxOut, append to transaction output list
CTxOut txout(value, scriptPubKey);
tx.vout.push_back(txout);
}
static void MutateTxAddOutData(CMutableTransaction &tx,
const std::string &strInput) {
Amount value = Amount::zero();
// separate [VALUE:]DATA in string
size_t pos = strInput.find(':');
if (pos == 0) {
throw std::runtime_error("TX output value not specified");
}
if (pos != std::string::npos) {
// Extract and validate VALUE
value = ExtractAndValidateValue(strInput.substr(0, pos));
}
// extract and validate DATA
std::string strData = strInput.substr(pos + 1, std::string::npos);
if (!IsHex(strData)) {
throw std::runtime_error("invalid TX output data");
}
std::vector<uint8_t> data = ParseHex(strData);
CTxOut txout(value, CScript() << OP_RETURN << data);
tx.vout.push_back(txout);
}
static void MutateTxAddOutScript(CMutableTransaction &tx,
const std::string &strInput) {
// separate VALUE:SCRIPT[:FLAGS]
std::vector<std::string> vStrInputParts;
boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
if (vStrInputParts.size() < 2)
throw std::runtime_error("TX output missing separator");
// Extract and validate VALUE
Amount value = ExtractAndValidateValue(vStrInputParts[0]);
// extract and validate script
std::string strScript = vStrInputParts[1];
CScript scriptPubKey = ParseScript(strScript);
// Extract FLAGS
bool bScriptHash = false;
if (vStrInputParts.size() == 3) {
std::string flags = vStrInputParts.back();
bScriptHash = (flags.find('S') != std::string::npos);
}
if (bScriptHash) {
scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
}
// construct TxOut, append to transaction output list
CTxOut txout(value, scriptPubKey);
tx.vout.push_back(txout);
}
static void MutateTxDelInput(CMutableTransaction &tx,
const std::string &strInIdx) {
// parse requested deletion index
int inIdx = atoi(strInIdx);
if (inIdx < 0 || inIdx >= (int)tx.vin.size()) {
std::string strErr = "Invalid TX input index '" + strInIdx + "'";
throw std::runtime_error(strErr.c_str());
}
// delete input from transaction
tx.vin.erase(tx.vin.begin() + inIdx);
}
static void MutateTxDelOutput(CMutableTransaction &tx,
const std::string &strOutIdx) {
// parse requested deletion index
int outIdx = atoi(strOutIdx);
if (outIdx < 0 || outIdx >= (int)tx.vout.size()) {
std::string strErr = "Invalid TX output index '" + strOutIdx + "'";
throw std::runtime_error(strErr.c_str());
}
// delete output from transaction
tx.vout.erase(tx.vout.begin() + outIdx);
}
static const unsigned int N_SIGHASH_OPTS = 12;
static const struct {
const char *flagStr;
int flags;
} sigHashOptions[N_SIGHASH_OPTS] = {
{"ALL", SIGHASH_ALL},
{"NONE", SIGHASH_NONE},
{"SINGLE", SIGHASH_SINGLE},
{"ALL|ANYONECANPAY", SIGHASH_ALL | SIGHASH_ANYONECANPAY},
{"NONE|ANYONECANPAY", SIGHASH_NONE | SIGHASH_ANYONECANPAY},
{"SINGLE|ANYONECANPAY", SIGHASH_SINGLE | SIGHASH_ANYONECANPAY},
{"ALL|FORKID", SIGHASH_ALL | SIGHASH_FORKID},
{"NONE|FORKID", SIGHASH_NONE | SIGHASH_FORKID},
{"SINGLE|FORKID", SIGHASH_SINGLE | SIGHASH_FORKID},
{"ALL|FORKID|ANYONECANPAY",
SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
{"NONE|FORKID|ANYONECANPAY",
SIGHASH_NONE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
{"SINGLE|FORKID|ANYONECANPAY",
SIGHASH_SINGLE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
};
static bool findSigHashFlags(SigHashType &sigHashType,
const std::string &flagStr) {
sigHashType = SigHashType();
for (unsigned int i = 0; i < N_SIGHASH_OPTS; i++) {
if (flagStr == sigHashOptions[i].flagStr) {
sigHashType = SigHashType(sigHashOptions[i].flags);
return true;
}
}
return false;
}
static Amount AmountFromValue(const UniValue &value) {
if (!value.isNum() && !value.isStr()) {
throw std::runtime_error("Amount is not a number or string");
}
int64_t n;
if (!ParseFixedPoint(value.getValStr(), 8, &n)) {
throw std::runtime_error("Invalid amount");
}
Amount amount = n * SATOSHI;
if (!MoneyRange(amount)) {
throw std::runtime_error("Amount out of range");
}
return amount;
}
static void MutateTxSign(CMutableTransaction &tx, const std::string &flagStr) {
SigHashType sigHashType = SigHashType().withForkId();
if ((flagStr.size() > 0) && !findSigHashFlags(sigHashType, flagStr)) {
throw std::runtime_error("unknown sighash flag/sign option");
}
// mergedTx will end up with all the signatures; it
// starts as a clone of the raw tx:
CMutableTransaction mergedTx{tx};
const CMutableTransaction txv{tx};
CCoinsView viewDummy;
CCoinsViewCache view(&viewDummy);
if (!registers.count("privatekeys")) {
throw std::runtime_error("privatekeys register variable must be set.");
}
CBasicKeyStore tempKeystore;
UniValue keysObj = registers["privatekeys"];
for (unsigned int kidx = 0; kidx < keysObj.size(); kidx++) {
if (!keysObj[kidx].isStr()) {
throw std::runtime_error("privatekey not a std::string");
}
CKey key = DecodeSecret(keysObj[kidx].getValStr());
if (!key.IsValid()) {
throw std::runtime_error("privatekey not valid");
}
tempKeystore.AddKey(key);
}
// Add previous txouts given in the RPC call:
if (!registers.count("prevtxs")) {
throw std::runtime_error("prevtxs register variable must be set.");
}
UniValue prevtxsObj = registers["prevtxs"];
for (unsigned int previdx = 0; previdx < prevtxsObj.size(); previdx++) {
UniValue prevOut = prevtxsObj[previdx];
if (!prevOut.isObject()) {
throw std::runtime_error("expected prevtxs internal object");
}
std::map<std::string, UniValue::VType> types = {
{"txid", UniValue::VSTR},
{"vout", UniValue::VNUM},
{"scriptPubKey", UniValue::VSTR}};
if (!prevOut.checkObject(types)) {
throw std::runtime_error("prevtxs internal object typecheck fail");
}
TxId txid(ParseHashUV(prevOut["txid"], "txid"));
int nOut = atoi(prevOut["vout"].getValStr());
if (nOut < 0) {
throw std::runtime_error("vout must be positive");
}
COutPoint out(txid, nOut);
std::vector<uint8_t> pkData(
ParseHexUV(prevOut["scriptPubKey"], "scriptPubKey"));
CScript scriptPubKey(pkData.begin(), pkData.end());
{
const Coin &coin = view.AccessCoin(out);
if (!coin.IsSpent() &&
coin.GetTxOut().scriptPubKey != scriptPubKey) {
std::string err("Previous output scriptPubKey mismatch:\n");
err = err + ScriptToAsmStr(coin.GetTxOut().scriptPubKey) +
"\nvs:\n" + ScriptToAsmStr(scriptPubKey);
throw std::runtime_error(err);
}
CTxOut txout;
txout.scriptPubKey = scriptPubKey;
txout.nValue = Amount::zero();
if (prevOut.exists("amount")) {
txout.nValue = AmountFromValue(prevOut["amount"]);
}
view.AddCoin(out, Coin(txout, 1, false), true);
}
// If redeemScript given and private keys given, add redeemScript to the
// tempKeystore so it can be signed:
if (scriptPubKey.IsPayToScriptHash() &&
prevOut.exists("redeemScript")) {
UniValue v = prevOut["redeemScript"];
std::vector<uint8_t> rsData(ParseHexUV(v, "redeemScript"));
CScript redeemScript(rsData.begin(), rsData.end());
tempKeystore.AddCScript(redeemScript);
}
}
const CKeyStore &keystore = tempKeystore;
// Sign what we can:
for (size_t i = 0; i < mergedTx.vin.size(); i++) {
CTxIn &txin = mergedTx.vin[i];
const Coin &coin = view.AccessCoin(txin.prevout);
if (coin.IsSpent()) {
continue;
}
const CScript &prevPubKey = coin.GetTxOut().scriptPubKey;
const Amount amount = coin.GetTxOut().nValue;
SignatureData sigdata =
DataFromTransaction(mergedTx, i, coin.GetTxOut());
// Only sign SIGHASH_SINGLE if there's a corresponding output:
if ((sigHashType.getBaseType() != BaseSigHashType::SINGLE) ||
(i < mergedTx.vout.size())) {
ProduceSignature(keystore,
MutableTransactionSignatureCreator(
&mergedTx, i, amount, sigHashType),
prevPubKey, sigdata);
}
- // ... and merge in other signatures:
- sigdata = CombineSignatures(
- prevPubKey,
- MutableTransactionSignatureChecker(&mergedTx, i, amount), sigdata,
- DataFromTransaction(txv, i, coin.GetTxOut()));
UpdateInput(txin, sigdata);
}
tx = mergedTx;
}
class Secp256k1Init {
ECCVerifyHandle globalVerifyHandle;
public:
Secp256k1Init() { ECC_Start(); }
~Secp256k1Init() { ECC_Stop(); }
};
static void MutateTx(CMutableTransaction &tx, const std::string &command,
const std::string &commandVal,
const CChainParams &chainParams) {
std::unique_ptr<Secp256k1Init> ecc;
if (command == "nversion") {
MutateTxVersion(tx, commandVal);
} else if (command == "locktime") {
MutateTxLocktime(tx, commandVal);
} else if (command == "delin") {
MutateTxDelInput(tx, commandVal);
} else if (command == "in") {
MutateTxAddInput(tx, commandVal);
} else if (command == "delout") {
MutateTxDelOutput(tx, commandVal);
} else if (command == "outaddr") {
MutateTxAddOutAddr(tx, commandVal, chainParams);
} else if (command == "outpubkey") {
ecc.reset(new Secp256k1Init());
MutateTxAddOutPubKey(tx, commandVal);
} else if (command == "outmultisig") {
ecc.reset(new Secp256k1Init());
MutateTxAddOutMultiSig(tx, commandVal);
} else if (command == "outscript") {
MutateTxAddOutScript(tx, commandVal);
} else if (command == "outdata") {
MutateTxAddOutData(tx, commandVal);
} else if (command == "sign") {
ecc.reset(new Secp256k1Init());
MutateTxSign(tx, commandVal);
} else if (command == "load") {
RegisterLoad(commandVal);
} else if (command == "set") {
RegisterSet(commandVal);
} else {
throw std::runtime_error("unknown command");
}
}
static void OutputTxJSON(const CTransaction &tx) {
UniValue entry(UniValue::VOBJ);
TxToUniv(tx, uint256(), entry);
std::string jsonOutput = entry.write(4);
fprintf(stdout, "%s\n", jsonOutput.c_str());
}
static void OutputTxHash(const CTransaction &tx) {
// the hex-encoded transaction id.
std::string strHexHash = tx.GetId().GetHex();
fprintf(stdout, "%s\n", strHexHash.c_str());
}
static void OutputTxHex(const CTransaction &tx) {
std::string strHex = EncodeHexTx(tx);
fprintf(stdout, "%s\n", strHex.c_str());
}
static void OutputTx(const CTransaction &tx) {
if (gArgs.GetBoolArg("-json", false)) {
OutputTxJSON(tx);
} else if (gArgs.GetBoolArg("-txid", false)) {
OutputTxHash(tx);
} else {
OutputTxHex(tx);
}
}
static std::string readStdin() {
char buf[4096];
std::string ret;
while (!feof(stdin)) {
size_t bread = fread(buf, 1, sizeof(buf), stdin);
ret.append(buf, bread);
if (bread < sizeof(buf)) {
break;
}
}
if (ferror(stdin)) {
throw std::runtime_error("error reading stdin");
}
boost::algorithm::trim_right(ret);
return ret;
}
static int CommandLineRawTx(int argc, char *argv[],
const CChainParams &chainParams) {
std::string strPrint;
int nRet = 0;
try {
// Skip switches; Permit common stdin convention "-"
while (argc > 1 && IsSwitchChar(argv[1][0]) && (argv[1][1] != 0)) {
argc--;
argv++;
}
CMutableTransaction tx;
int startArg;
if (!fCreateBlank) {
// require at least one param
if (argc < 2) {
throw std::runtime_error("too few parameters");
}
// param: hex-encoded bitcoin transaction
std::string strHexTx(argv[1]);
// "-" implies standard input
if (strHexTx == "-") {
strHexTx = readStdin();
}
if (!DecodeHexTx(tx, strHexTx)) {
throw std::runtime_error("invalid transaction encoding");
}
startArg = 2;
} else {
startArg = 1;
}
for (int i = startArg; i < argc; i++) {
std::string arg = argv[i];
std::string key, value;
size_t eqpos = arg.find('=');
if (eqpos == std::string::npos) {
key = arg;
} else {
key = arg.substr(0, eqpos);
value = arg.substr(eqpos + 1);
}
MutateTx(tx, key, value, chainParams);
}
OutputTx(CTransaction(tx));
}
catch (const boost::thread_interrupted &) {
throw;
} catch (const std::exception &e) {
strPrint = std::string("error: ") + e.what();
nRet = EXIT_FAILURE;
} catch (...) {
PrintExceptionContinue(nullptr, "CommandLineRawTx()");
throw;
}
if (strPrint != "") {
fprintf((nRet == 0 ? stdout : stderr), "%s\n", strPrint.c_str());
}
return nRet;
}
int main(int argc, char *argv[]) {
SetupEnvironment();
try {
int ret = AppInitRawTx(argc, argv);
if (ret != CONTINUE_EXECUTION) return ret;
} catch (const std::exception &e) {
PrintExceptionContinue(&e, "AppInitRawTx()");
return EXIT_FAILURE;
} catch (...) {
PrintExceptionContinue(nullptr, "AppInitRawTx()");
return EXIT_FAILURE;
}
int ret = EXIT_FAILURE;
try {
ret = CommandLineRawTx(argc, argv, Params());
} catch (const std::exception &e) {
PrintExceptionContinue(&e, "CommandLineRawTx()");
} catch (...) {
PrintExceptionContinue(nullptr, "CommandLineRawTx()");
}
return ret;
}
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 8b22b33718..4d146e2ce2 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -1,1358 +1,1355 @@
// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <chain.h>
#include <coins.h>
#include <config.h>
#include <consensus/validation.h>
#include <core_io.h>
#include <index/txindex.h>
#include <init.h>
#include <key_io.h>
#include <keystore.h>
#include <merkleblock.h>
#include <net.h>
#include <policy/policy.h>
#include <primitives/transaction.h>
#include <rpc/rawtransaction.h>
#include <rpc/server.h>
#include <script/script.h>
#include <script/script_error.h>
#include <script/sign.h>
#include <script/standard.h>
#include <txmempool.h>
#include <uint256.h>
#include <util/strencodings.h>
#include <validation.h>
#include <validationinterface.h>
#ifdef ENABLE_WALLET
#include <wallet/rpcwallet.h>
#endif
#include <cstdint>
#include <future>
#include <univalue.h>
static void TxToJSON(const CTransaction &tx, const uint256 hashBlock,
UniValue &entry) {
// Call into TxToUniv() in bitcoin-common to decode the transaction hex.
//
// Blockchain contextual information (confirmations and blocktime) is not
// available to code in bitcoin-common, so we query them here and push the
// data into the returned UniValue.
TxToUniv(tx, uint256(), entry, true, RPCSerializationFlags());
if (!hashBlock.IsNull()) {
LOCK(cs_main);
entry.pushKV("blockhash", hashBlock.GetHex());
CBlockIndex *pindex = LookupBlockIndex(hashBlock);
if (pindex) {
if (chainActive.Contains(pindex)) {
entry.pushKV("confirmations",
1 + chainActive.Height() - pindex->nHeight);
entry.pushKV("time", pindex->GetBlockTime());
entry.pushKV("blocktime", pindex->GetBlockTime());
} else {
entry.pushKV("confirmations", 0);
}
}
}
}
static UniValue getrawtransaction(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() < 1 ||
request.params.size() > 3) {
throw std::runtime_error(
"getrawtransaction \"txid\" ( verbose \"blockhash\" )\n"
"\nNOTE: By default this function only works for mempool "
"transactions. If the -txindex option is\n"
"enabled, it also works for blockchain transactions. If the block "
"which contains the transaction\n"
"is known, its hash can be provided even for nodes without "
"-txindex. Note that if a blockhash is\n"
"provided, only that block will be searched and if the transaction "
"is in the mempool or other\n"
"blocks, or if this node does not have the given block available, "
"the transaction will not be found.\n"
"DEPRECATED: for now, it also works for transactions with unspent "
"outputs.\n"
"\nReturn the raw transaction data.\n"
"\nIf verbose is 'true', returns an Object with information about "
"'txid'.\n"
"If verbose is 'false' or omitted, returns a string that is "
"serialized, hex-encoded data for 'txid'.\n"
"\nArguments:\n"
"1. \"txid\" (string, required) The transaction id\n"
"2. verbose (bool, optional, default=false) If false, return a "
"string, otherwise return a json object\n"
"3. \"blockhash\" (string, optional) The block in which to look "
"for the transaction\n"
"\nResult (if verbose is not set or set to false):\n"
"\"data\" (string) The serialized, hex-encoded data for "
"'txid'\n"
"\nResult (if verbose is set to true):\n"
"{\n"
" \"in_active_chain\": b, (bool) Whether specified block is in "
"the active chain or not (only present with explicit \"blockhash\" "
"argument)\n"
" \"hex\" : \"data\", (string) The serialized, hex-encoded "
"data for 'txid'\n"
" \"txid\" : \"id\", (string) The transaction id (same as "
"provided)\n"
" \"hash\" : \"id\", (string) The transaction hash "
"(differs from txid for witness transactions)\n"
" \"size\" : n, (numeric) The serialized transaction "
"size\n"
" \"version\" : n, (numeric) The version\n"
" \"locktime\" : ttt, (numeric) The lock time\n"
" \"vin\" : [ (array of json objects)\n"
" {\n"
" \"txid\": \"id\", (string) The transaction id\n"
" \"vout\": n, (numeric) \n"
" \"scriptSig\": { (json object) The script\n"
" \"asm\": \"asm\", (string) asm\n"
" \"hex\": \"hex\" (string) hex\n"
" },\n"
" \"sequence\": n (numeric) The script sequence number\n"
" }\n"
" ,...\n"
" ],\n"
" \"vout\" : [ (array of json objects)\n"
" {\n"
" \"value\" : x.xxx, (numeric) The value in " +
CURRENCY_UNIT +
"\n"
" \"n\" : n, (numeric) index\n"
" \"scriptPubKey\" : { (json object)\n"
" \"asm\" : \"asm\", (string) the asm\n"
" \"hex\" : \"hex\", (string) the hex\n"
" \"reqSigs\" : n, (numeric) The required sigs\n"
" \"type\" : \"pubkeyhash\", (string) The type, eg "
"'pubkeyhash'\n"
" \"addresses\" : [ (json array of string)\n"
" \"address\" (string) bitcoin address\n"
" ,...\n"
" ]\n"
" }\n"
" }\n"
" ,...\n"
" ],\n"
" \"blockhash\" : \"hash\", (string) the block hash\n"
" \"confirmations\" : n, (numeric) The confirmations\n"
" \"time\" : ttt, (numeric) The transaction time in "
"seconds since epoch (Jan 1 1970 GMT)\n"
" \"blocktime\" : ttt (numeric) The block time in seconds "
"since epoch (Jan 1 1970 GMT)\n"
"}\n"
"\nExamples:\n" +
HelpExampleCli("getrawtransaction", "\"mytxid\"") +
HelpExampleCli("getrawtransaction", "\"mytxid\" true") +
HelpExampleRpc("getrawtransaction", "\"mytxid\", true") +
HelpExampleCli("getrawtransaction",
"\"mytxid\" false \"myblockhash\"") +
HelpExampleCli("getrawtransaction",
"\"mytxid\" true \"myblockhash\""));
}
bool in_active_chain = true;
TxId txid = TxId(ParseHashV(request.params[0], "parameter 1"));
CBlockIndex *blockindex = nullptr;
const CChainParams ¶ms = config.GetChainParams();
if (txid == params.GenesisBlock().hashMerkleRoot) {
// Special exception for the genesis block coinbase transaction
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
"The genesis block coinbase is not considered an "
"ordinary transaction and cannot be retrieved");
}
// Accept either a bool (true) or a num (>=1) to indicate verbose output.
bool fVerbose = false;
if (!request.params[1].isNull()) {
fVerbose = request.params[1].isNum()
? (request.params[1].get_int() != 0)
: request.params[1].get_bool();
}
if (!request.params[2].isNull()) {
LOCK(cs_main);
uint256 blockhash = ParseHashV(request.params[2], "parameter 3");
blockindex = LookupBlockIndex(blockhash);
if (!blockindex) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
"Block hash not found");
}
in_active_chain = chainActive.Contains(blockindex);
}
bool f_txindex_ready = false;
if (g_txindex && !blockindex) {
f_txindex_ready = g_txindex->BlockUntilSyncedToCurrentChain();
}
CTransactionRef tx;
uint256 hash_block;
if (!GetTransaction(params.GetConsensus(), txid, tx, hash_block, true,
blockindex)) {
std::string errmsg;
if (blockindex) {
if (!blockindex->nStatus.hasData()) {
throw JSONRPCError(RPC_MISC_ERROR, "Block not available");
}
errmsg = "No such transaction found in the provided block";
} else if (!g_txindex) {
errmsg = "No such mempool transaction. Use -txindex to enable "
"blockchain transaction queries";
} else if (!f_txindex_ready) {
errmsg = "No such mempool transaction. Blockchain transactions are "
"still in the process of being indexed";
} else {
errmsg = "No such mempool or blockchain transaction";
}
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
errmsg +
". Use gettransaction for wallet transactions.");
}
if (!fVerbose) {
return EncodeHexTx(*tx, RPCSerializationFlags());
}
UniValue result(UniValue::VOBJ);
if (blockindex) {
result.pushKV("in_active_chain", in_active_chain);
}
TxToJSON(*tx, hash_block, result);
return result;
}
static UniValue gettxoutproof(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp ||
(request.params.size() != 1 && request.params.size() != 2)) {
throw std::runtime_error(
"gettxoutproof [\"txid\",...] ( blockhash )\n"
"\nReturns a hex-encoded proof that \"txid\" was included in a "
"block.\n"
"\nNOTE: By default this function only works sometimes. This is "
"when there is an\n"
"unspent output in the utxo for this transaction. To make it "
"always work,\n"
"you need to maintain a transaction index, using the -txindex "
"command line option or\n"
"specify the block in which the transaction is included manually "
"(by blockhash).\n"
"\nArguments:\n"
"1. \"txids\" (string) A json array of txids to filter\n"
" [\n"
" \"txid\" (string) A transaction hash\n"
" ,...\n"
" ]\n"
"2. \"blockhash\" (string, optional) If specified, looks for "
"txid in the block with this hash\n"
"\nResult:\n"
"\"data\" (string) A string that is a serialized, "
"hex-encoded data for the proof.\n");
}
std::set<TxId> setTxIds;
TxId oneTxId;
UniValue txids = request.params[0].get_array();
for (unsigned int idx = 0; idx < txids.size(); idx++) {
const UniValue &utxid = txids[idx];
if (utxid.get_str().length() != 64 || !IsHex(utxid.get_str())) {
throw JSONRPCError(RPC_INVALID_PARAMETER,
std::string("Invalid txid ") + utxid.get_str());
}
TxId txid(uint256S(utxid.get_str()));
if (setTxIds.count(txid)) {
throw JSONRPCError(
RPC_INVALID_PARAMETER,
std::string("Invalid parameter, duplicated txid: ") +
utxid.get_str());
}
setTxIds.insert(txid);
oneTxId = txid;
}
CBlockIndex *pblockindex = nullptr;
uint256 hashBlock;
if (!request.params[1].isNull()) {
LOCK(cs_main);
hashBlock = uint256S(request.params[1].get_str());
pblockindex = LookupBlockIndex(hashBlock);
if (!pblockindex) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Block not found");
}
} else {
LOCK(cs_main);
// Loop through txids and try to find which block they're in. Exit loop
// once a block is found.
for (const auto &txid : setTxIds) {
const Coin &coin = AccessByTxid(*pcoinsTip, txid);
if (!coin.IsSpent()) {
pblockindex = chainActive[coin.GetHeight()];
break;
}
}
}
// Allow txindex to catch up if we need to query it and before we acquire
// cs_main.
if (g_txindex && !pblockindex) {
g_txindex->BlockUntilSyncedToCurrentChain();
}
const Consensus::Params ¶ms = config.GetChainParams().GetConsensus();
LOCK(cs_main);
if (pblockindex == nullptr) {
CTransactionRef tx;
if (!GetTransaction(params, oneTxId, tx, hashBlock, false) ||
hashBlock.IsNull()) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
"Transaction not yet in block");
}
pblockindex = LookupBlockIndex(hashBlock);
if (!pblockindex) {
throw JSONRPCError(RPC_INTERNAL_ERROR, "Transaction index corrupt");
}
}
CBlock block;
if (!ReadBlockFromDisk(block, pblockindex, params)) {
throw JSONRPCError(RPC_INTERNAL_ERROR, "Can't read block from disk");
}
unsigned int ntxFound = 0;
for (const auto &tx : block.vtx) {
if (setTxIds.count(tx->GetId())) {
ntxFound++;
}
}
if (ntxFound != setTxIds.size()) {
throw JSONRPCError(
RPC_INVALID_ADDRESS_OR_KEY,
"Not all transactions found in specified or retrieved block");
}
CDataStream ssMB(SER_NETWORK, PROTOCOL_VERSION);
CMerkleBlock mb(block, setTxIds);
ssMB << mb;
std::string strHex = HexStr(ssMB.begin(), ssMB.end());
return strHex;
}
static UniValue verifytxoutproof(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() != 1) {
throw std::runtime_error(
"verifytxoutproof \"proof\"\n"
"\nVerifies that a proof points to a transaction in a block, "
"returning the transaction it commits to\n"
"and throwing an RPC error if the block is not in our best chain\n"
"\nArguments:\n"
"1. \"proof\" (string, required) The hex-encoded proof "
"generated by gettxoutproof\n"
"\nResult:\n"
"[\"txid\"] (array, strings) The txid(s) which the proof "
"commits to, or empty array if the proof can not be validated.\n");
}
CDataStream ssMB(ParseHexV(request.params[0], "proof"), SER_NETWORK,
PROTOCOL_VERSION);
CMerkleBlock merkleBlock;
ssMB >> merkleBlock;
UniValue res(UniValue::VARR);
std::vector<uint256> vMatch;
std::vector<size_t> vIndex;
if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) !=
merkleBlock.header.hashMerkleRoot) {
return res;
}
LOCK(cs_main);
const CBlockIndex *pindex = LookupBlockIndex(merkleBlock.header.GetHash());
if (!pindex || !chainActive.Contains(pindex) || pindex->nTx == 0) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
"Block not found in chain");
}
// Check if proof is valid, only add results if so
if (pindex->nTx == merkleBlock.txn.GetNumTransactions()) {
for (const uint256 &hash : vMatch) {
res.push_back(hash.GetHex());
}
}
return res;
}
static UniValue createrawtransaction(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() < 2 ||
request.params.size() > 3) {
throw std::runtime_error(
// clang-format off
"createrawtransaction [{\"txid\":\"id\",\"vout\":n},...] [{\"address\":amount},{\"data\":\"hex\"},...] ( locktime )\n"
"\nCreate a transaction spending the given inputs and creating new outputs.\n"
"Outputs can be addresses or data.\n"
"Returns hex-encoded raw transaction.\n"
"Note that the transaction's inputs are not signed, and\n"
"it is not stored in the wallet or transmitted to the network.\n"
"\nArguments:\n"
"1. \"inputs\" (array, required) A json array of "
"json objects\n"
" [\n"
" {\n"
" \"txid\":\"id\", (string, required) The transaction id\n"
" \"vout\":n, (numeric, required) The output number\n"
" \"sequence\":n (numeric, optional) The sequence number\n"
" } \n"
" ,...\n"
" ]\n"
"2. \"outputs\" (array, required) a json array with outputs (key-value pairs)\n"
" [\n"
" {\n"
" \"address\": x.xxx, (obj, optional) A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT + "\n"
" },\n"
" {\n"
" \"data\": \"hex\" (obj, optional) A key-value pair. The key must be \"data\", the value is hex encoded data\n"
" }\n"
" ,... More key-value pairs of the above form. For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n"
" accepted as second parameter.\n"
" ]\n"
"3. locktime (numeric, optional, default=0) Raw locktime. Non-0 value also locktime-activates inputs\n"
"\nResult:\n"
"\"transaction\" (string) hex string of the transaction\n"
"\nExamples:\n"
+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"address\\\":0.01}]\"")
+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")
+ HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"address\\\":0.01}]\"")
+ HelpExampleRpc("createrawtransaction", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\", \"[{\\\"data\\\":\\\"00010203\\\"}]\"")
// clang-format on
);
}
RPCTypeCheck(request.params,
{UniValue::VARR,
UniValueType(), // ARR or OBJ, checked later
UniValue::VNUM, UniValue::VBOOL},
true);
if (request.params[0].isNull() || request.params[1].isNull()) {
throw JSONRPCError(
RPC_INVALID_PARAMETER,
"Invalid parameter, arguments 1 and 2 must be non-null");
}
UniValue inputs = request.params[0].get_array();
const bool outputs_is_obj = request.params[1].isObject();
UniValue outputs = outputs_is_obj ? request.params[1].get_obj()
: request.params[1].get_array();
CMutableTransaction rawTx;
if (request.params.size() > 2 && !request.params[2].isNull()) {
int64_t nLockTime = request.params[2].get_int64();
if (nLockTime < 0 || nLockTime > std::numeric_limits<uint32_t>::max()) {
throw JSONRPCError(RPC_INVALID_PARAMETER,
"Invalid parameter, locktime out of range");
}
rawTx.nLockTime = nLockTime;
}
for (size_t idx = 0; idx < inputs.size(); idx++) {
const UniValue &input = inputs[idx];
const UniValue &o = input.get_obj();
TxId txid(ParseHashO(o, "txid"));
const UniValue &vout_v = find_value(o, "vout");
if (vout_v.isNull()) {
throw JSONRPCError(RPC_INVALID_PARAMETER,
"Invalid parameter, missing vout key");
}
if (!vout_v.isNum()) {
throw JSONRPCError(RPC_INVALID_PARAMETER,
"Invalid parameter, vout must be a number");
}
int nOutput = vout_v.get_int();
if (nOutput < 0) {
throw JSONRPCError(RPC_INVALID_PARAMETER,
"Invalid parameter, vout must be positive");
}
uint32_t nSequence =
(rawTx.nLockTime ? std::numeric_limits<uint32_t>::max() - 1
: std::numeric_limits<uint32_t>::max());
// Set the sequence number if passed in the parameters object.
const UniValue &sequenceObj = find_value(o, "sequence");
if (sequenceObj.isNum()) {
int64_t seqNr64 = sequenceObj.get_int64();
if (seqNr64 < 0 || seqNr64 > std::numeric_limits<uint32_t>::max()) {
throw JSONRPCError(
RPC_INVALID_PARAMETER,
"Invalid parameter, sequence number is out of range");
}
nSequence = uint32_t(seqNr64);
}
CTxIn in(COutPoint(txid, nOutput), CScript(), nSequence);
rawTx.vin.push_back(in);
}
std::set<CTxDestination> destinations;
if (!outputs_is_obj) {
// Translate array of key-value pairs into dict
UniValue outputs_dict = UniValue(UniValue::VOBJ);
for (size_t i = 0; i < outputs.size(); ++i) {
const UniValue &output = outputs[i];
if (!output.isObject()) {
throw JSONRPCError(RPC_INVALID_PARAMETER,
"Invalid parameter, key-value pair not an "
"object as expected");
}
if (output.size() != 1) {
throw JSONRPCError(RPC_INVALID_PARAMETER,
"Invalid parameter, key-value pair must "
"contain exactly one key");
}
outputs_dict.pushKVs(output);
}
outputs = std::move(outputs_dict);
}
for (const std::string &name_ : outputs.getKeys()) {
if (name_ == "data") {
std::vector<uint8_t> data =
ParseHexV(outputs[name_].getValStr(), "Data");
CTxOut out(Amount::zero(), CScript() << OP_RETURN << data);
rawTx.vout.push_back(out);
} else {
CTxDestination destination =
DecodeDestination(name_, config.GetChainParams());
if (!IsValidDestination(destination)) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
std::string("Invalid Bitcoin address: ") +
name_);
}
if (!destinations.insert(destination).second) {
throw JSONRPCError(
RPC_INVALID_PARAMETER,
std::string("Invalid parameter, duplicated address: ") +
name_);
}
CScript scriptPubKey = GetScriptForDestination(destination);
Amount nAmount = AmountFromValue(outputs[name_]);
CTxOut out(nAmount, scriptPubKey);
rawTx.vout.push_back(out);
}
}
return EncodeHexTx(CTransaction(rawTx));
}
static UniValue decoderawtransaction(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() != 1) {
throw std::runtime_error(
"decoderawtransaction \"hexstring\"\n"
"\nReturn a JSON object representing the serialized, hex-encoded "
"transaction.\n"
"\nArguments:\n"
"1. \"hexstring\" (string, required) The transaction hex "
"string\n"
"\nResult:\n"
"{\n"
" \"txid\" : \"id\", (string) The transaction id\n"
" \"hash\" : \"id\", (string) The transaction hash "
"(differs from txid for witness transactions)\n"
" \"size\" : n, (numeric) The transaction size\n"
" \"version\" : n, (numeric) The version\n"
" \"locktime\" : ttt, (numeric) The lock time\n"
" \"vin\" : [ (array of json objects)\n"
" {\n"
" \"txid\": \"id\", (string) The transaction id\n"
" \"vout\": n, (numeric) The output number\n"
" \"scriptSig\": { (json object) The script\n"
" \"asm\": \"asm\", (string) asm\n"
" \"hex\": \"hex\" (string) hex\n"
" },\n"
" \"sequence\": n (numeric) The script sequence number\n"
" }\n"
" ,...\n"
" ],\n"
" \"vout\" : [ (array of json objects)\n"
" {\n"
" \"value\" : x.xxx, (numeric) The value in " +
CURRENCY_UNIT +
"\n"
" \"n\" : n, (numeric) index\n"
" \"scriptPubKey\" : { (json object)\n"
" \"asm\" : \"asm\", (string) the asm\n"
" \"hex\" : \"hex\", (string) the hex\n"
" \"reqSigs\" : n, (numeric) The required sigs\n"
" \"type\" : \"pubkeyhash\", (string) The type, eg "
"'pubkeyhash'\n"
" \"addresses\" : [ (json array of string)\n"
" \"12tvKAXCxZjSmdNbao16dKXC8tRWfcF5oc\" (string) "
"bitcoin address\n"
" ,...\n"
" ]\n"
" }\n"
" }\n"
" ,...\n"
" ],\n"
"}\n"
"\nExamples:\n" +
HelpExampleCli("decoderawtransaction", "\"hexstring\"") +
HelpExampleRpc("decoderawtransaction", "\"hexstring\""));
}
LOCK(cs_main);
RPCTypeCheck(request.params, {UniValue::VSTR});
CMutableTransaction mtx;
if (!DecodeHexTx(mtx, request.params[0].get_str())) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
}
UniValue result(UniValue::VOBJ);
TxToUniv(CTransaction(std::move(mtx)), uint256(), result, false);
return result;
}
static UniValue decodescript(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() != 1) {
throw std::runtime_error(
"decodescript \"hexstring\"\n"
"\nDecode a hex-encoded script.\n"
"\nArguments:\n"
"1. \"hexstring\" (string) the hex encoded script\n"
"\nResult:\n"
"{\n"
" \"asm\":\"asm\", (string) Script public key\n"
" \"hex\":\"hex\", (string) hex encoded public key\n"
" \"type\":\"type\", (string) The output type\n"
" \"reqSigs\": n, (numeric) The required signatures\n"
" \"addresses\": [ (json array of string)\n"
" \"address\" (string) bitcoin address\n"
" ,...\n"
" ],\n"
" \"p2sh\",\"address\" (string) address of P2SH script wrapping "
"this redeem script (not returned if the script is already a "
"P2SH).\n"
"}\n"
"\nExamples:\n" +
HelpExampleCli("decodescript", "\"hexstring\"") +
HelpExampleRpc("decodescript", "\"hexstring\""));
}
RPCTypeCheck(request.params, {UniValue::VSTR});
UniValue r(UniValue::VOBJ);
CScript script;
if (request.params[0].get_str().size() > 0) {
std::vector<uint8_t> scriptData(
ParseHexV(request.params[0], "argument"));
script = CScript(scriptData.begin(), scriptData.end());
} else {
// Empty scripts are valid.
}
ScriptPubKeyToUniv(script, r, false);
UniValue type;
type = find_value(r, "type");
if (type.isStr() && type.get_str() != "scripthash") {
// P2SH cannot be wrapped in a P2SH. If this script is already a P2SH,
// don't return the address for a P2SH of the P2SH.
r.pushKV("p2sh", EncodeDestination(CScriptID(script), config));
}
return r;
}
/**
* Pushes a JSON object for script verification or signing errors to vErrorsRet.
*/
static void TxInErrorToJSON(const CTxIn &txin, UniValue &vErrorsRet,
const std::string &strMessage) {
UniValue entry(UniValue::VOBJ);
entry.pushKV("txid", txin.prevout.GetTxId().ToString());
entry.pushKV("vout", uint64_t(txin.prevout.GetN()));
entry.pushKV("scriptSig",
HexStr(txin.scriptSig.begin(), txin.scriptSig.end()));
entry.pushKV("sequence", uint64_t(txin.nSequence));
entry.pushKV("error", strMessage);
vErrorsRet.push_back(entry);
}
static UniValue combinerawtransaction(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() != 1) {
throw std::runtime_error(
"combinerawtransaction [\"hexstring\",...]\n"
"\nCombine multiple partially signed transactions into one "
"transaction.\n"
"The combined transaction may be another partially signed "
"transaction or a \n"
"fully signed transaction."
"\nArguments:\n"
"1. \"txs\" (string) A json array of hex strings of "
"partially signed transactions\n"
" [\n"
" \"hexstring\" (string) A transaction hash\n"
" ,...\n"
" ]\n"
"\nResult:\n"
"\"hex\" (string) The hex-encoded raw transaction with "
"signature(s)\n"
"\nExamples:\n" +
HelpExampleCli("combinerawtransaction",
"[\"myhex1\", \"myhex2\", \"myhex3\"]"));
}
UniValue txs = request.params[0].get_array();
std::vector<CMutableTransaction> txVariants(txs.size());
for (unsigned int idx = 0; idx < txs.size(); idx++) {
if (!DecodeHexTx(txVariants[idx], txs[idx].get_str())) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
strprintf("TX decode failed for tx %d", idx));
}
}
if (txVariants.empty()) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transactions");
}
// mergedTx will end up with all the signatures; it
// starts as a clone of the rawtx:
CMutableTransaction mergedTx(txVariants[0]);
// Fetch previous transactions (inputs):
CCoinsView viewDummy;
CCoinsViewCache view(&viewDummy);
{
LOCK(cs_main);
LOCK(g_mempool.cs);
CCoinsViewCache &viewChain = *pcoinsTip;
CCoinsViewMemPool viewMempool(&viewChain, g_mempool);
// temporarily switch cache backend to db+mempool view
view.SetBackend(viewMempool);
for (const CTxIn &txin : mergedTx.vin) {
// Load entries from viewChain into view; can fail.
view.AccessCoin(txin.prevout);
}
// switch back to avoid locking mempool for too long
view.SetBackend(viewDummy);
}
// Use CTransaction for the constant parts of the
// transaction to avoid rehashing.
const CTransaction txConst(mergedTx);
// Sign what we can:
for (size_t i = 0; i < mergedTx.vin.size(); i++) {
CTxIn &txin = mergedTx.vin[i];
const Coin &coin = view.AccessCoin(txin.prevout);
if (coin.IsSpent()) {
throw JSONRPCError(RPC_VERIFY_ERROR,
"Input not found or already spent");
}
- const CScript &prevPubKey = coin.GetTxOut().scriptPubKey;
- const Amount &amount = coin.GetTxOut().nValue;
-
SignatureData sigdata;
+ const CTxOut &txout = coin.GetTxOut();
+
// ... and merge in other signatures:
for (const CMutableTransaction &txv : txVariants) {
if (txv.vin.size() > i) {
- sigdata = CombineSignatures(
- prevPubKey,
- TransactionSignatureChecker(&txConst, i, amount), sigdata,
- DataFromTransaction(txv, i, coin.GetTxOut()));
+ sigdata.MergeSignatureData(DataFromTransaction(txv, i, txout));
}
}
+ ProduceSignature(
+ DUMMY_SIGNING_PROVIDER,
+ MutableTransactionSignatureCreator(&mergedTx, i, txout.nValue),
+ txout.scriptPubKey, sigdata);
UpdateInput(txin, sigdata);
}
return EncodeHexTx(CTransaction(mergedTx));
}
UniValue SignTransaction(CMutableTransaction &mtx,
const UniValue &prevTxsUnival,
CBasicKeyStore *keystore, bool is_temp_keystore,
const UniValue &hashType) {
// Fetch previous transactions (inputs):
CCoinsView viewDummy;
CCoinsViewCache view(&viewDummy);
{
LOCK2(cs_main, g_mempool.cs);
CCoinsViewCache &viewChain = *pcoinsTip;
CCoinsViewMemPool viewMempool(&viewChain, g_mempool);
// Temporarily switch cache backend to db+mempool view.
view.SetBackend(viewMempool);
for (const CTxIn &txin : mtx.vin) {
// Load entries from viewChain into view; can fail.
view.AccessCoin(txin.prevout);
}
// Switch back to avoid locking mempool for too long.
view.SetBackend(viewDummy);
}
// Add previous txouts given in the RPC call:
if (!prevTxsUnival.isNull()) {
UniValue prevTxs = prevTxsUnival.get_array();
for (size_t idx = 0; idx < prevTxs.size(); ++idx) {
const UniValue &p = prevTxs[idx];
if (!p.isObject()) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
"expected object with "
"{\"txid'\",\"vout\",\"scriptPubKey\"}");
}
UniValue prevOut = p.get_obj();
RPCTypeCheckObj(prevOut,
{
{"txid", UniValueType(UniValue::VSTR)},
{"vout", UniValueType(UniValue::VNUM)},
{"scriptPubKey", UniValueType(UniValue::VSTR)},
// "amount" is also required but check is done
// below due to UniValue::VNUM erroneously
// not accepting quoted numerics
// (which are valid JSON)
});
TxId txid(ParseHashO(prevOut, "txid"));
int nOut = find_value(prevOut, "vout").get_int();
if (nOut < 0) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
"vout must be positive");
}
COutPoint out(txid, nOut);
std::vector<uint8_t> pkData(ParseHexO(prevOut, "scriptPubKey"));
CScript scriptPubKey(pkData.begin(), pkData.end());
{
const Coin &coin = view.AccessCoin(out);
if (!coin.IsSpent() &&
coin.GetTxOut().scriptPubKey != scriptPubKey) {
std::string err("Previous output scriptPubKey mismatch:\n");
err = err + ScriptToAsmStr(coin.GetTxOut().scriptPubKey) +
"\nvs:\n" + ScriptToAsmStr(scriptPubKey);
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, err);
}
CTxOut txout;
txout.scriptPubKey = scriptPubKey;
txout.nValue = Amount::zero();
if (prevOut.exists("amount")) {
txout.nValue =
AmountFromValue(find_value(prevOut, "amount"));
} else {
// amount param is required in replay-protected txs.
// Note that we must check for its presence here rather
// than use RPCTypeCheckObj() above, since UniValue::VNUM
// parser incorrectly parses numerics with quotes, eg
// "3.12" as a string when JSON allows it to also parse
// as numeric. And we have to accept numerics with quotes
// because our own dogfood (our rpc results) always
// produces decimal numbers that are quoted
// eg getbalance returns "3.14152" rather than 3.14152
throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing amount");
}
view.AddCoin(out, Coin(txout, 1, false), true);
}
// If redeemScript given and not using the local wallet (private
// keys given), add redeemScript to the keystore so it can be
// signed:
if (is_temp_keystore && scriptPubKey.IsPayToScriptHash()) {
RPCTypeCheckObj(
prevOut, {
{"redeemScript", UniValueType(UniValue::VSTR)},
});
UniValue v = find_value(prevOut, "redeemScript");
if (!v.isNull()) {
std::vector<uint8_t> rsData(ParseHexV(v, "redeemScript"));
CScript redeemScript(rsData.begin(), rsData.end());
keystore->AddCScript(redeemScript);
}
}
}
}
SigHashType sigHashType = SigHashType().withForkId();
if (!hashType.isNull()) {
static std::map<std::string, int> mapSigHashValues = {
{"ALL", SIGHASH_ALL},
{"ALL|ANYONECANPAY", SIGHASH_ALL | SIGHASH_ANYONECANPAY},
{"ALL|FORKID", SIGHASH_ALL | SIGHASH_FORKID},
{"ALL|FORKID|ANYONECANPAY",
SIGHASH_ALL | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
{"NONE", SIGHASH_NONE},
{"NONE|ANYONECANPAY", SIGHASH_NONE | SIGHASH_ANYONECANPAY},
{"NONE|FORKID", SIGHASH_NONE | SIGHASH_FORKID},
{"NONE|FORKID|ANYONECANPAY",
SIGHASH_NONE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
{"SINGLE", SIGHASH_SINGLE},
{"SINGLE|ANYONECANPAY", SIGHASH_SINGLE | SIGHASH_ANYONECANPAY},
{"SINGLE|FORKID", SIGHASH_SINGLE | SIGHASH_FORKID},
{"SINGLE|FORKID|ANYONECANPAY",
SIGHASH_SINGLE | SIGHASH_FORKID | SIGHASH_ANYONECANPAY},
};
std::string strHashType = hashType.get_str();
if (!mapSigHashValues.count(strHashType)) {
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid sighash param");
}
sigHashType = SigHashType(mapSigHashValues[strHashType]);
if (!sigHashType.hasForkId()) {
throw JSONRPCError(RPC_INVALID_PARAMETER,
"Signature must use SIGHASH_FORKID");
}
}
// Script verification errors.
UniValue vErrors(UniValue::VARR);
// Use CTransaction for the constant parts of the transaction to avoid
// rehashing.
const CTransaction txConst(mtx);
// Sign what we can:
for (size_t i = 0; i < mtx.vin.size(); i++) {
CTxIn &txin = mtx.vin[i];
const Coin &coin = view.AccessCoin(txin.prevout);
if (coin.IsSpent()) {
TxInErrorToJSON(txin, vErrors, "Input not found or already spent");
continue;
}
const CScript &prevPubKey = coin.GetTxOut().scriptPubKey;
const Amount amount = coin.GetTxOut().nValue;
SignatureData sigdata = DataFromTransaction(mtx, i, coin.GetTxOut());
// Only sign SIGHASH_SINGLE if there's a corresponding output:
if ((sigHashType.getBaseType() != BaseSigHashType::SINGLE) ||
(i < mtx.vout.size())) {
ProduceSignature(*keystore,
MutableTransactionSignatureCreator(&mtx, i, amount,
sigHashType),
prevPubKey, sigdata);
}
- sigdata = CombineSignatures(
- prevPubKey, TransactionSignatureChecker(&txConst, i, amount),
- sigdata, DataFromTransaction(mtx, i, coin.GetTxOut()));
UpdateInput(txin, sigdata);
ScriptError serror = ScriptError::OK;
if (!VerifyScript(
txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS,
TransactionSignatureChecker(&txConst, i, amount), &serror)) {
if (serror == ScriptError::INVALID_STACK_OPERATION) {
// Unable to sign input and verification failed (possible
// attempt to partially sign).
TxInErrorToJSON(txin, vErrors,
"Unable to sign input, invalid "
"stack size (possibly missing "
"key)");
} else {
TxInErrorToJSON(txin, vErrors, ScriptErrorString(serror));
}
}
}
bool fComplete = vErrors.empty();
UniValue result(UniValue::VOBJ);
result.pushKV("hex", EncodeHexTx(CTransaction(mtx)));
result.pushKV("complete", fComplete);
if (!vErrors.empty()) {
result.pushKV("errors", vErrors);
}
return result;
}
static UniValue signrawtransactionwithkey(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() < 2 ||
request.params.size() > 4) {
throw std::runtime_error(
"signrawtransactionwithkey \"hexstring\" [\"privatekey1\",...] ( "
"[{\"txid\":\"id\",\"vout\":n,\"scriptPubKey\":\"hex\","
"\"redeemScript\":\"hex\"},...] sighashtype )\n"
"\nSign inputs for raw transaction (serialized, hex-encoded).\n"
"The second argument is an array of base58-encoded private\n"
"keys that will be the only keys used to sign the transaction.\n"
"The third optional argument (may be null) is an array of previous "
"transaction outputs that\n"
"this transaction depends on but may not yet be in the block "
"chain.\n"
"\nArguments:\n"
"1. \"hexstring\" (string, required) The "
"transaction hex string\n"
"2. \"privkeys\" (string, required) A json "
"array of base58-encoded private keys for signing\n"
" [ (json array of strings)\n"
" \"privatekey\" (string) private key in "
"base58-encoding\n"
" ,...\n"
" ]\n"
"3. \"prevtxs\" (string, optional) An json "
"array of previous dependent transaction outputs\n"
" [ (json array of json objects, "
"or 'null' if none provided)\n"
" {\n"
" \"txid\":\"id\", (string, required) The "
"transaction id\n"
" \"vout\":n, (numeric, required) The "
"output number\n"
" \"scriptPubKey\": \"hex\", (string, required) script "
"key\n"
" \"redeemScript\": \"hex\", (string, required for "
"P2SH) redeem script\n"
" \"amount\": value (numeric, required) The "
"amount spent\n"
" }\n"
" ,...\n"
" ]\n"
"4. \"sighashtype\" (string, optional, "
"default=ALL) The signature hash type. Must be one of\n"
" \"ALL|FORKID\"\n"
" \"NONE|FORKID\"\n"
" \"SINGLE|FORKID\"\n"
" \"ALL|FORKID|ANYONECANPAY\"\n"
" \"NONE|FORKID|ANYONECANPAY\"\n"
" \"SINGLE|FORKID|ANYONECANPAY\"\n"
"\nResult:\n"
"{\n"
" \"hex\" : \"value\", (string) The hex-encoded "
"raw transaction with signature(s)\n"
" \"complete\" : true|false, (boolean) If the "
"transaction has a complete set of signatures\n"
" \"errors\" : [ (json array of objects) "
"Script verification errors (if there are any)\n"
" {\n"
" \"txid\" : \"hash\", (string) The hash of the "
"referenced, previous transaction\n"
" \"vout\" : n, (numeric) The index of the "
"output to spent and used as input\n"
" \"scriptSig\" : \"hex\", (string) The hex-encoded "
"signature script\n"
" \"sequence\" : n, (numeric) Script sequence "
"number\n"
" \"error\" : \"text\" (string) Verification or "
"signing error related to the input\n"
" }\n"
" ,...\n"
" ]\n"
"}\n"
"\nExamples:\n" +
HelpExampleCli("signrawtransactionwithkey", "\"myhex\"") +
HelpExampleRpc("signrawtransactionwithkey", "\"myhex\""));
}
RPCTypeCheck(
request.params,
{UniValue::VSTR, UniValue::VARR, UniValue::VARR, UniValue::VSTR}, true);
CMutableTransaction mtx;
if (!DecodeHexTx(mtx, request.params[0].get_str())) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
}
CBasicKeyStore keystore;
const UniValue &keys = request.params[1].get_array();
for (size_t idx = 0; idx < keys.size(); ++idx) {
UniValue k = keys[idx];
CKey key = DecodeSecret(k.get_str());
if (!key.IsValid()) {
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
"Invalid private key");
}
keystore.AddKey(key);
}
return SignTransaction(mtx, request.params[2], &keystore, true,
request.params[3]);
}
static UniValue sendrawtransaction(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() < 1 ||
request.params.size() > 2) {
throw std::runtime_error(
"sendrawtransaction \"hexstring\" ( allowhighfees )\n"
"\nSubmits raw transaction (serialized, hex-encoded) to local node "
"and network.\n"
"\nAlso see createrawtransaction and signrawtransactionwithkey "
"calls.\n"
"\nArguments:\n"
"1. \"hexstring\" (string, required) The hex string of the raw "
"transaction)\n"
"2. allowhighfees (boolean, optional, default=false) Allow high "
"fees\n"
"\nResult:\n"
"\"hex\" (string) The transaction hash in hex\n"
"\nExamples:\n"
"\nCreate a transaction\n" +
HelpExampleCli(
"createrawtransaction",
"\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" "
"\"{\\\"myaddress\\\":0.01}\"") +
"Sign the transaction, and get back the hex\n" +
HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
"\nSend the transaction (signed hex)\n" +
HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
"\nAs a json rpc call\n" +
HelpExampleRpc("sendrawtransaction", "\"signedhex\""));
}
std::promise<void> promise;
RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL});
// parse hex string from parameter
CMutableTransaction mtx;
if (!DecodeHexTx(mtx, request.params[0].get_str())) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
}
CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
const TxId &txid = tx->GetId();
Amount nMaxRawTxFee = maxTxFee;
if (request.params.size() > 1 && request.params[1].get_bool()) {
nMaxRawTxFee = Amount::zero();
}
{ // cs_main scope
LOCK(cs_main);
CCoinsViewCache &view = *pcoinsTip;
bool fHaveChain = false;
for (size_t o = 0; !fHaveChain && o < tx->vout.size(); o++) {
const Coin &existingCoin = view.AccessCoin(COutPoint(txid, o));
fHaveChain = !existingCoin.IsSpent();
}
bool fHaveMempool = g_mempool.exists(txid);
if (!fHaveMempool && !fHaveChain) {
// Push to local node and sync with wallets.
CValidationState state;
bool fMissingInputs;
bool fLimitFree = false;
if (!AcceptToMemoryPool(config, g_mempool, state, std::move(tx),
fLimitFree, &fMissingInputs, false,
nMaxRawTxFee)) {
if (state.IsInvalid()) {
throw JSONRPCError(RPC_TRANSACTION_REJECTED,
FormatStateMessage(state));
}
if (fMissingInputs) {
throw JSONRPCError(RPC_TRANSACTION_ERROR, "Missing inputs");
}
throw JSONRPCError(RPC_TRANSACTION_ERROR,
FormatStateMessage(state));
} else {
// If wallet is enabled, ensure that the wallet has been made
// aware of the new transaction prior to returning. This
// prevents a race where a user might call sendrawtransaction
// with a transaction to/from their wallet, immediately call
// some wallet RPC, and get a stale result because callbacks
// have not yet been processed.
CallFunctionInValidationInterfaceQueue(
[&promise] { promise.set_value(); });
}
} else if (fHaveChain) {
throw JSONRPCError(RPC_TRANSACTION_ALREADY_IN_CHAIN,
"transaction already in block chain");
} else {
// Make sure we don't block forever if re-sending a transaction
// already in mempool.
promise.set_value();
}
} // cs_main
promise.get_future().wait();
if (!g_connman) {
throw JSONRPCError(
RPC_CLIENT_P2P_DISABLED,
"Error: Peer-to-peer functionality missing or disabled");
}
CInv inv(MSG_TX, txid);
g_connman->ForEachNode([&inv](CNode *pnode) { pnode->PushInventory(inv); });
return txid.GetHex();
}
static UniValue testmempoolaccept(const Config &config,
const JSONRPCRequest &request) {
if (request.fHelp || request.params.size() < 1 ||
request.params.size() > 2) {
throw std::runtime_error(
// clang-format off
"testmempoolaccept [\"rawtxs\"] ( allowhighfees )\n"
"\nReturns if raw transaction (serialized, hex-encoded) would be accepted by mempool.\n"
"\nThis checks if the transaction violates the consensus or policy rules.\n"
"\nSee sendrawtransaction call.\n"
"\nArguments:\n"
"1. [\"rawtxs\"] (array, required) An array of hex strings of raw transactions.\n"
" Length must be one for now.\n"
"2. allowhighfees (boolean, optional, default=false) Allow high fees\n"
"\nResult:\n"
"[ (array) The result of the mempool acceptance test for each raw transaction in the input array.\n"
" Length is exactly one for now.\n"
" {\n"
" \"txid\" (string) The transaction hash in hex\n"
" \"allowed\" (boolean) If the mempool allows this tx to be inserted\n"
" \"reject-reason\" (string) Rejection string (only present when 'allowed' is false)\n"
" }\n"
"]\n"
"\nExamples:\n"
"\nCreate a transaction\n"
+ HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
"Sign the transaction, and get back the hex\n"
+ HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
"\nTest acceptance of the transaction (signed hex)\n"
+ HelpExampleCli("testmempoolaccept", "\"signedhex\"") +
"\nAs a json rpc call\n"
+ HelpExampleRpc("testmempoolaccept", "[\"signedhex\"]")
// clang-format on
);
}
RPCTypeCheck(request.params, {UniValue::VARR, UniValue::VBOOL});
if (request.params[0].get_array().size() != 1) {
throw JSONRPCError(
RPC_INVALID_PARAMETER,
"Array must contain exactly one raw transaction for now");
}
CMutableTransaction mtx;
if (!DecodeHexTx(mtx, request.params[0].get_array()[0].get_str())) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
}
CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
const uint256 &txid = tx->GetId();
bool fLimitFree = false;
Amount max_raw_tx_fee = maxTxFee;
if (!request.params[1].isNull() && request.params[1].get_bool()) {
max_raw_tx_fee = Amount::zero();
}
UniValue result(UniValue::VARR);
UniValue result_0(UniValue::VOBJ);
result_0.pushKV("txid", txid.GetHex());
CValidationState state;
bool missing_inputs;
bool test_accept_res;
{
LOCK(cs_main);
test_accept_res = AcceptToMemoryPool(
config, g_mempool, state, std::move(tx), fLimitFree,
&missing_inputs, /* bypass_limits */ false, max_raw_tx_fee,
/* test_accept */ true);
}
result_0.pushKV("allowed", test_accept_res);
if (!test_accept_res) {
if (state.IsInvalid()) {
result_0.pushKV("reject-reason",
strprintf("%i: %s", state.GetRejectCode(),
state.GetRejectReason()));
} else if (missing_inputs) {
result_0.pushKV("reject-reason", "missing-inputs");
} else {
result_0.pushKV("reject-reason", state.GetRejectReason());
}
}
result.push_back(std::move(result_0));
return result;
}
// clang-format off
static const ContextFreeRPCCommand commands[] = {
// category name actor (function) argNames
// ------------------- ------------------------ ---------------------- ----------
{ "rawtransactions", "getrawtransaction", getrawtransaction, {"txid","verbose","blockhash"} },
{ "rawtransactions", "createrawtransaction", createrawtransaction, {"inputs","outputs","locktime"} },
{ "rawtransactions", "decoderawtransaction", decoderawtransaction, {"hexstring"} },
{ "rawtransactions", "decodescript", decodescript, {"hexstring"} },
{ "rawtransactions", "sendrawtransaction", sendrawtransaction, {"hexstring","allowhighfees"} },
{ "rawtransactions", "combinerawtransaction", combinerawtransaction, {"txs"} },
{ "rawtransactions", "signrawtransactionwithkey", signrawtransactionwithkey, {"hexstring","privkeys","prevtxs","sighashtype"} },
{ "rawtransactions", "testmempoolaccept", testmempoolaccept, {"rawtxs","allowhighfees"} },
{ "blockchain", "gettxoutproof", gettxoutproof, {"txids", "blockhash"} },
{ "blockchain", "verifytxoutproof", verifytxoutproof, {"proof"} },
};
// clang-format on
void RegisterRawTransactionRPCCommands(CRPCTable &t) {
for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
t.appendCommand(commands[vcidx].name, &commands[vcidx]);
}
}
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 43760c1570..7b5a8c1bc1 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -1,457 +1,526 @@
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <script/sign.h>
#include <key.h>
#include <policy/policy.h>
#include <primitives/transaction.h>
#include <script/standard.h>
#include <uint256.h>
typedef std::vector<uint8_t> valtype;
MutableTransactionSignatureCreator::MutableTransactionSignatureCreator(
const CMutableTransaction *txToIn, unsigned int nInIn,
const Amount &amountIn, SigHashType sigHashTypeIn)
: txTo(txToIn), nIn(nInIn), amount(amountIn), sigHashType(sigHashTypeIn),
checker(txTo, nIn, amountIn) {}
bool MutableTransactionSignatureCreator::CreateSig(
const SigningProvider &provider, std::vector<uint8_t> &vchSig,
const CKeyID &address, const CScript &scriptCode) const {
CKey key;
if (!provider.GetKey(address, key)) {
return false;
}
uint256 hash = SignatureHash(scriptCode, *txTo, nIn, sigHashType, amount);
if (!key.SignECDSA(hash, vchSig)) {
return false;
}
vchSig.push_back(uint8_t(sigHashType.getRawSigHashType()));
return true;
}
+static bool GetCScript(const SigningProvider &provider,
+ const SignatureData &sigdata, const CScriptID &scriptid,
+ CScript &script) {
+ if (provider.GetCScript(scriptid, script)) {
+ return true;
+ }
+ // Look for scripts in SignatureData
+ if (CScriptID(sigdata.redeem_script) == scriptid) {
+ script = sigdata.redeem_script;
+ return true;
+ }
+ return false;
+}
+
+static bool GetPubKey(const SigningProvider &provider,
+ const SignatureData &sigdata, const CKeyID &address,
+ CPubKey &pubkey) {
+ if (provider.GetPubKey(address, pubkey)) {
+ return true;
+ }
+ // Look for pubkey in all partial sigs
+ const auto it = sigdata.signatures.find(address);
+ if (it != sigdata.signatures.end()) {
+ pubkey = it->second.first;
+ return true;
+ }
+ return false;
+}
+
+static bool CreateSig(const BaseSignatureCreator &creator,
+ SignatureData &sigdata, const SigningProvider &provider,
+ std::vector<uint8_t> &sig_out, const CKeyID &keyid,
+ const CScript &scriptcode) {
+ const auto it = sigdata.signatures.find(keyid);
+ if (it != sigdata.signatures.end()) {
+ sig_out = it->second.second;
+ return true;
+ }
+ if (creator.CreateSig(provider, sig_out, keyid, scriptcode)) {
+ CPubKey pubkey;
+ GetPubKey(provider, sigdata, keyid, pubkey);
+ auto i = sigdata.signatures.emplace(keyid, SigPair(pubkey, sig_out));
+ assert(i.second);
+ return true;
+ }
+ return false;
+}
+
/**
* Sign scriptPubKey using signature made with creator.
* Signatures are returned in scriptSigRet (or returns false if scriptPubKey
* can't be signed), unless whichTypeRet is TX_SCRIPTHASH, in which case
* scriptSigRet is the redemption script.
* Returns false if scriptPubKey could not be completely satisfied.
*/
static bool SignStep(const SigningProvider &provider,
const BaseSignatureCreator &creator,
const CScript &scriptPubKey, std::vector<valtype> &ret,
- txnouttype &whichTypeRet) {
+ txnouttype &whichTypeRet, SignatureData &sigdata) {
CScript scriptRet;
uint160 h160;
ret.clear();
std::vector<uint8_t> sig;
std::vector<valtype> vSolutions;
if (!Solver(scriptPubKey, whichTypeRet, vSolutions)) {
return false;
}
switch (whichTypeRet) {
case TX_NONSTANDARD:
case TX_NULL_DATA:
return false;
case TX_PUBKEY:
- if (!creator.CreateSig(provider, sig,
- CPubKey(vSolutions[0]).GetID(),
- scriptPubKey)) {
+ if (!CreateSig(creator, sigdata, provider, sig,
+ CPubKey(vSolutions[0]).GetID(), scriptPubKey)) {
return false;
}
ret.push_back(std::move(sig));
return true;
case TX_PUBKEYHASH: {
CKeyID keyID = CKeyID(uint160(vSolutions[0]));
- if (!creator.CreateSig(provider, sig, keyID, scriptPubKey)) {
+ if (!CreateSig(creator, sigdata, provider, sig, keyID,
+ scriptPubKey)) {
return false;
}
ret.push_back(std::move(sig));
CPubKey pubkey;
provider.GetPubKey(keyID, pubkey);
ret.push_back(ToByteVector(pubkey));
return true;
}
case TX_SCRIPTHASH:
- if (provider.GetCScript(uint160(vSolutions[0]), scriptRet)) {
+ if (GetCScript(provider, sigdata, uint160(vSolutions[0]),
+ scriptRet)) {
ret.push_back(
std::vector<uint8_t>(scriptRet.begin(), scriptRet.end()));
return true;
}
return false;
case TX_MULTISIG: {
size_t required = vSolutions.front()[0];
// workaround CHECKMULTISIG bug
ret.push_back(valtype());
for (size_t i = 1; i < vSolutions.size() - 1; ++i) {
CPubKey pubkey = CPubKey(vSolutions[i]);
if (ret.size() < required + 1 &&
- creator.CreateSig(provider, sig, pubkey.GetID(),
- scriptPubKey)) {
+ CreateSig(creator, sigdata, provider, sig, pubkey.GetID(),
+ scriptPubKey)) {
ret.push_back(std::move(sig));
}
}
bool ok = ret.size() == required + 1;
for (size_t i = 0; i + ret.size() < required + 1; ++i) {
ret.push_back(valtype());
}
return ok;
}
default:
return false;
}
}
static CScript PushAll(const std::vector<valtype> &values) {
CScript result;
for (const valtype &v : values) {
if (v.size() == 0) {
result << OP_0;
} else if (v.size() == 1 && v[0] >= 1 && v[0] <= 16) {
result << CScript::EncodeOP_N(v[0]);
} else {
result << v;
}
}
return result;
}
bool ProduceSignature(const SigningProvider &provider,
const BaseSignatureCreator &creator,
const CScript &fromPubKey, SignatureData &sigdata) {
if (sigdata.complete) {
return true;
}
std::vector<valtype> result;
txnouttype whichType;
- bool solved = SignStep(provider, creator, fromPubKey, result, whichType);
+ bool solved =
+ SignStep(provider, creator, fromPubKey, result, whichType, sigdata);
CScript subscript;
if (solved && whichType == TX_SCRIPTHASH) {
// Solver returns the subscript that needs to be evaluated; the final
// scriptSig is the signatures from that and then the serialized
// subscript:
subscript = CScript(result[0].begin(), result[0].end());
+ sigdata.redeem_script = subscript;
+
solved = solved &&
- SignStep(provider, creator, subscript, result, whichType) &&
+ SignStep(provider, creator, subscript, result, whichType,
+ sigdata) &&
whichType != TX_SCRIPTHASH;
result.push_back(
std::vector<uint8_t>(subscript.begin(), subscript.end()));
}
sigdata.scriptSig = PushAll(result);
// Test solution
sigdata.complete =
solved && VerifyScript(sigdata.scriptSig, fromPubKey,
STANDARD_SCRIPT_VERIFY_FLAGS, creator.Checker());
return sigdata.complete;
}
class SignatureExtractorChecker final : public BaseSignatureChecker {
private:
SignatureData &sigdata;
BaseSignatureChecker &checker;
public:
SignatureExtractorChecker(SignatureData &sigdata_,
BaseSignatureChecker &checker_)
: sigdata(sigdata_), checker(checker_) {}
bool CheckSig(const std::vector<uint8_t> &scriptSig,
const std::vector<uint8_t> &vchPubKey,
const CScript &scriptCode, uint32_t flags) const override;
};
bool SignatureExtractorChecker::CheckSig(const std::vector<uint8_t> &scriptSig,
const std::vector<uint8_t> &vchPubKey,
const CScript &scriptCode,
uint32_t flags) const {
if (checker.CheckSig(scriptSig, vchPubKey, scriptCode, flags)) {
CPubKey pubkey(vchPubKey);
sigdata.signatures.emplace(pubkey.GetID(), SigPair(pubkey, scriptSig));
return true;
}
return false;
}
namespace {
struct Stacks {
std::vector<valtype> script;
Stacks() {}
explicit Stacks(const std::vector<valtype> &scriptSigStack_)
: script(scriptSigStack_) {}
explicit Stacks(const SignatureData &data) {
EvalScript(script, data.scriptSig, MANDATORY_SCRIPT_VERIFY_FLAGS,
BaseSignatureChecker());
}
SignatureData Output() const {
SignatureData result;
result.scriptSig = PushAll(script);
return result;
}
};
} // namespace
// Extracts signatures and scripts from incomplete scriptSigs. Please do not
// extend this, use PSBT instead
SignatureData DataFromTransaction(const CMutableTransaction &tx,
unsigned int nIn, const CTxOut &txout) {
SignatureData data;
assert(tx.vin.size() > nIn);
data.scriptSig = tx.vin[nIn].scriptSig;
Stacks stack(data);
// Get signatures
MutableTransactionSignatureChecker tx_checker(&tx, nIn, txout.nValue);
SignatureExtractorChecker extractor_checker(data, tx_checker);
if (VerifyScript(data.scriptSig, txout.scriptPubKey,
STANDARD_SCRIPT_VERIFY_FLAGS, extractor_checker)) {
data.complete = true;
return data;
}
// Get scripts
txnouttype script_type;
std::vector<std::vector<uint8_t>> solutions;
Solver(txout.scriptPubKey, script_type, solutions);
CScript next_script = txout.scriptPubKey;
if (script_type == TX_SCRIPTHASH && !stack.script.empty() &&
!stack.script.back().empty()) {
// Get the redeemScript
CScript redeem_script(stack.script.back().begin(),
stack.script.back().end());
data.redeem_script = redeem_script;
next_script = std::move(redeem_script);
// Get redeemScript type
Solver(next_script, script_type, solutions);
stack.script.pop_back();
}
if (script_type == TX_MULTISIG && !stack.script.empty()) {
// Build a map of pubkey -> signature by matching sigs to pubkeys:
assert(solutions.size() > 1);
unsigned int num_pubkeys = solutions.size() - 2;
unsigned int last_success_key = 0;
for (const valtype &sig : stack.script) {
for (unsigned int i = last_success_key; i < num_pubkeys; ++i) {
const valtype &pubkey = solutions[i + 1];
// We either have a signature for this pubkey, or we have found
// a signature and it is valid
if (data.signatures.count(CPubKey(pubkey).GetID()) ||
extractor_checker.CheckSig(sig, pubkey, next_script,
STANDARD_SCRIPT_VERIFY_FLAGS)) {
last_success_key = i + 1;
break;
}
}
}
}
return data;
}
void UpdateInput(CTxIn &input, const SignatureData &data) {
input.scriptSig = data.scriptSig;
}
+void SignatureData::MergeSignatureData(SignatureData sigdata) {
+ if (complete) {
+ return;
+ }
+ if (sigdata.complete) {
+ *this = std::move(sigdata);
+ return;
+ }
+ if (redeem_script.empty() && !sigdata.redeem_script.empty()) {
+ redeem_script = sigdata.redeem_script;
+ }
+ signatures.insert(std::make_move_iterator(sigdata.signatures.begin()),
+ std::make_move_iterator(sigdata.signatures.end()));
+}
+
bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey,
CMutableTransaction &txTo, unsigned int nIn,
const Amount amount, SigHashType sigHashType) {
assert(nIn < txTo.vin.size());
MutableTransactionSignatureCreator creator(&txTo, nIn, amount, sigHashType);
SignatureData sigdata;
bool ret = ProduceSignature(provider, creator, fromPubKey, sigdata);
UpdateInput(txTo.vin.at(nIn), sigdata);
return ret;
}
bool SignSignature(const SigningProvider &provider, const CTransaction &txFrom,
CMutableTransaction &txTo, unsigned int nIn,
SigHashType sigHashType) {
assert(nIn < txTo.vin.size());
CTxIn &txin = txTo.vin[nIn];
assert(txin.prevout.GetN() < txFrom.vout.size());
const CTxOut &txout = txFrom.vout[txin.prevout.GetN()];
return SignSignature(provider, txout.scriptPubKey, txTo, nIn, txout.nValue,
sigHashType);
}
static std::vector<valtype> CombineMultisig(
const CScript &scriptPubKey, const BaseSignatureChecker &checker,
const std::vector<valtype> &vSolutions, const std::vector<valtype> &sigs1,
const std::vector<valtype> &sigs2) {
// Combine all the signatures we've got:
std::set<valtype> allsigs;
for (const valtype &v : sigs1) {
if (!v.empty()) {
allsigs.insert(v);
}
}
for (const valtype &v : sigs2) {
if (!v.empty()) {
allsigs.insert(v);
}
}
// Build a map of pubkey -> signature by matching sigs to pubkeys:
assert(vSolutions.size() > 1);
unsigned int nSigsRequired = vSolutions.front()[0];
unsigned int nPubKeys = vSolutions.size() - 2;
std::map<valtype, valtype> sigs;
for (const valtype &sig : allsigs) {
for (unsigned int i = 0; i < nPubKeys; i++) {
const valtype &pubkey = vSolutions[i + 1];
// Already got a sig for this pubkey
if (sigs.count(pubkey)) {
continue;
}
if (checker.CheckSig(sig, pubkey, scriptPubKey,
STANDARD_SCRIPT_VERIFY_FLAGS)) {
sigs[pubkey] = sig;
break;
}
}
}
// Now build a merged CScript:
unsigned int nSigsHave = 0;
// pop-one-too-many workaround
std::vector<valtype> result;
result.push_back(valtype());
for (unsigned int i = 0; i < nPubKeys && nSigsHave < nSigsRequired; i++) {
if (sigs.count(vSolutions[i + 1])) {
result.push_back(sigs[vSolutions[i + 1]]);
++nSigsHave;
}
}
// Fill any missing with OP_0:
for (unsigned int i = nSigsHave; i < nSigsRequired; i++) {
result.push_back(valtype());
}
return result;
}
static Stacks CombineSignatures(const CScript &scriptPubKey,
const BaseSignatureChecker &checker,
const txnouttype txType,
const std::vector<valtype> &vSolutions,
Stacks sigs1, Stacks sigs2) {
switch (txType) {
case TX_NONSTANDARD:
case TX_NULL_DATA:
// Don't know anything about this, assume bigger one is correct:
if (sigs1.script.size() >= sigs2.script.size()) {
return sigs1;
}
return sigs2;
case TX_PUBKEY:
case TX_PUBKEYHASH:
// Signatures are bigger than placeholders or empty scripts:
if (sigs1.script.empty() || sigs1.script[0].empty()) {
return sigs2;
}
return sigs1;
case TX_SCRIPTHASH: {
if (sigs1.script.empty() || sigs1.script.back().empty()) {
return sigs2;
}
if (sigs2.script.empty() || sigs2.script.back().empty()) {
return sigs1;
}
// Recur to combine:
valtype spk = sigs1.script.back();
CScript pubKey2(spk.begin(), spk.end());
txnouttype txType2;
std::vector<std::vector<uint8_t>> vSolutions2;
Solver(pubKey2, txType2, vSolutions2);
sigs1.script.pop_back();
sigs2.script.pop_back();
Stacks result = CombineSignatures(pubKey2, checker, txType2,
vSolutions2, sigs1, sigs2);
result.script.push_back(spk);
return result;
}
case TX_MULTISIG:
return Stacks(CombineMultisig(scriptPubKey, checker, vSolutions,
sigs1.script, sigs2.script));
default:
return Stacks();
}
}
SignatureData CombineSignatures(const CScript &scriptPubKey,
const BaseSignatureChecker &checker,
const SignatureData &scriptSig1,
const SignatureData &scriptSig2) {
txnouttype txType;
std::vector<std::vector<uint8_t>> vSolutions;
Solver(scriptPubKey, txType, vSolutions);
return CombineSignatures(scriptPubKey, checker, txType, vSolutions,
Stacks(scriptSig1), Stacks(scriptSig2))
.Output();
}
namespace {
/** Dummy signature checker which accepts all signatures. */
class DummySignatureChecker final : public BaseSignatureChecker {
public:
DummySignatureChecker() {}
bool CheckSig(const std::vector<uint8_t> &scriptSig,
const std::vector<uint8_t> &vchPubKey,
const CScript &scriptCode, uint32_t flags) const override {
return true;
}
};
const DummySignatureChecker DUMMY_CHECKER;
class DummySignatureCreator final : public BaseSignatureCreator {
public:
DummySignatureCreator() {}
const BaseSignatureChecker &Checker() const override {
return DUMMY_CHECKER;
}
bool CreateSig(const SigningProvider &provider,
std::vector<uint8_t> &vchSig, const CKeyID &keyid,
const CScript &scriptCode) const override {
// Create a dummy signature that is a valid DER-encoding
vchSig.assign(72, '\000');
vchSig[0] = 0x30;
vchSig[1] = 69;
vchSig[2] = 0x02;
vchSig[3] = 33;
vchSig[4] = 0x01;
vchSig[4 + 33] = 0x02;
vchSig[5 + 33] = 32;
vchSig[6 + 33] = 0x01;
vchSig[6 + 33 + 32] = SIGHASH_ALL | SIGHASH_FORKID;
return true;
}
};
} // namespace
const BaseSignatureCreator &DUMMY_SIGNATURE_CREATOR = DummySignatureCreator();
+const SigningProvider &DUMMY_SIGNING_PROVIDER = SigningProvider();
diff --git a/src/script/sign.h b/src/script/sign.h
index 28e8658bd0..cd56756600 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -1,111 +1,119 @@
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_SCRIPT_SIGN_H
#define BITCOIN_SCRIPT_SIGN_H
#include <script/interpreter.h>
#include <script/sighashtype.h>
class CKey;
class CKeyID;
class CMutableTransaction;
class CScript;
class CScriptID;
class CTransaction;
/** An interface to be implemented by keystores that support signing. */
class SigningProvider {
public:
virtual ~SigningProvider() {}
- virtual bool GetCScript(const CScriptID &scriptid,
- CScript &script) const = 0;
- virtual bool GetPubKey(const CKeyID &address, CPubKey &pubkey) const = 0;
- virtual bool GetKey(const CKeyID &address, CKey &key) const = 0;
+ virtual bool GetCScript(const CScriptID &scriptid, CScript &script) const {
+ return false;
+ }
+ virtual bool GetPubKey(const CKeyID &address, CPubKey &pubkey) const {
+ return false;
+ }
+ virtual bool GetKey(const CKeyID &address, CKey &key) const {
+ return false;
+ }
};
+extern const SigningProvider &DUMMY_SIGNING_PROVIDER;
+
/** Interface for signature creators. */
class BaseSignatureCreator {
public:
virtual ~BaseSignatureCreator() {}
virtual const BaseSignatureChecker &Checker() const = 0;
/** Create a singular (non-script) signature. */
virtual bool CreateSig(const SigningProvider &provider,
std::vector<uint8_t> &vchSig, const CKeyID &keyid,
const CScript &scriptCode) const = 0;
};
/** A signature creator for transactions. */
class MutableTransactionSignatureCreator : public BaseSignatureCreator {
const CMutableTransaction *txTo;
unsigned int nIn;
Amount amount;
SigHashType sigHashType;
const MutableTransactionSignatureChecker checker;
public:
MutableTransactionSignatureCreator(
const CMutableTransaction *txToIn, unsigned int nInIn,
const Amount &amountIn, SigHashType sigHashTypeIn = SigHashType());
const BaseSignatureChecker &Checker() const override { return checker; }
bool CreateSig(const SigningProvider &provider,
std::vector<uint8_t> &vchSig, const CKeyID &keyid,
const CScript &scriptCode) const override;
};
/** A signature creator that just produces 72-byte empty signatures. */
extern const BaseSignatureCreator &DUMMY_SIGNATURE_CREATOR;
typedef std::pair<CPubKey, std::vector<uint8_t>> SigPair;
// This struct contains information from a transaction input and also contains
// signatures for that input. The information contained here can be used to
// create a signature and is also filled by ProduceSignature in order to
// construct final scriptSigs.
struct SignatureData {
/// Stores whether the scriptSig and scriptWitness are complete.
bool complete = false;
/// The scriptSig of an input. Contains complete signatures or the
/// traditional partial signatures format.
CScript scriptSig;
/// The redeemScript (if any) for the input.
CScript redeem_script;
/// BIP 174 style partial signatures for the input. May contain all
/// signatures necessary for producing a final scriptSig.
std::map<CKeyID, SigPair> signatures;
SignatureData() {}
explicit SignatureData(const CScript &script) : scriptSig(script) {}
+ void MergeSignatureData(SignatureData sigdata);
};
/** Produce a script signature using a generic signature creator. */
bool ProduceSignature(const SigningProvider &provider,
const BaseSignatureCreator &creator,
const CScript &scriptPubKey, SignatureData &sigdata);
/** Produce a script signature for a transaction. */
bool SignSignature(const SigningProvider &provider, const CScript &fromPubKey,
CMutableTransaction &txTo, unsigned int nIn,
const Amount amount, SigHashType sigHashType);
bool SignSignature(const SigningProvider &provider, const CTransaction &txFrom,
CMutableTransaction &txTo, unsigned int nIn,
SigHashType sigHashType);
/**
* Combine two script signatures using a generic signature checker,
* intelligently, possibly with OP_0 placeholders.
*/
SignatureData CombineSignatures(const CScript &scriptPubKey,
const BaseSignatureChecker &checker,
const SignatureData &scriptSig1,
const SignatureData &scriptSig2);
/** Extract signature data from a transaction input, and insert it. */
SignatureData DataFromTransaction(const CMutableTransaction &tx,
unsigned int nIn, const CTxOut &txout);
void UpdateInput(CTxIn &input, const SignatureData &data);
#endif // BITCOIN_SCRIPT_SIGN_H