Bitcoin Core 29.99.0
P2P Digital Currency
mempool.cpp
Go to the documentation of this file.
1// Copyright (c) 2010 Satoshi Nakamoto
2// Copyright (c) 2009-2022 The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <rpc/blockchain.h>
7
9
10#include <chainparams.h>
12#include <core_io.h>
14#include <net_processing.h>
16#include <node/types.h>
17#include <policy/rbf.h>
18#include <policy/settings.h>
20#include <rpc/server.h>
21#include <rpc/server_util.h>
22#include <rpc/util.h>
23#include <txmempool.h>
24#include <univalue.h>
25#include <util/fs.h>
26#include <util/moneystr.h>
27#include <util/strencodings.h>
28#include <util/time.h>
29#include <util/vector.h>
30
31#include <utility>
32
34
40using util::ToString;
41
43{
44 return RPCHelpMan{
45 "sendrawtransaction",
46 "Submit a raw transaction (serialized, hex-encoded) to local node and network.\n"
47 "\nThe transaction will be sent unconditionally to all peers, so using sendrawtransaction\n"
48 "for manual rebroadcast may degrade privacy by leaking the transaction's origin, as\n"
49 "nodes will normally not rebroadcast non-wallet transactions already in their mempool.\n"
50 "\nA specific exception, RPC_TRANSACTION_ALREADY_IN_UTXO_SET, may throw if the transaction cannot be added to the mempool.\n"
51 "\nRelated RPCs: createrawtransaction, signrawtransactionwithkey\n",
52 {
53 {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex string of the raw transaction"},
55 "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT +
56 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
58 "Reject transactions with provably unspendable outputs (e.g. 'datacarrier' outputs that use the OP_RETURN opcode) greater than the specified value, expressed in " + CURRENCY_UNIT + ".\n"
59 "If burning funds through unspendable outputs is desired, increase this value.\n"
60 "This check is based on heuristics and does not guarantee spendability of outputs.\n"},
61 },
63 RPCResult::Type::STR_HEX, "", "The transaction hash in hex"
64 },
66 "\nCreate a transaction\n"
67 + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
68 "Sign the transaction, and get back the hex\n"
69 + HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
70 "\nSend the transaction (signed hex)\n"
71 + HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
72 "\nAs a JSON-RPC call\n"
73 + HelpExampleRpc("sendrawtransaction", "\"signedhex\"")
74 },
75 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
76 {
77 const CAmount max_burn_amount = request.params[2].isNull() ? 0 : AmountFromValue(request.params[2]);
78
80 if (!DecodeHexTx(mtx, request.params[0].get_str())) {
81 throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed. Make sure the tx has at least one input.");
82 }
83
84 for (const auto& out : mtx.vout) {
85 if((out.scriptPubKey.IsUnspendable() || !out.scriptPubKey.HasValidOps()) && out.nValue > max_burn_amount) {
86 throw JSONRPCTransactionError(TransactionError::MAX_BURN_EXCEEDED);
87 }
88 }
89
90 CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
91
92 const CFeeRate max_raw_tx_fee_rate{ParseFeeRate(self.Arg<UniValue>("maxfeerate"))};
93
94 int64_t virtual_size = GetVirtualTransactionSize(*tx);
95 CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
96
97 std::string err_string;
99 NodeContext& node = EnsureAnyNodeContext(request.context);
100 const TransactionError err = BroadcastTransaction(node, tx, err_string, max_raw_tx_fee, /*relay=*/true, /*wait_callback=*/true);
101 if (TransactionError::OK != err) {
102 throw JSONRPCTransactionError(err, err_string);
103 }
104
105 return tx->GetHash().GetHex();
106 },
107 };
108}
109
111{
112 return RPCHelpMan{
113 "testmempoolaccept",
114 "Returns result of mempool acceptance tests indicating if raw transaction(s) (serialized, hex-encoded) would be accepted by mempool.\n"
115 "\nIf multiple transactions are passed in, parents must come before children and package policies apply: the transactions cannot conflict with any mempool transactions or each other.\n"
116 "\nIf one transaction fails, other transactions may not be fully validated (the 'allowed' key will be blank).\n"
117 "\nThe maximum number of transactions allowed is " + ToString(MAX_PACKAGE_COUNT) + ".\n"
118 "\nThis checks if transactions violate the consensus or policy rules.\n"
119 "\nSee sendrawtransaction call.\n",
120 {
121 {"rawtxs", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of hex strings of raw transactions.",
122 {
124 },
125 },
127 "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT +
128 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
129 },
130 RPCResult{
131 RPCResult::Type::ARR, "", "The result of the mempool acceptance test for each raw transaction in the input array.\n"
132 "Returns results for each transaction in the same order they were passed in.\n"
133 "Transactions that cannot be fully validated due to failures in other transactions will not contain an 'allowed' result.\n",
134 {
135 {RPCResult::Type::OBJ, "", "",
136 {
137 {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
138 {RPCResult::Type::STR_HEX, "wtxid", "The transaction witness hash in hex"},
139 {RPCResult::Type::STR, "package-error", /*optional=*/true, "Package validation error, if any (only possible if rawtxs had more than 1 transaction)."},
140 {RPCResult::Type::BOOL, "allowed", /*optional=*/true, "Whether this tx would be accepted to the mempool and pass client-specified maxfeerate. "
141 "If not present, the tx was not fully validated due to a failure in another tx in the list."},
142 {RPCResult::Type::NUM, "vsize", /*optional=*/true, "Virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted (only present when 'allowed' is true)"},
143 {RPCResult::Type::OBJ, "fees", /*optional=*/true, "Transaction fees (only present if 'allowed' is true)",
144 {
145 {RPCResult::Type::STR_AMOUNT, "base", "transaction fee in " + CURRENCY_UNIT},
146 {RPCResult::Type::STR_AMOUNT, "effective-feerate", /*optional=*/false, "the effective feerate in " + CURRENCY_UNIT + " per KvB. May differ from the base feerate if, for example, there are modified fees from prioritisetransaction or a package feerate was used."},
147 {RPCResult::Type::ARR, "effective-includes", /*optional=*/false, "transactions whose fees and vsizes are included in effective-feerate.",
148 {RPCResult{RPCResult::Type::STR_HEX, "", "transaction wtxid in hex"},
149 }},
150 }},
151 {RPCResult::Type::STR, "reject-reason", /*optional=*/true, "Rejection reason (only present when 'allowed' is false)"},
152 {RPCResult::Type::STR, "reject-details", /*optional=*/true, "Rejection details (only present when 'allowed' is false and rejection details exist)"},
153 }},
154 }
155 },
157 "\nCreate a transaction\n"
158 + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
159 "Sign the transaction, and get back the hex\n"
160 + HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
161 "\nTest acceptance of the transaction (signed hex)\n"
162 + HelpExampleCli("testmempoolaccept", R"('["signedhex"]')") +
163 "\nAs a JSON-RPC call\n"
164 + HelpExampleRpc("testmempoolaccept", "[\"signedhex\"]")
165 },
166 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
167 {
168 const UniValue raw_transactions = request.params[0].get_array();
169 if (raw_transactions.size() < 1 || raw_transactions.size() > MAX_PACKAGE_COUNT) {
171 "Array must contain between 1 and " + ToString(MAX_PACKAGE_COUNT) + " transactions.");
172 }
173
174 const CFeeRate max_raw_tx_fee_rate{ParseFeeRate(self.Arg<UniValue>("maxfeerate"))};
175
176 std::vector<CTransactionRef> txns;
177 txns.reserve(raw_transactions.size());
178 for (const auto& rawtx : raw_transactions.getValues()) {
180 if (!DecodeHexTx(mtx, rawtx.get_str())) {
182 "TX decode failed: " + rawtx.get_str() + " Make sure the tx has at least one input.");
183 }
184 txns.emplace_back(MakeTransactionRef(std::move(mtx)));
185 }
186
187 NodeContext& node = EnsureAnyNodeContext(request.context);
188 CTxMemPool& mempool = EnsureMemPool(node);
190 Chainstate& chainstate = chainman.ActiveChainstate();
191 const PackageMempoolAcceptResult package_result = [&] {
193 if (txns.size() > 1) return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/true, /*client_maxfeerate=*/{});
194 return PackageMempoolAcceptResult(txns[0]->GetWitnessHash(),
195 chainman.ProcessTransaction(txns[0], /*test_accept=*/true));
196 }();
197
198 UniValue rpc_result(UniValue::VARR);
199 // We will check transaction fees while we iterate through txns in order. If any transaction fee
200 // exceeds maxfeerate, we will leave the rest of the validation results blank, because it
201 // doesn't make sense to return a validation result for a transaction if its ancestor(s) would
202 // not be submitted.
203 bool exit_early{false};
204 for (const auto& tx : txns) {
205 UniValue result_inner(UniValue::VOBJ);
206 result_inner.pushKV("txid", tx->GetHash().GetHex());
207 result_inner.pushKV("wtxid", tx->GetWitnessHash().GetHex());
209 result_inner.pushKV("package-error", package_result.m_state.ToString());
210 }
211 auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
212 if (exit_early || it == package_result.m_tx_results.end()) {
213 // Validation unfinished. Just return the txid and wtxid.
214 rpc_result.push_back(std::move(result_inner));
215 continue;
216 }
217 const auto& tx_result = it->second;
218 // Package testmempoolaccept doesn't allow transactions to already be in the mempool.
220 if (tx_result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
221 const CAmount fee = tx_result.m_base_fees.value();
222 // Check that fee does not exceed maximum fee
223 const int64_t virtual_size = tx_result.m_vsize.value();
224 const CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
225 if (max_raw_tx_fee && fee > max_raw_tx_fee) {
226 result_inner.pushKV("allowed", false);
227 result_inner.pushKV("reject-reason", "max-fee-exceeded");
228 exit_early = true;
229 } else {
230 // Only return the fee and vsize if the transaction would pass ATMP.
231 // These can be used to calculate the feerate.
232 result_inner.pushKV("allowed", true);
233 result_inner.pushKV("vsize", virtual_size);
235 fees.pushKV("base", ValueFromAmount(fee));
236 fees.pushKV("effective-feerate", ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
237 UniValue effective_includes_res(UniValue::VARR);
238 for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
239 effective_includes_res.push_back(wtxid.ToString());
240 }
241 fees.pushKV("effective-includes", std::move(effective_includes_res));
242 result_inner.pushKV("fees", std::move(fees));
243 }
244 } else {
245 result_inner.pushKV("allowed", false);
246 const TxValidationState state = tx_result.m_state;
248 result_inner.pushKV("reject-reason", "missing-inputs");
249 } else {
250 result_inner.pushKV("reject-reason", state.GetRejectReason());
251 result_inner.pushKV("reject-details", state.ToString());
252 }
253 }
254 rpc_result.push_back(std::move(result_inner));
255 }
256 return rpc_result;
257 },
258 };
259}
260
261static std::vector<RPCResult> MempoolEntryDescription()
262{
263 return {
264 RPCResult{RPCResult::Type::NUM, "vsize", "virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted."},
265 RPCResult{RPCResult::Type::NUM, "weight", "transaction weight as defined in BIP 141."},
266 RPCResult{RPCResult::Type::NUM_TIME, "time", "local time transaction entered pool in seconds since 1 Jan 1970 GMT"},
267 RPCResult{RPCResult::Type::NUM, "height", "block height when transaction entered pool"},
268 RPCResult{RPCResult::Type::NUM, "descendantcount", "number of in-mempool descendant transactions (including this one)"},
269 RPCResult{RPCResult::Type::NUM, "descendantsize", "virtual transaction size of in-mempool descendants (including this one)"},
270 RPCResult{RPCResult::Type::NUM, "ancestorcount", "number of in-mempool ancestor transactions (including this one)"},
271 RPCResult{RPCResult::Type::NUM, "ancestorsize", "virtual transaction size of in-mempool ancestors (including this one)"},
272 RPCResult{RPCResult::Type::STR_HEX, "wtxid", "hash of serialized transaction, including witness data"},
274 {
275 RPCResult{RPCResult::Type::STR_AMOUNT, "base", "transaction fee, denominated in " + CURRENCY_UNIT},
276 RPCResult{RPCResult::Type::STR_AMOUNT, "modified", "transaction fee with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
277 RPCResult{RPCResult::Type::STR_AMOUNT, "ancestor", "transaction fees of in-mempool ancestors (including this one) with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
278 RPCResult{RPCResult::Type::STR_AMOUNT, "descendant", "transaction fees of in-mempool descendants (including this one) with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
279 }},
280 RPCResult{RPCResult::Type::ARR, "depends", "unconfirmed transactions used as inputs for this transaction",
281 {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "parent transaction id"}}},
282 RPCResult{RPCResult::Type::ARR, "spentby", "unconfirmed transactions spending outputs from this transaction",
283 {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "child transaction id"}}},
284 RPCResult{RPCResult::Type::BOOL, "bip125-replaceable", "Whether this transaction signals BIP125 replaceability or has an unconfirmed ancestor signaling BIP125 replaceability. (DEPRECATED)\n"},
285 RPCResult{RPCResult::Type::BOOL, "unbroadcast", "Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)"},
286 };
287}
288
289static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPoolEntry& e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
290{
291 AssertLockHeld(pool.cs);
292
293 info.pushKV("vsize", (int)e.GetTxSize());
294 info.pushKV("weight", (int)e.GetTxWeight());
295 info.pushKV("time", count_seconds(e.GetTime()));
296 info.pushKV("height", (int)e.GetHeight());
297 info.pushKV("descendantcount", e.GetCountWithDescendants());
298 info.pushKV("descendantsize", e.GetSizeWithDescendants());
299 info.pushKV("ancestorcount", e.GetCountWithAncestors());
300 info.pushKV("ancestorsize", e.GetSizeWithAncestors());
301 info.pushKV("wtxid", e.GetTx().GetWitnessHash().ToString());
302
304 fees.pushKV("base", ValueFromAmount(e.GetFee()));
305 fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
306 fees.pushKV("ancestor", ValueFromAmount(e.GetModFeesWithAncestors()));
307 fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants()));
308 info.pushKV("fees", std::move(fees));
309
310 const CTransaction& tx = e.GetTx();
311 std::set<std::string> setDepends;
312 for (const CTxIn& txin : tx.vin)
313 {
314 if (pool.exists(GenTxid::Txid(txin.prevout.hash)))
315 setDepends.insert(txin.prevout.hash.ToString());
316 }
317
318 UniValue depends(UniValue::VARR);
319 for (const std::string& dep : setDepends)
320 {
321 depends.push_back(dep);
322 }
323
324 info.pushKV("depends", std::move(depends));
325
327 for (const CTxMemPoolEntry& child : e.GetMemPoolChildrenConst()) {
328 spent.push_back(child.GetTx().GetHash().ToString());
329 }
330
331 info.pushKV("spentby", std::move(spent));
332
333 // Add opt-in RBF status
334 bool rbfStatus = false;
335 RBFTransactionState rbfState = IsRBFOptIn(tx, pool);
336 if (rbfState == RBFTransactionState::UNKNOWN) {
337 throw JSONRPCError(RPC_MISC_ERROR, "Transaction is not in mempool");
338 } else if (rbfState == RBFTransactionState::REPLACEABLE_BIP125) {
339 rbfStatus = true;
340 }
341
342 info.pushKV("bip125-replaceable", rbfStatus);
343 info.pushKV("unbroadcast", pool.IsUnbroadcastTx(tx.GetHash()));
344}
345
346UniValue MempoolToJSON(const CTxMemPool& pool, bool verbose, bool include_mempool_sequence)
347{
348 if (verbose) {
349 if (include_mempool_sequence) {
350 throw JSONRPCError(RPC_INVALID_PARAMETER, "Verbose results cannot contain mempool sequence values.");
351 }
352 LOCK(pool.cs);
354 for (const CTxMemPoolEntry& e : pool.entryAll()) {
356 entryToJSON(pool, info, e);
357 // Mempool has unique entries so there is no advantage in using
358 // UniValue::pushKV, which checks if the key already exists in O(N).
359 // UniValue::pushKVEnd is used instead which currently is O(1).
360 o.pushKVEnd(e.GetTx().GetHash().ToString(), std::move(info));
361 }
362 return o;
363 } else {
365 uint64_t mempool_sequence;
366 {
367 LOCK(pool.cs);
368 for (const CTxMemPoolEntry& e : pool.entryAll()) {
369 a.push_back(e.GetTx().GetHash().ToString());
370 }
371 mempool_sequence = pool.GetSequence();
372 }
373 if (!include_mempool_sequence) {
374 return a;
375 } else {
377 o.pushKV("txids", std::move(a));
378 o.pushKV("mempool_sequence", mempool_sequence);
379 return o;
380 }
381 }
382}
383
385{
386 return RPCHelpMan{
387 "getrawmempool",
388 "Returns all transaction ids in memory pool as a json array of string transaction ids.\n"
389 "\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n",
390 {
391 {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
392 {"mempool_sequence", RPCArg::Type::BOOL, RPCArg::Default{false}, "If verbose=false, returns a json object with transaction list and mempool sequence number attached."},
393 },
394 {
395 RPCResult{"for verbose = false",
396 RPCResult::Type::ARR, "", "",
397 {
398 {RPCResult::Type::STR_HEX, "", "The transaction id"},
399 }},
400 RPCResult{"for verbose = true",
402 {
403 {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
404 }},
405 RPCResult{"for verbose = false and mempool_sequence = true",
406 RPCResult::Type::OBJ, "", "",
407 {
408 {RPCResult::Type::ARR, "txids", "",
409 {
410 {RPCResult::Type::STR_HEX, "", "The transaction id"},
411 }},
412 {RPCResult::Type::NUM, "mempool_sequence", "The mempool sequence value."},
413 }},
414 },
416 HelpExampleCli("getrawmempool", "true")
417 + HelpExampleRpc("getrawmempool", "true")
418 },
419 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
420{
421 bool fVerbose = false;
422 if (!request.params[0].isNull())
423 fVerbose = request.params[0].get_bool();
424
425 bool include_mempool_sequence = false;
426 if (!request.params[1].isNull()) {
427 include_mempool_sequence = request.params[1].get_bool();
428 }
429
430 return MempoolToJSON(EnsureAnyMemPool(request.context), fVerbose, include_mempool_sequence);
431},
432 };
433}
434
436{
437 return RPCHelpMan{
438 "getmempoolancestors",
439 "If txid is in the mempool, returns all in-mempool ancestors.\n",
440 {
441 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
442 {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
443 },
444 {
445 RPCResult{"for verbose = false",
446 RPCResult::Type::ARR, "", "",
447 {{RPCResult::Type::STR_HEX, "", "The transaction id of an in-mempool ancestor transaction"}}},
448 RPCResult{"for verbose = true",
450 {
451 {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
452 }},
453 },
455 HelpExampleCli("getmempoolancestors", "\"mytxid\"")
456 + HelpExampleRpc("getmempoolancestors", "\"mytxid\"")
457 },
458 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
459{
460 bool fVerbose = false;
461 if (!request.params[1].isNull())
462 fVerbose = request.params[1].get_bool();
463
464 uint256 hash = ParseHashV(request.params[0], "parameter 1");
465
466 const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
467 LOCK(mempool.cs);
468
469 const auto entry{mempool.GetEntry(Txid::FromUint256(hash))};
470 if (entry == nullptr) {
471 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
472 }
473
474 auto ancestors{mempool.AssumeCalculateMemPoolAncestors(self.m_name, *entry, CTxMemPool::Limits::NoLimits(), /*fSearchForParents=*/false)};
475
476 if (!fVerbose) {
478 for (CTxMemPool::txiter ancestorIt : ancestors) {
479 o.push_back(ancestorIt->GetTx().GetHash().ToString());
480 }
481 return o;
482 } else {
484 for (CTxMemPool::txiter ancestorIt : ancestors) {
485 const CTxMemPoolEntry &e = *ancestorIt;
486 const uint256& _hash = e.GetTx().GetHash();
488 entryToJSON(mempool, info, e);
489 o.pushKV(_hash.ToString(), std::move(info));
490 }
491 return o;
492 }
493},
494 };
495}
496
498{
499 return RPCHelpMan{
500 "getmempooldescendants",
501 "If txid is in the mempool, returns all in-mempool descendants.\n",
502 {
503 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
504 {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
505 },
506 {
507 RPCResult{"for verbose = false",
508 RPCResult::Type::ARR, "", "",
509 {{RPCResult::Type::STR_HEX, "", "The transaction id of an in-mempool descendant transaction"}}},
510 RPCResult{"for verbose = true",
512 {
513 {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
514 }},
515 },
517 HelpExampleCli("getmempooldescendants", "\"mytxid\"")
518 + HelpExampleRpc("getmempooldescendants", "\"mytxid\"")
519 },
520 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
521{
522 bool fVerbose = false;
523 if (!request.params[1].isNull())
524 fVerbose = request.params[1].get_bool();
525
526 uint256 hash = ParseHashV(request.params[0], "parameter 1");
527
528 const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
529 LOCK(mempool.cs);
530
531 const auto it{mempool.GetIter(hash)};
532 if (!it) {
533 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
534 }
535
536 CTxMemPool::setEntries setDescendants;
537 mempool.CalculateDescendants(*it, setDescendants);
538 // CTxMemPool::CalculateDescendants will include the given tx
539 setDescendants.erase(*it);
540
541 if (!fVerbose) {
543 for (CTxMemPool::txiter descendantIt : setDescendants) {
544 o.push_back(descendantIt->GetTx().GetHash().ToString());
545 }
546
547 return o;
548 } else {
550 for (CTxMemPool::txiter descendantIt : setDescendants) {
551 const CTxMemPoolEntry &e = *descendantIt;
552 const uint256& _hash = e.GetTx().GetHash();
554 entryToJSON(mempool, info, e);
555 o.pushKV(_hash.ToString(), std::move(info));
556 }
557 return o;
558 }
559},
560 };
561}
562
564{
565 return RPCHelpMan{
566 "getmempoolentry",
567 "Returns mempool data for given transaction\n",
568 {
569 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
570 },
571 RPCResult{
574 HelpExampleCli("getmempoolentry", "\"mytxid\"")
575 + HelpExampleRpc("getmempoolentry", "\"mytxid\"")
576 },
577 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
578{
579 uint256 hash = ParseHashV(request.params[0], "parameter 1");
580
581 const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
582 LOCK(mempool.cs);
583
584 const auto entry{mempool.GetEntry(Txid::FromUint256(hash))};
585 if (entry == nullptr) {
586 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
587 }
588
590 entryToJSON(mempool, info, *entry);
591 return info;
592},
593 };
594}
595
597{
598 return RPCHelpMan{"gettxspendingprevout",
599 "Scans the mempool to find transactions spending any of the given outputs",
600 {
601 {"outputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The transaction outputs that we want to check, and within each, the txid (string) vout (numeric).",
602 {
604 {
605 {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
606 {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
607 },
608 },
609 },
610 },
611 },
612 RPCResult{
613 RPCResult::Type::ARR, "", "",
614 {
615 {RPCResult::Type::OBJ, "", "",
616 {
617 {RPCResult::Type::STR_HEX, "txid", "the transaction id of the checked output"},
618 {RPCResult::Type::NUM, "vout", "the vout value of the checked output"},
619 {RPCResult::Type::STR_HEX, "spendingtxid", /*optional=*/true, "the transaction id of the mempool transaction spending this output (omitted if unspent)"},
620 }},
621 }
622 },
624 HelpExampleCli("gettxspendingprevout", "\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
625 + HelpExampleRpc("gettxspendingprevout", "\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
626 },
627 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
628 {
629 const UniValue& output_params = request.params[0].get_array();
630 if (output_params.empty()) {
631 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, outputs are missing");
632 }
633
634 std::vector<COutPoint> prevouts;
635 prevouts.reserve(output_params.size());
636
637 for (unsigned int idx = 0; idx < output_params.size(); idx++) {
638 const UniValue& o = output_params[idx].get_obj();
639
641 {
642 {"txid", UniValueType(UniValue::VSTR)},
643 {"vout", UniValueType(UniValue::VNUM)},
644 }, /*fAllowNull=*/false, /*fStrict=*/true);
645
646 const Txid txid = Txid::FromUint256(ParseHashO(o, "txid"));
647 const int nOutput{o.find_value("vout").getInt<int>()};
648 if (nOutput < 0) {
649 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
650 }
651
652 prevouts.emplace_back(txid, nOutput);
653 }
654
655 const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
656 LOCK(mempool.cs);
657
658 UniValue result{UniValue::VARR};
659
660 for (const COutPoint& prevout : prevouts) {
662 o.pushKV("txid", prevout.hash.ToString());
663 o.pushKV("vout", (uint64_t)prevout.n);
664
665 const CTransaction* spendingTx = mempool.GetConflictTx(prevout);
666 if (spendingTx != nullptr) {
667 o.pushKV("spendingtxid", spendingTx->GetHash().ToString());
668 }
669
670 result.push_back(std::move(o));
671 }
672
673 return result;
674 },
675 };
676}
677
679{
680 // Make sure this call is atomic in the pool.
681 LOCK(pool.cs);
683 ret.pushKV("loaded", pool.GetLoadTried());
684 ret.pushKV("size", (int64_t)pool.size());
685 ret.pushKV("bytes", (int64_t)pool.GetTotalTxSize());
686 ret.pushKV("usage", (int64_t)pool.DynamicMemoryUsage());
687 ret.pushKV("total_fee", ValueFromAmount(pool.GetTotalFee()));
688 ret.pushKV("maxmempool", pool.m_opts.max_size_bytes);
689 ret.pushKV("mempoolminfee", ValueFromAmount(std::max(pool.GetMinFee(), pool.m_opts.min_relay_feerate).GetFeePerK()));
690 ret.pushKV("minrelaytxfee", ValueFromAmount(pool.m_opts.min_relay_feerate.GetFeePerK()));
691 ret.pushKV("incrementalrelayfee", ValueFromAmount(pool.m_opts.incremental_relay_feerate.GetFeePerK()));
692 ret.pushKV("unbroadcastcount", uint64_t{pool.GetUnbroadcastTxs().size()});
693 ret.pushKV("fullrbf", true);
694 return ret;
695}
696
698{
699 return RPCHelpMan{"getmempoolinfo",
700 "Returns details on the active state of the TX memory pool.",
701 {},
702 RPCResult{
703 RPCResult::Type::OBJ, "", "",
704 {
705 {RPCResult::Type::BOOL, "loaded", "True if the initial load attempt of the persisted mempool finished"},
706 {RPCResult::Type::NUM, "size", "Current tx count"},
707 {RPCResult::Type::NUM, "bytes", "Sum of all virtual transaction sizes as defined in BIP 141. Differs from actual serialized size because witness data is discounted"},
708 {RPCResult::Type::NUM, "usage", "Total memory usage for the mempool"},
709 {RPCResult::Type::STR_AMOUNT, "total_fee", "Total fees for the mempool in " + CURRENCY_UNIT + ", ignoring modified fees through prioritisetransaction"},
710 {RPCResult::Type::NUM, "maxmempool", "Maximum memory usage for the mempool"},
711 {RPCResult::Type::STR_AMOUNT, "mempoolminfee", "Minimum fee rate in " + CURRENCY_UNIT + "/kvB for tx to be accepted. Is the maximum of minrelaytxfee and minimum mempool fee"},
712 {RPCResult::Type::STR_AMOUNT, "minrelaytxfee", "Current minimum relay fee for transactions"},
713 {RPCResult::Type::NUM, "incrementalrelayfee", "minimum fee rate increment for mempool limiting or replacement in " + CURRENCY_UNIT + "/kvB"},
714 {RPCResult::Type::NUM, "unbroadcastcount", "Current number of transactions that haven't passed initial broadcast yet"},
715 {RPCResult::Type::BOOL, "fullrbf", "True if the mempool accepts RBF without replaceability signaling inspection (DEPRECATED)"},
716 }},
718 HelpExampleCli("getmempoolinfo", "")
719 + HelpExampleRpc("getmempoolinfo", "")
720 },
721 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
722{
723 return MempoolInfoToJSON(EnsureAnyMemPool(request.context));
724},
725 };
726}
727
729{
730 return RPCHelpMan{
731 "importmempool",
732 "Import a mempool.dat file and attempt to add its contents to the mempool.\n"
733 "Warning: Importing untrusted files is dangerous, especially if metadata from the file is taken over.",
734 {
735 {"filepath", RPCArg::Type::STR, RPCArg::Optional::NO, "The mempool file"},
736 {"options",
739 "",
740 {
741 {"use_current_time", RPCArg::Type::BOOL, RPCArg::Default{true},
742 "Whether to use the current system time or use the entry time metadata from the mempool file.\n"
743 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
744 {"apply_fee_delta_priority", RPCArg::Type::BOOL, RPCArg::Default{false},
745 "Whether to apply the fee delta metadata from the mempool file.\n"
746 "It will be added to any existing fee deltas.\n"
747 "The fee delta can be set by the prioritisetransaction RPC.\n"
748 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior.\n"
749 "Only set this bool if you understand what it does."},
750 {"apply_unbroadcast_set", RPCArg::Type::BOOL, RPCArg::Default{false},
751 "Whether to apply the unbroadcast set metadata from the mempool file.\n"
752 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
753 },
754 RPCArgOptions{.oneline_description = "options"}},
755 },
756 RPCResult{RPCResult::Type::OBJ, "", "", std::vector<RPCResult>{}},
757 RPCExamples{HelpExampleCli("importmempool", "/path/to/mempool.dat") + HelpExampleRpc("importmempool", "/path/to/mempool.dat")},
758 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
759 const NodeContext& node{EnsureAnyNodeContext(request.context)};
760
761 CTxMemPool& mempool{EnsureMemPool(node)};
763 Chainstate& chainstate = chainman.ActiveChainstate();
764
765 if (chainman.IsInitialBlockDownload()) {
766 throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Can only import the mempool after the block download and sync is done.");
767 }
768
769 const fs::path load_path{fs::u8path(request.params[0].get_str())};
770 const UniValue& use_current_time{request.params[1]["use_current_time"]};
771 const UniValue& apply_fee_delta{request.params[1]["apply_fee_delta_priority"]};
772 const UniValue& apply_unbroadcast{request.params[1]["apply_unbroadcast_set"]};
774 .use_current_time = use_current_time.isNull() ? true : use_current_time.get_bool(),
775 .apply_fee_delta_priority = apply_fee_delta.isNull() ? false : apply_fee_delta.get_bool(),
776 .apply_unbroadcast_set = apply_unbroadcast.isNull() ? false : apply_unbroadcast.get_bool(),
777 };
778
779 if (!node::LoadMempool(mempool, load_path, chainstate, std::move(opts))) {
780 throw JSONRPCError(RPC_MISC_ERROR, "Unable to import mempool file, see debug.log for details.");
781 }
782
784 return ret;
785 },
786 };
787}
788
790{
791 return RPCHelpMan{
792 "savemempool",
793 "Dumps the mempool to disk. It will fail until the previous dump is fully loaded.\n",
794 {},
795 RPCResult{
796 RPCResult::Type::OBJ, "", "",
797 {
798 {RPCResult::Type::STR, "filename", "the directory and file where the mempool was saved"},
799 }},
801 HelpExampleCli("savemempool", "")
802 + HelpExampleRpc("savemempool", "")
803 },
804 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
805{
806 const ArgsManager& args{EnsureAnyArgsman(request.context)};
807 const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
808
809 if (!mempool.GetLoadTried()) {
810 throw JSONRPCError(RPC_MISC_ERROR, "The mempool was not loaded yet");
811 }
812
813 const fs::path& dump_path = MempoolPath(args);
814
815 if (!DumpMempool(mempool, dump_path)) {
816 throw JSONRPCError(RPC_MISC_ERROR, "Unable to dump mempool to disk");
817 }
818
820 ret.pushKV("filename", dump_path.utf8string());
821
822 return ret;
823},
824 };
825}
826
827static std::vector<RPCResult> OrphanDescription()
828{
829 return {
830 RPCResult{RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
831 RPCResult{RPCResult::Type::STR_HEX, "wtxid", "The transaction witness hash in hex"},
832 RPCResult{RPCResult::Type::NUM, "bytes", "The serialized transaction size in bytes"},
833 RPCResult{RPCResult::Type::NUM, "vsize", "The virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted."},
834 RPCResult{RPCResult::Type::NUM, "weight", "The transaction weight as defined in BIP 141."},
835 RPCResult{RPCResult::Type::NUM_TIME, "entry", "The entry time into the orphanage expressed in " + UNIX_EPOCH_TIME},
836 RPCResult{RPCResult::Type::NUM_TIME, "expiration", "The orphan expiration time expressed in " + UNIX_EPOCH_TIME},
838 {
839 RPCResult{RPCResult::Type::NUM, "peer_id", "Peer ID"},
840 }},
841 };
842}
843
845{
847 o.pushKV("txid", orphan.tx->GetHash().ToString());
848 o.pushKV("wtxid", orphan.tx->GetWitnessHash().ToString());
849 o.pushKV("bytes", orphan.tx->GetTotalSize());
850 o.pushKV("vsize", GetVirtualTransactionSize(*orphan.tx));
851 o.pushKV("weight", GetTransactionWeight(*orphan.tx));
852 o.pushKV("entry", int64_t{TicksSinceEpoch<std::chrono::seconds>(orphan.nTimeExpire - ORPHAN_TX_EXPIRE_TIME)});
853 o.pushKV("expiration", int64_t{TicksSinceEpoch<std::chrono::seconds>(orphan.nTimeExpire)});
855 for (const auto fromPeer: orphan.announcers) {
856 from.push_back(fromPeer);
857 }
858 o.pushKV("from", from);
859 return o;
860}
861
863{
864 return RPCHelpMan{
865 "getorphantxs",
866 "Shows transactions in the tx orphanage.\n"
867 "\nEXPERIMENTAL warning: this call may be changed in future releases.\n",
868 {
869 {"verbosity", RPCArg::Type::NUM, RPCArg::Default{0}, "0 for an array of txids (may contain duplicates), 1 for an array of objects with tx details, and 2 for details from (1) and tx hex",
871 },
872 {
873 RPCResult{"for verbose = 0",
874 RPCResult::Type::ARR, "", "",
875 {
876 {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
877 }},
878 RPCResult{"for verbose = 1",
879 RPCResult::Type::ARR, "", "",
880 {
882 }},
883 RPCResult{"for verbose = 2",
884 RPCResult::Type::ARR, "", "",
885 {
886 {RPCResult::Type::OBJ, "", "",
887 Cat<std::vector<RPCResult>>(
889 {{RPCResult::Type::STR_HEX, "hex", "The serialized, hex-encoded transaction data"}}
890 )
891 },
892 }},
893 },
895 HelpExampleCli("getorphantxs", "2")
896 + HelpExampleRpc("getorphantxs", "2")
897 },
898 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
899 {
900 const NodeContext& node = EnsureAnyNodeContext(request.context);
901 PeerManager& peerman = EnsurePeerman(node);
902 std::vector<TxOrphanage::OrphanTxBase> orphanage = peerman.GetOrphanTransactions();
903
904 int verbosity{ParseVerbosity(request.params[0], /*default_verbosity=*/0, /*allow_bool*/false)};
905
907
908 if (verbosity == 0) {
909 for (auto const& orphan : orphanage) {
910 ret.push_back(orphan.tx->GetHash().ToString());
911 }
912 } else if (verbosity == 1) {
913 for (auto const& orphan : orphanage) {
914 ret.push_back(OrphanToJSON(orphan));
915 }
916 } else if (verbosity == 2) {
917 for (auto const& orphan : orphanage) {
918 UniValue o{OrphanToJSON(orphan)};
919 o.pushKV("hex", EncodeHexTx(*orphan.tx));
920 ret.push_back(o);
921 }
922 } else {
923 throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid verbosity value " + ToString(verbosity));
924 }
925
926 return ret;
927 },
928 };
929}
930
932{
933 return RPCHelpMan{"submitpackage",
934 "Submit a package of raw transactions (serialized, hex-encoded) to local node.\n"
935 "The package will be validated according to consensus and mempool policy rules. If any transaction passes, it will be accepted to mempool.\n"
936 "This RPC is experimental and the interface may be unstable. Refer to doc/policy/packages.md for documentation on package policies.\n"
937 "Warning: successful submission does not mean the transactions will propagate throughout the network.\n"
938 ,
939 {
940 {"package", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of raw transactions.\n"
941 "The package must solely consist of a child transaction and all of its unconfirmed parents, if any. None of the parents may depend on each other.\n"
942 "The package must be topologically sorted, with the child being the last element in the array.",
943 {
945 },
946 },
948 "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT +
949 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
951 "Reject transactions with provably unspendable outputs (e.g. 'datacarrier' outputs that use the OP_RETURN opcode) greater than the specified value, expressed in " + CURRENCY_UNIT + ".\n"
952 "If burning funds through unspendable outputs is desired, increase this value.\n"
953 "This check is based on heuristics and does not guarantee spendability of outputs.\n"
954 },
955 },
956 RPCResult{
957 RPCResult::Type::OBJ, "", "",
958 {
959 {RPCResult::Type::STR, "package_msg", "The transaction package result message. \"success\" indicates all transactions were accepted into or are already in the mempool."},
960 {RPCResult::Type::OBJ_DYN, "tx-results", "transaction results keyed by wtxid",
961 {
962 {RPCResult::Type::OBJ, "wtxid", "transaction wtxid", {
963 {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
964 {RPCResult::Type::STR_HEX, "other-wtxid", /*optional=*/true, "The wtxid of a different transaction with the same txid but different witness found in the mempool. This means the submitted transaction was ignored."},
965 {RPCResult::Type::NUM, "vsize", /*optional=*/true, "Sigops-adjusted virtual transaction size."},
966 {RPCResult::Type::OBJ, "fees", /*optional=*/true, "Transaction fees", {
967 {RPCResult::Type::STR_AMOUNT, "base", "transaction fee in " + CURRENCY_UNIT},
968 {RPCResult::Type::STR_AMOUNT, "effective-feerate", /*optional=*/true, "if the transaction was not already in the mempool, the effective feerate in " + CURRENCY_UNIT + " per KvB. For example, the package feerate and/or feerate with modified fees from prioritisetransaction."},
969 {RPCResult::Type::ARR, "effective-includes", /*optional=*/true, "if effective-feerate is provided, the wtxids of the transactions whose fees and vsizes are included in effective-feerate.",
970 {{RPCResult::Type::STR_HEX, "", "transaction wtxid in hex"},
971 }},
972 }},
973 {RPCResult::Type::STR, "error", /*optional=*/true, "The transaction error string, if it was rejected by the mempool"},
974 }}
975 }},
976 {RPCResult::Type::ARR, "replaced-transactions", /*optional=*/true, "List of txids of replaced transactions",
977 {
978 {RPCResult::Type::STR_HEX, "", "The transaction id"},
979 }},
980 },
981 },
983 HelpExampleRpc("submitpackage", R"(["raw-parent-tx-1", "raw-parent-tx-2", "raw-child-tx"])") +
984 HelpExampleCli("submitpackage", R"('["raw-tx-without-unconfirmed-parents"]')")
985 },
986 [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
987 {
988 const UniValue raw_transactions = request.params[0].get_array();
989 if (raw_transactions.empty() || raw_transactions.size() > MAX_PACKAGE_COUNT) {
991 "Array must contain between 1 and " + ToString(MAX_PACKAGE_COUNT) + " transactions.");
992 }
993
994 // Fee check needs to be run with chainstate and package context
995 const CFeeRate max_raw_tx_fee_rate{ParseFeeRate(self.Arg<UniValue>("maxfeerate"))};
996 std::optional<CFeeRate> client_maxfeerate{max_raw_tx_fee_rate};
997 // 0-value is special; it's mapped to no sanity check
998 if (max_raw_tx_fee_rate == CFeeRate(0)) {
999 client_maxfeerate = std::nullopt;
1000 }
1001
1002 // Burn sanity check is run with no context
1003 const CAmount max_burn_amount = request.params[2].isNull() ? 0 : AmountFromValue(request.params[2]);
1004
1005 std::vector<CTransactionRef> txns;
1006 txns.reserve(raw_transactions.size());
1007 for (const auto& rawtx : raw_transactions.getValues()) {
1009 if (!DecodeHexTx(mtx, rawtx.get_str())) {
1011 "TX decode failed: " + rawtx.get_str() + " Make sure the tx has at least one input.");
1012 }
1013
1014 for (const auto& out : mtx.vout) {
1015 if((out.scriptPubKey.IsUnspendable() || !out.scriptPubKey.HasValidOps()) && out.nValue > max_burn_amount) {
1016 throw JSONRPCTransactionError(TransactionError::MAX_BURN_EXCEEDED);
1017 }
1018 }
1019
1020 txns.emplace_back(MakeTransactionRef(std::move(mtx)));
1021 }
1022 CHECK_NONFATAL(!txns.empty());
1023 if (txns.size() > 1 && !IsChildWithParentsTree(txns)) {
1024 throw JSONRPCTransactionError(TransactionError::INVALID_PACKAGE, "package topology disallowed. not child-with-parents or parents depend on each other.");
1025 }
1026
1027 NodeContext& node = EnsureAnyNodeContext(request.context);
1028 CTxMemPool& mempool = EnsureMemPool(node);
1030 const auto package_result = WITH_LOCK(::cs_main, return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/ false, client_maxfeerate));
1031
1032 std::string package_msg = "success";
1033
1034 // First catch package-wide errors, continue if we can
1035 switch(package_result.m_state.GetResult()) {
1037 {
1038 // Belt-and-suspenders check; everything should be successful here
1039 CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size());
1040 for (const auto& tx : txns) {
1041 CHECK_NONFATAL(mempool.exists(GenTxid::Txid(tx->GetHash())));
1042 }
1043 break;
1044 }
1046 {
1047 // This only happens with internal bug; user should stop and report
1048 throw JSONRPCTransactionError(TransactionError::MEMPOOL_ERROR,
1049 package_result.m_state.GetRejectReason());
1050 }
1053 {
1054 // Package-wide error we want to return, but we also want to return individual responses
1055 package_msg = package_result.m_state.ToString();
1056 CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size() ||
1057 package_result.m_tx_results.empty());
1058 break;
1059 }
1060 }
1061
1062 size_t num_broadcast{0};
1063 for (const auto& tx : txns) {
1064 // We don't want to re-submit the txn for validation in BroadcastTransaction
1065 if (!mempool.exists(GenTxid::Txid(tx->GetHash()))) {
1066 continue;
1067 }
1068
1069 // We do not expect an error here; we are only broadcasting things already/still in mempool
1070 std::string err_string;
1071 const auto err = BroadcastTransaction(node, tx, err_string, /*max_tx_fee=*/0, /*relay=*/true, /*wait_callback=*/true);
1072 if (err != TransactionError::OK) {
1073 throw JSONRPCTransactionError(err,
1074 strprintf("transaction broadcast failed: %s (%d transactions were broadcast successfully)",
1075 err_string, num_broadcast));
1076 }
1077 num_broadcast++;
1078 }
1079
1080 UniValue rpc_result{UniValue::VOBJ};
1081 rpc_result.pushKV("package_msg", package_msg);
1082 UniValue tx_result_map{UniValue::VOBJ};
1083 std::set<uint256> replaced_txids;
1084 for (const auto& tx : txns) {
1085 UniValue result_inner{UniValue::VOBJ};
1086 result_inner.pushKV("txid", tx->GetHash().GetHex());
1087 auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
1088 if (it == package_result.m_tx_results.end()) {
1089 // No results, report error and continue
1090 result_inner.pushKV("error", "unevaluated");
1091 continue;
1092 }
1093 const auto& tx_result = it->second;
1094 switch(it->second.m_result_type) {
1096 result_inner.pushKV("other-wtxid", it->second.m_other_wtxid.value().GetHex());
1097 break;
1099 result_inner.pushKV("error", it->second.m_state.ToString());
1100 break;
1103 result_inner.pushKV("vsize", int64_t{it->second.m_vsize.value()});
1105 fees.pushKV("base", ValueFromAmount(it->second.m_base_fees.value()));
1106 if (tx_result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
1107 // Effective feerate is not provided for MEMPOOL_ENTRY transactions even
1108 // though modified fees is known, because it is unknown whether package
1109 // feerate was used when it was originally submitted.
1110 fees.pushKV("effective-feerate", ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
1111 UniValue effective_includes_res(UniValue::VARR);
1112 for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
1113 effective_includes_res.push_back(wtxid.ToString());
1114 }
1115 fees.pushKV("effective-includes", std::move(effective_includes_res));
1116 }
1117 result_inner.pushKV("fees", std::move(fees));
1118 for (const auto& ptx : it->second.m_replaced_transactions) {
1119 replaced_txids.insert(ptx->GetHash());
1120 }
1121 break;
1122 }
1123 tx_result_map.pushKV(tx->GetWitnessHash().GetHex(), std::move(result_inner));
1124 }
1125 rpc_result.pushKV("tx-results", std::move(tx_result_map));
1126 UniValue replaced_list(UniValue::VARR);
1127 for (const uint256& hash : replaced_txids) replaced_list.push_back(hash.ToString());
1128 rpc_result.pushKV("replaced-transactions", std::move(replaced_list));
1129 return rpc_result;
1130 },
1131 };
1132}
1133
1135{
1136 static const CRPCCommand commands[]{
1137 {"rawtransactions", &sendrawtransaction},
1138 {"rawtransactions", &testmempoolaccept},
1139 {"blockchain", &getmempoolancestors},
1140 {"blockchain", &getmempooldescendants},
1141 {"blockchain", &getmempoolentry},
1142 {"blockchain", &gettxspendingprevout},
1143 {"blockchain", &getmempoolinfo},
1144 {"blockchain", &getrawmempool},
1145 {"blockchain", &importmempool},
1146 {"blockchain", &savemempool},
1147 {"hidden", &getorphantxs},
1148 {"rawtransactions", &submitpackage},
1149 };
1150 for (const auto& c : commands) {
1151 t.appendCommand(c.name, &c);
1152 }
1153}
int64_t CAmount
Amount in satoshis (Can be negative)
Definition: amount.h:12
int ret
static CAmount AmountFromValue(const UniValue &value)
Definition: bitcoin-tx.cpp:554
ArgsManager & args
Definition: bitcoind.cpp:277
#define CHECK_NONFATAL(condition)
Identity function.
Definition: check.h:102
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
CAmount GetFeePerK() const
Return the fee in satoshis for a vsize of 1000 vbytes.
Definition: feerate.h:63
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:29
Txid hash
Definition: transaction.h:31
RPC command dispatcher.
Definition: server.h:127
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:296
const Txid & GetHash() const LIFETIMEBOUND
Definition: transaction.h:343
const std::vector< CTxIn > vin
Definition: transaction.h:306
An input of a transaction.
Definition: transaction.h:67
COutPoint prevout
Definition: transaction.h:69
CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool...
Definition: mempool_entry.h:66
const CTransaction & GetTx() const
const Children & GetMemPoolChildrenConst() const
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:304
setEntries AssumeCalculateMemPoolAncestors(std::string_view calling_fn_name, const CTxMemPoolEntry &entry, const Limits &limits, bool fSearchForParents=true) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Same as CalculateMemPoolAncestors, but always returns a (non-optional) setEntries.
Definition: txmempool.cpp:275
std::set< uint256 > GetUnbroadcastTxs() const
Returns transactions in unbroadcast set.
Definition: txmempool.h:687
bool GetLoadTried() const
Definition: txmempool.cpp:1236
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:390
CFeeRate GetMinFee(size_t sizelimit) const
Definition: txmempool.cpp:1126
std::optional< txiter > GetIter(const uint256 &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Returns an iterator to the given hash, if found.
Definition: txmempool.cpp:987
size_t DynamicMemoryUsage() const
Definition: txmempool.cpp:1063
const Options m_opts
Definition: txmempool.h:439
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:396
uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:705
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
Definition: txmempool.h:393
bool exists(const GenTxid &gtxid) const
Definition: txmempool.h:647
const CTransaction * GetConflictTx(const COutPoint &prevout) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Get the transaction in the pool that spends the same prevout.
Definition: txmempool.cpp:981
void CalculateDescendants(txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Populate setDescendants with all in-mempool descendants of hash.
Definition: txmempool.cpp:571
unsigned long size() const
Definition: txmempool.h:629
std::vector< CTxMemPoolEntryRef > entryAll() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:851
CAmount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:641
uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:635
const CTxMemPoolEntry * GetEntry(const Txid &txid) const LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.cpp:877
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:507
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:867
SnapshotCompletionResult MaybeCompleteSnapshotValidation() EXCLUSIVE_LOCKS_REQUIRED(const CBlockIndex *GetSnapshotBaseBlock() const EXCLUSIVE_LOCKS_REQUIRED(Chainstate ActiveChainstate)() const
Once the background validation chainstate has reached the height which is the base of the UTXO snapsh...
Definition: validation.h:1109
MempoolAcceptResult ProcessTransaction(const CTransactionRef &tx, bool test_accept=false) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
Try to add a transaction to the memory pool.
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
static GenTxid Txid(const uint256 &hash)
Definition: transaction.h:434
virtual std::vector< TxOrphanage::OrphanTxBase > GetOrphanTransactions()=0
const std::string m_name
Definition: util.h:492
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
Definition: util.h:440
void push_back(UniValue val)
Definition: univalue.cpp:104
const UniValue & find_value(std::string_view key) const
Definition: univalue.cpp:233
@ VOBJ
Definition: univalue.h:24
@ VSTR
Definition: univalue.h:24
@ VARR
Definition: univalue.h:24
@ VNUM
Definition: univalue.h:24
bool isNull() const
Definition: univalue.h:79
const UniValue & get_obj() const
size_t size() const
Definition: univalue.h:71
const std::vector< UniValue > & getValues() const
bool empty() const
Definition: univalue.h:69
void pushKVEnd(std::string key, UniValue val)
Definition: univalue.cpp:118
Int getInt() const
Definition: univalue.h:138
const UniValue & get_array() const
void pushKV(std::string key, UniValue val)
Definition: univalue.cpp:126
bool get_bool() const
std::string GetRejectReason() const
Definition: validation.h:109
Result GetResult() const
Definition: validation.h:108
std::string ToString() const
Definition: validation.h:111
std::string ToString() const
Definition: uint256.cpp:21
std::string ToString() const
static transaction_identifier FromUint256(const uint256 &id)
256-bit opaque blob.
Definition: uint256.h:196
static int32_t GetTransactionWeight(const CTransaction &tx)
Definition: validation.h:132
@ TX_MISSING_INPUTS
transaction was missing some of its inputs
std::string EncodeHexTx(const CTransaction &tx)
Definition: core_write.cpp:143
UniValue ValueFromAmount(const CAmount amount)
Definition: core_write.cpp:26
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
Definition: core_read.cpp:196
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
const std::string CURRENCY_UNIT
Definition: feerate.h:17
static path u8path(const std::string &utf8_str)
Definition: fs.h:75
uint64_t fee
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
Definition: moneystr.cpp:19
Definition: messages.h:20
static const CAmount DEFAULT_MAX_BURN_AMOUNT
Maximum burn value for sendrawtransaction, submitpackage, and testmempoolaccept RPC calls.
Definition: transaction.h:33
TransactionError
Definition: types.h:23
TransactionError BroadcastTransaction(NodeContext &node, const CTransactionRef tx, std::string &err_string, const CAmount &max_tx_fee, bool relay, bool wait_callback)
Submit a transaction to the mempool and (optionally) relay it to all P2P peers.
Definition: transaction.cpp:34
fs::path MempoolPath(const ArgsManager &argsman)
static const CFeeRate DEFAULT_MAX_RAW_TX_FEE_RATE
Maximum fee rate for sendrawtransaction and testmempoolaccept RPC calls.
Definition: transaction.h:27
bool LoadMempool(CTxMemPool &pool, const fs::path &load_path, Chainstate &active_chainstate, ImportMempoolOptions &&opts)
Import the file and attempt to add its contents to the mempool.
bool DumpMempool(const CTxMemPool &pool, const fs::path &dump_path, FopenFn mockable_fopen_function, bool skip_file_commit)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:233
is a home for public enum and struct type definitions that are used internally by node code,...
bool IsChildWithParentsTree(const Package &package)
Context-free check that a package IsChildWithParents() and none of the parents depend on each other (...
Definition: packages.cpp:136
static constexpr uint32_t MAX_PACKAGE_COUNT
Default maximum number of transactions in a package.
Definition: packages.h:19
@ PCKG_POLICY
The package itself is invalid (e.g. too many transactions).
@ PCKG_RESULT_UNSET
Initial value. The package has not yet been rejected.
@ PCKG_MEMPOOL_ERROR
Mempool logic error.
@ PCKG_TX
At least one tx is invalid.
RBFTransactionState IsRBFOptIn(const CTransaction &tx, const CTxMemPool &pool)
Determine whether an unconfirmed transaction is signaling opt-in to RBF according to BIP 125 This inv...
Definition: rbf.cpp:24
RBFTransactionState
The rbf state of unconfirmed transactions.
Definition: rbf.h:29
@ UNKNOWN
Unconfirmed tx that does not signal rbf and is not in the mempool.
@ REPLACEABLE_BIP125
Either this tx or a mempool ancestor signals rbf.
int64_t GetVirtualTransactionSize(int64_t nWeight, int64_t nSigOpCost, unsigned int bytes_per_sigop)
Compute the virtual transaction size (weight reinterpreted as bytes).
Definition: policy.cpp:310
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:424
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:423
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:70
static RPCHelpMan getmempoolinfo()
Definition: mempool.cpp:697
static RPCHelpMan sendrawtransaction()
Definition: mempool.cpp:42
static std::vector< RPCResult > OrphanDescription()
Definition: mempool.cpp:827
static void entryToJSON(const CTxMemPool &pool, UniValue &info, const CTxMemPoolEntry &e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
Definition: mempool.cpp:289
static RPCHelpMan importmempool()
Definition: mempool.cpp:728
static UniValue OrphanToJSON(const TxOrphanage::OrphanTxBase &orphan)
Definition: mempool.cpp:844
void RegisterMempoolRPCCommands(CRPCTable &t)
Definition: mempool.cpp:1134
static RPCHelpMan getrawmempool()
Definition: mempool.cpp:384
static RPCHelpMan getmempoolentry()
Definition: mempool.cpp:563
UniValue MempoolInfoToJSON(const CTxMemPool &pool)
Mempool information to JSON.
Definition: mempool.cpp:678
static RPCHelpMan gettxspendingprevout()
Definition: mempool.cpp:596
static std::vector< RPCResult > MempoolEntryDescription()
Definition: mempool.cpp:261
static RPCHelpMan submitpackage()
Definition: mempool.cpp:931
static RPCHelpMan getorphantxs()
Definition: mempool.cpp:862
UniValue MempoolToJSON(const CTxMemPool &pool, bool verbose, bool include_mempool_sequence)
Mempool to JSON.
Definition: mempool.cpp:346
static RPCHelpMan testmempoolaccept()
Definition: mempool.cpp:110
static RPCHelpMan getmempooldescendants()
Definition: mempool.cpp:497
static RPCHelpMan getmempoolancestors()
Definition: mempool.cpp:435
static RPCHelpMan savemempool()
Definition: mempool.cpp:789
@ RPC_MISC_ERROR
General application defined errors.
Definition: protocol.h:40
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:44
@ RPC_CLIENT_IN_INITIAL_DOWNLOAD
Still downloading initial blocks.
Definition: protocol.h:59
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
Definition: protocol.h:46
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
Definition: protocol.h:42
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:186
UniValue JSONRPCTransactionError(TransactionError terr, const std::string &err_string)
Definition: util.cpp:411
CFeeRate ParseFeeRate(const UniValue &json)
Parse a json number or string, denoting BTC/kvB, into a CFeeRate (sat/kvB).
Definition: util.cpp:113
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:204
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
Definition: util.cpp:46
int ParseVerbosity(const UniValue &arg, int default_verbosity, bool allow_bool)
Parses verbosity from provided UniValue.
Definition: util.cpp:86
uint256 ParseHashO(const UniValue &o, std::string_view strKey)
Definition: util.cpp:129
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
Definition: util.cpp:59
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
Definition: util.cpp:120
NodeContext & EnsureAnyNodeContext(const std::any &context)
Definition: server_util.cpp:25
CTxMemPool & EnsureMemPool(const NodeContext &node)
Definition: server_util.cpp:34
PeerManager & EnsurePeerman(const NodeContext &node)
ChainstateManager & EnsureChainman(const NodeContext &node)
Definition: server_util.cpp:74
CTxMemPool & EnsureAnyMemPool(const std::any &context)
Definition: server_util.cpp:42
ArgsManager & EnsureAnyArgsman(const std::any &context)
Definition: server_util.cpp:69
A mutable version of CTransaction.
Definition: transaction.h:378
std::vector< CTxOut > vout
Definition: transaction.h:380
@ DIFFERENT_WITNESS
‍Valid, transaction was already in the mempool.
@ INVALID
‍Fully validated, valid.
Validation result for package mempool acceptance.
Definition: validation.h:230
PackageValidationState m_state
Definition: validation.h:231
std::map< Wtxid, MempoolAcceptResult > m_tx_results
Map from wtxid to finished MempoolAcceptResults.
Definition: validation.h:238
@ STR_HEX
Special type that is a STR with only hex chars.
@ AMOUNT
Special type representing a floating point amount (can be either NUM or STR)
@ OBJ_NAMED_PARAMS
Special type that behaves almost exactly like OBJ, defining an options object with a list of pre-defi...
@ OMITTED
Optional argument for which the default value is omitted from help text for one of two reasons:
@ NO
Required arg.
std::string oneline_description
Should be empty unless it is supposed to override the auto-generated summary line.
Definition: util.h:167
bool skip_type_check
Definition: util.h:166
@ NUM_TIME
Special numeric to denote unix epoch time.
@ OBJ_DYN
Special dictionary with keys that are not literals.
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
Allows providing orphan information externally.
Definition: txorphanage.h:82
CTransactionRef tx
Definition: txorphanage.h:83
std::set< NodeId > announcers
Peers added with AddTx or AddAnnouncer.
Definition: txorphanage.h:85
Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type.
Definition: util.h:79
static constexpr MemPoolLimits NoLimits()
CFeeRate incremental_relay_feerate
CFeeRate min_relay_feerate
A fee rate smaller than this is considered zero fee (for relaying, mining and transaction creation)
NodeContext struct containing references to chain state and connection state.
Definition: context.h:56
#define AssertLockNotHeld(cs)
Definition: sync.h:147
#define LOCK(cs)
Definition: sync.h:257
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:302
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1172
static constexpr auto ORPHAN_TX_EXPIRE_TIME
Expiration time for orphan transactions.
Definition: txorphanage.h:19
constexpr int64_t count_seconds(std::chrono::seconds t)
Definition: time.h:82
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept, const std::optional< CFeeRate > &client_maxfeerate)
Validate (and maybe submit) a package to the mempool.
AssertLockHeld(pool.cs)