10 #include <chainparams.h>
20 #include <txmempool.h>
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",
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."},
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"},
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"
61 "\nSend the transaction (signed hex)\n"
63 "\nAs a JSON-RPC call\n"
71 if (!
DecodeHexTx(mtx, request.params[0].get_str())) {
75 for (
const auto&
out : mtx.
vout) {
76 if((
out.scriptPubKey.IsUnspendable() || !
out.scriptPubKey.HasValidOps()) &&
out.nValue > max_burn_amount) {
83 const CFeeRate max_raw_tx_fee_rate = request.params[1].isNull() ?
88 CAmount max_raw_tx_fee = max_raw_tx_fee_rate.
GetFee(virtual_size);
90 std::string err_string;
98 return tx->GetHash().GetHex();
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"
110 "\nThis checks if transactions violate the consensus or policy rules.\n"
111 "\nSee sendrawtransaction call.\n",
119 "Reject transactions whose fee rate is higher than the specified value, expressed in " +
CURRENCY_UNIT +
"/kvB\n"},
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",
130 {
RPCResult::Type::STR,
"package-error",
true,
"Package validation error, if any (only possible if rawtxs had more than 1 transaction)."},
131 {
RPCResult::Type::BOOL,
"allowed",
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",
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)"},
137 {
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."},
138 {
RPCResult::Type::ARR,
"effective-includes",
false,
"transactions whose fees and vsizes are included in effective-feerate.",
142 {
RPCResult::Type::STR,
"reject-reason",
true,
"Rejection string (only present when 'allowed' is false)"},
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"
151 "\nTest acceptance of the transaction (signed hex)\n"
153 "\nAs a JSON-RPC call\n"
164 const CFeeRate max_raw_tx_fee_rate = request.params[1].isNull() ?
168 std::vector<CTransactionRef> txns;
169 txns.reserve(raw_transactions.
size());
170 for (
const auto& rawtx : raw_transactions.
getValues()) {
174 "TX decode failed: " + rawtx.get_str() +
" Make sure the tx has at least one input.");
182 Chainstate& chainstate = chainman.ActiveChainstate();
195 bool exit_early{
false};
196 for (
const auto& tx : txns) {
198 result_inner.
pushKV(
"txid", tx->GetHash().GetHex());
199 result_inner.
pushKV(
"wtxid", tx->GetWitnessHash().GetHex());
203 auto it = package_result.
m_tx_results.find(tx->GetWitnessHash());
204 if (exit_early || it == package_result.
m_tx_results.end()) {
209 const auto& tx_result = it->second;
213 const CAmount fee = tx_result.m_base_fees.value();
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");
224 result_inner.
pushKV(
"allowed",
true);
225 result_inner.
pushKV(
"vsize", virtual_size);
228 fees.
pushKV(
"effective-feerate",
ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
230 for (
const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
231 effective_includes_res.
push_back(wtxid.ToString());
233 fees.
pushKV(
"effective-includes", effective_includes_res);
234 result_inner.
pushKV(
"fees", fees);
237 result_inner.
pushKV(
"allowed",
false);
240 result_inner.
pushKV(
"reject-reason",
"missing-inputs");
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."},
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)"},
284 info.pushKV(
"vsize", (
int)e.GetTxSize());
285 info.pushKV(
"weight", (
int)e.GetTxWeight());
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());
299 info.pushKV(
"fees", fees);
302 std::set<std::string> setDepends;
310 for (
const std::string& dep : setDepends)
315 info.pushKV(
"depends", depends);
321 spent.
push_back(child.GetTx().GetHash().ToString());
324 info.pushKV(
"spentby", spent);
327 bool rbfStatus =
false;
335 info.pushKV(
"bip125-replaceable", rbfStatus);
336 info.pushKV(
"unbroadcast", pool.IsUnbroadcastTx(tx.
GetHash()));
342 if (include_mempool_sequence) {
358 uint64_t mempool_sequence;
359 std::vector<uint256> vtxid;
366 for (
const uint256& hash : vtxid)
369 if (!include_mempool_sequence) {
374 o.
pushKV(
"mempool_sequence", mempool_sequence);
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",
387 {
"mempool_sequence",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"If verbose=false, returns a json object with transaction list and mempool sequence number attached."},
400 RPCResult{
"for verbose = false and mempool_sequence = true",
416 bool fVerbose =
false;
417 if (!request.params[0].isNull())
418 fVerbose = request.params[0].
get_bool();
420 bool include_mempool_sequence =
false;
421 if (!request.params[1].isNull()) {
422 include_mempool_sequence = request.params[1].get_bool();
433 "\nIf txid is in the mempool, returns all in-mempool ancestors.\n",
454 bool fVerbose =
false;
455 if (!request.params[1].isNull())
456 fVerbose = request.params[1].
get_bool();
464 if (it == mempool.mapTx.end()) {
473 o.
push_back(ancestorIt->GetTx().GetHash().ToString());
494 "\nIf txid is in the mempool, returns all in-mempool descendants.\n",
515 bool fVerbose =
false;
516 if (!request.params[1].isNull())
517 fVerbose = request.params[1].
get_bool();
525 if (it == mempool.mapTx.end()) {
532 setDescendants.erase(it);
537 o.
push_back(descendantIt->GetTx().GetHash().ToString());
559 "\nReturns mempool data for given transaction\n",
577 if (it == mempool.mapTx.end()) {
592 "Scans the mempool to find transactions spending any of the given outputs",
612 {
RPCResult::Type::STR_HEX,
"spendingtxid",
true,
"the transaction id of the mempool transaction spending this output (omitted if unspent)"},
617 HelpExampleCli(
"gettxspendingprevout",
"\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
618 +
HelpExampleRpc(
"gettxspendingprevout",
"\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
623 if (output_params.
empty()) {
627 std::vector<COutPoint> prevouts;
628 prevouts.reserve(output_params.
size());
630 for (
unsigned int idx = 0; idx < output_params.
size(); idx++) {
645 prevouts.emplace_back(txid, nOutput);
653 for (
const COutPoint& prevout : prevouts) {
655 o.
pushKV(
"txid", prevout.hash.ToString());
656 o.
pushKV(
"vout", (uint64_t)prevout.n);
659 if (spendingTx !=
nullptr) {
677 ret.pushKV(
"size", (int64_t)pool.
size());
693 "Returns details on the active state of the TX memory pool.",
698 {
RPCResult::Type::BOOL,
"loaded",
"True if the initial load attempt of the persisted mempool finished"},
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"},
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"},
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.",
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."},
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."},
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."},
756 Chainstate& chainstate = chainman.ActiveChainstate();
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(),
785 "\nDumps the mempool to disk. It will fail until the previous dump is fully loaded.\n",
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"
842 {
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."},
846 {
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."},
847 {
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.",
866 throw std::runtime_error(
"submitpackage is for regression testing (-regtest mode) only");
874 std::vector<CTransactionRef> txns;
875 txns.reserve(raw_transactions.
size());
876 for (
const auto& rawtx : raw_transactions.
getValues()) {
880 "TX decode failed: " + rawtx.get_str() +
" Make sure the tx has at least one input.");
891 switch(package_result.m_state.GetResult()) {
896 package_result.m_state.GetRejectReason());
901 package_result.m_state.GetRejectReason());
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()));
916 size_t num_broadcast{0};
917 for (
const auto& tx : txns) {
918 std::string err_string;
922 strprintf(
"transaction broadcast failed: %s (all transactions were submitted, %d transactions were broadcast successfully)",
923 err_string, num_broadcast));
929 std::set<uint256> replaced_txids;
930 for (
const auto& tx : txns) {
931 auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
934 result_inner.pushKV(
"txid", tx->GetHash().GetHex());
935 const auto& tx_result = it->second;
937 result_inner.pushKV(
"other-wtxid", it->second.m_other_wtxid.value().GetHex());
941 result_inner.pushKV(
"vsize", int64_t{it->second.m_vsize.value()});
948 fees.
pushKV(
"effective-feerate",
ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
950 for (
const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
951 effective_includes_res.
push_back(wtxid.ToString());
953 fees.
pushKV(
"effective-includes", effective_includes_res);
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());
962 tx_result_map.pushKV(tx->GetWitnessHash().GetHex(), result_inner);
964 rpc_result.pushKV(
"tx-results", tx_result_map);
966 for (
const uint256& hash : replaced_txids) replaced_list.
push_back(hash.ToString());
967 rpc_result.pushKV(
"replaced-transactions", replaced_list);
988 for (
const auto& c : commands) {
989 t.appendCommand(c.name, &c);
int64_t CAmount
Amount in satoshis (Can be negative)
static CAmount AmountFromValue(const UniValue &value)
const CChainParams & Params()
Return the currently selected parameters.
#define CHECK_NONFATAL(condition)
Identity function.
#define NONFATAL_UNREACHABLE()
NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code.
ChainType GetChainType() const
Return the chain type.
Fee rate in satoshis per kilovirtualbyte: CAmount / kvB.
CAmount GetFee(uint32_t num_bytes) const
Return the fee in satoshis for the given vsize in vbytes.
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 uint256 & GetHash() const
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
std::set< CTxMemPoolEntryRef, CompareIteratorByHash > Children
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.
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
const int64_t m_max_size_bytes
size_t DynamicMemoryUsage() const
std::set< txiter, CompareIteratorByHash > setEntries
std::set< uint256 > GetUnbroadcastTxs() const
Returns transactions in unbroadcast set.
void queryHashes(std::vector< uint256 > &vtxid) const
const CFeeRate m_min_relay_feerate
uint64_t GetSequence() const EXCLUSIVE_LOCKS_REQUIRED(cs)
indexed_transaction_set::nth_index< 0 >::type::const_iterator txiter
const CFeeRate m_incremental_relay_feerate
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
CAmount GetTotalFee() const EXCLUSIVE_LOCKS_REQUIRED(cs)
uint64_t GetTotalTxSize() const 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...
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)
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
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
std::string u8string() const
@ TX_MISSING_INPUTS
transaction was missing some of its inputs
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
std::string FormatMoney(const CAmount n)
Money parsing/formatting utilities.
static path u8path(const std::string &utf8_str)
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)
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.
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 void entryToJSON(const CTxMemPool &pool, UniValue &info, const CTxMemPoolEntry &e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
static RPCHelpMan importmempool()
static std::vector< RPCResult > MempoolEntryDescription()
void RegisterMempoolRPCCommands(CRPCTable &t)
static RPCHelpMan getrawmempool()
static RPCHelpMan getmempoolentry()
UniValue MempoolInfoToJSON(const CTxMemPool &pool)
Mempool information to JSON.
static RPCHelpMan gettxspendingprevout()
static RPCHelpMan submitpackage()
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)
std::string HelpExampleRpc(const std::string &methodname, const std::string &args)
uint256 ParseHashO(const UniValue &o, std::string strKey)
uint256 ParseHashV(const UniValue &v, std::string strName)
Utilities: convert hex-encoded Values (throws error if not hex).
void RPCTypeCheckObj(const UniValue &o, const std::map< std::string, UniValueType > &typesExpected, bool fAllowNull, bool fStrict)
ArgsManager & EnsureAnyArgsman(const std::any &context)
CTxMemPool & EnsureAnyMemPool(const std::any &context)
NodeContext & EnsureAnyNodeContext(const std::any &context)
CTxMemPool & EnsureMemPool(const NodeContext &node)
ChainstateManager & EnsureChainman(const NodeContext &node)
std::string ToString(const T &t)
Locale-independent version of std::to_string.
A mutable version of CTransaction.
std::vector< CTxOut > vout
@ DIFFERENT_WITNESS
Valid, transaction was already in the mempool.
Validation result for package mempool acceptance.
PackageValidationState m_state
std::map< uint256, 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.
Wrapper for UniValue::VType, which includes typeAny: Used to denote don't care type.
static constexpr MemPoolLimits NoLimits()
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(...)
constexpr int64_t count_seconds(std::chrono::seconds t)
PackageMempoolAcceptResult ProcessNewPackage(Chainstate &active_chainstate, CTxMemPool &pool, const Package &package, bool test_accept)
Validate (and maybe submit) a package to the mempool.