Bitcoin Core  25.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>
11 #include <core_io.h>
12 #include <kernel/mempool_entry.h>
14 #include <policy/rbf.h>
15 #include <policy/settings.h>
16 #include <primitives/transaction.h>
17 #include <rpc/server.h>
18 #include <rpc/server_util.h>
19 #include <rpc/util.h>
20 #include <txmempool.h>
21 #include <univalue.h>
22 #include <util/fs.h>
23 #include <util/moneystr.h>
24 #include <util/time.h>
25 
26 #include <utility>
27 
29 
31 using node::MempoolPath;
32 using node::NodeContext;
33 
35 {
36  return RPCHelpMan{"sendrawtransaction",
37  "\nSubmit a raw transaction (serialized, hex-encoded) to local node and network.\n"
38  "\nThe transaction will be sent unconditionally to all peers, so using sendrawtransaction\n"
39  "for manual rebroadcast may degrade privacy by leaking the transaction's origin, as\n"
40  "nodes will normally not rebroadcast non-wallet transactions already in their mempool.\n"
41  "\nA specific exception, RPC_TRANSACTION_ALREADY_IN_CHAIN, may throw if the transaction cannot be added to the mempool.\n"
42  "\nRelated RPCs: createrawtransaction, signrawtransactionwithkey\n",
43  {
44  {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex string of the raw transaction"},
46  "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT +
47  "/kvB.\nSet to 0 to accept any fee rate."},
48  {"maxburnamount", RPCArg::Type::AMOUNT, RPCArg::Default{FormatMoney(0)},
49  "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"
50  "If burning funds through unspendable outputs is desired, increase this value.\n"
51  "This check is based on heuristics and does not guarantee spendability of outputs.\n"},
52  },
53  RPCResult{
54  RPCResult::Type::STR_HEX, "", "The transaction hash in hex"
55  },
57  "\nCreate a transaction\n"
58  + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
59  "Sign the transaction, and get back the hex\n"
60  + HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
61  "\nSend the transaction (signed hex)\n"
62  + HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
63  "\nAs a JSON-RPC call\n"
64  + HelpExampleRpc("sendrawtransaction", "\"signedhex\"")
65  },
66  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
67  {
68  const CAmount max_burn_amount = request.params[2].isNull() ? 0 : AmountFromValue(request.params[2]);
69 
71  if (!DecodeHexTx(mtx, request.params[0].get_str())) {
72  throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed. Make sure the tx has at least one input.");
73  }
74 
75  for (const auto& out : mtx.vout) {
76  if((out.scriptPubKey.IsUnspendable() || !out.scriptPubKey.HasValidOps()) && out.nValue > max_burn_amount) {
78  }
79  }
80 
81  CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
82 
83  const CFeeRate max_raw_tx_fee_rate = request.params[1].isNull() ?
85  CFeeRate(AmountFromValue(request.params[1]));
86 
87  int64_t virtual_size = GetVirtualTransactionSize(*tx);
88  CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
89 
90  std::string err_string;
92  NodeContext& node = EnsureAnyNodeContext(request.context);
93  const TransactionError err = BroadcastTransaction(node, tx, err_string, max_raw_tx_fee, /*relay=*/true, /*wait_callback=*/true);
94  if (TransactionError::OK != err) {
95  throw JSONRPCTransactionError(err, err_string);
96  }
97 
98  return tx->GetHash().GetHex();
99  },
100  };
101 }
102 
104 {
105  return RPCHelpMan{"testmempoolaccept",
106  "\nReturns result of mempool acceptance tests indicating if raw transaction(s) (serialized, hex-encoded) would be accepted by mempool.\n"
107  "\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"
108  "\nIf one transaction fails, other transactions may not be fully validated (the 'allowed' key will be blank).\n"
109  "\nThe maximum number of transactions allowed is " + ToString(MAX_PACKAGE_COUNT) + ".\n"
110  "\nThis checks if transactions violate the consensus or policy rules.\n"
111  "\nSee sendrawtransaction call.\n",
112  {
113  {"rawtxs", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of hex strings of raw transactions.",
114  {
116  },
117  },
119  "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT + "/kvB\n"},
120  },
121  RPCResult{
122  RPCResult::Type::ARR, "", "The result of the mempool acceptance test for each raw transaction in the input array.\n"
123  "Returns results for each transaction in the same order they were passed in.\n"
124  "Transactions that cannot be fully validated due to failures in other transactions will not contain an 'allowed' result.\n",
125  {
126  {RPCResult::Type::OBJ, "", "",
127  {
128  {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
129  {RPCResult::Type::STR_HEX, "wtxid", "The transaction witness hash in hex"},
130  {RPCResult::Type::STR, "package-error", /*optional=*/true, "Package validation error, if any (only possible if rawtxs had more than 1 transaction)."},
131  {RPCResult::Type::BOOL, "allowed", /*optional=*/true, "Whether this tx would be accepted to the mempool and pass client-specified maxfeerate. "
132  "If not present, the tx was not fully validated due to a failure in another tx in the list."},
133  {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)"},
134  {RPCResult::Type::OBJ, "fees", /*optional=*/true, "Transaction fees (only present if 'allowed' is true)",
135  {
136  {RPCResult::Type::STR_AMOUNT, "base", "transaction fee in " + CURRENCY_UNIT},
137  {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."},
138  {RPCResult::Type::ARR, "effective-includes", /*optional=*/false, "transactions whose fees and vsizes are included in effective-feerate.",
139  {RPCResult{RPCResult::Type::STR_HEX, "", "transaction wtxid in hex"},
140  }},
141  }},
142  {RPCResult::Type::STR, "reject-reason", /*optional=*/true, "Rejection string (only present when 'allowed' is false)"},
143  }},
144  }
145  },
146  RPCExamples{
147  "\nCreate a transaction\n"
148  + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
149  "Sign the transaction, and get back the hex\n"
150  + HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
151  "\nTest acceptance of the transaction (signed hex)\n"
152  + HelpExampleCli("testmempoolaccept", R"('["signedhex"]')") +
153  "\nAs a JSON-RPC call\n"
154  + HelpExampleRpc("testmempoolaccept", "[\"signedhex\"]")
155  },
156  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
157  {
158  const UniValue raw_transactions = request.params[0].get_array();
159  if (raw_transactions.size() < 1 || raw_transactions.size() > MAX_PACKAGE_COUNT) {
161  "Array must contain between 1 and " + ToString(MAX_PACKAGE_COUNT) + " transactions.");
162  }
163 
164  const CFeeRate max_raw_tx_fee_rate = request.params[1].isNull() ?
166  CFeeRate(AmountFromValue(request.params[1]));
167 
168  std::vector<CTransactionRef> txns;
169  txns.reserve(raw_transactions.size());
170  for (const auto& rawtx : raw_transactions.getValues()) {
172  if (!DecodeHexTx(mtx, rawtx.get_str())) {
174  "TX decode failed: " + rawtx.get_str() + " Make sure the tx has at least one input.");
175  }
176  txns.emplace_back(MakeTransactionRef(std::move(mtx)));
177  }
178 
179  NodeContext& node = EnsureAnyNodeContext(request.context);
180  CTxMemPool& mempool = EnsureMemPool(node);
182  Chainstate& chainstate = chainman.ActiveChainstate();
183  const PackageMempoolAcceptResult package_result = [&] {
184  LOCK(::cs_main);
185  if (txns.size() > 1) return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/true);
186  return PackageMempoolAcceptResult(txns[0]->GetWitnessHash(),
187  chainman.ProcessTransaction(txns[0], /*test_accept=*/true));
188  }();
189 
190  UniValue rpc_result(UniValue::VARR);
191  // We will check transaction fees while we iterate through txns in order. If any transaction fee
192  // exceeds maxfeerate, we will leave the rest of the validation results blank, because it
193  // doesn't make sense to return a validation result for a transaction if its ancestor(s) would
194  // not be submitted.
195  bool exit_early{false};
196  for (const auto& tx : txns) {
197  UniValue result_inner(UniValue::VOBJ);
198  result_inner.pushKV("txid", tx->GetHash().GetHex());
199  result_inner.pushKV("wtxid", tx->GetWitnessHash().GetHex());
200  if (package_result.m_state.GetResult() == PackageValidationResult::PCKG_POLICY) {
201  result_inner.pushKV("package-error", package_result.m_state.GetRejectReason());
202  }
203  auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
204  if (exit_early || it == package_result.m_tx_results.end()) {
205  // Validation unfinished. Just return the txid and wtxid.
206  rpc_result.push_back(result_inner);
207  continue;
208  }
209  const auto& tx_result = it->second;
210  // Package testmempoolaccept doesn't allow transactions to already be in the mempool.
212  if (tx_result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
213  const CAmount fee = tx_result.m_base_fees.value();
214  // Check that fee does not exceed maximum fee
215  const int64_t virtual_size = tx_result.m_vsize.value();
216  const CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
217  if (max_raw_tx_fee && fee > max_raw_tx_fee) {
218  result_inner.pushKV("allowed", false);
219  result_inner.pushKV("reject-reason", "max-fee-exceeded");
220  exit_early = true;
221  } else {
222  // Only return the fee and vsize if the transaction would pass ATMP.
223  // These can be used to calculate the feerate.
224  result_inner.pushKV("allowed", true);
225  result_inner.pushKV("vsize", virtual_size);
226  UniValue fees(UniValue::VOBJ);
227  fees.pushKV("base", ValueFromAmount(fee));
228  fees.pushKV("effective-feerate", ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
229  UniValue effective_includes_res(UniValue::VARR);
230  for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
231  effective_includes_res.push_back(wtxid.ToString());
232  }
233  fees.pushKV("effective-includes", effective_includes_res);
234  result_inner.pushKV("fees", fees);
235  }
236  } else {
237  result_inner.pushKV("allowed", false);
238  const TxValidationState state = tx_result.m_state;
240  result_inner.pushKV("reject-reason", "missing-inputs");
241  } else {
242  result_inner.pushKV("reject-reason", state.GetRejectReason());
243  }
244  }
245  rpc_result.push_back(result_inner);
246  }
247  return rpc_result;
248  },
249  };
250 }
251 
252 static std::vector<RPCResult> MempoolEntryDescription()
253 {
254  return {
255  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."},
256  RPCResult{RPCResult::Type::NUM, "weight", "transaction weight as defined in BIP 141."},
257  RPCResult{RPCResult::Type::NUM_TIME, "time", "local time transaction entered pool in seconds since 1 Jan 1970 GMT"},
258  RPCResult{RPCResult::Type::NUM, "height", "block height when transaction entered pool"},
259  RPCResult{RPCResult::Type::NUM, "descendantcount", "number of in-mempool descendant transactions (including this one)"},
260  RPCResult{RPCResult::Type::NUM, "descendantsize", "virtual transaction size of in-mempool descendants (including this one)"},
261  RPCResult{RPCResult::Type::NUM, "ancestorcount", "number of in-mempool ancestor transactions (including this one)"},
262  RPCResult{RPCResult::Type::NUM, "ancestorsize", "virtual transaction size of in-mempool ancestors (including this one)"},
263  RPCResult{RPCResult::Type::STR_HEX, "wtxid", "hash of serialized transaction, including witness data"},
264  RPCResult{RPCResult::Type::OBJ, "fees", "",
265  {
266  RPCResult{RPCResult::Type::STR_AMOUNT, "base", "transaction fee, denominated in " + CURRENCY_UNIT},
267  RPCResult{RPCResult::Type::STR_AMOUNT, "modified", "transaction fee with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
268  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},
269  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},
270  }},
271  RPCResult{RPCResult::Type::ARR, "depends", "unconfirmed transactions used as inputs for this transaction",
272  {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "parent transaction id"}}},
273  RPCResult{RPCResult::Type::ARR, "spentby", "unconfirmed transactions spending outputs from this transaction",
274  {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "child transaction id"}}},
275  RPCResult{RPCResult::Type::BOOL, "bip125-replaceable", "Whether this transaction signals BIP125 replaceability or has an unconfirmed ancestor signaling BIP125 replaceability.\n"},
276  RPCResult{RPCResult::Type::BOOL, "unbroadcast", "Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)"},
277  };
278 }
279 
280 static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPoolEntry& e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
281 {
282  AssertLockHeld(pool.cs);
283 
284  info.pushKV("vsize", (int)e.GetTxSize());
285  info.pushKV("weight", (int)e.GetTxWeight());
286  info.pushKV("time", count_seconds(e.GetTime()));
287  info.pushKV("height", (int)e.GetHeight());
288  info.pushKV("descendantcount", e.GetCountWithDescendants());
289  info.pushKV("descendantsize", e.GetSizeWithDescendants());
290  info.pushKV("ancestorcount", e.GetCountWithAncestors());
291  info.pushKV("ancestorsize", e.GetSizeWithAncestors());
292  info.pushKV("wtxid", pool.vTxHashes[e.vTxHashesIdx].first.ToString());
293 
294  UniValue fees(UniValue::VOBJ);
295  fees.pushKV("base", ValueFromAmount(e.GetFee()));
296  fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
297  fees.pushKV("ancestor", ValueFromAmount(e.GetModFeesWithAncestors()));
298  fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants()));
299  info.pushKV("fees", fees);
300 
301  const CTransaction& tx = e.GetTx();
302  std::set<std::string> setDepends;
303  for (const CTxIn& txin : tx.vin)
304  {
305  if (pool.exists(GenTxid::Txid(txin.prevout.hash)))
306  setDepends.insert(txin.prevout.hash.ToString());
307  }
308 
309  UniValue depends(UniValue::VARR);
310  for (const std::string& dep : setDepends)
311  {
312  depends.push_back(dep);
313  }
314 
315  info.pushKV("depends", depends);
316 
317  UniValue spent(UniValue::VARR);
318  const CTxMemPool::txiter& it = pool.mapTx.find(tx.GetHash());
319  const CTxMemPoolEntry::Children& children = it->GetMemPoolChildrenConst();
320  for (const CTxMemPoolEntry& child : children) {
321  spent.push_back(child.GetTx().GetHash().ToString());
322  }
323 
324  info.pushKV("spentby", spent);
325 
326  // Add opt-in RBF status
327  bool rbfStatus = false;
328  RBFTransactionState rbfState = IsRBFOptIn(tx, pool);
329  if (rbfState == RBFTransactionState::UNKNOWN) {
330  throw JSONRPCError(RPC_MISC_ERROR, "Transaction is not in mempool");
331  } else if (rbfState == RBFTransactionState::REPLACEABLE_BIP125) {
332  rbfStatus = true;
333  }
334 
335  info.pushKV("bip125-replaceable", rbfStatus);
336  info.pushKV("unbroadcast", pool.IsUnbroadcastTx(tx.GetHash()));
337 }
338 
339 UniValue MempoolToJSON(const CTxMemPool& pool, bool verbose, bool include_mempool_sequence)
340 {
341  if (verbose) {
342  if (include_mempool_sequence) {
343  throw JSONRPCError(RPC_INVALID_PARAMETER, "Verbose results cannot contain mempool sequence values.");
344  }
345  LOCK(pool.cs);
347  for (const CTxMemPoolEntry& e : pool.mapTx) {
348  const uint256& hash = e.GetTx().GetHash();
349  UniValue info(UniValue::VOBJ);
350  entryToJSON(pool, info, e);
351  // Mempool has unique entries so there is no advantage in using
352  // UniValue::pushKV, which checks if the key already exists in O(N).
353  // UniValue::pushKVEnd is used instead which currently is O(1).
354  o.pushKVEnd(hash.ToString(), info);
355  }
356  return o;
357  } else {
358  uint64_t mempool_sequence;
359  std::vector<uint256> vtxid;
360  {
361  LOCK(pool.cs);
362  pool.queryHashes(vtxid);
363  mempool_sequence = pool.GetSequence();
364  }
366  for (const uint256& hash : vtxid)
367  a.push_back(hash.ToString());
368 
369  if (!include_mempool_sequence) {
370  return a;
371  } else {
373  o.pushKV("txids", a);
374  o.pushKV("mempool_sequence", mempool_sequence);
375  return o;
376  }
377  }
378 }
379 
381 {
382  return RPCHelpMan{"getrawmempool",
383  "\nReturns all transaction ids in memory pool as a json array of string transaction ids.\n"
384  "\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n",
385  {
386  {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
387  {"mempool_sequence", RPCArg::Type::BOOL, RPCArg::Default{false}, "If verbose=false, returns a json object with transaction list and mempool sequence number attached."},
388  },
389  {
390  RPCResult{"for verbose = false",
391  RPCResult::Type::ARR, "", "",
392  {
393  {RPCResult::Type::STR_HEX, "", "The transaction id"},
394  }},
395  RPCResult{"for verbose = true",
396  RPCResult::Type::OBJ_DYN, "", "",
397  {
398  {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
399  }},
400  RPCResult{"for verbose = false and mempool_sequence = true",
401  RPCResult::Type::OBJ, "", "",
402  {
403  {RPCResult::Type::ARR, "txids", "",
404  {
405  {RPCResult::Type::STR_HEX, "", "The transaction id"},
406  }},
407  {RPCResult::Type::NUM, "mempool_sequence", "The mempool sequence value."},
408  }},
409  },
410  RPCExamples{
411  HelpExampleCli("getrawmempool", "true")
412  + HelpExampleRpc("getrawmempool", "true")
413  },
414  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
415 {
416  bool fVerbose = false;
417  if (!request.params[0].isNull())
418  fVerbose = request.params[0].get_bool();
419 
420  bool include_mempool_sequence = false;
421  if (!request.params[1].isNull()) {
422  include_mempool_sequence = request.params[1].get_bool();
423  }
424 
425  return MempoolToJSON(EnsureAnyMemPool(request.context), fVerbose, include_mempool_sequence);
426 },
427  };
428 }
429 
431 {
432  return RPCHelpMan{"getmempoolancestors",
433  "\nIf txid is in the mempool, returns all in-mempool ancestors.\n",
434  {
435  {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
436  {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
437  },
438  {
439  RPCResult{"for verbose = false",
440  RPCResult::Type::ARR, "", "",
441  {{RPCResult::Type::STR_HEX, "", "The transaction id of an in-mempool ancestor transaction"}}},
442  RPCResult{"for verbose = true",
443  RPCResult::Type::OBJ_DYN, "", "",
444  {
445  {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
446  }},
447  },
448  RPCExamples{
449  HelpExampleCli("getmempoolancestors", "\"mytxid\"")
450  + HelpExampleRpc("getmempoolancestors", "\"mytxid\"")
451  },
452  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
453 {
454  bool fVerbose = false;
455  if (!request.params[1].isNull())
456  fVerbose = request.params[1].get_bool();
457 
458  uint256 hash = ParseHashV(request.params[0], "parameter 1");
459 
460  const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
461  LOCK(mempool.cs);
462 
463  CTxMemPool::txiter it = mempool.mapTx.find(hash);
464  if (it == mempool.mapTx.end()) {
465  throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
466  }
467 
468  auto ancestors{mempool.AssumeCalculateMemPoolAncestors(__func__, *it, CTxMemPool::Limits::NoLimits(), /*fSearchForParents=*/false)};
469 
470  if (!fVerbose) {
472  for (CTxMemPool::txiter ancestorIt : ancestors) {
473  o.push_back(ancestorIt->GetTx().GetHash().ToString());
474  }
475  return o;
476  } else {
478  for (CTxMemPool::txiter ancestorIt : ancestors) {
479  const CTxMemPoolEntry &e = *ancestorIt;
480  const uint256& _hash = e.GetTx().GetHash();
481  UniValue info(UniValue::VOBJ);
482  entryToJSON(mempool, info, e);
483  o.pushKV(_hash.ToString(), info);
484  }
485  return o;
486  }
487 },
488  };
489 }
490 
492 {
493  return RPCHelpMan{"getmempooldescendants",
494  "\nIf txid is in the mempool, returns all in-mempool descendants.\n",
495  {
496  {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
497  {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
498  },
499  {
500  RPCResult{"for verbose = false",
501  RPCResult::Type::ARR, "", "",
502  {{RPCResult::Type::STR_HEX, "", "The transaction id of an in-mempool descendant transaction"}}},
503  RPCResult{"for verbose = true",
504  RPCResult::Type::OBJ_DYN, "", "",
505  {
506  {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
507  }},
508  },
509  RPCExamples{
510  HelpExampleCli("getmempooldescendants", "\"mytxid\"")
511  + HelpExampleRpc("getmempooldescendants", "\"mytxid\"")
512  },
513  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
514 {
515  bool fVerbose = false;
516  if (!request.params[1].isNull())
517  fVerbose = request.params[1].get_bool();
518 
519  uint256 hash = ParseHashV(request.params[0], "parameter 1");
520 
521  const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
522  LOCK(mempool.cs);
523 
524  CTxMemPool::txiter it = mempool.mapTx.find(hash);
525  if (it == mempool.mapTx.end()) {
526  throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
527  }
528 
529  CTxMemPool::setEntries setDescendants;
530  mempool.CalculateDescendants(it, setDescendants);
531  // CTxMemPool::CalculateDescendants will include the given tx
532  setDescendants.erase(it);
533 
534  if (!fVerbose) {
536  for (CTxMemPool::txiter descendantIt : setDescendants) {
537  o.push_back(descendantIt->GetTx().GetHash().ToString());
538  }
539 
540  return o;
541  } else {
543  for (CTxMemPool::txiter descendantIt : setDescendants) {
544  const CTxMemPoolEntry &e = *descendantIt;
545  const uint256& _hash = e.GetTx().GetHash();
546  UniValue info(UniValue::VOBJ);
547  entryToJSON(mempool, info, e);
548  o.pushKV(_hash.ToString(), info);
549  }
550  return o;
551  }
552 },
553  };
554 }
555 
557 {
558  return RPCHelpMan{"getmempoolentry",
559  "\nReturns mempool data for given transaction\n",
560  {
561  {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
562  },
563  RPCResult{
565  RPCExamples{
566  HelpExampleCli("getmempoolentry", "\"mytxid\"")
567  + HelpExampleRpc("getmempoolentry", "\"mytxid\"")
568  },
569  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
570 {
571  uint256 hash = ParseHashV(request.params[0], "parameter 1");
572 
573  const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
574  LOCK(mempool.cs);
575 
576  CTxMemPool::txiter it = mempool.mapTx.find(hash);
577  if (it == mempool.mapTx.end()) {
578  throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
579  }
580 
581  const CTxMemPoolEntry &e = *it;
582  UniValue info(UniValue::VOBJ);
583  entryToJSON(mempool, info, e);
584  return info;
585 },
586  };
587 }
588 
590 {
591  return RPCHelpMan{"gettxspendingprevout",
592  "Scans the mempool to find transactions spending any of the given outputs",
593  {
594  {"outputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The transaction outputs that we want to check, and within each, the txid (string) vout (numeric).",
595  {
597  {
598  {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
599  {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
600  },
601  },
602  },
603  },
604  },
605  RPCResult{
606  RPCResult::Type::ARR, "", "",
607  {
608  {RPCResult::Type::OBJ, "", "",
609  {
610  {RPCResult::Type::STR_HEX, "txid", "the transaction id of the checked output"},
611  {RPCResult::Type::NUM, "vout", "the vout value of the checked output"},
612  {RPCResult::Type::STR_HEX, "spendingtxid", /*optional=*/true, "the transaction id of the mempool transaction spending this output (omitted if unspent)"},
613  }},
614  }
615  },
616  RPCExamples{
617  HelpExampleCli("gettxspendingprevout", "\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
618  + HelpExampleRpc("gettxspendingprevout", "\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
619  },
620  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
621  {
622  const UniValue& output_params = request.params[0].get_array();
623  if (output_params.empty()) {
624  throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, outputs are missing");
625  }
626 
627  std::vector<COutPoint> prevouts;
628  prevouts.reserve(output_params.size());
629 
630  for (unsigned int idx = 0; idx < output_params.size(); idx++) {
631  const UniValue& o = output_params[idx].get_obj();
632 
633  RPCTypeCheckObj(o,
634  {
635  {"txid", UniValueType(UniValue::VSTR)},
636  {"vout", UniValueType(UniValue::VNUM)},
637  }, /*fAllowNull=*/false, /*fStrict=*/true);
638 
639  const uint256 txid(ParseHashO(o, "txid"));
640  const int nOutput{o.find_value("vout").getInt<int>()};
641  if (nOutput < 0) {
642  throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
643  }
644 
645  prevouts.emplace_back(txid, nOutput);
646  }
647 
648  const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
649  LOCK(mempool.cs);
650 
651  UniValue result{UniValue::VARR};
652 
653  for (const COutPoint& prevout : prevouts) {
655  o.pushKV("txid", prevout.hash.ToString());
656  o.pushKV("vout", (uint64_t)prevout.n);
657 
658  const CTransaction* spendingTx = mempool.GetConflictTx(prevout);
659  if (spendingTx != nullptr) {
660  o.pushKV("spendingtxid", spendingTx->GetHash().ToString());
661  }
662 
663  result.push_back(o);
664  }
665 
666  return result;
667  },
668  };
669 }
670 
672 {
673  // Make sure this call is atomic in the pool.
674  LOCK(pool.cs);
676  ret.pushKV("loaded", pool.GetLoadTried());
677  ret.pushKV("size", (int64_t)pool.size());
678  ret.pushKV("bytes", (int64_t)pool.GetTotalTxSize());
679  ret.pushKV("usage", (int64_t)pool.DynamicMemoryUsage());
680  ret.pushKV("total_fee", ValueFromAmount(pool.GetTotalFee()));
681  ret.pushKV("maxmempool", pool.m_max_size_bytes);
682  ret.pushKV("mempoolminfee", ValueFromAmount(std::max(pool.GetMinFee(), pool.m_min_relay_feerate).GetFeePerK()));
683  ret.pushKV("minrelaytxfee", ValueFromAmount(pool.m_min_relay_feerate.GetFeePerK()));
684  ret.pushKV("incrementalrelayfee", ValueFromAmount(pool.m_incremental_relay_feerate.GetFeePerK()));
685  ret.pushKV("unbroadcastcount", uint64_t{pool.GetUnbroadcastTxs().size()});
686  ret.pushKV("fullrbf", pool.m_full_rbf);
687  return ret;
688 }
689 
691 {
692  return RPCHelpMan{"getmempoolinfo",
693  "Returns details on the active state of the TX memory pool.",
694  {},
695  RPCResult{
696  RPCResult::Type::OBJ, "", "",
697  {
698  {RPCResult::Type::BOOL, "loaded", "True if the initial load attempt of the persisted mempool finished"},
699  {RPCResult::Type::NUM, "size", "Current tx count"},
700  {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"},
701  {RPCResult::Type::NUM, "usage", "Total memory usage for the mempool"},
702  {RPCResult::Type::STR_AMOUNT, "total_fee", "Total fees for the mempool in " + CURRENCY_UNIT + ", ignoring modified fees through prioritisetransaction"},
703  {RPCResult::Type::NUM, "maxmempool", "Maximum memory usage for the mempool"},
704  {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"},
705  {RPCResult::Type::STR_AMOUNT, "minrelaytxfee", "Current minimum relay fee for transactions"},
706  {RPCResult::Type::NUM, "incrementalrelayfee", "minimum fee rate increment for mempool limiting or replacement in " + CURRENCY_UNIT + "/kvB"},
707  {RPCResult::Type::NUM, "unbroadcastcount", "Current number of transactions that haven't passed initial broadcast yet"},
708  {RPCResult::Type::BOOL, "fullrbf", "True if the mempool accepts RBF without replaceability signaling inspection"},
709  }},
710  RPCExamples{
711  HelpExampleCli("getmempoolinfo", "")
712  + HelpExampleRpc("getmempoolinfo", "")
713  },
714  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
715 {
716  return MempoolInfoToJSON(EnsureAnyMemPool(request.context));
717 },
718  };
719 }
720 
722 {
723  return RPCHelpMan{
724  "importmempool",
725  "Import a mempool.dat file and attempt to add its contents to the mempool.\n"
726  "Warning: Importing untrusted files is dangerous, especially if metadata from the file is taken over.",
727  {
728  {"filepath", RPCArg::Type::STR, RPCArg::Optional::NO, "The mempool file"},
729  {"options",
732  "",
733  {
734  {"use_current_time", RPCArg::Type::BOOL, RPCArg::Default{true},
735  "Whether to use the current system time or use the entry time metadata from the mempool file.\n"
736  "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
737  {"apply_fee_delta_priority", RPCArg::Type::BOOL, RPCArg::Default{false},
738  "Whether to apply the fee delta metadata from the mempool file.\n"
739  "It will be added to any existing fee deltas.\n"
740  "The fee delta can be set by the prioritisetransaction RPC.\n"
741  "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior.\n"
742  "Only set this bool if you understand what it does."},
743  {"apply_unbroadcast_set", RPCArg::Type::BOOL, RPCArg::Default{false},
744  "Whether to apply the unbroadcast set metadata from the mempool file.\n"
745  "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
746  },
747  RPCArgOptions{.oneline_description = "options"}},
748  },
749  RPCResult{RPCResult::Type::OBJ, "", "", std::vector<RPCResult>{}},
750  RPCExamples{HelpExampleCli("importmempool", "/path/to/mempool.dat") + HelpExampleRpc("importmempool", "/path/to/mempool.dat")},
751  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
752  const NodeContext& node{EnsureAnyNodeContext(request.context)};
753 
754  CTxMemPool& mempool{EnsureMemPool(node)};
756  Chainstate& chainstate = chainman.ActiveChainstate();
757 
758  if (chainman.IsInitialBlockDownload()) {
759  throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Can only import the mempool after the block download and sync is done.");
760  }
761 
762  const fs::path load_path{fs::u8path(request.params[0].get_str())};
763  const UniValue& use_current_time{request.params[1]["use_current_time"]};
764  const UniValue& apply_fee_delta{request.params[1]["apply_fee_delta_priority"]};
765  const UniValue& apply_unbroadcast{request.params[1]["apply_unbroadcast_set"]};
767  .use_current_time = use_current_time.isNull() ? true : use_current_time.get_bool(),
768  .apply_fee_delta_priority = apply_fee_delta.isNull() ? false : apply_fee_delta.get_bool(),
769  .apply_unbroadcast_set = apply_unbroadcast.isNull() ? false : apply_unbroadcast.get_bool(),
770  };
771 
772  if (!kernel::LoadMempool(mempool, load_path, chainstate, std::move(opts))) {
773  throw JSONRPCError(RPC_MISC_ERROR, "Unable to import mempool file, see debug.log for details.");
774  }
775 
777  return ret;
778  },
779  };
780 }
781 
783 {
784  return RPCHelpMan{"savemempool",
785  "\nDumps the mempool to disk. It will fail until the previous dump is fully loaded.\n",
786  {},
787  RPCResult{
788  RPCResult::Type::OBJ, "", "",
789  {
790  {RPCResult::Type::STR, "filename", "the directory and file where the mempool was saved"},
791  }},
792  RPCExamples{
793  HelpExampleCli("savemempool", "")
794  + HelpExampleRpc("savemempool", "")
795  },
796  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
797 {
798  const ArgsManager& args{EnsureAnyArgsman(request.context)};
799  const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
800 
801  if (!mempool.GetLoadTried()) {
802  throw JSONRPCError(RPC_MISC_ERROR, "The mempool was not loaded yet");
803  }
804 
805  const fs::path& dump_path = MempoolPath(args);
806 
807  if (!DumpMempool(mempool, dump_path)) {
808  throw JSONRPCError(RPC_MISC_ERROR, "Unable to dump mempool to disk");
809  }
810 
812  ret.pushKV("filename", dump_path.u8string());
813 
814  return ret;
815 },
816  };
817 }
818 
820 {
821  return RPCHelpMan{"submitpackage",
822  "Submit a package of raw transactions (serialized, hex-encoded) to local node (-regtest only).\n"
823  "The package will be validated according to consensus and mempool policy rules. If all transactions pass, they will be accepted to mempool.\n"
824  "This RPC is experimental and the interface may be unstable. Refer to doc/policy/packages.md for documentation on package policies.\n"
825  "Warning: until package relay is in use, successful submission does not mean the transaction will propagate to other nodes on the network.\n"
826  "Currently, each transaction is broadcasted individually after submission, which means they must meet other nodes' feerate requirements alone.\n"
827  ,
828  {
829  {"package", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of raw transactions.",
830  {
832  },
833  },
834  },
835  RPCResult{
836  RPCResult::Type::OBJ, "", "",
837  {
838  {RPCResult::Type::OBJ_DYN, "tx-results", "transaction results keyed by wtxid",
839  {
840  {RPCResult::Type::OBJ, "wtxid", "transaction wtxid", {
841  {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
842  {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."},
843  {RPCResult::Type::NUM, "vsize", "Virtual transaction size as defined in BIP 141."},
844  {RPCResult::Type::OBJ, "fees", "Transaction fees", {
845  {RPCResult::Type::STR_AMOUNT, "base", "transaction fee in " + CURRENCY_UNIT},
846  {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."},
847  {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.",
848  {{RPCResult::Type::STR_HEX, "", "transaction wtxid in hex"},
849  }},
850  }},
851  }}
852  }},
853  {RPCResult::Type::ARR, "replaced-transactions", /*optional=*/true, "List of txids of replaced transactions",
854  {
855  {RPCResult::Type::STR_HEX, "", "The transaction id"},
856  }},
857  },
858  },
859  RPCExamples{
860  HelpExampleCli("testmempoolaccept", "[rawtx1, rawtx2]") +
861  HelpExampleCli("submitpackage", "[rawtx1, rawtx2]")
862  },
863  [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
864  {
866  throw std::runtime_error("submitpackage is for regression testing (-regtest mode) only");
867  }
868  const UniValue raw_transactions = request.params[0].get_array();
869  if (raw_transactions.size() < 1 || raw_transactions.size() > MAX_PACKAGE_COUNT) {
871  "Array must contain between 1 and " + ToString(MAX_PACKAGE_COUNT) + " transactions.");
872  }
873 
874  std::vector<CTransactionRef> txns;
875  txns.reserve(raw_transactions.size());
876  for (const auto& rawtx : raw_transactions.getValues()) {
878  if (!DecodeHexTx(mtx, rawtx.get_str())) {
880  "TX decode failed: " + rawtx.get_str() + " Make sure the tx has at least one input.");
881  }
882  txns.emplace_back(MakeTransactionRef(std::move(mtx)));
883  }
884 
885  NodeContext& node = EnsureAnyNodeContext(request.context);
886  CTxMemPool& mempool = EnsureMemPool(node);
887  Chainstate& chainstate = EnsureChainman(node).ActiveChainstate();
888  const auto package_result = WITH_LOCK(::cs_main, return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/ false));
889 
890  // First catch any errors.
891  switch(package_result.m_state.GetResult()) {
894  {
896  package_result.m_state.GetRejectReason());
897  }
899  {
901  package_result.m_state.GetRejectReason());
902  }
904  {
905  for (const auto& tx : txns) {
906  auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
907  if (it != package_result.m_tx_results.end() && it->second.m_state.IsInvalid()) {
909  strprintf("%s failed: %s", tx->GetHash().ToString(), it->second.m_state.GetRejectReason()));
910  }
911  }
912  // If a PCKG_TX error was returned, there must have been an invalid transaction.
914  }
915  }
916  size_t num_broadcast{0};
917  for (const auto& tx : txns) {
918  std::string err_string;
919  const auto err = BroadcastTransaction(node, tx, err_string, /*max_tx_fee=*/0, /*relay=*/true, /*wait_callback=*/true);
920  if (err != TransactionError::OK) {
921  throw JSONRPCTransactionError(err,
922  strprintf("transaction broadcast failed: %s (all transactions were submitted, %d transactions were broadcast successfully)",
923  err_string, num_broadcast));
924  }
925  num_broadcast++;
926  }
927  UniValue rpc_result{UniValue::VOBJ};
928  UniValue tx_result_map{UniValue::VOBJ};
929  std::set<uint256> replaced_txids;
930  for (const auto& tx : txns) {
931  auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
932  CHECK_NONFATAL(it != package_result.m_tx_results.end());
933  UniValue result_inner{UniValue::VOBJ};
934  result_inner.pushKV("txid", tx->GetHash().GetHex());
935  const auto& tx_result = it->second;
936  if (it->second.m_result_type == MempoolAcceptResult::ResultType::DIFFERENT_WITNESS) {
937  result_inner.pushKV("other-wtxid", it->second.m_other_wtxid.value().GetHex());
938  }
939  if (it->second.m_result_type == MempoolAcceptResult::ResultType::VALID ||
940  it->second.m_result_type == MempoolAcceptResult::ResultType::MEMPOOL_ENTRY) {
941  result_inner.pushKV("vsize", int64_t{it->second.m_vsize.value()});
942  UniValue fees(UniValue::VOBJ);
943  fees.pushKV("base", ValueFromAmount(it->second.m_base_fees.value()));
944  if (tx_result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
945  // Effective feerate is not provided for MEMPOOL_ENTRY transactions even
946  // though modified fees is known, because it is unknown whether package
947  // feerate was used when it was originally submitted.
948  fees.pushKV("effective-feerate", ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
949  UniValue effective_includes_res(UniValue::VARR);
950  for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
951  effective_includes_res.push_back(wtxid.ToString());
952  }
953  fees.pushKV("effective-includes", effective_includes_res);
954  }
955  result_inner.pushKV("fees", fees);
956  if (it->second.m_replaced_transactions.has_value()) {
957  for (const auto& ptx : it->second.m_replaced_transactions.value()) {
958  replaced_txids.insert(ptx->GetHash());
959  }
960  }
961  }
962  tx_result_map.pushKV(tx->GetWitnessHash().GetHex(), result_inner);
963  }
964  rpc_result.pushKV("tx-results", tx_result_map);
965  UniValue replaced_list(UniValue::VARR);
966  for (const uint256& hash : replaced_txids) replaced_list.push_back(hash.ToString());
967  rpc_result.pushKV("replaced-transactions", replaced_list);
968  return rpc_result;
969  },
970  };
971 }
972 
974 {
975  static const CRPCCommand commands[]{
976  {"rawtransactions", &sendrawtransaction},
977  {"rawtransactions", &testmempoolaccept},
978  {"blockchain", &getmempoolancestors},
979  {"blockchain", &getmempooldescendants},
980  {"blockchain", &getmempoolentry},
981  {"blockchain", &gettxspendingprevout},
982  {"blockchain", &getmempoolinfo},
983  {"blockchain", &getrawmempool},
984  {"blockchain", &importmempool},
985  {"blockchain", &savemempool},
986  {"hidden", &submitpackage},
987  };
988  for (const auto& c : commands) {
989  t.appendCommand(c.name, &c);
990  }
991 }
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:553
ArgsManager & args
Definition: bitcoind.cpp:269
const CChainParams & Params()
Return the currently selected parameters.
#define CHECK_NONFATAL(condition)
Identity function.
Definition: check.h:46
#define NONFATAL_UNREACHABLE()
NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code.
Definition: check.h:90
ChainType GetChainType() const
Return the chain type.
Definition: chainparams.h:109
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
Definition: feerate.h:33
CAmount GetFee(uint32_t num_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
Definition: feerate.cpp:23
CAmount GetFeePerK() const
Return the fee in satoshis for a vsize of 1000 vbytes.
Definition: feerate.h:65
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:36
uint256 hash
Definition: transaction.h:38
RPC command dispatcher.
Definition: server.h:135
The basic transaction that is broadcasted on the network and contained in blocks.
Definition: transaction.h:295
const uint256 & GetHash() const
Definition: transaction.h:337
const std::vector< CTxIn > vin
Definition: transaction.h:305
An input of a transaction.
Definition: transaction.h:75
COutPoint prevout
Definition: transaction.h:77
CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool...
Definition: mempool_entry.h:66
const CTransaction & GetTx() const
std::set< CTxMemPoolEntryRef, CompareIteratorByHash > Children
Definition: mempool_entry.h:71
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:302
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
bool GetLoadTried() const
Definition: txmempool.cpp:1210
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
Definition: txmempool.h:391
CFeeRate GetMinFee(size_t sizelimit) const
Definition: txmempool.cpp:1101
const bool m_full_rbf
Definition: txmempool.h:448
const int64_t m_max_size_bytes
Definition: txmempool.h:440
size_t DynamicMemoryUsage() const
Definition: txmempool.cpp:1033
std::set< txiter, CompareIteratorByHash > setEntries
Definition: txmempool.h:397
std::set< uint256 > GetUnbroadcastTxs() const
Returns transactions in unbroadcast set.
Definition: txmempool.h:715
void queryHashes(std::vector< uint256 > &vtxid) const
Definition: txmempool.cpp:822
const CFeeRate m_min_relay_feerate
Definition: txmempool.h:443
uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:733
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
Definition: txmempool.h:394
const CFeeRate m_incremental_relay_feerate
Definition: txmempool.h:442
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:950
void CalculateDescendants(txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Populate setDescendants with all in-mempool descendants of hash.
Definition: txmempool.cpp:544
unsigned long size() const
Definition: txmempool.h:660
CAmount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:672
uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs)
Definition: txmempool.h:666
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Definition: validation.h:466
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:818
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:432
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:23
@ VSTR
Definition: univalue.h:23
@ VARR
Definition: univalue.h:23
@ VNUM
Definition: univalue.h:23
bool isNull() const
Definition: univalue.h:78
const UniValue & get_obj() const
size_t size() const
Definition: univalue.h:70
const std::vector< UniValue > & getValues() const
bool empty() const
Definition: univalue.h:68
void pushKVEnd(std::string key, UniValue val)
Definition: univalue.cpp:118
Int getInt() const
Definition: univalue.h:137
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:125
Result GetResult() const
Definition: validation.h:124
std::string ToString() const
Definition: uint256.cpp:55
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Definition: fs.h:31
std::string u8string() const
Definition: fs.h:55
256-bit opaque blob.
Definition: uint256.h:106
@ TX_MISSING_INPUTS
transaction was missing some of its inputs
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:195
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:8
TransactionError
Definition: error.h:22
const std::string CURRENCY_UNIT
Definition: feerate.h:17
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
Definition: moneystr.cpp:16
static path u8path(const std::string &utf8_str)
Definition: fs.h:70
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)
Definition: init.h:25
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:33
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
static constexpr uint32_t MAX_PACKAGE_COUNT
Default maximum number of transactions in a package.
Definition: packages.h:17
@ 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:21
RBFTransactionState
The rbf state of unconfirmed transactions.
Definition: rbf.h:27
@ 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:295
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition: transaction.h:422
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:421
UniValue JSONRPCError(int code, const std::string &message)
Definition: request.cpp:58
static RPCHelpMan getmempoolinfo()
Definition: mempool.cpp:690
static RPCHelpMan sendrawtransaction()
Definition: mempool.cpp:34
static void entryToJSON(const CTxMemPool &pool, UniValue &info, const CTxMemPoolEntry &e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
Definition: mempool.cpp:280
static RPCHelpMan importmempool()
Definition: mempool.cpp:721
static std::vector< RPCResult > MempoolEntryDescription()
Definition: mempool.cpp:252
void RegisterMempoolRPCCommands(CRPCTable &t)
Definition: mempool.cpp:973
static RPCHelpMan getrawmempool()
Definition: mempool.cpp:380
static RPCHelpMan getmempoolentry()
Definition: mempool.cpp:556
UniValue MempoolInfoToJSON(const CTxMemPool &pool)
Mempool information to JSON.
Definition: mempool.cpp:671
static RPCHelpMan gettxspendingprevout()
Definition: mempool.cpp:589
static RPCHelpMan submitpackage()
Definition: mempool.cpp:819
UniValue MempoolToJSON(const CTxMemPool &pool, bool verbose, bool include_mempool_sequence)
Mempool to JSON.
Definition: mempool.cpp:339
static RPCHelpMan testmempoolaccept()
Definition: mempool.cpp:103
static RPCHelpMan getmempooldescendants()
Definition: mempool.cpp:491
static RPCHelpMan getmempoolancestors()
Definition: mempool.cpp:430
static RPCHelpMan savemempool()
Definition: mempool.cpp:782
@ RPC_MISC_ERROR
General application defined errors.
Definition: protocol.h:39
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
Definition: protocol.h:43
@ 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:45
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
Definition: protocol.h:41
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
Definition: util.cpp:143
UniValue JSONRPCTransactionError(TransactionError terr, const std::string &err_string)
Definition: util.cpp:368
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
Definition: util.cpp:161
uint256 ParseHashO(const UniValue &o, std::string strKey)
Definition: util.cpp:86
uint256 ParseHashV(const UniValue &v, std::string strName)
Utilities: convert hex-encoded Values (throws error if not hex).
Definition: util.cpp:77
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
Definition: util.cpp:38
ArgsManager & EnsureAnyArgsman(const std::any &context)
Definition: server_util.cpp:65
CTxMemPool & EnsureAnyMemPool(const std::any &context)
Definition: server_util.cpp:38
NodeContext & EnsureAnyNodeContext(const std::any &context)
Definition: server_util.cpp:21
CTxMemPool & EnsureMemPool(const NodeContext &node)
Definition: server_util.cpp:30
ChainstateManager & EnsureChainman(const NodeContext &node)
Definition: server_util.cpp:70
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:109
A mutable version of CTransaction.
Definition: transaction.h:380
std::vector< CTxOut > vout
Definition: transaction.h:382
@ DIFFERENT_WITNESS
Valid, transaction was already in the mempool.
Validation result for package mempool acceptance.
Definition: validation.h:212
PackageValidationState m_state
Definition: validation.h:213
std::map< uint256, MempoolAcceptResult > m_tx_results
Map from wtxid to finished MempoolAcceptResults.
Definition: validation.h:220
@ 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:150
@ 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.
Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type.
Definition: util.h:75
static constexpr MemPoolLimits NoLimits()
NodeContext struct containing references to chain state and connection state.
Definition: context.h:48
#define AssertLockNotHeld(cs)
Definition: sync.h:148
#define LOCK(cs)
Definition: sync.h:258
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:302
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:49
constexpr int64_t count_seconds(std::chrono::seconds t)
Definition: time.h:54
#define strprintf
Format arguments and return the string or write to given std::ostream (see tinyformat::format doc for...
Definition: tinyformat.h:1162
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept)
Validate (and maybe submit) a package to the mempool.
AssertLockHeld(pool.cs)