Differential D1967 Diff 5589 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) {
		throw std::runtime_error(
		"combinerawtransaction [\"hexstring\",...]\n"
		"\nCombine multiple partially signed transactions into one "
		schancelUnsubmitted Not Done Inline Actions What is going on with this API? Can you point me to the docs? I doesn't look like this actually combines transactions, but only signatures? schancel: What is going on with this API? Can you point me to the docs? I doesn't look like this…
		FabienAuthorUnsubmitted Done Inline Actions My understanding is that it targets partially signed multisig txs, and effectively combines the signatures in order to make the tx fully signed, hence spendable. I could not find any documentation apart from the help lines, but fund the functional test case being quiet self-explanatory. Fabien: My understanding is that it targets partially signed multisig txs, and effectively combines the…
		"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);
		// 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 (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,
		schancelUnsubmitted Not Done Inline Actions So this assumes that the prevouts are all the same? schancel: So this assumes that the prevouts are all the same?
		FabienAuthorUnsubmitted Done Inline Actions My understanding is that the pk script should be the same. Fabien: My understanding is that the pk script should be the same.
		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())) {
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]);
}		}
}		}