mempool RPCs: match Bitcoin Core's getmempoolentry, getmempoolinfo, gettxout and sendrawtransaction

[bkeroack]

Based on release/0.6; #937 and #942 have merged, and this branch includes them.

Problem

Several mempool RPCs answered differently from Bitcoin Core, and the mempool reload and block paths dropped state Core keeps. Core citations are to src/ at 16613c9d.

getmempoolentry / getrawmempool verbose (pool.rs get_entry_verbose; Core entryToJSON, rpc/mempool.cpp:508-569):

• vsize was weight / 4, rounded down. Core's GetVirtualTransactionSize rounds up (policy/policy.cpp:395-398), so most segwit transactions read one vbyte low, and testmempoolaccept and Esplora (which round up) disagreed with it. ancestorsize / descendantsize summed the rounded-down values.
• height was hard-coded to 0. Core reports the tip height when the transaction entered (entryHeight).
• depends listed every in-mempool ancestor. Core lists only the direct in-mempool parents, once each, in string order (rpc/mempool.cpp:536-549).
• bip125-replaceable looked only at the transaction's own inputs. Core's IsRBFOptIn also reports a transaction whose in-mempool ancestor signals (policy/rbf.cpp:24-50).
• The ancestor and descendant fee rollups (fees.ancestor, fees.descendant, ancestorfees, descendantfees) summed base fees. Core sums modified fees (CalculateAncestorData, txmempool.cpp:913-941).

getmempoolinfo (rawtx.rs; Core MempoolInfoToJSON, rpc/mempool.cpp:1043-1065): total_fee was missing; bytes and usage were both the serialized size (Core: the sum of virtual sizes, and memory use); loaded was always true, including while mempool.dat was still loading after RPC came up (Core: GetLoadTried(), set after the load attempt, init.cpp:2046-2048).

sendrawtransaction (server.rs):

• maxfeerate and maxburnamount were parsed by hand. A negative value became 0, which disabled the check; text it could not parse became the default; a rate of 1 BTC/kvB or more was accepted. Core reads both with AmountFromValue / ParseFeeRate (rpc/util.cpp:98-115), as satd's testmempoolaccept and submitpackage already do.
• When the pre-flight dry run refused the transaction for any reason other than "already in the mempool", the maxfeerate check was skipped. With a policy ruleset loaded, the submission can admit what the dry run refused (an allow rule forgiving a standardness failure, or allowquarantined), so such a transaction was admitted without the fee cap.
• "Already confirmed" (-27) was decided by the txindex (get_tx_location), which only answers with -txindex on. Core checks whether any of the transaction's outputs is still a coin (node/transaction.cpp:53-61). Without -txindex, satd answered -25 for a confirmed transaction with an unspent output; with it, -27 for one whose outputs were all spent, where Core answers missing inputs.

gettxout (server.rs, blockchain.rs) ignored include_mempool (Core default true, rpc/blockchain.cpp:1226-1242): a coin spent by a mempool transaction was reported unspent, and a mempool transaction's outputs came back null.

remove_for_block (pool.rs):

• A transaction that conflicts with the block was removed, but its descendants stayed. Core's removeConflicts removes the conflict with removeRecursive (txmempool.cpp:388-403). On a connect, accept_block later runs remove_for_reorg, which drops them, but the stored-tail drain path calls only remove_for_block, so the stranded children stayed in the pool (relayed and counted) until the next accept_block.
• prioritisetransaction deltas were never cleared on confirmation, so getprioritisedtransactions listed mined transactions for good and a transaction reorged back in got its old delta again. Core clears the delta of each block transaction and of each direct conflict (txmempool.cpp:398, 420).

Mempool reload (persist.rs; Core LoadMempool, node/mempool_persist.cpp:43-139):

• The persisted entry time was used only for ordering; every re-admitted transaction got the current time, so getmempoolentry.time and the -mempoolexpiry clock restarted on every restart, and records that had already expired were re-admitted. Core passes the persisted time to AcceptToMemoryPool and skips records past expiry (:103).
• The persisted prioritisetransaction delta was applied after admission, so a transaction that met the relay floor only through its delta was dropped. Core applies it first (:101).
• Every admission ran remove_expired, which walked the whole pool under the write lock, so loading N transactions cost O(N²). Core's Expire walks its entry-time index from the oldest.

Docs. The manual said -limitclustercount bounds a transaction's whole cluster, but satd counts in-mempool ancestors only (expand_ancestors); max_descendant_count is never read. -maxmempool is measured by serialized size, not memory, which was not documented. CORE_DIFFERENCES.md said submitpackage refuses maxfeerate / maxburnamount, but it applies both.

Fix

• MempoolEntry records height (the tip at admission). get_entry_verbose and getmempoolsummary (whose rows mirror it) use rounded-up vsize, signed modified fees in the rollups (as Core's m_modified_fee; a negative prioritisetransaction delta lowers them, and fees.modified can print negative, as ValueFromAmount formats it), direct parents for depends, and ancestor signalling for bip125-replaceable.
• MempoolInfo gains vsize, total_fee and usage; getmempoolinfo reports them as bytes, total_fee and usage. MempoolInfo.bytes (serialized size) is unchanged, so -maxmempool, satd_mempool_bytes and the status page keep their meaning. usage is an estimate added up from what each entry holds; CORE_DIFFERENCES.md says so.
• Mempool keeps Core's load-tried flag; satd sets it after the startup load step, whether or not -persistmempool is on; getmempoolinfo.loaded reports it.
• sendrawtransaction parses its limits with parse_btc_amount_arg / parse_fee_rate_arg, in Core's order (burn limit, decode, burn check, fee rate). The pre-submit checks move into rawtx::send_raw_transaction_preflight: -27 from the UTXO set (shared with testmempoolaccept), then the fee cap. When the dry run refuses and a ruleset is loaded, the fee is worked out from the inputs so the cap still applies. Without a ruleset the submission refuses whatever the dry run refused and reports why, so nothing changes there.
• gettxout takes include_mempool (default true): an output an acting mempool transaction spends is null, and an acting mempool transaction's outputs are reported with confirmations: 0, as Core's CCoinsViewMemPool does. Quarantined transactions stay invisible, as on every standard surface. The pool is read in one lock acquisition (Mempool::acting_view_of) inside the same chain snapshot as the coin and the tip. Because the pool trails the chain until remove_for_block runs, a pool transaction counts only while every coin it and its in-pool ancestors spend is still a coin at that tip.
• remove_for_block removes each conflict's descendants (as LeaveEvicted { BlockConflict }) and clears the deltas Core clears.
• load_mempool applies the delta first, skips expired records (counted in a new LoadStats.expired), and admits the rest with their persisted time (Mempool::accept_persisted_transaction).
• remove_expired keeps a lower bound on the entries' times (EntryMap::time_floor: lowered by every insert, reset by an in-place edit of a resident entry, raised to the exact minimum by each walk), and walks the pool only when something can have expired. An admission no longer costs a walk over the pool, and the reload is linear.
• Docs: configuration.md and config-reference.md describe -limitclustercount as the ancestor limit it is, and -maxmempool as serialized size; the config-reference note no longer lists limitclustercount among unrecognized keys. CORE_DIFFERENCES.md drops the submitpackage row, updates the savemempool entry, and gains a "Mempool size and descendant limits" entry.

Tests

New files: node/src/mempool/pool_mempoolrpc_tests.rs, node/src/rpc/rawtx_mempoolrpc_tests.rs, satd/tests/mempool_rpc.rs (new test target); three tests added to persist.rs's test module.

Each named test was run against the code with its guard reverted (the old behaviour put back in place) and failed on the assertion noted; restored, it passes.

node/src/mempool/pool_mempoolrpc_tests.rs:

• entry_vsize_rounds_up_as_core_does — fails without the fix: yes (vsize 83, expected 84; with getmempoolsummary.bytes reverted alone: 174 serialized bytes, expected the vsize sum).
• entry_height_is_the_tip_when_it_entered — yes (height 0, expected 3).
• entry_depends_names_direct_parents_only — yes (depends listed both ancestors).
• entry_bip125_replaceable_follows_an_ancestor_that_signals — yes (child reported false).
• entry_fee_rollups_use_modified_fees — yes (fees.ancestor 3000, expected 8000; with total_fee summing modified fees instead: 8000, expected 3000).
• entry_fee_rollups_carry_a_negative_modified_fee: yes (with the modified fee clamped at zero, the rollups read 2000 instead of 1000).
• prioritising_a_transaction_not_in_the_pool_keeps_the_expiry_floor: yes (with the floor reset on a missed lookup).
• acting_view_reads_spend_and_creation_together: covers the single-lock pool view gettxout uses.
• info_usage_grows_with_the_pool — yes (usage 0).
• block_conflict_takes_the_conflicts_descendants — yes ("its child must leave the pool").
• block_clears_the_priority_of_what_it_confirms — yes, for each of the two clears ("a confirmed transaction's delta is cleared"; "a block conflict's delta is cleared").
• expiry_pass_skips_the_walk_until_something_can_have_expired — yes, for both halves (the floor check, and the reset on an in-place edit).

node/src/mempool/persist.rs (test module):

• load_keeps_each_records_entry_time — yes (entry time was the load time).
• load_skips_a_record_past_expiry — yes ((accepted, skipped, expired) was (2, 0, 0)).
• load_applies_the_delta_before_admission — yes (accepted 0).
• load_decodes_records_but_skips_unfunded now uses recent record times, so expiry is not what skips its records.

node/src/rpc/rawtx_mempoolrpc_tests.rs:

• getmempoolinfo_loaded_waits_for_the_load — yes (loaded true on a pool that never loaded). rawtx::tests::test_getmempoolinfo_empty now expects false for the same reason.
• getmempoolinfo_bytes_is_vsize_and_total_fee_is_base_fees — yes (bytes 83, expected 84).
• gettxout_hides_an_output_spent_in_the_mempool — yes (the spent coin was reported).
• gettxout_reports_a_mempool_output_with_no_confirmations — yes (null).
• gettxout_does_not_see_a_quarantined_transaction — yes (a held transaction's output was reported).
• preflight_finds_a_confirmed_transaction_in_the_utxo_set — yes (Ok(()), expected -27).
• preflight_caps_the_fee_rate — passes with and without (the existing cap, kept as a regression test).
• gettxout_trusts_the_pool_only_while_the_coins_it_spends_remain: yes (with the coin check removed, an output the tip had already spent was reported unspent).
• a_negative_amount_formats_as_core_does.
• preflight_caps_the_fee_of_a_transaction_only_a_policy_admits — yes (Ok(()), expected -25); paired with the same transaction going through uncapped and being admitted.

satd/tests/mempool_rpc.rs (live regtest node):

• mempool_rpcs_match_core — the maxfeerate/maxburnamount refusals, the getmempoolentry/getmempoolinfo fields, gettxout with and without the mempool, and -27 for a confirmed transaction on a node without -txindex Fails without the fix: yes, for each piece of handler wiring reverted on its own: the old maxfeerate parser (sendrawtransaction <hex> -1 was accepted and returned the txid), the txindex-based -27 (-25 bad-txns-inputs-missingorspent instead of -27), and gettxout ignoring include_mempool (the coinbase the mempool spends was reported).
• sendrawtransaction_of_a_spent_confirmed_transaction_is_missing_inputs — with -txindex=1, a confirmed transaction whose outputs are all spent is answered as missing inputs (-25), not -27. Fails without the fix: yes (-27).

Also run locally: cargo clippy --all-targets --all-features -D warnings, cargo clippy -p node --no-default-features --all-targets -D warnings, cargo test -p node --lib, cargo test -p satd-mcp, cargo test -p satd --test policy, and the regtest tests for getmempoolentry, getmempoolinfo, getrawmempool, gettxout, sendrawtransaction, testmempoolaccept, savemempool, prioritisetransaction, the default-units tests, the SIGHUP mempool-policy reload and the Esplora mempool views.

Notes

• vsize is ceil(weight / 4). Core's is also sigop-adjusted (-bytespersigop); satd accepts that flag and ignores it everywhere, which is a separate change.
• Kept: remove_for_reorg still runs on every connect in accept_block (a full-pool coin scan). Running it only after a reorg would touch chain/state.rs; left for a separate change.
• Kept: prioritisetransaction deltas for transactions not in the pool are still not persisted (that needs a mempool.dat format change).
• Kept: savemempool does not refuse before the startup load finishes, as Core does with GetLoadTried(). Wiring it would make existing regtest tests that call savemempool right after startup race the load. CORE_DIFFERENCES.md says so.
• Kept: the maxfeerate comparison (floor(fee * 1000 / vsize) > rate) is the one testmempoolaccept already uses. Core compares fee > ceil(rate * vsize / 1000), which can differ by one satoshi at the boundary.
• Kept: no descendant or cluster limit is added; only the docs change to say what -limitclustercount does.
• Behaviour changes callers can see, all to Core's answer: gettxout now consults the mempool by default; sendrawtransaction now refuses a negative, unreadable or ≥ 1 BTC/kvB maxfeerate/maxburnamount (as testmempoolaccept and submitpackage already did) instead of accepting the transaction with the limit dropped; getmempoolinfo.bytes is now total vsize and loaded is false until the startup load finishes. satd_mempool_bytes and the -maxmempool budget still count serialized bytes.

Release notes

REL- vsize is ceil(weight / 4). Core's is also sigop-adjusted (-bytespersigop); satd accepts that flag and ignores it everywhere, which is a separate change.

• Kept: remove_for_reorg still runs on every connect in accept_block (a full-pool coin scan). Running it only after a reorg would touch chain/state.rs; left for a separate change.
• Kept: prioritisetransaction deltas for transactions not in the pool are still not persisted (that needs a mempool.dat format change).
• Kept: savemempool does not refuse before the startup load finishes, as Core does with GetLoadTried(). Wiring it would make existing regtest tests that call savemempool right after startup race the load. CORE_DIFFERENCES.md says so.
• Kept: the maxfeerate comparison (floor(fee * 1000 / vsize) > rate) is the one testmempoolaccept already uses. Core compares fee > ceil(rate * vsize / 1000), which can differ by one satoshi at the boundary.
• Kept: no descendant or cluster limit is added; only the docs change to say what -limitclustercount does.
• Behaviour changes callers can see, all to Core's answer: gettxout now consults the mempool by default; sendrawtransaction now refuses a negative, unreadable or ≥ 1 BTC/kvB maxfeerate/maxburnamount (as testmempoolaccept and submitpackage already did) instead of accepting the transaction with the limit dropped; getmempoolinfo.bytes is now total vsize and loaded is false until the startup load finishes. satd_mempool_bytes and the -maxmempool budget still count serialized bytes.

🤖 Generated with Claude Code