10 #include <chainparams.h>
20 #include <txmempool.h>
39 "\nSubmit a raw transaction (serialized, hex-encoded) to local node and network.\n"
40 "\nThe transaction will be sent unconditionally to all peers, so using sendrawtransaction\n"
41 "for manual rebroadcast may degrade privacy by leaking the transaction's origin, as\n"
42 "nodes will normally not rebroadcast non-wallet transactions already in their mempool.\n"
43 "\nA specific exception, RPC_TRANSACTION_ALREADY_IN_CHAIN, may throw if the transaction cannot be added to the mempool.\n"
44 "\nRelated RPCs: createrawtransaction, signrawtransactionwithkey\n",
48 "Reject transactions whose fee rate is higher than the specified value, expressed in " +
CURRENCY_UNIT +
49 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
51 "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"
52 "If burning funds through unspendable outputs is desired, increase this value.\n"
53 "This check is based on heuristics and does not guarantee spendability of outputs.\n"},
59 "\nCreate a transaction\n"
60 +
HelpExampleCli(
"createrawtransaction",
"\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
61 "Sign the transaction, and get back the hex\n"
63 "\nSend the transaction (signed hex)\n"
65 "\nAs a JSON-RPC call\n"
73 if (!
DecodeHexTx(mtx, request.params[0].get_str())) {
77 for (
const auto&
out : mtx.
vout) {
78 if((
out.scriptPubKey.IsUnspendable() || !
out.scriptPubKey.HasValidOps()) &&
out.nValue > max_burn_amount) {
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 +
120 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
123 RPCResult::Type::ARR,
"",
"The result of the mempool acceptance test for each raw transaction in the input array.\n"
124 "Returns results for each transaction in the same order they were passed in.\n"
125 "Transactions that cannot be fully validated due to failures in other transactions will not contain an 'allowed' result.\n",
131 {
RPCResult::Type::STR,
"package-error",
true,
"Package validation error, if any (only possible if rawtxs had more than 1 transaction)."},
132 {
RPCResult::Type::BOOL,
"allowed",
true,
"Whether this tx would be accepted to the mempool and pass client-specified maxfeerate. "
133 "If not present, the tx was not fully validated due to a failure in another tx in the list."},
134 {
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)"},
138 {
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."},
139 {
RPCResult::Type::ARR,
"effective-includes",
false,
"transactions whose fees and vsizes are included in effective-feerate.",
143 {
RPCResult::Type::STR,
"reject-reason",
true,
"Rejection string (only present when 'allowed' is false)"},
148 "\nCreate a transaction\n"
149 +
HelpExampleCli(
"createrawtransaction",
"\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
150 "Sign the transaction, and get back the hex\n"
152 "\nTest acceptance of the transaction (signed hex)\n"
154 "\nAs a JSON-RPC call\n"
167 std::vector<CTransactionRef> txns;
168 txns.reserve(raw_transactions.
size());
169 for (
const auto& rawtx : raw_transactions.
getValues()) {
173 "TX decode failed: " + rawtx.get_str() +
" Make sure the tx has at least one input.");
184 if (txns.size() > 1)
return ProcessNewPackage(chainstate, mempool, txns,
true, {});
194 bool exit_early{
false};
195 for (
const auto& tx : txns) {
197 result_inner.
pushKV(
"txid", tx->GetHash().GetHex());
198 result_inner.
pushKV(
"wtxid", tx->GetWitnessHash().GetHex());
202 auto it = package_result.
m_tx_results.find(tx->GetWitnessHash());
203 if (exit_early || it == package_result.
m_tx_results.end()) {
208 const auto& tx_result = it->second;
212 const CAmount fee = tx_result.m_base_fees.value();
214 const int64_t virtual_size = tx_result.m_vsize.value();
215 const CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
216 if (max_raw_tx_fee && fee > max_raw_tx_fee) {
217 result_inner.
pushKV(
"allowed",
false);
218 result_inner.
pushKV(
"reject-reason",
"max-fee-exceeded");
223 result_inner.
pushKV(
"allowed",
true);
224 result_inner.
pushKV(
"vsize", virtual_size);
227 fees.
pushKV(
"effective-feerate",
ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
229 for (
const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
230 effective_includes_res.
push_back(wtxid.ToString());
232 fees.
pushKV(
"effective-includes", effective_includes_res);
233 result_inner.
pushKV(
"fees", fees);
236 result_inner.
pushKV(
"allowed",
false);
239 result_inner.
pushKV(
"reject-reason",
"missing-inputs");
254 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."},
274 RPCResult{
RPCResult::Type::BOOL,
"bip125-replaceable",
"Whether this transaction signals BIP125 replaceability or has an unconfirmed ancestor signaling BIP125 replaceability.\n"},
275 RPCResult{
RPCResult::Type::BOOL,
"unbroadcast",
"Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)"},
283 info.pushKV(
"vsize", (
int)e.GetTxSize());
284 info.pushKV(
"weight", (
int)e.GetTxWeight());
286 info.pushKV(
"height", (
int)e.GetHeight());
287 info.pushKV(
"descendantcount", e.GetCountWithDescendants());
288 info.pushKV(
"descendantsize", e.GetSizeWithDescendants());
289 info.pushKV(
"ancestorcount", e.GetCountWithAncestors());
290 info.pushKV(
"ancestorsize", e.GetSizeWithAncestors());
291 info.pushKV(
"wtxid", e.GetTx().GetWitnessHash().ToString());
298 info.pushKV(
"fees", fees);
301 std::set<std::string> setDepends;
309 for (
const std::string& dep : setDepends)
314 info.pushKV(
"depends", depends);
318 spent.
push_back(child.GetTx().GetHash().ToString());
321 info.pushKV(
"spentby", spent);
324 bool rbfStatus =
false;
332 info.pushKV(
"bip125-replaceable", rbfStatus);
333 info.pushKV(
"unbroadcast", pool.IsUnbroadcastTx(tx.
GetHash()));
339 if (include_mempool_sequence) {
350 o.
pushKVEnd(e.GetTx().GetHash().ToString(), info);
355 uint64_t mempool_sequence;
359 a.
push_back(e.GetTx().GetHash().ToString());
363 if (!include_mempool_sequence) {
368 o.
pushKV(
"mempool_sequence", mempool_sequence);
377 "\nReturns all transaction ids in memory pool as a json array of string transaction ids.\n"
378 "\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n",
381 {
"mempool_sequence",
RPCArg::Type::BOOL,
RPCArg::Default{
false},
"If verbose=false, returns a json object with transaction list and mempool sequence number attached."},
394 RPCResult{
"for verbose = false and mempool_sequence = true",
410 bool fVerbose =
false;
411 if (!request.params[0].isNull())
412 fVerbose = request.params[0].
get_bool();
414 bool include_mempool_sequence =
false;
415 if (!request.params[1].isNull()) {
416 include_mempool_sequence = request.params[1].get_bool();
427 "\nIf txid is in the mempool, returns all in-mempool ancestors.\n",
448 bool fVerbose =
false;
449 if (!request.params[1].isNull())
450 fVerbose = request.params[1].
get_bool();
458 if (entry ==
nullptr) {
467 o.
push_back(ancestorIt->GetTx().GetHash().ToString());
488 "\nIf txid is in the mempool, returns all in-mempool descendants.\n",
509 bool fVerbose =
false;
510 if (!request.params[1].isNull())
511 fVerbose = request.params[1].
get_bool();
518 const auto it{mempool.
GetIter(hash)};
526 setDescendants.erase(*it);
531 o.
push_back(descendantIt->GetTx().GetHash().ToString());
553 "\nReturns mempool data for given transaction\n",
571 if (entry ==
nullptr) {
585 "Scans the mempool to find transactions spending any of the given outputs",
605 {
RPCResult::Type::STR_HEX,
"spendingtxid",
true,
"the transaction id of the mempool transaction spending this output (omitted if unspent)"},
610 HelpExampleCli(
"gettxspendingprevout",
"\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
611 +
HelpExampleRpc(
"gettxspendingprevout",
"\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
616 if (output_params.
empty()) {
620 std::vector<COutPoint> prevouts;
621 prevouts.reserve(output_params.
size());
623 for (
unsigned int idx = 0; idx < output_params.
size(); idx++) {
638 prevouts.emplace_back(txid, nOutput);
646 for (
const COutPoint& prevout : prevouts) {
648 o.
pushKV(
"txid", prevout.hash.ToString());
649 o.
pushKV(
"vout", (uint64_t)prevout.n);
652 if (spendingTx !=
nullptr) {
670 ret.pushKV(
"size", (int64_t)pool.
size());
686 "Returns details on the active state of the TX memory pool.",
691 {
RPCResult::Type::BOOL,
"loaded",
"True if the initial load attempt of the persisted mempool finished"},
693 {
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"},
700 {
RPCResult::Type::NUM,
"unbroadcastcount",
"Current number of transactions that haven't passed initial broadcast yet"},
701 {
RPCResult::Type::BOOL,
"fullrbf",
"True if the mempool accepts RBF without replaceability signaling inspection"},
718 "Import a mempool.dat file and attempt to add its contents to the mempool.\n"
719 "Warning: Importing untrusted files is dangerous, especially if metadata from the file is taken over.",
728 "Whether to use the current system time or use the entry time metadata from the mempool file.\n"
729 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
731 "Whether to apply the fee delta metadata from the mempool file.\n"
732 "It will be added to any existing fee deltas.\n"
733 "The fee delta can be set by the prioritisetransaction RPC.\n"
734 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior.\n"
735 "Only set this bool if you understand what it does."},
737 "Whether to apply the unbroadcast set metadata from the mempool file.\n"
738 "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
756 const UniValue& use_current_time{request.params[1][
"use_current_time"]};
757 const UniValue& apply_fee_delta{request.params[1][
"apply_fee_delta_priority"]};
758 const UniValue& apply_unbroadcast{request.params[1][
"apply_unbroadcast_set"]};
760 .
use_current_time = use_current_time.isNull() ? true : use_current_time.get_bool(),
761 .apply_fee_delta_priority = apply_fee_delta.isNull() ? false : apply_fee_delta.get_bool(),
762 .apply_unbroadcast_set = apply_unbroadcast.isNull() ? false : apply_unbroadcast.get_bool(),
778 "\nDumps the mempool to disk. It will fail until the previous dump is fully loaded.\n",
815 "Submit a package of raw transactions (serialized, hex-encoded) to local node.\n"
816 "The package must consist of a child with its parents, and none of the parents may depend on one another.\n"
817 "The package will be validated according to consensus and mempool policy rules. If any transaction passes, it will be accepted to mempool.\n"
818 "This RPC is experimental and the interface may be unstable. Refer to doc/policy/packages.md for documentation on package policies.\n"
819 "Warning: successful submission does not mean the transactions will propagate throughout the network.\n"
828 "Reject transactions whose fee rate is higher than the specified value, expressed in " +
CURRENCY_UNIT +
829 "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
831 "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"
832 "If burning funds through unspendable outputs is desired, increase this value.\n"
833 "This check is based on heuristics and does not guarantee spendability of outputs.\n"
839 {
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::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."},
848 {
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."},
849 {
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.",
853 {
RPCResult::Type::STR,
"error",
true,
"The transaction error string, if it was rejected by the mempool"},
876 std::optional<CFeeRate> client_maxfeerate{max_raw_tx_fee_rate};
878 if (max_raw_tx_fee_rate ==
CFeeRate(0)) {
879 client_maxfeerate = std::nullopt;
885 std::vector<CTransactionRef> txns;
886 txns.reserve(raw_transactions.
size());
887 for (
const auto& rawtx : raw_transactions.
getValues()) {
891 "TX decode failed: " + rawtx.get_str() +
" Make sure the tx has at least one input.");
894 for (
const auto&
out : mtx.
vout) {
895 if((
out.scriptPubKey.IsUnspendable() || !
out.scriptPubKey.HasValidOps()) &&
out.nValue > max_burn_amount) {
911 std::string package_msg =
"success";
914 switch(package_result.m_state.GetResult()) {
918 CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size());
919 for (
const auto& tx : txns) {
928 package_result.m_state.GetRejectReason());
934 package_msg = package_result.m_state.ToString();
935 CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size() ||
936 package_result.m_tx_results.empty());
941 size_t num_broadcast{0};
942 for (
const auto& tx : txns) {
949 std::string err_string;
953 strprintf(
"transaction broadcast failed: %s (%d transactions were broadcast successfully)",
954 err_string, num_broadcast));
960 rpc_result.pushKV(
"package_msg", package_msg);
962 std::set<uint256> replaced_txids;
963 for (
const auto& tx : txns) {
965 result_inner.pushKV(
"txid", tx->GetHash().GetHex());
966 auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
967 if (it == package_result.m_tx_results.end()) {
969 result_inner.pushKV(
"error",
"unevaluated");
972 const auto& tx_result = it->second;
973 switch(it->second.m_result_type) {
975 result_inner.pushKV(
"other-wtxid", it->second.m_other_wtxid.value().GetHex());
978 result_inner.pushKV(
"error", it->second.m_state.ToString());
982 result_inner.pushKV(
"vsize", int64_t{it->second.m_vsize.value()});
989 fees.
pushKV(
"effective-feerate",
ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
991 for (
const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
992 effective_includes_res.
push_back(wtxid.ToString());
994 fees.
pushKV(
"effective-includes", effective_includes_res);
996 result_inner.pushKV(
"fees", fees);
997 if (it->second.m_replaced_transactions.has_value()) {
998 for (
const auto& ptx : it->second.m_replaced_transactions.value()) {
999 replaced_txids.insert(ptx->GetHash());
1004 tx_result_map.pushKV(tx->GetWitnessHash().GetHex(), result_inner);
1006 rpc_result.pushKV(
"tx-results", tx_result_map);
1008 for (
const uint256& hash : replaced_txids) replaced_list.
push_back(hash.ToString());
1009 rpc_result.pushKV(
"replaced-transactions", replaced_list);
1030 for (
const auto& c : commands) {
1031 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.
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.
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.
const CFeeRate m_min_relay_feerate
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 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
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)
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
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
std::string utf8string() const
Return a UTF-8 representation of the path as a std::string, for compatibility with code using std::st...
std::string ToString() const
static transaction_identifier FromUint256(const uint256 &id)
@ 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)
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 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 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)
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)
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).
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.
@ INVALID
Fully validated, valid.
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, const std::optional< CFeeRate > &client_maxfeerate)
Validate (and maybe submit) a package to the mempool.