Branch data Line data Source code
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 : :
8 : : #include <node/mempool_persist.h>
9 : :
10 : : #include <chainparams.h>
11 : : #include <consensus/validation.h>
12 : : #include <core_io.h>
13 : : #include <kernel/mempool_entry.h>
14 : : #include <net_processing.h>
15 : : #include <node/mempool_persist_args.h>
16 : : #include <node/types.h>
17 : : #include <policy/rbf.h>
18 : : #include <policy/settings.h>
19 : : #include <primitives/transaction.h>
20 : : #include <rpc/server.h>
21 : : #include <rpc/server_util.h>
22 : : #include <rpc/util.h>
23 : : #include <txmempool.h>
24 : : #include <univalue.h>
25 : : #include <util/fs.h>
26 : : #include <util/moneystr.h>
27 : : #include <util/strencodings.h>
28 : : #include <util/time.h>
29 : : #include <util/vector.h>
30 : :
31 : : #include <utility>
32 : :
33 : : using node::DumpMempool;
34 : :
35 : : using node::DEFAULT_MAX_BURN_AMOUNT;
36 : : using node::DEFAULT_MAX_RAW_TX_FEE_RATE;
37 : : using node::MempoolPath;
38 : : using node::NodeContext;
39 : : using node::TransactionError;
40 : : using util::ToString;
41 : :
42 : 22681 : static RPCHelpMan sendrawtransaction()
43 : : {
44 : 22681 : return RPCHelpMan{"sendrawtransaction",
45 : : "\nSubmit a raw transaction (serialized, hex-encoded) to local node and network.\n"
46 : : "\nThe transaction will be sent unconditionally to all peers, so using sendrawtransaction\n"
47 : : "for manual rebroadcast may degrade privacy by leaking the transaction's origin, as\n"
48 : : "nodes will normally not rebroadcast non-wallet transactions already in their mempool.\n"
49 : : "\nA specific exception, RPC_TRANSACTION_ALREADY_IN_UTXO_SET, may throw if the transaction cannot be added to the mempool.\n"
50 : : "\nRelated RPCs: createrawtransaction, signrawtransactionwithkey\n",
51 : : {
52 [ + - ]: 22681 : {"hexstring", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The hex string of the raw transaction"},
53 [ + - + - ]: 45362 : {"maxfeerate", RPCArg::Type::AMOUNT, RPCArg::Default{FormatMoney(DEFAULT_MAX_RAW_TX_FEE_RATE.GetFeePerK())},
54 : 22681 : "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT +
55 : 22681 : "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
56 [ + - + - ]: 45362 : {"maxburnamount", RPCArg::Type::AMOUNT, RPCArg::Default{FormatMoney(DEFAULT_MAX_BURN_AMOUNT)},
57 : 22681 : "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"
58 : : "If burning funds through unspendable outputs is desired, increase this value.\n"
59 : 22681 : "This check is based on heuristics and does not guarantee spendability of outputs.\n"},
60 : : },
61 : 0 : RPCResult{
62 : : RPCResult::Type::STR_HEX, "", "The transaction hash in hex"
63 [ + - + - : 45362 : },
+ - ]
64 : 22681 : RPCExamples{
65 : : "\nCreate a transaction\n"
66 [ + - + - : 45362 : + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
+ - + - ]
67 : 22681 : "Sign the transaction, and get back the hex\n"
68 [ + - + - : 90724 : + HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
+ - + - ]
69 : 22681 : "\nSend the transaction (signed hex)\n"
70 [ + - + - : 90724 : + HelpExampleCli("sendrawtransaction", "\"signedhex\"") +
+ - + - ]
71 : 22681 : "\nAs a JSON-RPC call\n"
72 [ + - + - : 90724 : + HelpExampleRpc("sendrawtransaction", "\"signedhex\"")
+ - + - ]
73 [ + - ]: 22681 : },
74 : 20618 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
75 : : {
76 [ + + ]: 20618 : const CAmount max_burn_amount = request.params[2].isNull() ? 0 : AmountFromValue(request.params[2]);
77 : :
78 : 20618 : CMutableTransaction mtx;
79 [ + - + - : 20618 : if (!DecodeHexTx(mtx, request.params[0].get_str())) {
+ - + + ]
80 [ + - + - ]: 4 : throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed. Make sure the tx has at least one input.");
81 : : }
82 : :
83 [ + + ]: 79805 : for (const auto& out : mtx.vout) {
84 [ + + + - : 59193 : if((out.scriptPubKey.IsUnspendable() || !out.scriptPubKey.HasValidOps()) && out.nValue > max_burn_amount) {
+ + + + ]
85 [ + - + - ]: 8 : throw JSONRPCTransactionError(TransactionError::MAX_BURN_EXCEEDED);
86 : : }
87 : : }
88 : :
89 [ + - ]: 20612 : CTransactionRef tx(MakeTransactionRef(std::move(mtx)));
90 : :
91 [ + - + - ]: 20612 : const CFeeRate max_raw_tx_fee_rate{ParseFeeRate(self.Arg<UniValue>("maxfeerate"))};
92 : :
93 [ + - ]: 20612 : int64_t virtual_size = GetVirtualTransactionSize(*tx);
94 [ + - ]: 20612 : CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
95 : :
96 [ + - ]: 20612 : std::string err_string;
97 : 20612 : AssertLockNotHeld(cs_main);
98 [ + - ]: 20612 : NodeContext& node = EnsureAnyNodeContext(request.context);
99 [ + - + - : 41224 : const TransactionError err = BroadcastTransaction(node, tx, err_string, max_raw_tx_fee, /*relay=*/true, /*wait_callback=*/true);
+ - ]
100 [ + + ]: 20612 : if (TransactionError::OK != err) {
101 [ + - ]: 4195 : throw JSONRPCTransactionError(err, err_string);
102 : : }
103 : :
104 [ + - + - ]: 32834 : return tx->GetHash().GetHex();
105 [ + - ]: 57641 : },
106 [ + - + - : 430939 : };
+ - + - +
- + - + -
+ - + - +
- + + -
- ]
107 [ + - + - : 158767 : }
+ - + - -
- ]
108 : :
109 : 3520 : static RPCHelpMan testmempoolaccept()
110 : : {
111 : 3520 : return RPCHelpMan{"testmempoolaccept",
112 : : "\nReturns result of mempool acceptance tests indicating if raw transaction(s) (serialized, hex-encoded) would be accepted by mempool.\n"
113 : : "\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"
114 : : "\nIf one transaction fails, other transactions may not be fully validated (the 'allowed' key will be blank).\n"
115 [ + - + - ]: 7040 : "\nThe maximum number of transactions allowed is " + ToString(MAX_PACKAGE_COUNT) + ".\n"
116 : : "\nThis checks if transactions violate the consensus or policy rules.\n"
117 : 3520 : "\nSee sendrawtransaction call.\n",
118 : : {
119 [ + - ]: 3520 : {"rawtxs", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of hex strings of raw transactions.",
120 : : {
121 [ + - ]: 3520 : {"rawtx", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, ""},
122 : : },
123 : : },
124 [ + - + - ]: 7040 : {"maxfeerate", RPCArg::Type::AMOUNT, RPCArg::Default{FormatMoney(DEFAULT_MAX_RAW_TX_FEE_RATE.GetFeePerK())},
125 : 3520 : "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT +
126 : 3520 : "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
127 : : },
128 : 0 : RPCResult{
129 : : RPCResult::Type::ARR, "", "The result of the mempool acceptance test for each raw transaction in the input array.\n"
130 : : "Returns results for each transaction in the same order they were passed in.\n"
131 : : "Transactions that cannot be fully validated due to failures in other transactions will not contain an 'allowed' result.\n",
132 : : {
133 : : {RPCResult::Type::OBJ, "", "",
134 : : {
135 : : {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
136 : : {RPCResult::Type::STR_HEX, "wtxid", "The transaction witness hash in hex"},
137 : : {RPCResult::Type::STR, "package-error", /*optional=*/true, "Package validation error, if any (only possible if rawtxs had more than 1 transaction)."},
138 : : {RPCResult::Type::BOOL, "allowed", /*optional=*/true, "Whether this tx would be accepted to the mempool and pass client-specified maxfeerate. "
139 : : "If not present, the tx was not fully validated due to a failure in another tx in the list."},
140 : : {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)"},
141 : : {RPCResult::Type::OBJ, "fees", /*optional=*/true, "Transaction fees (only present if 'allowed' is true)",
142 : : {
143 [ + - ]: 7040 : {RPCResult::Type::STR_AMOUNT, "base", "transaction fee in " + CURRENCY_UNIT},
144 [ + - ]: 7040 : {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."},
145 : : {RPCResult::Type::ARR, "effective-includes", /*optional=*/false, "transactions whose fees and vsizes are included in effective-feerate.",
146 [ + - + - : 7040 : {RPCResult{RPCResult::Type::STR_HEX, "", "transaction wtxid in hex"},
+ - ]
147 : : }},
148 : : }},
149 : : {RPCResult::Type::STR, "reject-reason", /*optional=*/true, "Rejection string (only present when 'allowed' is false)"},
150 : : }},
151 : : }
152 [ + - + - : 80960 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + + + +
+ + + + -
- - - - -
- - ]
153 : 3520 : RPCExamples{
154 : : "\nCreate a transaction\n"
155 [ + - + - : 7040 : + HelpExampleCli("createrawtransaction", "\"[{\\\"txid\\\" : \\\"mytxid\\\",\\\"vout\\\":0}]\" \"{\\\"myaddress\\\":0.01}\"") +
+ - + - ]
156 : 3520 : "Sign the transaction, and get back the hex\n"
157 [ + - + - : 14080 : + HelpExampleCli("signrawtransactionwithwallet", "\"myhex\"") +
+ - + - ]
158 : 3520 : "\nTest acceptance of the transaction (signed hex)\n"
159 [ + - + - : 14080 : + HelpExampleCli("testmempoolaccept", R"('["signedhex"]')") +
+ - + - ]
160 : 3520 : "\nAs a JSON-RPC call\n"
161 [ + - + - ]: 14080 : + HelpExampleRpc("testmempoolaccept", "[\"signedhex\"]")
162 [ + - ]: 3520 : },
163 : 1457 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
164 : : {
165 : 1457 : const UniValue raw_transactions = request.params[0].get_array();
166 [ + + + + ]: 1457 : if (raw_transactions.size() < 1 || raw_transactions.size() > MAX_PACKAGE_COUNT) {
167 : 2 : throw JSONRPCError(RPC_INVALID_PARAMETER,
168 [ + - + - : 6 : "Array must contain between 1 and " + ToString(MAX_PACKAGE_COUNT) + " transactions.");
+ - ]
169 : : }
170 : :
171 [ + - + + ]: 1455 : const CFeeRate max_raw_tx_fee_rate{ParseFeeRate(self.Arg<UniValue>("maxfeerate"))};
172 : :
173 : 1453 : std::vector<CTransactionRef> txns;
174 [ + - ]: 1453 : txns.reserve(raw_transactions.size());
175 [ + - + + ]: 3507 : for (const auto& rawtx : raw_transactions.getValues()) {
176 [ + - ]: 2055 : CMutableTransaction mtx;
177 [ + - + - : 2055 : if (!DecodeHexTx(mtx, rawtx.get_str())) {
+ + ]
178 : 1 : throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
179 [ + - + - : 3 : "TX decode failed: " + rawtx.get_str() + " Make sure the tx has at least one input.");
+ - ]
180 : : }
181 [ + - + - ]: 6162 : txns.emplace_back(MakeTransactionRef(std::move(mtx)));
182 : 2055 : }
183 : :
184 [ + - ]: 1452 : NodeContext& node = EnsureAnyNodeContext(request.context);
185 [ + - ]: 1452 : CTxMemPool& mempool = EnsureMemPool(node);
186 [ + - ]: 1452 : ChainstateManager& chainman = EnsureChainman(node);
187 [ + - ]: 1452 : Chainstate& chainstate = chainman.ActiveChainstate();
188 : 2904 : const PackageMempoolAcceptResult package_result = [&] {
189 : 1452 : LOCK(::cs_main);
190 [ + + + - ]: 1452 : if (txns.size() > 1) return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/true, /*client_maxfeerate=*/{});
191 [ + - ]: 1369 : return PackageMempoolAcceptResult(txns[0]->GetWitnessHash(),
192 [ + - + - ]: 1369 : chainman.ProcessTransaction(txns[0], /*test_accept=*/true));
193 [ + - ]: 2904 : }();
194 : :
195 : 1452 : UniValue rpc_result(UniValue::VARR);
196 : : // We will check transaction fees while we iterate through txns in order. If any transaction fee
197 : : // exceeds maxfeerate, we will leave the rest of the validation results blank, because it
198 : : // doesn't make sense to return a validation result for a transaction if its ancestor(s) would
199 : : // not be submitted.
200 : 1452 : bool exit_early{false};
201 [ + + ]: 3506 : for (const auto& tx : txns) {
202 : 2054 : UniValue result_inner(UniValue::VOBJ);
203 [ + - + - : 4108 : result_inner.pushKV("txid", tx->GetHash().GetHex());
+ - + - ]
204 [ + - + - : 4108 : result_inner.pushKV("wtxid", tx->GetWitnessHash().GetHex());
+ - + - ]
205 [ + + ]: 2054 : if (package_result.m_state.GetResult() == PackageValidationResult::PCKG_POLICY) {
206 [ + - + - : 220 : result_inner.pushKV("package-error", package_result.m_state.ToString());
+ - + - ]
207 : : }
208 : 2054 : auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
209 [ + + + + ]: 2054 : if (exit_early || it == package_result.m_tx_results.end()) {
210 : : // Validation unfinished. Just return the txid and wtxid.
211 [ + - ]: 149 : rpc_result.push_back(std::move(result_inner));
212 : 149 : continue;
213 : : }
214 [ + - ]: 1905 : const auto& tx_result = it->second;
215 : : // Package testmempoolaccept doesn't allow transactions to already be in the mempool.
216 [ + - ]: 1905 : CHECK_NONFATAL(tx_result.m_result_type != MempoolAcceptResult::ResultType::MEMPOOL_ENTRY);
217 [ + + ]: 1905 : if (tx_result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
218 [ + - ]: 1773 : const CAmount fee = tx_result.m_base_fees.value();
219 : : // Check that fee does not exceed maximum fee
220 [ + - ]: 1773 : const int64_t virtual_size = tx_result.m_vsize.value();
221 [ + - ]: 1773 : const CAmount max_raw_tx_fee = max_raw_tx_fee_rate.GetFee(virtual_size);
222 [ + + ]: 1773 : if (max_raw_tx_fee && fee > max_raw_tx_fee) {
223 [ + - + - : 8 : result_inner.pushKV("allowed", false);
+ - ]
224 [ + - + - : 4 : result_inner.pushKV("reject-reason", "max-fee-exceeded");
+ - ]
225 : 4 : exit_early = true;
226 : : } else {
227 : : // Only return the fee and vsize if the transaction would pass ATMP.
228 : : // These can be used to calculate the feerate.
229 [ + - + - : 3538 : result_inner.pushKV("allowed", true);
+ - ]
230 [ + - + - : 3538 : result_inner.pushKV("vsize", virtual_size);
+ - ]
231 : 1769 : UniValue fees(UniValue::VOBJ);
232 [ + - + - : 3538 : fees.pushKV("base", ValueFromAmount(fee));
+ - ]
233 [ + - + - : 3538 : fees.pushKV("effective-feerate", ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
+ - + - ]
234 : 1769 : UniValue effective_includes_res(UniValue::VARR);
235 [ + - + + ]: 3538 : for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
236 [ + - + - : 1769 : effective_includes_res.push_back(wtxid.ToString());
+ - ]
237 : : }
238 [ + - + - ]: 3538 : fees.pushKV("effective-includes", std::move(effective_includes_res));
239 [ + - + - ]: 3538 : result_inner.pushKV("fees", std::move(fees));
240 : 1769 : }
241 : : } else {
242 [ + - + - : 264 : result_inner.pushKV("allowed", false);
+ - ]
243 [ + - ]: 132 : const TxValidationState state = tx_result.m_state;
244 [ + + ]: 132 : if (state.GetResult() == TxValidationResult::TX_MISSING_INPUTS) {
245 [ + - + - : 12 : result_inner.pushKV("reject-reason", "missing-inputs");
+ - ]
246 : : } else {
247 [ + - + - : 252 : result_inner.pushKV("reject-reason", state.GetRejectReason());
+ - + - ]
248 : : }
249 : 132 : }
250 [ + - ]: 1905 : rpc_result.push_back(std::move(result_inner));
251 : 2054 : }
252 : 1452 : return rpc_result;
253 : 1458 : },
254 [ + - + - : 66880 : };
+ - + - +
- + - + -
+ - + - +
- + + + +
- - - - ]
255 [ + - + - : 70400 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
- - - - -
- ]
256 : :
257 : 15183 : static std::vector<RPCResult> MempoolEntryDescription()
258 : : {
259 : 15183 : return {
260 [ + - + - : 30366 : 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."},
+ - ]
261 [ + - + - : 30366 : RPCResult{RPCResult::Type::NUM, "weight", "transaction weight as defined in BIP 141."},
+ - ]
262 [ + - + - : 30366 : RPCResult{RPCResult::Type::NUM_TIME, "time", "local time transaction entered pool in seconds since 1 Jan 1970 GMT"},
+ - ]
263 [ + - + - : 30366 : RPCResult{RPCResult::Type::NUM, "height", "block height when transaction entered pool"},
+ - ]
264 [ + - + - : 30366 : RPCResult{RPCResult::Type::NUM, "descendantcount", "number of in-mempool descendant transactions (including this one)"},
+ - ]
265 [ + - + - : 30366 : RPCResult{RPCResult::Type::NUM, "descendantsize", "virtual transaction size of in-mempool descendants (including this one)"},
+ - ]
266 [ + - + - : 30366 : RPCResult{RPCResult::Type::NUM, "ancestorcount", "number of in-mempool ancestor transactions (including this one)"},
+ - ]
267 [ + - + - : 30366 : RPCResult{RPCResult::Type::NUM, "ancestorsize", "virtual transaction size of in-mempool ancestors (including this one)"},
+ - ]
268 [ + - + - : 30366 : RPCResult{RPCResult::Type::STR_HEX, "wtxid", "hash of serialized transaction, including witness data"},
+ - ]
269 : : RPCResult{RPCResult::Type::OBJ, "fees", "",
270 : : {
271 [ + - + - : 30366 : RPCResult{RPCResult::Type::STR_AMOUNT, "base", "transaction fee, denominated in " + CURRENCY_UNIT},
+ - ]
272 [ + - + - : 30366 : RPCResult{RPCResult::Type::STR_AMOUNT, "modified", "transaction fee with fee deltas used for mining priority, denominated in " + CURRENCY_UNIT},
+ - ]
273 [ + - + - : 30366 : 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},
+ - ]
274 [ + - + - : 30366 : 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},
+ - ]
275 [ + - + - : 121464 : }},
+ - + + -
- ]
276 : : RPCResult{RPCResult::Type::ARR, "depends", "unconfirmed transactions used as inputs for this transaction",
277 [ + - + - : 45549 : {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "parent transaction id"}}},
+ - + - +
- + - + +
- - ]
278 : : RPCResult{RPCResult::Type::ARR, "spentby", "unconfirmed transactions spending outputs from this transaction",
279 [ + - + - : 45549 : {RPCResult{RPCResult::Type::STR_HEX, "transactionid", "child transaction id"}}},
+ - + - +
- + - + +
- - ]
280 [ + - + - : 30366 : RPCResult{RPCResult::Type::BOOL, "bip125-replaceable", "Whether this transaction signals BIP125 replaceability or has an unconfirmed ancestor signaling BIP125 replaceability.\n"},
+ - ]
281 [ + - + - : 30366 : RPCResult{RPCResult::Type::BOOL, "unbroadcast", "Whether this transaction is currently unbroadcast (initial broadcast not yet acknowledged by any peers)"},
+ - ]
282 [ + - + + : 258111 : };
- - ]
283 [ + - + - : 318843 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - - -
- - ]
284 : :
285 : 4399 : static void entryToJSON(const CTxMemPool& pool, UniValue& info, const CTxMemPoolEntry& e) EXCLUSIVE_LOCKS_REQUIRED(pool.cs)
286 : : {
287 : 4399 : AssertLockHeld(pool.cs);
288 : :
289 [ + - + - ]: 8798 : info.pushKV("vsize", (int)e.GetTxSize());
290 [ + - + - ]: 8798 : info.pushKV("weight", (int)e.GetTxWeight());
291 [ + - + - ]: 8798 : info.pushKV("time", count_seconds(e.GetTime()));
292 [ + - + - ]: 8798 : info.pushKV("height", (int)e.GetHeight());
293 [ + - + - ]: 8798 : info.pushKV("descendantcount", e.GetCountWithDescendants());
294 [ + - + - ]: 8798 : info.pushKV("descendantsize", e.GetSizeWithDescendants());
295 [ + - + - ]: 8798 : info.pushKV("ancestorcount", e.GetCountWithAncestors());
296 [ + - + - ]: 8798 : info.pushKV("ancestorsize", e.GetSizeWithAncestors());
297 [ + - + - : 8798 : info.pushKV("wtxid", e.GetTx().GetWitnessHash().ToString());
+ - ]
298 : :
299 : 4399 : UniValue fees(UniValue::VOBJ);
300 [ + - + - : 8798 : fees.pushKV("base", ValueFromAmount(e.GetFee()));
+ - ]
301 [ + - + - : 8798 : fees.pushKV("modified", ValueFromAmount(e.GetModifiedFee()));
+ - ]
302 [ + - + - : 8798 : fees.pushKV("ancestor", ValueFromAmount(e.GetModFeesWithAncestors()));
+ - ]
303 [ + - + - : 8798 : fees.pushKV("descendant", ValueFromAmount(e.GetModFeesWithDescendants()));
+ - ]
304 [ + - + - ]: 8798 : info.pushKV("fees", std::move(fees));
305 : :
306 : 4399 : const CTransaction& tx = e.GetTx();
307 : 4399 : std::set<std::string> setDepends;
308 [ + + ]: 15518 : for (const CTxIn& txin : tx.vin)
309 : : {
310 [ + - + + ]: 11119 : if (pool.exists(GenTxid::Txid(txin.prevout.hash)))
311 [ + - + - ]: 12470 : setDepends.insert(txin.prevout.hash.ToString());
312 : : }
313 : :
314 : 4399 : UniValue depends(UniValue::VARR);
315 [ + + ]: 10634 : for (const std::string& dep : setDepends)
316 : : {
317 [ + - + - ]: 6235 : depends.push_back(dep);
318 : : }
319 : :
320 [ + - + - ]: 8798 : info.pushKV("depends", std::move(depends));
321 : :
322 : 4399 : UniValue spent(UniValue::VARR);
323 [ + - + + ]: 10451 : for (const CTxMemPoolEntry& child : e.GetMemPoolChildrenConst()) {
324 [ + - + - : 6052 : spent.push_back(child.GetTx().GetHash().ToString());
+ - ]
325 : : }
326 : :
327 [ + - + - ]: 8798 : info.pushKV("spentby", std::move(spent));
328 : :
329 : : // Add opt-in RBF status
330 : 4399 : bool rbfStatus = false;
331 [ + - ]: 4399 : RBFTransactionState rbfState = IsRBFOptIn(tx, pool);
332 [ - + ]: 4399 : if (rbfState == RBFTransactionState::UNKNOWN) {
333 [ # # # # ]: 0 : throw JSONRPCError(RPC_MISC_ERROR, "Transaction is not in mempool");
334 [ + + ]: 4399 : } else if (rbfState == RBFTransactionState::REPLACEABLE_BIP125) {
335 : 3517 : rbfStatus = true;
336 : : }
337 : :
338 [ + - + - : 8798 : info.pushKV("bip125-replaceable", rbfStatus);
+ - ]
339 [ + - + - : 8798 : info.pushKV("unbroadcast", pool.IsUnbroadcastTx(tx.GetHash()));
+ - ]
340 : 4399 : }
341 : :
342 : 5934 : UniValue MempoolToJSON(const CTxMemPool& pool, bool verbose, bool include_mempool_sequence)
343 : : {
344 [ + + ]: 5934 : if (verbose) {
345 [ + + ]: 960 : if (include_mempool_sequence) {
346 [ + - + - ]: 2 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Verbose results cannot contain mempool sequence values.");
347 : : }
348 : 959 : LOCK(pool.cs);
349 : 959 : UniValue o(UniValue::VOBJ);
350 [ + - + + ]: 3814 : for (const CTxMemPoolEntry& e : pool.entryAll()) {
351 : 2855 : UniValue info(UniValue::VOBJ);
352 [ + - ]: 2855 : entryToJSON(pool, info, e);
353 : : // Mempool has unique entries so there is no advantage in using
354 : : // UniValue::pushKV, which checks if the key already exists in O(N).
355 : : // UniValue::pushKVEnd is used instead which currently is O(1).
356 [ + - + - ]: 5710 : o.pushKVEnd(e.GetTx().GetHash().ToString(), std::move(info));
357 : 2855 : }
358 [ + - ]: 959 : return o;
359 : 959 : } else {
360 : 4974 : UniValue a(UniValue::VARR);
361 : 4974 : uint64_t mempool_sequence;
362 : 4974 : {
363 [ + - ]: 4974 : LOCK(pool.cs);
364 [ + - + - : 169441 : for (const CTxMemPoolEntry& e : pool.entryAll()) {
+ + ]
365 [ + - + - : 164467 : a.push_back(e.GetTx().GetHash().ToString());
+ - ]
366 : 0 : }
367 [ + - ]: 4974 : mempool_sequence = pool.GetSequence();
368 : 0 : }
369 [ + + ]: 4974 : if (!include_mempool_sequence) {
370 : 4967 : return a;
371 : : } else {
372 : 7 : UniValue o(UniValue::VOBJ);
373 [ + - + - ]: 14 : o.pushKV("txids", std::move(a));
374 [ + - + - : 14 : o.pushKV("mempool_sequence", mempool_sequence);
+ - ]
375 : 7 : return o;
376 : 7 : }
377 : 4974 : }
378 : : }
379 : :
380 : 7992 : static RPCHelpMan getrawmempool()
381 : : {
382 : 7992 : return RPCHelpMan{"getrawmempool",
383 : : "\nReturns all transaction ids in memory pool as a json array of string transaction ids.\n"
384 : : "\nHint: use getmempoolentry to fetch a specific transaction from the mempool.\n",
385 : : {
386 [ + - ]: 15984 : {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
387 [ + - ]: 15984 : {"mempool_sequence", RPCArg::Type::BOOL, RPCArg::Default{false}, "If verbose=false, returns a json object with transaction list and mempool sequence number attached."},
388 : : },
389 : : {
390 : : RPCResult{"for verbose = false",
391 : : RPCResult::Type::ARR, "", "",
392 : : {
393 : : {RPCResult::Type::STR_HEX, "", "The transaction id"},
394 [ + - + - : 23976 : }},
+ - + - +
- + - + -
+ + - - ]
395 : : RPCResult{"for verbose = true",
396 : : RPCResult::Type::OBJ_DYN, "", "",
397 : : {
398 [ + - ]: 15984 : {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
399 [ + - + - : 39960 : }},
+ - + - +
- + - + +
- - ]
400 : : RPCResult{"for verbose = false and mempool_sequence = true",
401 : : RPCResult::Type::OBJ, "", "",
402 : : {
403 : : {RPCResult::Type::ARR, "txids", "",
404 : : {
405 : : {RPCResult::Type::STR_HEX, "", "The transaction id"},
406 : : }},
407 : : {RPCResult::Type::NUM, "mempool_sequence", "The mempool sequence value."},
408 [ + - + - : 47952 : }},
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + + +
+ - - -
- ]
409 : : },
410 : 7992 : RPCExamples{
411 [ + - + - : 15984 : HelpExampleCli("getrawmempool", "true")
+ - ]
412 [ + - + - : 31968 : + HelpExampleRpc("getrawmempool", "true")
+ - + - ]
413 [ + - ]: 7992 : },
414 : 5930 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
415 : : {
416 : 5930 : bool fVerbose = false;
417 [ + + ]: 5930 : if (!request.params[0].isNull())
418 : 994 : fVerbose = request.params[0].get_bool();
419 : :
420 : 5930 : bool include_mempool_sequence = false;
421 [ + + ]: 5930 : if (!request.params[1].isNull()) {
422 : 8 : include_mempool_sequence = request.params[1].get_bool();
423 : : }
424 : :
425 : 5930 : return MempoolToJSON(EnsureAnyMemPool(request.context), fVerbose, include_mempool_sequence);
426 : : },
427 [ + - + - : 159840 : };
+ - + - +
- + - + -
+ - + - +
+ + + - -
- - ]
428 [ + - + - : 111888 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
- - - - -
- ]
429 : :
430 : 2113 : static RPCHelpMan getmempoolancestors()
431 : : {
432 : 2113 : return RPCHelpMan{"getmempoolancestors",
433 : : "\nIf txid is in the mempool, returns all in-mempool ancestors.\n",
434 : : {
435 [ + - ]: 2113 : {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
436 [ + - ]: 4226 : {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
437 : : },
438 : : {
439 : : RPCResult{"for verbose = false",
440 : : RPCResult::Type::ARR, "", "",
441 [ + - + - : 6339 : {{RPCResult::Type::STR_HEX, "", "The transaction id of an in-mempool ancestor transaction"}}},
+ - + - +
- + - + -
+ + - - ]
442 : : RPCResult{"for verbose = true",
443 : : RPCResult::Type::OBJ_DYN, "", "",
444 : : {
445 [ + - ]: 4226 : {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
446 [ + - + - : 10565 : }},
+ - + - +
- + - + +
- - ]
447 : : },
448 : 2113 : RPCExamples{
449 [ + - + - : 4226 : HelpExampleCli("getmempoolancestors", "\"mytxid\"")
+ - ]
450 [ + - + - : 8452 : + HelpExampleRpc("getmempoolancestors", "\"mytxid\"")
+ - + - ]
451 [ + - ]: 2113 : },
452 : 51 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
453 : : {
454 : 51 : bool fVerbose = false;
455 [ + + ]: 51 : if (!request.params[1].isNull())
456 : 26 : fVerbose = request.params[1].get_bool();
457 : :
458 : 51 : uint256 hash = ParseHashV(request.params[0], "parameter 1");
459 : :
460 : 51 : const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
461 : 51 : LOCK(mempool.cs);
462 : :
463 [ + - ]: 51 : const auto entry{mempool.GetEntry(Txid::FromUint256(hash))};
464 [ - + ]: 51 : if (entry == nullptr) {
465 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
466 : : }
467 : :
468 [ + - ]: 51 : auto ancestors{mempool.AssumeCalculateMemPoolAncestors(self.m_name, *entry, CTxMemPool::Limits::NoLimits(), /*fSearchForParents=*/false)};
469 : :
470 [ + + ]: 51 : if (!fVerbose) {
471 : 25 : UniValue o(UniValue::VARR);
472 [ + + ]: 325 : for (CTxMemPool::txiter ancestorIt : ancestors) {
473 [ + - + - : 300 : o.push_back(ancestorIt->GetTx().GetHash().ToString());
+ - ]
474 : : }
475 : : return o;
476 : 0 : } else {
477 : 26 : UniValue o(UniValue::VOBJ);
478 [ + + ]: 350 : for (CTxMemPool::txiter ancestorIt : ancestors) {
479 : 324 : const CTxMemPoolEntry &e = *ancestorIt;
480 : 324 : const uint256& _hash = e.GetTx().GetHash();
481 : 324 : UniValue info(UniValue::VOBJ);
482 [ + - ]: 324 : entryToJSON(mempool, info, e);
483 [ + - + - ]: 648 : o.pushKV(_hash.ToString(), std::move(info));
484 : 324 : }
485 : 26 : return o;
486 : 26 : }
487 [ + - ]: 102 : },
488 [ + - + - : 35921 : };
+ - + - +
- + - + -
+ - + - +
+ + + - -
- - ]
489 [ + - + - : 21130 : }
+ - + - +
- + - + -
+ - - - -
- ]
490 : :
491 : 2113 : static RPCHelpMan getmempooldescendants()
492 : : {
493 : 2113 : return RPCHelpMan{"getmempooldescendants",
494 : : "\nIf txid is in the mempool, returns all in-mempool descendants.\n",
495 : : {
496 [ + - ]: 2113 : {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
497 [ + - ]: 4226 : {"verbose", RPCArg::Type::BOOL, RPCArg::Default{false}, "True for a json object, false for array of transaction ids"},
498 : : },
499 : : {
500 : : RPCResult{"for verbose = false",
501 : : RPCResult::Type::ARR, "", "",
502 [ + - + - : 6339 : {{RPCResult::Type::STR_HEX, "", "The transaction id of an in-mempool descendant transaction"}}},
+ - + - +
- + - + -
+ + - - ]
503 : : RPCResult{"for verbose = true",
504 : : RPCResult::Type::OBJ_DYN, "", "",
505 : : {
506 [ + - ]: 4226 : {RPCResult::Type::OBJ, "transactionid", "", MempoolEntryDescription()},
507 [ + - + - : 10565 : }},
+ - + - +
- + - + +
- - ]
508 : : },
509 : 2113 : RPCExamples{
510 [ + - + - : 4226 : HelpExampleCli("getmempooldescendants", "\"mytxid\"")
+ - ]
511 [ + - + - : 8452 : + HelpExampleRpc("getmempooldescendants", "\"mytxid\"")
+ - + - ]
512 [ + - ]: 2113 : },
513 : 51 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
514 : : {
515 : 51 : bool fVerbose = false;
516 [ + + ]: 51 : if (!request.params[1].isNull())
517 : 26 : fVerbose = request.params[1].get_bool();
518 : :
519 : 51 : uint256 hash = ParseHashV(request.params[0], "parameter 1");
520 : :
521 : 51 : const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
522 : 51 : LOCK(mempool.cs);
523 : :
524 [ + - ]: 51 : const auto it{mempool.GetIter(hash)};
525 [ - + ]: 51 : if (!it) {
526 [ # # # # ]: 0 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
527 : : }
528 : :
529 [ + - ]: 51 : CTxMemPool::setEntries setDescendants;
530 [ + - ]: 51 : mempool.CalculateDescendants(*it, setDescendants);
531 : : // CTxMemPool::CalculateDescendants will include the given tx
532 : 51 : setDescendants.erase(*it);
533 : :
534 [ + + ]: 51 : if (!fVerbose) {
535 : 25 : UniValue o(UniValue::VARR);
536 [ + + ]: 325 : for (CTxMemPool::txiter descendantIt : setDescendants) {
537 [ + - + - : 300 : o.push_back(descendantIt->GetTx().GetHash().ToString());
+ - ]
538 : : }
539 : :
540 : : return o;
541 : 0 : } else {
542 : 26 : UniValue o(UniValue::VOBJ);
543 [ + + ]: 350 : for (CTxMemPool::txiter descendantIt : setDescendants) {
544 : 324 : const CTxMemPoolEntry &e = *descendantIt;
545 : 324 : const uint256& _hash = e.GetTx().GetHash();
546 : 324 : UniValue info(UniValue::VOBJ);
547 [ + - ]: 324 : entryToJSON(mempool, info, e);
548 [ + - + - ]: 648 : o.pushKV(_hash.ToString(), std::move(info));
549 : 324 : }
550 : 26 : return o;
551 : 26 : }
552 [ + - ]: 102 : },
553 [ + - + - : 35921 : };
+ - + - +
- + - + -
+ - + - +
+ + + - -
- - ]
554 [ + - + - : 21130 : }
+ - + - +
- + - + -
+ - - - -
- ]
555 : :
556 : 2965 : static RPCHelpMan getmempoolentry()
557 : : {
558 : 2965 : return RPCHelpMan{"getmempoolentry",
559 : : "\nReturns mempool data for given transaction\n",
560 : : {
561 [ + - ]: 2965 : {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id (must be in mempool)"},
562 : : },
563 : 0 : RPCResult{
564 [ + - + - : 5930 : RPCResult::Type::OBJ, "", "", MempoolEntryDescription()},
+ - + - ]
565 : 2965 : RPCExamples{
566 [ + - + - : 5930 : HelpExampleCli("getmempoolentry", "\"mytxid\"")
+ - ]
567 [ + - + - : 11860 : + HelpExampleRpc("getmempoolentry", "\"mytxid\"")
+ - + - ]
568 [ + - ]: 2965 : },
569 : 903 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
570 : : {
571 : 903 : uint256 hash = ParseHashV(request.params[0], "parameter 1");
572 : :
573 : 903 : const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
574 : 903 : LOCK(mempool.cs);
575 : :
576 [ + - ]: 903 : const auto entry{mempool.GetEntry(Txid::FromUint256(hash))};
577 [ + + ]: 903 : if (entry == nullptr) {
578 [ + - + - ]: 14 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Transaction not in mempool");
579 : : }
580 : :
581 : 896 : UniValue info(UniValue::VOBJ);
582 [ + - ]: 896 : entryToJSON(mempool, info, *entry);
583 [ + - ]: 896 : return info;
584 : 896 : },
585 [ + - + - : 26685 : };
+ - + - +
- + - + +
- - ]
586 [ + - + - ]: 8895 : }
587 : :
588 : 2098 : static RPCHelpMan gettxspendingprevout()
589 : : {
590 : 2098 : return RPCHelpMan{"gettxspendingprevout",
591 : : "Scans the mempool to find transactions spending any of the given outputs",
592 : : {
593 [ + - ]: 2098 : {"outputs", RPCArg::Type::ARR, RPCArg::Optional::NO, "The transaction outputs that we want to check, and within each, the txid (string) vout (numeric).",
594 : : {
595 [ + - ]: 2098 : {"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, "",
596 : : {
597 [ + - ]: 2098 : {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
598 [ + - ]: 2098 : {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
599 : : },
600 : : },
601 : : },
602 : : },
603 : : },
604 : 0 : RPCResult{
605 : : RPCResult::Type::ARR, "", "",
606 : : {
607 : : {RPCResult::Type::OBJ, "", "",
608 : : {
609 : : {RPCResult::Type::STR_HEX, "txid", "the transaction id of the checked output"},
610 : : {RPCResult::Type::NUM, "vout", "the vout value of the checked output"},
611 : : {RPCResult::Type::STR_HEX, "spendingtxid", /*optional=*/true, "the transaction id of the mempool transaction spending this output (omitted if unspent)"},
612 : : }},
613 : : }
614 [ + - + - : 14686 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + +
+ + - - -
- ]
615 : 2098 : RPCExamples{
616 [ + - + - : 4196 : HelpExampleCli("gettxspendingprevout", "\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
+ - ]
617 [ + - + - : 8392 : + HelpExampleRpc("gettxspendingprevout", "\"[{\\\"txid\\\":\\\"a08e6907dbbd3d809776dbfc5d82e371b764ed838b5655e72f463568df1aadf0\\\",\\\"vout\\\":3}]\"")
+ - + - ]
618 [ + - ]: 2098 : },
619 : 36 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
620 : : {
621 : 36 : const UniValue& output_params = request.params[0].get_array();
622 [ + + ]: 36 : if (output_params.empty()) {
623 [ + - + - ]: 2 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, outputs are missing");
624 : : }
625 : :
626 : 35 : std::vector<COutPoint> prevouts;
627 [ + - ]: 35 : prevouts.reserve(output_params.size());
628 : :
629 [ + + ]: 68 : for (unsigned int idx = 0; idx < output_params.size(); idx++) {
630 [ + - + - ]: 38 : const UniValue& o = output_params[idx].get_obj();
631 : :
632 [ + + + + : 156 : RPCTypeCheckObj(o,
+ + ]
633 : : {
634 [ + - ]: 38 : {"txid", UniValueType(UniValue::VSTR)},
635 [ + - ]: 38 : {"vout", UniValueType(UniValue::VNUM)},
636 : : }, /*fAllowNull=*/false, /*fStrict=*/true);
637 : :
638 [ + - ]: 34 : const Txid txid = Txid::FromUint256(ParseHashO(o, "txid"));
639 [ + - + - ]: 34 : const int nOutput{o.find_value("vout").getInt<int>()};
640 [ + + ]: 34 : if (nOutput < 0) {
641 [ + - + - ]: 2 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
642 : : }
643 : :
644 [ + - ]: 33 : prevouts.emplace_back(txid, nOutput);
645 : : }
646 : :
647 [ + - ]: 30 : const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
648 [ + - ]: 30 : LOCK(mempool.cs);
649 : :
650 : 30 : UniValue result{UniValue::VARR};
651 : :
652 [ + + ]: 63 : for (const COutPoint& prevout : prevouts) {
653 : 33 : UniValue o(UniValue::VOBJ);
654 [ + - + - : 66 : o.pushKV("txid", prevout.hash.ToString());
+ - + - ]
655 [ + - + - : 66 : o.pushKV("vout", (uint64_t)prevout.n);
+ - ]
656 : :
657 [ + - ]: 33 : const CTransaction* spendingTx = mempool.GetConflictTx(prevout);
658 [ + + ]: 33 : if (spendingTx != nullptr) {
659 [ + - + - : 60 : o.pushKV("spendingtxid", spendingTx->GetHash().ToString());
+ - + - ]
660 : : }
661 : :
662 [ + - ]: 33 : result.push_back(std::move(o));
663 : 33 : }
664 : :
665 [ + - ]: 30 : return result;
666 [ + - + - : 72 : },
+ - - + ]
667 [ + - + - : 37764 : };
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
+ + + + +
- - - - -
- ]
668 [ + - + - : 29372 : }
+ - + - +
- + - + -
+ - + - +
- - - -
- ]
669 : :
670 : 2676 : UniValue MempoolInfoToJSON(const CTxMemPool& pool)
671 : : {
672 : : // Make sure this call is atomic in the pool.
673 : 2676 : LOCK(pool.cs);
674 : 2676 : UniValue ret(UniValue::VOBJ);
675 [ + - + - : 5352 : ret.pushKV("loaded", pool.GetLoadTried());
+ - + - ]
676 [ + - + - : 5352 : ret.pushKV("size", (int64_t)pool.size());
+ - + - ]
677 [ + - + - : 5352 : ret.pushKV("bytes", (int64_t)pool.GetTotalTxSize());
+ - ]
678 [ + - + - : 5352 : ret.pushKV("usage", (int64_t)pool.DynamicMemoryUsage());
+ - + - ]
679 [ + - + - : 5352 : ret.pushKV("total_fee", ValueFromAmount(pool.GetTotalFee()));
+ - ]
680 [ + - + - : 5352 : ret.pushKV("maxmempool", pool.m_opts.max_size_bytes);
+ - ]
681 [ + - + + : 7957 : ret.pushKV("mempoolminfee", ValueFromAmount(std::max(pool.GetMinFee(), pool.m_opts.min_relay_feerate).GetFeePerK()));
+ - + - +
- ]
682 [ + - + - : 5352 : ret.pushKV("minrelaytxfee", ValueFromAmount(pool.m_opts.min_relay_feerate.GetFeePerK()));
+ - ]
683 [ + - + - : 5352 : ret.pushKV("incrementalrelayfee", ValueFromAmount(pool.m_opts.incremental_relay_feerate.GetFeePerK()));
+ - ]
684 [ + - + - : 5352 : ret.pushKV("unbroadcastcount", uint64_t{pool.GetUnbroadcastTxs().size()});
+ - + - ]
685 [ + - + - : 5352 : ret.pushKV("fullrbf", pool.m_opts.full_rbf);
+ - ]
686 [ + - ]: 2676 : return ret;
687 : 2676 : }
688 : :
689 : 4737 : static RPCHelpMan getmempoolinfo()
690 : : {
691 : 4737 : return RPCHelpMan{"getmempoolinfo",
692 : : "Returns details on the active state of the TX memory pool.",
693 : : {},
694 : 0 : RPCResult{
695 : : RPCResult::Type::OBJ, "", "",
696 : : {
697 : : {RPCResult::Type::BOOL, "loaded", "True if the initial load attempt of the persisted mempool finished"},
698 : : {RPCResult::Type::NUM, "size", "Current tx count"},
699 : : {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, "usage", "Total memory usage for the mempool"},
701 [ + - ]: 9474 : {RPCResult::Type::STR_AMOUNT, "total_fee", "Total fees for the mempool in " + CURRENCY_UNIT + ", ignoring modified fees through prioritisetransaction"},
702 : : {RPCResult::Type::NUM, "maxmempool", "Maximum memory usage for the mempool"},
703 [ + - ]: 9474 : {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"},
704 : : {RPCResult::Type::STR_AMOUNT, "minrelaytxfee", "Current minimum relay fee for transactions"},
705 [ + - ]: 9474 : {RPCResult::Type::NUM, "incrementalrelayfee", "minimum fee rate increment for mempool limiting or replacement in " + CURRENCY_UNIT + "/kvB"},
706 : : {RPCResult::Type::NUM, "unbroadcastcount", "Current number of transactions that haven't passed initial broadcast yet"},
707 : : {RPCResult::Type::BOOL, "fullrbf", "True if the mempool accepts RBF without replaceability signaling inspection"},
708 [ + - + - : 90003 : }},
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
+ - - ]
709 : 4737 : RPCExamples{
710 [ + - + - : 9474 : HelpExampleCli("getmempoolinfo", "")
+ - ]
711 [ + - + - : 18948 : + HelpExampleRpc("getmempoolinfo", "")
+ - + - ]
712 [ + - ]: 4737 : },
713 : 2675 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
714 : : {
715 : 2675 : return MempoolInfoToJSON(EnsureAnyMemPool(request.context));
716 : : },
717 [ + - + - : 28422 : };
+ - + - ]
718 [ + - + - : 56844 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
- - ]
719 : :
720 : 2065 : static RPCHelpMan importmempool()
721 : : {
722 : 2065 : return RPCHelpMan{
723 : : "importmempool",
724 : : "Import a mempool.dat file and attempt to add its contents to the mempool.\n"
725 : : "Warning: Importing untrusted files is dangerous, especially if metadata from the file is taken over.",
726 : : {
727 [ + - ]: 2065 : {"filepath", RPCArg::Type::STR, RPCArg::Optional::NO, "The mempool file"},
728 : : {"options",
729 : : RPCArg::Type::OBJ_NAMED_PARAMS,
730 [ + - ]: 2065 : RPCArg::Optional::OMITTED,
731 : : "",
732 : : {
733 [ + - ]: 4130 : {"use_current_time", RPCArg::Type::BOOL, RPCArg::Default{true},
734 : : "Whether to use the current system time or use the entry time metadata from the mempool file.\n"
735 : : "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
736 [ + - ]: 4130 : {"apply_fee_delta_priority", RPCArg::Type::BOOL, RPCArg::Default{false},
737 : : "Whether to apply the fee delta metadata from the mempool file.\n"
738 : : "It will be added to any existing fee deltas.\n"
739 : : "The fee delta can be set by the prioritisetransaction RPC.\n"
740 : : "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior.\n"
741 : : "Only set this bool if you understand what it does."},
742 [ + - ]: 4130 : {"apply_unbroadcast_set", RPCArg::Type::BOOL, RPCArg::Default{false},
743 : : "Whether to apply the unbroadcast set metadata from the mempool file.\n"
744 : : "Warning: Importing untrusted metadata may lead to unexpected issues and undesirable behavior."},
745 : : },
746 [ + - + - ]: 2065 : RPCArgOptions{.oneline_description = "options"}},
747 : : },
748 [ + - + - : 4130 : RPCResult{RPCResult::Type::OBJ, "", "", std::vector<RPCResult>{}},
+ - ]
749 [ + - + - : 6195 : RPCExamples{HelpExampleCli("importmempool", "/path/to/mempool.dat") + HelpExampleRpc("importmempool", "/path/to/mempool.dat")},
+ - + - +
- + - + -
+ - ]
750 : 3 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
751 : 3 : const NodeContext& node{EnsureAnyNodeContext(request.context)};
752 : :
753 : 3 : CTxMemPool& mempool{EnsureMemPool(node)};
754 : 3 : ChainstateManager& chainman = EnsureChainman(node);
755 : 3 : Chainstate& chainstate = chainman.ActiveChainstate();
756 : :
757 [ - + ]: 3 : if (chainman.IsInitialBlockDownload()) {
758 [ # # # # ]: 0 : throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, "Can only import the mempool after the block download and sync is done.");
759 : : }
760 : :
761 : 3 : const fs::path load_path{fs::u8path(request.params[0].get_str())};
762 [ + - + - : 3 : const UniValue& use_current_time{request.params[1]["use_current_time"]};
+ - ]
763 [ + - + - : 3 : const UniValue& apply_fee_delta{request.params[1]["apply_fee_delta_priority"]};
+ - ]
764 [ + - + - : 3 : const UniValue& apply_unbroadcast{request.params[1]["apply_unbroadcast_set"]};
+ - ]
765 [ - + ]: 3 : node::ImportMempoolOptions opts{
766 [ - + - - ]: 3 : .use_current_time = use_current_time.isNull() ? true : use_current_time.get_bool(),
767 [ + + + - ]: 3 : .apply_fee_delta_priority = apply_fee_delta.isNull() ? false : apply_fee_delta.get_bool(),
768 [ + + + - ]: 3 : .apply_unbroadcast_set = apply_unbroadcast.isNull() ? false : apply_unbroadcast.get_bool(),
769 [ - + + + : 5 : };
+ + ]
770 : :
771 [ + - - + ]: 3 : if (!node::LoadMempool(mempool, load_path, chainstate, std::move(opts))) {
772 [ # # # # ]: 0 : throw JSONRPCError(RPC_MISC_ERROR, "Unable to import mempool file, see debug.log for details.");
773 : : }
774 : :
775 : 3 : UniValue ret{UniValue::VOBJ};
776 : 3 : return ret;
777 : 6 : },
778 [ + - + - : 55755 : };
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + + + +
- - - - ]
779 [ + - + - : 20650 : }
+ - + - +
- + - - -
- - ]
780 : :
781 : 2066 : static RPCHelpMan savemempool()
782 : : {
783 : 2066 : return RPCHelpMan{"savemempool",
784 : : "\nDumps the mempool to disk. It will fail until the previous dump is fully loaded.\n",
785 : : {},
786 : 0 : RPCResult{
787 : : RPCResult::Type::OBJ, "", "",
788 : : {
789 : : {RPCResult::Type::STR, "filename", "the directory and file where the mempool was saved"},
790 [ + - + - : 6198 : }},
+ - + - +
- + - + -
+ + - - ]
791 : 2066 : RPCExamples{
792 [ + - + - : 4132 : HelpExampleCli("savemempool", "")
+ - ]
793 [ + - + - : 8264 : + HelpExampleRpc("savemempool", "")
+ - + - ]
794 [ + - ]: 2066 : },
795 : 4 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
796 : : {
797 : 4 : const ArgsManager& args{EnsureAnyArgsman(request.context)};
798 : 4 : const CTxMemPool& mempool = EnsureAnyMemPool(request.context);
799 : :
800 [ - + ]: 4 : if (!mempool.GetLoadTried()) {
801 [ # # # # ]: 0 : throw JSONRPCError(RPC_MISC_ERROR, "The mempool was not loaded yet");
802 : : }
803 : :
804 : 4 : const fs::path& dump_path = MempoolPath(args);
805 : :
806 [ + - + + ]: 4 : if (!DumpMempool(mempool, dump_path)) {
807 [ + - + - ]: 2 : throw JSONRPCError(RPC_MISC_ERROR, "Unable to dump mempool to disk");
808 : : }
809 : :
810 : 3 : UniValue ret(UniValue::VOBJ);
811 [ + - + - : 6 : ret.pushKV("filename", dump_path.utf8string());
+ - + - ]
812 : :
813 : 3 : return ret;
814 : 3 : },
815 [ + - + - : 12396 : };
+ - + - ]
816 [ + - + - ]: 4132 : }
817 : :
818 : 4350 : static std::vector<RPCResult> OrphanDescription()
819 : : {
820 : 4350 : return {
821 [ + - + - : 8700 : RPCResult{RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
+ - ]
822 [ + - + - : 8700 : RPCResult{RPCResult::Type::STR_HEX, "wtxid", "The transaction witness hash in hex"},
+ - ]
823 [ + - + - : 8700 : RPCResult{RPCResult::Type::NUM, "bytes", "The serialized transaction size in bytes"},
+ - ]
824 [ + - + - : 8700 : 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."},
+ - ]
825 [ + - + - : 8700 : RPCResult{RPCResult::Type::NUM, "weight", "The transaction weight as defined in BIP 141."},
+ - ]
826 [ + - + - : 8700 : RPCResult{RPCResult::Type::NUM_TIME, "entry", "The entry time into the orphanage expressed in " + UNIX_EPOCH_TIME},
+ - ]
827 [ + - + - : 8700 : RPCResult{RPCResult::Type::NUM_TIME, "expiration", "The orphan expiration time expressed in " + UNIX_EPOCH_TIME},
+ - ]
828 : : RPCResult{RPCResult::Type::ARR, "from", "",
829 : : {
830 [ + - + - : 8700 : RPCResult{RPCResult::Type::NUM, "peer_id", "Peer ID"},
+ - ]
831 [ + - + - : 21750 : }},
+ - + + -
- ]
832 [ + - + + : 47850 : };
- - ]
833 [ + - + - : 43500 : }
+ - + - +
- + - + -
+ - + - +
- - - ]
834 : :
835 : 10014 : static UniValue OrphanToJSON(const TxOrphanage::OrphanTxBase& orphan)
836 : : {
837 : 10014 : UniValue o(UniValue::VOBJ);
838 [ + - + - : 20028 : o.pushKV("txid", orphan.tx->GetHash().ToString());
+ - + - ]
839 [ + - + - : 20028 : o.pushKV("wtxid", orphan.tx->GetWitnessHash().ToString());
+ - + - ]
840 [ + - + - : 20028 : o.pushKV("bytes", orphan.tx->GetTotalSize());
+ - + - ]
841 [ + - + - : 20028 : o.pushKV("vsize", GetVirtualTransactionSize(*orphan.tx));
+ - + - ]
842 [ + - + - : 20028 : o.pushKV("weight", GetTransactionWeight(*orphan.tx));
+ - ]
843 [ + - + - : 20028 : o.pushKV("entry", int64_t{TicksSinceEpoch<std::chrono::seconds>(orphan.nTimeExpire - ORPHAN_TX_EXPIRE_TIME)});
+ - ]
844 [ + - + - : 20028 : o.pushKV("expiration", int64_t{TicksSinceEpoch<std::chrono::seconds>(orphan.nTimeExpire)});
+ - ]
845 : 10014 : UniValue from(UniValue::VARR);
846 [ + - + - ]: 10014 : from.push_back(orphan.fromPeer); // only one fromPeer for now
847 [ + - + - : 20028 : o.pushKV("from", from);
+ - ]
848 : 10014 : return o;
849 : 10014 : }
850 : :
851 : 2175 : static RPCHelpMan getorphantxs()
852 : : {
853 : 2175 : return RPCHelpMan{"getorphantxs",
854 : : "\nShows transactions in the tx orphanage.\n"
855 : : "\nEXPERIMENTAL warning: this call may be changed in future releases.\n",
856 : : {
857 [ + - ]: 4350 : {"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",
858 [ + - ]: 4350 : RPCArgOptions{.skip_type_check = true}},
859 : : },
860 : : {
861 : : RPCResult{"for verbose = 0",
862 : : RPCResult::Type::ARR, "", "",
863 : : {
864 : : {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
865 [ + - + - : 6525 : }},
+ - + - +
- + - + -
+ + - - ]
866 : : RPCResult{"for verbose = 1",
867 : : RPCResult::Type::ARR, "", "",
868 : : {
869 [ + - ]: 4350 : {RPCResult::Type::OBJ, "", "", OrphanDescription()},
870 [ + - + - : 10875 : }},
+ - + - +
- + - + +
- - ]
871 : : RPCResult{"for verbose = 2",
872 : : RPCResult::Type::ARR, "", "",
873 : : {
874 : : {RPCResult::Type::OBJ, "", "",
875 [ + - + - : 10875 : Cat<std::vector<RPCResult>>(
+ - + - +
- + + -
- ]
876 [ + - ]: 4350 : OrphanDescription(),
877 : : {{RPCResult::Type::STR_HEX, "hex", "The serialized, hex-encoded transaction data"}}
878 : : )
879 : : },
880 [ + - + - : 10875 : }},
+ - + - +
- + - + +
- - ]
881 : : },
882 : 2175 : RPCExamples{
883 [ + - + - : 4350 : HelpExampleCli("getorphantxs", "2")
+ - ]
884 [ + - + - : 8700 : + HelpExampleRpc("getorphantxs", "2")
+ - + - ]
885 [ + - ]: 2175 : },
886 : 121 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
887 : : {
888 : 121 : const NodeContext& node = EnsureAnyNodeContext(request.context);
889 : 121 : PeerManager& peerman = EnsurePeerman(node);
890 : 121 : std::vector<TxOrphanage::OrphanTxBase> orphanage = peerman.GetOrphanTransactions();
891 : :
892 [ + - + + ]: 121 : int verbosity{ParseVerbosity(request.params[0], /*default_verbosity=*/0, /*allow_bool*/false)};
893 : :
894 : 119 : UniValue ret(UniValue::VARR);
895 : :
896 [ + + ]: 119 : if (verbosity == 0) {
897 [ + + ]: 212 : for (auto const& orphan : orphanage) {
898 [ + - + - : 204 : ret.push_back(orphan.tx->GetHash().ToString());
+ - ]
899 : : }
900 [ + + ]: 111 : } else if (verbosity == 1) {
901 [ + + ]: 10118 : for (auto const& orphan : orphanage) {
902 [ + - + - ]: 10011 : ret.push_back(OrphanToJSON(orphan));
903 : : }
904 [ + + ]: 4 : } else if (verbosity == 2) {
905 [ + + ]: 5 : for (auto const& orphan : orphanage) {
906 [ + - ]: 3 : UniValue o{OrphanToJSON(orphan)};
907 [ + - + - : 6 : o.pushKV("hex", EncodeHexTx(*orphan.tx));
+ - + - ]
908 [ + - + - ]: 3 : ret.push_back(o);
909 : 3 : }
910 : : } else {
911 [ + - + - : 4 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid verbosity value " + ToString(verbosity));
+ - ]
912 : : }
913 : :
914 : 117 : return ret;
915 : 123 : },
916 [ + - + - : 32625 : };
+ - + - +
- + - + -
+ + + + -
- - - ]
917 [ + - + - : 21750 : }
+ - + - +
- + - + -
+ - + - +
- - - ]
918 : :
919 : 2133 : static RPCHelpMan submitpackage()
920 : : {
921 : 2133 : return RPCHelpMan{"submitpackage",
922 : : "Submit a package of raw transactions (serialized, hex-encoded) to local node.\n"
923 : : "The package will be validated according to consensus and mempool policy rules. If any transaction passes, it will be accepted to mempool.\n"
924 : : "This RPC is experimental and the interface may be unstable. Refer to doc/policy/packages.md for documentation on package policies.\n"
925 : : "Warning: successful submission does not mean the transactions will propagate throughout the network.\n"
926 : : ,
927 : : {
928 [ + - ]: 2133 : {"package", RPCArg::Type::ARR, RPCArg::Optional::NO, "An array of raw transactions.\n"
929 : : "The package must solely consist of a child and its parents. None of the parents may depend on each other.\n"
930 : : "The package must be topologically sorted, with the child being the last element in the array.",
931 : : {
932 [ + - ]: 2133 : {"rawtx", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, ""},
933 : : },
934 : : },
935 [ + - + - ]: 4266 : {"maxfeerate", RPCArg::Type::AMOUNT, RPCArg::Default{FormatMoney(DEFAULT_MAX_RAW_TX_FEE_RATE.GetFeePerK())},
936 : 2133 : "Reject transactions whose fee rate is higher than the specified value, expressed in " + CURRENCY_UNIT +
937 : 2133 : "/kvB.\nFee rates larger than 1BTC/kvB are rejected.\nSet to 0 to accept any fee rate."},
938 [ + - + - ]: 4266 : {"maxburnamount", RPCArg::Type::AMOUNT, RPCArg::Default{FormatMoney(DEFAULT_MAX_BURN_AMOUNT)},
939 : 2133 : "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"
940 : : "If burning funds through unspendable outputs is desired, increase this value.\n"
941 : 2133 : "This check is based on heuristics and does not guarantee spendability of outputs.\n"
942 : : },
943 : : },
944 : 0 : RPCResult{
945 : : RPCResult::Type::OBJ, "", "",
946 : : {
947 : : {RPCResult::Type::STR, "package_msg", "The transaction package result message. \"success\" indicates all transactions were accepted into or are already in the mempool."},
948 : : {RPCResult::Type::OBJ_DYN, "tx-results", "transaction results keyed by wtxid",
949 : : {
950 : : {RPCResult::Type::OBJ, "wtxid", "transaction wtxid", {
951 : : {RPCResult::Type::STR_HEX, "txid", "The transaction hash in hex"},
952 : : {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."},
953 : : {RPCResult::Type::NUM, "vsize", /*optional=*/true, "Sigops-adjusted virtual transaction size."},
954 : : {RPCResult::Type::OBJ, "fees", /*optional=*/true, "Transaction fees", {
955 [ + - ]: 4266 : {RPCResult::Type::STR_AMOUNT, "base", "transaction fee in " + CURRENCY_UNIT},
956 [ + - ]: 4266 : {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."},
957 : : {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.",
958 : : {{RPCResult::Type::STR_HEX, "", "transaction wtxid in hex"},
959 : : }},
960 : : }},
961 : : {RPCResult::Type::STR, "error", /*optional=*/true, "The transaction error string, if it was rejected by the mempool"},
962 : : }}
963 : : }},
964 : : {RPCResult::Type::ARR, "replaced-transactions", /*optional=*/true, "List of txids of replaced transactions",
965 : : {
966 : : {RPCResult::Type::STR_HEX, "", "The transaction id"},
967 : : }},
968 : : },
969 [ + - + - : 53325 : },
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
+ + + + +
+ + + + +
+ - - - -
- - - - -
- - - ]
970 : 2133 : RPCExamples{
971 [ + - + - : 4266 : HelpExampleRpc("submitpackage", R"(["rawtx1", "rawtx2"])") +
+ - ]
972 [ + - + - : 6399 : HelpExampleCli("submitpackage", R"('["rawtx1", "rawtx2"]')")
+ - + - ]
973 [ + - ]: 2133 : },
974 : 71 : [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue
975 : : {
976 : 71 : const UniValue raw_transactions = request.params[0].get_array();
977 [ + + + + ]: 71 : if (raw_transactions.size() < 2 || raw_transactions.size() > MAX_PACKAGE_COUNT) {
978 : 3 : throw JSONRPCError(RPC_INVALID_PARAMETER,
979 [ + - + - : 9 : "Array must contain between 2 and " + ToString(MAX_PACKAGE_COUNT) + " transactions.");
+ - ]
980 : : }
981 : :
982 : : // Fee check needs to be run with chainstate and package context
983 [ + - + - ]: 68 : const CFeeRate max_raw_tx_fee_rate{ParseFeeRate(self.Arg<UniValue>("maxfeerate"))};
984 [ + + ]: 68 : std::optional<CFeeRate> client_maxfeerate{max_raw_tx_fee_rate};
985 : : // 0-value is special; it's mapped to no sanity check
986 [ + + ]: 68 : if (max_raw_tx_fee_rate == CFeeRate(0)) {
987 : 5 : client_maxfeerate = std::nullopt;
988 : : }
989 : :
990 : : // Burn sanity check is run with no context
991 [ + - + + : 68 : const CAmount max_burn_amount = request.params[2].isNull() ? 0 : AmountFromValue(request.params[2]);
+ - + - ]
992 : :
993 : 68 : std::vector<CTransactionRef> txns;
994 [ + - ]: 68 : txns.reserve(raw_transactions.size());
995 [ + - + + ]: 263 : for (const auto& rawtx : raw_transactions.getValues()) {
996 [ + - ]: 197 : CMutableTransaction mtx;
997 [ + - + - : 197 : if (!DecodeHexTx(mtx, rawtx.get_str())) {
+ + ]
998 : 1 : throw JSONRPCError(RPC_DESERIALIZATION_ERROR,
999 [ + - + - : 3 : "TX decode failed: " + rawtx.get_str() + " Make sure the tx has at least one input.");
+ - ]
1000 : : }
1001 : :
1002 [ + + ]: 419 : for (const auto& out : mtx.vout) {
1003 [ + + + - : 224 : if((out.scriptPubKey.IsUnspendable() || !out.scriptPubKey.HasValidOps()) && out.nValue > max_burn_amount) {
- + + + ]
1004 [ + - + - ]: 2 : throw JSONRPCTransactionError(TransactionError::MAX_BURN_EXCEEDED);
1005 : : }
1006 : : }
1007 : :
1008 [ + - + - ]: 585 : txns.emplace_back(MakeTransactionRef(std::move(mtx)));
1009 : 197 : }
1010 [ + - + + ]: 66 : if (!IsChildWithParentsTree(txns)) {
1011 [ + - + - ]: 2 : throw JSONRPCTransactionError(TransactionError::INVALID_PACKAGE, "package topology disallowed. not child-with-parents or parents depend on each other.");
1012 : : }
1013 : :
1014 [ + - ]: 65 : NodeContext& node = EnsureAnyNodeContext(request.context);
1015 [ + - ]: 65 : CTxMemPool& mempool = EnsureMemPool(node);
1016 [ + - + - ]: 65 : Chainstate& chainstate = EnsureChainman(node).ActiveChainstate();
1017 [ + - + - ]: 195 : const auto package_result = WITH_LOCK(::cs_main, return ProcessNewPackage(chainstate, mempool, txns, /*test_accept=*/ false, client_maxfeerate));
1018 : :
1019 [ + - ]: 65 : std::string package_msg = "success";
1020 : :
1021 : : // First catch package-wide errors, continue if we can
1022 [ + - + - ]: 65 : switch(package_result.m_state.GetResult()) {
1023 : 27 : case PackageValidationResult::PCKG_RESULT_UNSET:
1024 : 27 : {
1025 : : // Belt-and-suspenders check; everything should be successful here
1026 [ + - ]: 27 : CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size());
1027 [ + + ]: 133 : for (const auto& tx : txns) {
1028 [ + - + - ]: 106 : CHECK_NONFATAL(mempool.exists(GenTxid::Txid(tx->GetHash())));
1029 : : }
1030 : : break;
1031 : : }
1032 : 0 : case PackageValidationResult::PCKG_MEMPOOL_ERROR:
1033 : 0 : {
1034 : : // This only happens with internal bug; user should stop and report
1035 : 0 : throw JSONRPCTransactionError(TransactionError::MEMPOOL_ERROR,
1036 [ # # # # ]: 0 : package_result.m_state.GetRejectReason());
1037 : : }
1038 : 38 : case PackageValidationResult::PCKG_POLICY:
1039 : 38 : case PackageValidationResult::PCKG_TX:
1040 : 38 : {
1041 : : // Package-wide error we want to return, but we also want to return individual responses
1042 [ + - ]: 38 : package_msg = package_result.m_state.ToString();
1043 [ + + + - : 42 : CHECK_NONFATAL(package_result.m_tx_results.size() == txns.size() ||
+ - ]
1044 : : package_result.m_tx_results.empty());
1045 : : break;
1046 : : }
1047 : : }
1048 : :
1049 : 65 : size_t num_broadcast{0};
1050 [ + + ]: 256 : for (const auto& tx : txns) {
1051 : : // We don't want to re-submit the txn for validation in BroadcastTransaction
1052 [ + - + + ]: 191 : if (!mempool.exists(GenTxid::Txid(tx->GetHash()))) {
1053 : 74 : continue;
1054 : : }
1055 : :
1056 : : // We do not expect an error here; we are only broadcasting things already/still in mempool
1057 [ + - ]: 117 : std::string err_string;
1058 [ + - + - : 234 : const auto err = BroadcastTransaction(node, tx, err_string, /*max_tx_fee=*/0, /*relay=*/true, /*wait_callback=*/true);
+ - ]
1059 [ - + ]: 117 : if (err != TransactionError::OK) {
1060 : 0 : throw JSONRPCTransactionError(err,
1061 [ # # ]: 0 : strprintf("transaction broadcast failed: %s (%d transactions were broadcast successfully)",
1062 [ # # ]: 0 : err_string, num_broadcast));
1063 : : }
1064 : 117 : num_broadcast++;
1065 : 117 : }
1066 : :
1067 : 65 : UniValue rpc_result{UniValue::VOBJ};
1068 [ + - + - : 130 : rpc_result.pushKV("package_msg", package_msg);
+ - ]
1069 : 130 : UniValue tx_result_map{UniValue::VOBJ};
1070 : 130 : std::set<uint256> replaced_txids;
1071 [ + + ]: 256 : for (const auto& tx : txns) {
1072 : 191 : UniValue result_inner{UniValue::VOBJ};
1073 [ + - + - : 382 : result_inner.pushKV("txid", tx->GetHash().GetHex());
+ - + - ]
1074 : 191 : auto it = package_result.m_tx_results.find(tx->GetWitnessHash());
1075 [ + + ]: 191 : if (it == package_result.m_tx_results.end()) {
1076 : : // No results, report error and continue
1077 [ + - + - : 20 : result_inner.pushKV("error", "unevaluated");
+ - ]
1078 : 10 : continue;
1079 : : }
1080 [ - + + - ]: 181 : const auto& tx_result = it->second;
1081 [ - + + - ]: 181 : switch(it->second.m_result_type) {
1082 : 0 : case MempoolAcceptResult::ResultType::DIFFERENT_WITNESS:
1083 [ # # # # : 0 : result_inner.pushKV("other-wtxid", it->second.m_other_wtxid.value().GetHex());
# # # # #
# ]
1084 : 0 : break;
1085 : 65 : case MempoolAcceptResult::ResultType::INVALID:
1086 [ + - + - : 130 : result_inner.pushKV("error", it->second.m_state.ToString());
+ - + - ]
1087 : 65 : break;
1088 : 116 : case MempoolAcceptResult::ResultType::VALID:
1089 : 116 : case MempoolAcceptResult::ResultType::MEMPOOL_ENTRY:
1090 [ + - + - : 232 : result_inner.pushKV("vsize", int64_t{it->second.m_vsize.value()});
+ - + - ]
1091 : 116 : UniValue fees(UniValue::VOBJ);
1092 [ + - + - : 232 : fees.pushKV("base", ValueFromAmount(it->second.m_base_fees.value()));
+ - + - ]
1093 [ + + ]: 116 : if (tx_result.m_result_type == MempoolAcceptResult::ResultType::VALID) {
1094 : : // Effective feerate is not provided for MEMPOOL_ENTRY transactions even
1095 : : // though modified fees is known, because it is unknown whether package
1096 : : // feerate was used when it was originally submitted.
1097 [ + - + - : 210 : fees.pushKV("effective-feerate", ValueFromAmount(tx_result.m_effective_feerate.value().GetFeePerK()));
+ - + - ]
1098 : 105 : UniValue effective_includes_res(UniValue::VARR);
1099 [ + - + + ]: 230 : for (const auto& wtxid : tx_result.m_wtxids_fee_calculations.value()) {
1100 [ + - + - : 125 : effective_includes_res.push_back(wtxid.ToString());
+ - ]
1101 : : }
1102 [ + - + - ]: 210 : fees.pushKV("effective-includes", std::move(effective_includes_res));
1103 : 105 : }
1104 [ + - + - ]: 232 : result_inner.pushKV("fees", std::move(fees));
1105 [ + + ]: 229 : for (const auto& ptx : it->second.m_replaced_transactions) {
1106 [ + - ]: 113 : replaced_txids.insert(ptx->GetHash());
1107 : : }
1108 : 116 : break;
1109 : : }
1110 [ + - + - ]: 362 : tx_result_map.pushKV(tx->GetWitnessHash().GetHex(), std::move(result_inner));
1111 : 191 : }
1112 [ + - + - ]: 130 : rpc_result.pushKV("tx-results", std::move(tx_result_map));
1113 : 130 : UniValue replaced_list(UniValue::VARR);
1114 [ + - + - : 178 : for (const uint256& hash : replaced_txids) replaced_list.push_back(hash.ToString());
+ - + + ]
1115 [ + - + - ]: 130 : rpc_result.pushKV("replaced-transactions", std::move(replaced_list));
1116 : 130 : return rpc_result;
1117 : 74 : },
1118 [ + - + - : 46926 : };
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + + +
+ - - -
- ]
1119 [ + - + - : 51192 : }
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- - - - -
- - - - ]
1120 : :
1121 : 1151 : void RegisterMempoolRPCCommands(CRPCTable& t)
1122 : : {
1123 : 1151 : static const CRPCCommand commands[]{
1124 : : {"rawtransactions", &sendrawtransaction},
1125 : : {"rawtransactions", &testmempoolaccept},
1126 : : {"blockchain", &getmempoolancestors},
1127 : : {"blockchain", &getmempooldescendants},
1128 : : {"blockchain", &getmempoolentry},
1129 : : {"blockchain", &gettxspendingprevout},
1130 : : {"blockchain", &getmempoolinfo},
1131 : : {"blockchain", &getrawmempool},
1132 : : {"blockchain", &importmempool},
1133 : : {"blockchain", &savemempool},
1134 : : {"hidden", &getorphantxs},
1135 : : {"rawtransactions", &submitpackage},
1136 [ + + + - : 1151 : };
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - -
- ]
1137 [ + + ]: 14963 : for (const auto& c : commands) {
1138 : 13812 : t.appendCommand(c.name, &c);
1139 : : }
1140 : 1151 : }
|
