Differential D1967 Diff 5522 src/rpc/rawtransaction.cpp

Changeset View

Standalone View

src/rpc/rawtransaction.cpp

Show First 20 Lines • Show All 718 Lines • ▼ Show 20 Lines	static void TxInErrorToJSON(const CTxIn &txin, UniValue &vErrorsRet,
entry.push_back(Pair("vout", uint64_t(txin.prevout.GetN())));		entry.push_back(Pair("vout", uint64_t(txin.prevout.GetN())));
entry.push_back(Pair("scriptSig",		entry.push_back(Pair("scriptSig",
HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));		HexStr(txin.scriptSig.begin(), txin.scriptSig.end())));
entry.push_back(Pair("sequence", uint64_t(txin.nSequence)));		entry.push_back(Pair("sequence", uint64_t(txin.nSequence)));
entry.push_back(Pair("error", strMessage));		entry.push_back(Pair("error", strMessage));
vErrorsRet.push_back(entry);		vErrorsRet.push_back(entry);
}		}

		UniValue combinerawtransaction(const Config &config,
		const JSONRPCRequest &request) {

		if (request.fHelp \|\| request.params.size() != 1)
		deadalnixUnsubmitted Not Done Inline Actions braces deadalnix: braces
		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\" : \"value\", (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(mempool.cs);
		CCoinsViewCache &viewChain = *pcoinsTip;
		CCoinsViewMemPool viewMempool(&viewChain, mempool);
		view.SetBackend(
		viewMempool); // temporarily switch cache backend to db+mempool view
		deadalnixUnsubmitted Not Done Inline Actions Move comment on previous line deadalnix: Move comment on previous line

		for (const CTxIn &txin : mergedTx.vin) {
		view.AccessCoin(txin.prevout); // Load entries from viewChain into
		// view; can fail.
		deadalnixUnsubmitted Not Done Inline Actions Move comment on previous line deadalnix: Move comment on previous line
		}

		view.SetBackend(
		viewDummy); // switch back to avoid locking mempool for too long
		deadalnixUnsubmitted Not Done Inline Actions Move comment on previous line deadalnix: Move comment on previous line
		}

		// Use CTransaction for the constant parts of the
		// transaction to avoid rehashing.
		const CTransaction txConst(mergedTx);
		// Sign what we can:
		for (unsigned int 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;

		// ... 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));
		}
		}

		UpdateTransaction(mergedTx, i, sigdata);
		}

		return EncodeHexTx(CTransaction(mergedTx));
		}

static UniValue signrawtransaction(const Config &config,		static UniValue signrawtransaction(const Config &config,
const JSONRPCRequest &request) {		const JSONRPCRequest &request) {
#ifdef ENABLE_WALLET		#ifdef ENABLE_WALLET
CWallet *const pwallet = GetWalletForJSONRPCRequest(request);		CWallet *const pwallet = GetWalletForJSONRPCRequest(request);
#endif		#endif

if (request.fHelp \|\| request.params.size() < 1 \|\|		if (request.fHelp \|\| request.params.size() < 1 \|\|
request.params.size() > 4) {		request.params.size() > 4) {
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines	#ifdef ENABLE_WALLET
LOCK2(cs_main, pwallet ? &pwallet->cs_wallet : nullptr);		LOCK2(cs_main, pwallet ? &pwallet->cs_wallet : nullptr);
#else		#else
LOCK(cs_main);		LOCK(cs_main);
#endif		#endif
RPCTypeCheck(		RPCTypeCheck(
request.params,		request.params,
{UniValue::VSTR, UniValue::VARR, UniValue::VARR, UniValue::VSTR}, true);		{UniValue::VSTR, UniValue::VARR, UniValue::VARR, UniValue::VSTR}, true);

std::vector<uint8_t> txData(ParseHexV(request.params[0], "argument 1"));		CMutableTransaction mtx;
CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);		if (!DecodeHexTx(mtx, request.params[0].get_str()))
		deadalnixUnsubmitted Not Done Inline Actions braces deadalnix: braces
std::vector<CMutableTransaction> txVariants;
while (!ssData.empty()) {
try {
CMutableTransaction tx;
ssData >> tx;
txVariants.push_back(tx);
} catch (const std::exception &) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");		throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
}
}

if (txVariants.empty()) {
throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Missing transaction");
}

// mergedTx will end up with all the signatures; it starts as a clone of the
// rawtx:
CMutableTransaction mergedTx(txVariants[0]);

// Fetch previous transactions (inputs):		// Fetch previous transactions (inputs):
CCoinsView viewDummy;		CCoinsView viewDummy;
CCoinsViewCache view(&viewDummy);		CCoinsViewCache view(&viewDummy);
{		{
LOCK(mempool.cs);		LOCK(mempool.cs);
CCoinsViewCache &viewChain = *pcoinsTip;		CCoinsViewCache &viewChain = *pcoinsTip;
CCoinsViewMemPool viewMempool(&viewChain, mempool);		CCoinsViewMemPool viewMempool(&viewChain, mempool);
// Temporarily switch cache backend to db+mempool view.		// Temporarily switch cache backend to db+mempool view.
view.SetBackend(viewMempool);		view.SetBackend(viewMempool);

for (const CTxIn &txin : mergedTx.vin) {		for (const CTxIn &txin : mtx.vin) {
// Load entries from viewChain into view; can fail.		// Load entries from viewChain into view; can fail.
view.AccessCoin(txin.prevout);		view.AccessCoin(txin.prevout);
}		}

// Switch back to avoid locking mempool for too long.		// Switch back to avoid locking mempool for too long.
view.SetBackend(viewDummy);		view.SetBackend(viewDummy);
}		}

▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines	if (request.params.size() > 3 && !request.params[3].isNull()) {
}		}
}		}

// Script verification errors.		// Script verification errors.
UniValue vErrors(UniValue::VARR);		UniValue vErrors(UniValue::VARR);

// Use CTransaction for the constant parts of the transaction to avoid		// Use CTransaction for the constant parts of the transaction to avoid
// rehashing.		// rehashing.
const CTransaction txConst(mergedTx);		const CTransaction txConst(mtx);
// Sign what we can:		// Sign what we can:
for (size_t i = 0; i < mergedTx.vin.size(); i++) {		for (size_t i = 0; i < mtx.vin.size(); i++) {
CTxIn &txin = mergedTx.vin[i];		CTxIn &txin = mtx.vin[i];
const Coin &coin = view.AccessCoin(txin.prevout);		const Coin &coin = view.AccessCoin(txin.prevout);
if (coin.IsSpent()) {		if (coin.IsSpent()) {
TxInErrorToJSON(txin, vErrors, "Input not found or already spent");		TxInErrorToJSON(txin, vErrors, "Input not found or already spent");
continue;		continue;
}		}

const CScript &prevPubKey = coin.GetTxOut().scriptPubKey;		const CScript &prevPubKey = coin.GetTxOut().scriptPubKey;
const Amount amount = coin.GetTxOut().nValue;		const Amount amount = coin.GetTxOut().nValue;

SignatureData sigdata;		SignatureData sigdata;
// Only sign SIGHASH_SINGLE if there's a corresponding output:		// Only sign SIGHASH_SINGLE if there's a corresponding output:
if ((sigHashType.getBaseType() != BaseSigHashType::SINGLE) \|\|		if ((sigHashType.getBaseType() != BaseSigHashType::SINGLE) \|\|
(i < mergedTx.vout.size())) {		(i < mtx.vout.size())) {
ProduceSignature(MutableTransactionSignatureCreator(		ProduceSignature(MutableTransactionSignatureCreator(
&keystore, &mergedTx, i, amount, sigHashType),		&keystore, &mtx, i, amount, sigHashType),
prevPubKey, sigdata);		prevPubKey, sigdata);
}		}

// ... and merge in other signatures:
for (const CMutableTransaction &txv : txVariants) {
if (txv.vin.size() > i) {
sigdata = CombineSignatures(		sigdata = CombineSignatures(
prevPubKey,		prevPubKey, TransactionSignatureChecker(&txConst, i, amount),
TransactionSignatureChecker(&txConst, i, amount), sigdata,		sigdata, DataFromTransaction(mtx, i));
DataFromTransaction(txv, i));
}
}

UpdateTransaction(mergedTx, i, sigdata);		UpdateTransaction(mtx, i, sigdata);

ScriptError serror = SCRIPT_ERR_OK;		ScriptError serror = SCRIPT_ERR_OK;
if (!VerifyScript(		if (!VerifyScript(
txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS,		txin.scriptSig, prevPubKey, STANDARD_SCRIPT_VERIFY_FLAGS,
TransactionSignatureChecker(&txConst, i, amount), &serror)) {		TransactionSignatureChecker(&txConst, i, amount), &serror)) {
TxInErrorToJSON(txin, vErrors, ScriptErrorString(serror));		TxInErrorToJSON(txin, vErrors, ScriptErrorString(serror));
}		}
}		}

bool fComplete = vErrors.empty();		bool fComplete = vErrors.empty();

UniValue result(UniValue::VOBJ);		UniValue result(UniValue::VOBJ);
result.push_back(Pair("hex", EncodeHexTx(CTransaction(mergedTx))));		result.push_back(Pair("hex", EncodeHexTx(CTransaction(mtx))));
result.push_back(Pair("complete", fComplete));		result.push_back(Pair("complete", fComplete));
if (!vErrors.empty()) {		if (!vErrors.empty()) {
result.push_back(Pair("errors", vErrors));		result.push_back(Pair("errors", vErrors));
}		}

return result;		return result;
}		}

▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines
static const ContextFreeRPCCommand commands[] = {		static const ContextFreeRPCCommand commands[] = {
// category name actor (function) argNames		// category name actor (function) argNames
// ------------------- ------------------------ ---------------------- ----------		// ------------------- ------------------------ ---------------------- ----------
{ "rawtransactions", "getrawtransaction", getrawtransaction, {"txid","verbose"} },		{ "rawtransactions", "getrawtransaction", getrawtransaction, {"txid","verbose"} },
{ "rawtransactions", "createrawtransaction", createrawtransaction, {"inputs","outputs","locktime"} },		{ "rawtransactions", "createrawtransaction", createrawtransaction, {"inputs","outputs","locktime"} },
{ "rawtransactions", "decoderawtransaction", decoderawtransaction, {"hexstring"} },		{ "rawtransactions", "decoderawtransaction", decoderawtransaction, {"hexstring"} },
{ "rawtransactions", "decodescript", decodescript, {"hexstring"} },		{ "rawtransactions", "decodescript", decodescript, {"hexstring"} },
{ "rawtransactions", "sendrawtransaction", sendrawtransaction, {"hexstring","allowhighfees"} },		{ "rawtransactions", "sendrawtransaction", sendrawtransaction, {"hexstring","allowhighfees"} },
		{ "rawtransactions", "combinerawtransaction", combinerawtransaction, {"txs"} },
{ "rawtransactions", "signrawtransaction", signrawtransaction, {"hexstring","prevtxs","privkeys","sighashtype"} }, /* uses wallet if enabled */		{ "rawtransactions", "signrawtransaction", signrawtransaction, {"hexstring","prevtxs","privkeys","sighashtype"} }, /* uses wallet if enabled */

{ "blockchain", "gettxoutproof", gettxoutproof, {"txids", "blockhash"} },		{ "blockchain", "gettxoutproof", gettxoutproof, {"txids", "blockhash"} },
{ "blockchain", "verifytxoutproof", verifytxoutproof, {"proof"} },		{ "blockchain", "verifytxoutproof", verifytxoutproof, {"proof"} },
};		};
// clang-format on		// clang-format on

void RegisterRawTransactionRPCCommands(CRPCTable &t) {		void RegisterRawTransactionRPCCommands(CRPCTable &t) {
for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {		for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
t.appendCommand(commands[vcidx].name, &commands[vcidx]);		t.appendCommand(commands[vcidx].name, &commands[vcidx]);
}		}
}		}