10#include <chainparams.h>
46 "Submit a raw transaction (serialized, hex-encoded) to local node and network.\n"
47 "\nThe transaction will be sent unconditionally to all peers, so using sendrawtransaction\n"
48 "for manual rebroadcast may degrade privacy by leaking the transaction's origin, as\n"
49 "nodes will normally not rebroadcast non-wallet transactions already in their mempool.\n"
50 "\nA specific exception, RPC_TRANSACTION_ALREADY_IN_UTXO_SET, may throw if the transaction cannot be added to the mempool.\n"
51 "\nRelated RPCs: createrawtransaction, signrawtransactionwithkey\n",
55 "Reject transactions whose fee rate is higher than the specified value, expressed in " +
CURRENCY_UNIT +
56 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
58 "Reject transactions with provably unspendable outputs (e.g. 'datacarrier' outputs that use the OP_RETURN opcode) greater than the specified value, expressed in " +
CURRENCY_UNIT +
".\n"
59 "If burning funds through unspendable outputs is desired, increase this value.\n"
60 "This check is based on heuristics and does not guarantee spendability of outputs.\n"},
66 "\nCreate a transaction\n"
67 +
HelpExampleCli(
"createrawtransaction",
"\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
68 "Sign the transaction, and get back the hex\n"
70 "\nSend the transaction (signed hex)\n"
72 "\nAs a JSON-RPC call\n"
80 if (!
DecodeHexTx(mtx, request.params[0].get_str())) {
84 for (
const auto&
out : mtx.
vout) {
85 if((
out.scriptPubKey.IsUnspendable() || !
out.scriptPubKey.HasValidOps()) &&
out.nValue > max_burn_amount) {
95 CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
97 std::string err_string;
101 if (TransactionError::OK != err) {
105 return tx->GetHash().GetHex();
114 "Returns result of mempool acceptance tests indicating if raw transaction(s) (serialized, hex-encoded) would be accepted by mempool.\n"
115 "\nIf multiple transactions are passed in, parents must come before children and package policies apply: the transactions cannot conflict with any mempool transactions or each other.\n"
116 "\nIf one transaction fails, other transactions may not be fully validated (the 'allowed' key will be blank).\n"
118 "\nThis checks if transactions violate the consensus or policy rules.\n"
119 "\nSee sendrawtransaction call.\n",
127 "Reject transactions whose fee rate is higher than the specified value, expressed in " +
CURRENCY_UNIT +
128 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
131 RPCResult::Type::ARR,
"",
"The result of the mempool acceptance test for each raw transaction in the input array.\n"
132 "Returns results for each transaction in the same order they were passed in.\n"
133 "Transactions that cannot be fully validated due to failures in other transactions will not contain an 'allowed' result.\n",
139 {
RPCResult::Type::STR,
"package-error",
true,
"Package validation error, if any (only possible if rawtxs had more than 1 transaction)."},
140 {
RPCResult::Type::BOOL,
"allowed",
true,
"Whether this tx would be accepted to the mempool and pass client-specified maxfeerate. "
141 "If not present, the tx was not fully validated due to a failure in another tx in the list."},
142 {
RPCResult::Type::NUM,
"vsize",
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)"},
146 {
RPCResult::Type::STR_AMOUNT,
"effective-feerate",
false,
"the effective feerate in " +
CURRENCY_UNIT +
" per KvB. May differ from the base feerate if, for example, there are modified fees from prioritisetransaction or a package feerate was used."},
147 {
RPCResult::Type::ARR,
"effective-includes",
false,
"transactions whose fees and vsizes are included in effective-feerate.",
151 {
RPCResult::Type::STR,
"reject-reason",
true,
"Rejection reason (only present when 'allowed' is false)"},
152 {
RPCResult::Type::STR,
"reject-details",
true,
"Rejection details (only present when 'allowed' is false and rejection details exist)"},
157 "\nCreate a transaction\n"
158 +
HelpExampleCli(
"createrawtransaction",
"\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
159 "Sign the transaction, and get back the hex\n"
161 "\nTest acceptance of the transaction (signed hex)\n"
163 "\nAs a JSON-RPC call\n"
176 std::vector<CTransactionRef> txns;
177 txns.reserve(raw_transactions.
size());
178 for (
const auto& rawtx : raw_transactions.
getValues()) {
182 "TX decode failed: " + rawtx.get_str() +
" Make sure the tx has at least one input.");
193 if (txns.size() > 1)
return ProcessNewPackage(chainstate, mempool, txns,
true, {});
203 bool exit_early{
false};
204 for (
const auto& tx : txns) {
206 result_inner.
pushKV(
"txid", tx->GetHash().GetHex());
207 result_inner.
pushKV(
"wtxid", tx->GetWitnessHash().GetHex());
211 auto it = package_result.
m_tx_results.find(tx->GetWitnessHash());
212 if (exit_early || it == package_result.
m_tx_results.end()) {
214 rpc_result.
push_back(std::move(result_inner));
217 const auto& tx_result = it->second;
221 const CAmount fee = tx_result.m_base_fees.value();
223 const int64_t virtual_size = tx_result.m_vsize.value();
224 const CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
225 if (max_raw_tx_fee &&
fee > max_raw_tx_fee) {
226 result_inner.
pushKV(
"allowed",
false);
227 result_inner.
pushKV(
"reject-reason",
"max-fee-exceeded");
232 result_inner.
pushKV(
"allowed",
true);
233 result_inner.
pushKV(
"vsize", virtual_size);
236 fees.
pushKV(
"effective-feerate",
ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
238 for (
const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
239 effective_includes_res.
push_back(wtxid.ToString());
241 fees.
pushKV(
"effective-includes", std::move(effective_includes_res));
242 result_inner.
pushKV(
"fees", std::move(fees));
245 result_inner.
pushKV(
"allowed",
false);
248 result_inner.
pushKV(
"reject-reason",
"missing-inputs");
254 rpc_result.
push_back(std::move(result_inner));
264 RPCResult{
RPCResult::Type::NUM,
"vsize",
"virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted."},
284 RPCResult{
RPCResult::Type::BOOL,
"bip125-replaceable",
"Whether this transaction signals BIP125 replaceability or has an unconfirmed ancestor signaling BIP125 replaceability. (DEPRECATED)\n"},
285 RPCResult{
RPCResult::Type::BOOL,
"unbroadcast",
"Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)"},
293 info.pushKV(
"vsize", (
int)e.GetTxSize());
294 info.pushKV(
"weight", (
int)e.GetTxWeight());
296 info.pushKV(
"height", (
int)e.GetHeight());
297 info.pushKV(
"descendantcount", e.GetCountWithDescendants());
298 info.pushKV(
"descendantsize", e.GetSizeWithDescendants());
299 info.pushKV(
"ancestorcount", e.GetCountWithAncestors());
300 info.pushKV(
"ancestorsize", e.GetSizeWithAncestors());
301 info.pushKV(
"wtxid", e.GetTx().GetWitnessHash().ToString());
308 info.pushKV(
"fees", std::move(fees));
311 std::set<std::string> setDepends;
319 for (
const std::string& dep : setDepends)
324 info.pushKV(
"depends", std::move(depends));
328 spent.
push_back(child.GetTx().GetHash().ToString());
331 info.pushKV(
"spentby", std::move(spent));
334 bool rbfStatus =
false;
342 info.pushKV(
"bip125-replaceable", rbfStatus);
343 info.pushKV(
"unbroadcast", pool.IsUnbroadcastTx(tx.
GetHash()));
349 if (include_mempool_sequence) {
360 o.
pushKVEnd(e.GetTx().GetHash().ToString(), std::move(info));
365 uint64_t mempool_sequence;
369 a.
push_back(e.GetTx().GetHash().ToString());
373 if (!include_mempool_sequence) {
377 o.
pushKV(
"txids", std::move(a));
378 o.
pushKV(
"mempool_sequence", mempool_sequence);
388 "Returns all transaction ids in memory pool as a json array of string transaction ids.\n"
389 "\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n",
392 {
"mempool_sequence",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"If verbose=false, returns a json object with transaction list and mempool sequence number attached."},
405 RPCResult{
"for verbose = false and mempool_sequence = true",
421 bool fVerbose =
false;
422 if (!request.params[0].isNull())
423 fVerbose = request.params[0].
get_bool();
425 bool include_mempool_sequence =
false;
426 if (!request.params[1].isNull()) {
427 include_mempool_sequence = request.params[1].get_bool();
438 "getmempoolancestors",
439 "If txid is in the mempool, returns all in-mempool ancestors.\n",
460 bool fVerbose =
false;
461 if (!request.params[1].isNull())
462 fVerbose = request.params[1].
get_bool();
470 if (entry ==
nullptr) {
479 o.
push_back(ancestorIt->GetTx().GetHash().ToString());
500 "getmempooldescendants",
501 "If txid is in the mempool, returns all in-mempool descendants.\n",
522 bool fVerbose =
false;
523 if (!request.params[1].isNull())
524 fVerbose = request.params[1].
get_bool();
531 const auto it{mempool.
GetIter(hash)};
539 setDescendants.erase(*it);
544 o.
push_back(descendantIt->GetTx().GetHash().ToString());
567 "Returns mempool data for given transaction\n",
585 if (entry ==
nullptr) {
599 "Scans the mempool to find transactions spending any of the given outputs",
619 {
RPCResult::Type::STR_HEX,
"spendingtxid",
true,
"the transaction id of the mempool transaction spending this output (omitted if unspent)"},
624 HelpExampleCli(
"gettxspendingprevout",
"\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
625 +
HelpExampleRpc(
"gettxspendingprevout",
"\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
630 if (output_params.
empty()) {
634 std::vector<COutPoint> prevouts;
635 prevouts.reserve(output_params.
size());
637 for (
unsigned int idx = 0; idx < output_params.
size(); idx++) {
652 prevouts.emplace_back(txid, nOutput);
660 for (
const COutPoint& prevout : prevouts) {
662 o.
pushKV(
"txid", prevout.hash.ToString());
663 o.
pushKV(
"vout", (uint64_t)prevout.n);
666 if (spendingTx !=
nullptr) {
670 result.push_back(std::move(o));
684 ret.pushKV(
"size", (int64_t)pool.
size());
693 ret.pushKV(
"fullrbf",
true);
700 "Returns details on the active state of the TX memory pool.",
705 {
RPCResult::Type::BOOL,
"loaded",
"True if the initial load attempt of the persisted mempool finished"},
707 {
RPCResult::Type::NUM,
"bytes",
"Sum of all virtual transaction sizes as defined in BIP 141. Differs from actual serialized size because witness data is discounted"},
714 {
RPCResult::Type::NUM,
"unbroadcastcount",
"Current number of transactions that haven't passed initial broadcast yet"},
715 {
RPCResult::Type::BOOL,
"fullrbf",
"True if the mempool accepts RBF without replaceability signaling inspection (DEPRECATED)"},
732 "Import a mempool.dat file and attempt to add its contents to the mempool.\n"
733 "Warning: Importing untrusted files is dangerous, especially if metadata from the file is taken over.",
742 "Whether to use the current system time or use the entry time metadata from the mempool file.\n"
743 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
745 "Whether to apply the fee delta metadata from the mempool file.\n"
746 "It will be added to any existing fee deltas.\n"
747 "The fee delta can be set by the prioritisetransaction RPC.\n"
748 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior.\n"
749 "Only set this bool if you understand what it does."},
751 "Whether to apply the unbroadcast set metadata from the mempool file.\n"
752 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
769 const fs::path load_path{
fs::u8path(request.params[0].get_str())};
770 const UniValue& use_current_time{request.params[1][
"use_current_time"]};
771 const UniValue& apply_fee_delta{request.params[1][
"apply_fee_delta_priority"]};
772 const UniValue& apply_unbroadcast{request.params[1][
"apply_unbroadcast_set"]};
774 .
use_current_time = use_current_time.isNull() ? true : use_current_time.get_bool(),
775 .apply_fee_delta_priority = apply_fee_delta.isNull() ? false : apply_fee_delta.get_bool(),
776 .apply_unbroadcast_set = apply_unbroadcast.isNull() ? false : apply_unbroadcast.get_bool(),
793 "Dumps the mempool to disk. It will fail until the previous dump is fully loaded.\n",
820 ret.pushKV(
"filename", dump_path.utf8string());
833 RPCResult{
RPCResult::Type::NUM,
"vsize",
"The virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted."},
847 o.
pushKV(
"txid", orphan.
tx->GetHash().ToString());
848 o.
pushKV(
"wtxid", orphan.
tx->GetWitnessHash().ToString());
849 o.
pushKV(
"bytes", orphan.
tx->GetTotalSize());
853 o.
pushKV(
"expiration", int64_t{TicksSinceEpoch<std::chrono::seconds>(orphan.
nTimeExpire)});
855 for (
const auto fromPeer: orphan.
announcers) {
866 "Shows transactions in the tx orphanage.\n"
867 "\nEXPERIMENTAL warning: this call may be changed in future releases.\n",
869 {
"verbosity",
RPCArg::Type::NUM,
RPCArg::Default{0},
"0 for an array of txids (may contain duplicates), 1 for an array of objects with tx details, and 2 for details from (1) and tx hex",
887 Cat<std::vector<RPCResult>>(
908 if (verbosity == 0) {
909 for (
auto const& orphan : orphanage) {
910 ret.push_back(orphan.tx->GetHash().ToString());
912 }
else if (verbosity == 1) {
913 for (
auto const& orphan : orphanage) {
916 }
else if (verbosity == 2) {
917 for (
auto const& orphan : orphanage) {
934 "Submit a package of raw transactions (serialized, hex-encoded) to local node.\n"
935 "The package will be validated according to consensus and mempool policy rules. If any transaction passes, it will be accepted to mempool.\n"
936 "This RPC is experimental and the interface may be unstable. Refer to doc/policy/packages.md for documentation on package policies.\n"
937 "Warning: successful submission does not mean the transactions will propagate throughout the network.\n"
941 "The package must solely consist of a child transaction and all of its unconfirmed parents, if any. None of the parents may depend on each other.\n"
942 "The package must be topologically sorted, with the child being the last element in the array.",
948 "Reject transactions whose fee rate is higher than the specified value, expressed in " +
CURRENCY_UNIT +
949 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
951 "Reject transactions with provably unspendable outputs (e.g. 'datacarrier' outputs that use the OP_RETURN opcode) greater than the specified value, expressed in " +
CURRENCY_UNIT +
".\n"
952 "If burning funds through unspendable outputs is desired, increase this value.\n"
953 "This check is based on heuristics and does not guarantee spendability of outputs.\n"
959 {
RPCResult::Type::STR,
"package_msg",
"The transaction package result message. \"success\" indicates all transactions were accepted into or are already in the mempool."},
964 {
RPCResult::Type::STR_HEX,
"other-wtxid",
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."},
968 {
RPCResult::Type::STR_AMOUNT,
"effective-feerate",
true,
"if the transaction was not already in the mempool, the effective feerate in " +
CURRENCY_UNIT +
" per KvB. For example, the package feerate and/or feerate with modified fees from prioritisetransaction."},
969 {
RPCResult::Type::ARR,
"effective-includes",
true,
"if effective-feerate is provided, the wtxids of the transactions whose fees and vsizes are included in effective-feerate.",
973 {
RPCResult::Type::STR,
"error",
true,
"The transaction error string, if it was rejected by the mempool"},
983 HelpExampleRpc(
"submitpackage", R
"(["raw-parent-tx-1", "raw-parent-tx-2", "raw-child-tx"])") +
984 HelpExampleCli("submitpackage", R
"('["raw-tx-without-unconfirmed-parents"]')")
996 std::optional<CFeeRate> client_maxfeerate{max_raw_tx_fee_rate};
998 if (max_raw_tx_fee_rate ==
CFeeRate(0)) {
999 client_maxfeerate = std::nullopt;
1005 std::vector<CTransactionRef> txns;
1006 txns.reserve(raw_transactions.
size());
1007 for (
const auto& rawtx : raw_transactions.
getValues()) {
1011 "TX decode failed: " + rawtx.get_str() +
" Make sure the tx has at least one input.");
1014 for (
const auto&
out : mtx.
vout) {
1015 if((
out.scriptPubKey.IsUnspendable() || !
out.scriptPubKey.HasValidOps()) &&
out.nValue > max_burn_amount) {
1024 throw JSONRPCTransactionError(TransactionError::INVALID_PACKAGE,
"package topology disallowed. not child-with-parents or parents depend on each other.");
1032 std::string package_msg =
"success";
1035 switch(package_result.m_state.GetResult()) {
1039 CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size());
1040 for (
const auto& tx : txns) {
1049 package_result.m_state.GetRejectReason());
1055 package_msg = package_result.m_state.ToString();
1056 CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size() ||
1057 package_result.m_tx_results.empty());
1062 size_t num_broadcast{0};
1063 for (
const auto& tx : txns) {
1070 std::string err_string;
1072 if (err != TransactionError::OK) {
1074 strprintf(
"transaction broadcast failed: %s (%d transactions were broadcast successfully)",
1075 err_string, num_broadcast));
1081 rpc_result.pushKV(
"package_msg", package_msg);
1083 std::set<uint256> replaced_txids;
1084 for (
const auto& tx : txns) {
1086 result_inner.pushKV(
"txid", tx->GetHash().GetHex());
1087 auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
1088 if (it == package_result.m_tx_results.end()) {
1090 result_inner.pushKV(
"error",
"unevaluated");
1093 const auto& tx_result = it->second;
1094 switch(it->second.m_result_type) {
1096 result_inner.pushKV(
"other-wtxid", it->second.m_other_wtxid.value().GetHex());
1099 result_inner.pushKV(
"error", it->second.m_state.ToString());
1103 result_inner.pushKV(
"vsize", int64_t{it->second.m_vsize.value()});
1110 fees.
pushKV(
"effective-feerate",
ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
1112 for (
const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
1113 effective_includes_res.
push_back(wtxid.ToString());
1115 fees.
pushKV(
"effective-includes", std::move(effective_includes_res));
1117 result_inner.pushKV(
"fees", std::move(fees));
1118 for (
const auto& ptx : it->second.m_replaced_transactions) {
1119 replaced_txids.insert(ptx->GetHash());
1123 tx_result_map.pushKV(tx->GetWitnessHash().GetHex(), std::move(result_inner));
1125 rpc_result.pushKV(
"tx-results", std::move(tx_result_map));
1127 for (
const uint256& hash : replaced_txids) replaced_list.
push_back(hash.ToString());
1128 rpc_result.pushKV(
"replaced-transactions", std::move(replaced_list));
1150 for (
const auto& c : commands) {
1151 t.appendCommand(c.name, &c);
int64_t CAmount
Amount in satoshis (Can be negative)
static CAmount AmountFromValue(const UniValue &value)
#define CHECK_NONFATAL(condition)
Identity function.
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
CAmount GetFeePerK() const
Return the fee in satoshis for a vsize of 1000 vbytes.
An outpoint - a combination of a transaction hash and an index n into its vout.
The basic transaction that is broadcasted on the network and contained in blocks.
const Txid & GetHash() const LIFETIMEBOUND
const std::vector< CTxIn > vin
An input of a transaction.
CTxMemPoolEntry stores data about the corresponding transaction, as well as data about all in-mempool...
const CTransaction & GetTx() const
const Children & GetMemPoolChildrenConst() const
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
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.
std::set< uint256 > GetUnbroadcastTxs() const
Returns transactions in unbroadcast set.
bool GetLoadTried() const
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
CFeeRate GetMinFee(size_t sizelimit) const
std::optional< txiter > GetIter(const uint256 &txid) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Returns an iterator to the given hash, if found.
size_t DynamicMemoryUsage() const
std::set< txiter, CompareIteratorByHash > setEntries
uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
bool exists(const GenTxid >xid) const
const CTransaction * GetConflictTx(const COutPoint &prevout) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Get the transaction in the pool that spends the same prevout.
void CalculateDescendants(txiter it, setEntries &setDescendants) const EXCLUSIVE_LOCKS_REQUIRED(cs)
Populate setDescendants with all in-mempool descendants of hash.
unsigned long size() const
std::vector< CTxMemPoolEntryRef > entryAll() const EXCLUSIVE_LOCKS_REQUIRED(cs)
CAmount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs)
uint64_t GetTotalTxSize() const EXCLUSIVE_LOCKS_REQUIRED(cs)
const CTxMemPoolEntry * GetEntry(const Txid &txid) const LIFETIMEBOUND EXCLUSIVE_LOCKS_REQUIRED(cs)
Chainstate stores and provides an API to update our local knowledge of the current best chain.
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
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...
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)
virtual std::vector< TxOrphanage::OrphanTxBase > GetOrphanTransactions()=0
auto Arg(std::string_view key) const
Helper to get a required or default-valued request argument.
void push_back(UniValue val)
const UniValue & find_value(std::string_view key) const
const UniValue & get_obj() const
const std::vector< UniValue > & getValues() const
void pushKVEnd(std::string key, UniValue val)
const UniValue & get_array() const
void pushKV(std::string key, UniValue val)
std::string GetRejectReason() const
std::string ToString() const
std::string ToString() const
std::string ToString() const
static transaction_identifier FromUint256(const uint256 &id)
static int32_t GetTransactionWeight(const CTransaction &tx)
@ TX_MISSING_INPUTS
transaction was missing some of its inputs
std::string EncodeHexTx(const CTransaction &tx)
UniValue ValueFromAmount(const CAmount amount)
bool DecodeHexTx(CMutableTransaction &tx, const std::string &hex_tx, bool try_no_witness=false, bool try_witness=true)
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
const std::string CURRENCY_UNIT
static path u8path(const std::string &utf8_str)
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
static const CAmount DEFAULT_MAX_BURN_AMOUNT
Maximum burn value for sendrawtransaction, submitpackage, and testmempoolaccept RPC calls.
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.
fs::path MempoolPath(const ArgsManager &argsman)
static const CFeeRate DEFAULT_MAX_RAW_TX_FEE_RATE
Maximum fee rate for sendrawtransaction and testmempoolaccept RPC calls.
bool LoadMempool(CTxMemPool &pool, const fs::path &load_path, Chainstate &active_chainstate, ImportMempoolOptions &&opts)
Import the file and attempt to add its contents to the mempool.
bool DumpMempool(const CTxMemPool &pool, const fs::path &dump_path, FopenFn mockable_fopen_function, bool skip_file_commit)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
is a home for public enum and struct type definitions that are used internally by node code,...
bool IsChildWithParentsTree(const Package &package)
Context-free check that a package IsChildWithParents() and none of the parents depend on each other (...
static constexpr uint32_t MAX_PACKAGE_COUNT
Default maximum number of transactions in a package.
@ 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...
RBFTransactionState
The rbf state of unconfirmed transactions.
@ 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).
static CTransactionRef MakeTransactionRef(Tx &&txIn)
std::shared_ptr< const CTransaction > CTransactionRef
UniValue JSONRPCError(int code, const std::string &message)
static RPCHelpMan getmempoolinfo()
static RPCHelpMan sendrawtransaction()
static std::vector< RPCResult > OrphanDescription()
static void entryToJSON(const CTxMemPool &pool, UniValue &info, const CTxMemPoolEntry &e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
static RPCHelpMan importmempool()
static UniValue OrphanToJSON(const TxOrphanage::OrphanTxBase &orphan)
void RegisterMempoolRPCCommands(CRPCTable &t)
static RPCHelpMan getrawmempool()
static RPCHelpMan getmempoolentry()
UniValue MempoolInfoToJSON(const CTxMemPool &pool)
Mempool information to JSON.
static RPCHelpMan gettxspendingprevout()
static std::vector< RPCResult > MempoolEntryDescription()
static RPCHelpMan submitpackage()
static RPCHelpMan getorphantxs()
UniValue MempoolToJSON(const CTxMemPool &pool, bool verbose, bool include_mempool_sequence)
Mempool to JSON.
static RPCHelpMan testmempoolaccept()
static RPCHelpMan getmempooldescendants()
static RPCHelpMan getmempoolancestors()
static RPCHelpMan savemempool()
@ RPC_MISC_ERROR
General application defined errors.
@ RPC_INVALID_PARAMETER
Invalid, missing or duplicate parameter.
@ RPC_CLIENT_IN_INITIAL_DOWNLOAD
Still downloading initial blocks.
@ RPC_DESERIALIZATION_ERROR
Error parsing or validating structure in raw format.
@ RPC_INVALID_ADDRESS_OR_KEY
Invalid address or key.
std::string HelpExampleCli(const std::string &methodname, const std::string &args)
UniValue JSONRPCTransactionError(TransactionError terr, const std::string &err_string)
CFeeRate ParseFeeRate(const UniValue &json)
Parse a json number or string, denoting BTC/kvB, into a CFeeRate (sat/kvB).
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
const std::string UNIX_EPOCH_TIME
String used to describe UNIX epoch time in documentation, factored out to a constant for consistency.
int ParseVerbosity(const UniValue &arg, int default_verbosity, bool allow_bool)
Parses verbosity from provided UniValue.
uint256 ParseHashO(const UniValue &o, std::string_view strKey)
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
uint256 ParseHashV(const UniValue &v, std::string_view name)
Utilities: convert hex-encoded Values (throws error if not hex).
NodeContext & EnsureAnyNodeContext(const std::any &context)
CTxMemPool & EnsureMemPool(const NodeContext &node)
PeerManager & EnsurePeerman(const NodeContext &node)
ChainstateManager & EnsureChainman(const NodeContext &node)
CTxMemPool & EnsureAnyMemPool(const std::any &context)
ArgsManager & EnsureAnyArgsman(const std::any &context)
A mutable version of CTransaction.
std::vector< CTxOut > vout
@ DIFFERENT_WITNESS
Valid, transaction was already in the mempool.
@ INVALID
Fully validated, valid.
Validation result for package mempool acceptance.
PackageValidationState m_state
std::map< Wtxid, MempoolAcceptResult > m_tx_results
Map from wtxid to finished MempoolAcceptResults.
@ 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:
std::string oneline_description
Should be empty unless it is supposed to override the auto-generated summary line.
@ NUM_TIME
Special numeric to denote unix epoch time.
@ OBJ_DYN
Special dictionary with keys that are not literals.
@ STR_HEX
Special string with only hex chars.
@ STR_AMOUNT
Special string to represent a floating point amount.
Allows providing orphan information externally.
std::set< NodeId > announcers
Peers added with AddTx or AddAnnouncer.
Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type.
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.
#define AssertLockNotHeld(cs)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
static constexpr auto ORPHAN_TX_EXPIRE_TIME
Expiration time for orphan transactions.
constexpr int64_t count_seconds(std::chrono::seconds t)
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.