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