btc(stratum): memoize per-job tx_data hex (H5 work_source.cpp:634 churn fix)

src/impl/btc/stratum/tx_data_memo.hpp

@@ -0,0 +1,69 @@
+#pragma once
+// H5 leak-fix seam (acceptance-gate testable unit).
+//
+// build_connection_coinbase rebuilt the per-job tx hex vector on every call
+// even when the mempool tx set was unchanged -- the dominant churn/leak site
+// in the 2026-06-02 heaptrack (work_source.cpp:634, 768MB / 1.2M calls, ~78%
+// of leaked bytes). The fix memoizes the shared_ptr in a single slot keyed to
+// a fingerprint over the merkle leaf set (wd->m_hashes, in merkle-leaf order):
+// a repeat call against the same tx set returns the cached shared_ptr (a
+// refcount bump) instead of re-serializing the whole mempool. The key is the
+// exact leaf set that built this job merkle, so a hit is atomic-with-merkle by
+// construction (no stale-tx-vs-fresh-merkle mismatch on submit). Single slot =>
+// bounded memory (one tx set retained), self-evicting on tx-set roll.
+//
+// Factored out of build_connection_coinbase so the invariant can be proven
+// deterministically by a standalone harness (pointer-identity + O(1) repeat
+// call) without standing up a full BTCWorkSource. The call site holds
+// template_mutex_ across the call; this helper itself does no locking.
+
+#include <memory>
+#include <span>
+#include <string>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include <btclibs/hash.h>       // CHash256
+#include <core/uint256.hpp>     // uint256 (c2pool canonical)
+
+namespace btc::stratum::detail {
+
+// Fingerprint the template tx set over its merkle leaf hashes, in leaf order.
+inline uint256 tx_data_fingerprint(const std::vector<uint256>& leaf_hashes)
+{
+    legacy::CHash256 fp_hasher;
+    for (const auto& h : leaf_hashes)
+        fp_hasher.Write(std::span<const unsigned char>(h.data(), 32));
+    uint256 fp;
+    fp_hasher.Finalize(std::span<unsigned char>(fp.data(), 32));
+    return fp;
+}
+
+// Single-slot memo: return the cached tx-hex vector when the leaf set matches
+// the fingerprint of the prior call; otherwise rebuild from txs_field and
+// overwrite the slot (the prior shared_ptr refcount drops). The two memo
+// fields are owned by the caller (BTCWorkSource members, guarded by
+// template_mutex_); this function mutates them but takes no lock itself.
+inline std::shared_ptr<std::vector<std::string>> tx_data_memo_get_or_build(
+    const std::vector<uint256>&                 leaf_hashes,
+    const nlohmann::json&                       txs_field,
+    uint256&                                    memo_fp,
+    std::shared_ptr<std::vector<std::string>>&  memo_slot)
+{
+    const uint256 fp = tx_data_fingerprint(leaf_hashes);
+    if (memo_slot && memo_fp == fp)
+        return memo_slot;  // unchanged tx set -> refcount bump, no rebuild
+
+    auto txd = std::make_shared<std::vector<std::string>>();
+    txd->reserve(txs_field.size());
+    for (const auto& t : txs_field) {
+        if (t.is_object() && t.contains("data") && t["data"].is_string())
+            txd->push_back(t["data"].get<std::string>());
+    }
+    memo_fp   = fp;    // single slot: overwrite, prior set refcount drops
+    memo_slot = txd;
+    return txd;
+}
+
+}  // namespace btc::stratum::detail

src/impl/btc/stratum/work_source.cpp

@@ -11,6 +11,7 @@
 // implementing the substantive logic.
 
 #include <impl/btc/stratum/work_source.hpp>
+#include <impl/btc/stratum/tx_data_memo.hpp>   // H5 tx_data memo seam (work_source.cpp:634 churn fix)
 #include <memory>
 
 #include <impl/btc/coin/header_chain.hpp>
@@ -630,44 +631,20 @@ core::stratum::CoinbaseResult BTCWorkSource::build_connection_coinbase(
     }
     auto txs_field = wd->m_data.find("transactions");
     if (txs_field != wd->m_data.end() && txs_field->is_array()) {
-        // a1 (shared_ptr + lazy materialize): build the per-tx hex vector ONCE
-        // and hand the snapshot a shared_ptr to it, so the copies made along
-        // CoinbaseResult -> JobSnapshot -> JobEntry become refcount bumps, not
-        // deep copies of the full mempool tx hex.
-        //
-        // H5 (memoize across calls): a1 collapsed the per-job copies, but the
-        // vector itself was still rebuilt from scratch on every call to this
-        // method even when the mempool tx set had not changed -- the dominant
-        // leak/churn site (work_source.cpp:634, 768MB / 1.2M calls). Fingerprint
-        // the template tx set over wd->m_hashes (the merkle leaf set, in
-        // merkle-leaf order) and reuse the memoized shared_ptr on a match.
-        // The fingerprint keys on the SAME leaves that built this job's merkle,
-        // so a hit is atomic with the witness_commitment/merkle captured for
-        // the job (no stale-tx-vs-fresh-merkle mismatch on submit). Single slot
-        // -> bounded memory (one tx set retained), self-evicting on tx-set roll.
-        CHash256 fp_hasher;
-        for (const auto& h : wd->m_hashes)
-            fp_hasher.Write(std::span<const unsigned char>(h.data(), 32));
-        uint256 fp;
-        fp_hasher.Finalize(std::span<unsigned char>(fp.data(), 32));
-
-        std::shared_ptr<std::vector<std::string>> txd;
-        {
-            std::lock_guard<std::mutex> lk(template_mutex_);
-            if (tx_data_memo_ && tx_data_fp_ == fp) {
-                txd = tx_data_memo_;  // unchanged tx set -> refcount bump, no rebuild
-            } else {
-                txd = std::make_shared<std::vector<std::string>>();
-                txd->reserve(txs_field->size());
-                for (const auto& t : *txs_field) {
-                    if (t.is_object() && t.contains("data") && t["data"].is_string())
-                        txd->push_back(t["data"].get<std::string>());
-                }
-                tx_data_fp_   = fp;    // single slot: overwrite, prior set refcount drops
-                tx_data_memo_ = txd;
-            }
-        }
-        snap.tx_data = std::move(txd);
+        // a1 + H5 memo: build the per-tx hex vector ONCE and hand the snapshot a
+        // shared_ptr to it (copies along CoinbaseResult -> JobSnapshot -> JobEntry
+        // become refcount bumps, not deep copies of the full mempool tx hex).
+        // The memo seam goes one further: it keys a single-slot cache to a
+        // fingerprint over the merkle leaf set (wd->m_hashes), so a repeat call
+        // against an UNCHANGED tx set reuses the cached shared_ptr instead of
+        // re-serializing the whole mempool -- the dominant churn site in the
+        // 2026-06-02 heaptrack (768MB / 1.2M calls). The key is the exact leaf
+        // set that built this job merkle, so a hit is atomic-with-merkle by
+        // construction. The seam does no locking; build_connection_coinbase runs
+        // on connection threads, so guard the memo members with template_mutex_.
+        std::lock_guard<std::mutex> lk(template_mutex_);
+        snap.tx_data = btc::stratum::detail::tx_data_memo_get_or_build(
+            wd->m_hashes, *txs_field, tx_data_fp_, tx_data_memo_);
     }
     snap.merkle_branches = std::move(branches);
 

src/impl/btc/stratum/work_source.hpp

@@ -266,20 +266,12 @@ class BTCWorkSource : public core::stratum::IWorkSource
     // Template cache (filled lazily; invalidated when work_generation_ bumps)
     // Stage 4c populates these.
     mutable std::mutex          template_mutex_;
-    // H5 fix: single-slot tx_data memo. build_connection_coinbase rebuilt
-    // the per-tx hex vector on every call; for an unchanged mempool tx set
-    // that is pure churn (768MB / 1.2M calls in the 2026-06-02 trace, ~78%
-    // of total leaked bytes). Memoize the shared_ptr keyed to a fingerprint
-    // over wd->m_hashes (the merkle leaf set, in merkle-leaf order) so a
-    // repeat call against the same tx set returns a refcount bump instead
-    // of a fresh deep copy. Single slot: only the latest tx set is ever
-    // needed, so the memo is O(1) and self-evicting (a new fingerprint
-    // overwrites the prior entry, dropping its refcount). Guarded by
-    // template_mutex_. Atomic-with-merkle by construction: the key is the
-    // exact leaf set that produced this job, so a memo hit implies an
-    // identical merkle (no stale-tx-vs-fresh-merkle submit mismatch).
-    mutable uint256                                   tx_data_fp_;
-    mutable std::shared_ptr<std::vector<std::string>> tx_data_memo_;
+    // H5 tx_data memo (single slot, guarded by template_mutex_): the per-job
+    // tx-hex vector and a fingerprint over its merkle leaf set, so repeat
+    // build_connection_coinbase calls against an unchanged tx set reuse the
+    // shared_ptr instead of re-serializing the mempool. See tx_data_memo.hpp.
+    mutable uint256                                     tx_data_fp_;
+    mutable std::shared_ptr<std::vector<std::string>>   tx_data_memo_;
 };
 
 }  // namespace btc::stratum

src/impl/btc/test/tx_data_memo_test.cpp

@@ -0,0 +1,109 @@
+// H5 acceptance gate: deterministic pointer-identity + O(1) proof for the
+// tx_data memo (the work_source.cpp:634 churn/leak fix). Standalone harness
+// in the style of template_parity_test.cpp -- no btc/test CMake plumbing
+// required.
+//
+// Build (from repo root):
+//   g++ -std=gnu++20 -I src -I src/btclibs \
+//       src/impl/btc/test/tx_data_memo_test.cpp src/btclibs/crypto/sha256.cpp \
+//       -o /tmp/tx_data_memo_test
+// Run:
+//   /tmp/tx_data_memo_test
+//
+// Proves the invariant the fix establishes:
+//   (1) same merkle leaf set on repeat calls -> SAME shared_ptr (no rebuild)
+//   (2) a changed leaf set -> a FRESH shared_ptr (correct invalidation)
+//   (3) content is correct (the tx "data" hex, in order)
+//   (4) N repeat calls do NOT grow allocations: exactly ONE vector ever built
+//       for an unchanged tx set, and the per-call cost is O(1) (fingerprint
+//       only), not O(mempool) -- this is the flatten of the :634 curve.
+
+#include <impl/btc/stratum/tx_data_memo.hpp>
+
+#include <chrono>
+#include <cstdio>
+#include <cstdint>
+
+using btc::stratum::detail::tx_data_memo_get_or_build;
+
+static int g_fails = 0;
+static void check(bool ok, const char* label) {
+    std::printf("  %s %s\n", ok ? "PASS" : "FAIL", label);
+    if (!ok) ++g_fails;
+}
+
+// Build a synthetic merkle leaf set (deterministic, no real PoW needed).
+static std::vector<uint256> make_leaves(unsigned n, unsigned char salt) {
+    std::vector<uint256> v(n);
+    for (unsigned i = 0; i < n; ++i) {
+        unsigned char* d = v[i].data();
+        for (int b = 0; b < 32; ++b) d[b] = (unsigned char)((i * 31 + b * 7 + salt) & 0xff);
+    }
+    return v;
+}
+
+// Build a synthetic getblocktemplate-style "transactions" array.
+static nlohmann::json make_txs(unsigned n) {
+    nlohmann::json arr = nlohmann::json::array();
+    for (unsigned i = 0; i < n; ++i)
+        arr.push_back({{"data", std::string("deadbeef") + std::to_string(i)}});
+    return arr;
+}
+
+int main() {
+    std::printf("== tx_data memo: pointer-identity + O(1) acceptance gate ==\n");
+
+    const unsigned NTX = 3000;                  // representative full mempool
+    auto leaves_a = make_leaves(NTX, 0x00);
+    auto leaves_b = make_leaves(NTX, 0x01);     // one differing tx set
+    auto txs_a    = make_txs(NTX);
+    auto txs_b    = make_txs(NTX);
+
+    uint256 memo_fp;
+    std::shared_ptr<std::vector<std::string>> memo_slot;
+
+    // (1) first call builds; second call against same leaves reuses the ptr.
+    auto p1 = tx_data_memo_get_or_build(leaves_a, txs_a, memo_fp, memo_slot);
+    auto p2 = tx_data_memo_get_or_build(leaves_a, txs_a, memo_fp, memo_slot);
+    check(p1.get() == p2.get(), "same leaf set -> identical shared_ptr (no rebuild)");
+    check(p1.use_count() >= 3,  "memoized ptr is shared, not re-materialized");
+
+    // (3) content correctness on the built vector.
+    bool content_ok = p1->size() == NTX && (*p1)[0] == "deadbeef0"
+                      && (*p1)[NTX - 1] == ("deadbeef" + std::to_string(NTX - 1));
+    check(content_ok, "tx hex content correct and in order");
+
+    // (2) a changed leaf set invalidates and yields a fresh ptr.
+    auto p3 = tx_data_memo_get_or_build(leaves_b, txs_b, memo_fp, memo_slot);
+    check(p3.get() != p1.get(), "changed leaf set -> fresh shared_ptr (invalidated)");
+
+    // rolling back to leaves_a is now a MISS (single slot holds leaves_b).
+    auto p4 = tx_data_memo_get_or_build(leaves_a, txs_a, memo_fp, memo_slot);
+    check(p4.get() != p1.get() && p4.get() != p3.get(),
+          "single-slot: rolled-back set rebuilds (bounded memory, one slot)");
+
+    // (4) O(1) proof: hammer the SAME leaf set N times. The original :634 code
+    // re-serialized the whole mempool every call (O(N*NTX)); the memo makes
+    // every repeat a fingerprint-only refcount bump. Assert exactly ONE vector
+    // identity is returned across all N calls, and report per-call timing.
+    const long N = 1000000;
+    // reset slot to a known single set
+    memo_slot.reset(); memo_fp = uint256();
+    auto base = tx_data_memo_get_or_build(leaves_a, txs_a, memo_fp, memo_slot);
+    void* base_id = base.get();
+    bool all_same = true;
+    auto t0 = std::chrono::steady_clock::now();
+    for (long i = 0; i < N; ++i) {
+        auto pp = tx_data_memo_get_or_build(leaves_a, txs_a, memo_fp, memo_slot);
+        if (pp.get() != base_id) { all_same = false; break; }
+    }
+    auto t1 = std::chrono::steady_clock::now();
+    double ns_per_call =
+        std::chrono::duration_cast<std::chrono::nanoseconds>(t1 - t0).count() / double(N);
+    check(all_same, "N repeat calls return the ONE memoized vector (no rebuild)");
+    std::printf("  curve: %ld unchanged-tx calls @ NTX=%u -> %.1f ns/call "
+                "(O(1) fingerprint, was O(NTX) re-serialize)\n", N, NTX, ns_per_call);
+
+    std::printf("\n%s (%d failures)\n", g_fails ? "FAILED" : "ALL PASS", g_fails);
+    return g_fails ? 1 : 0;
+}