@cogcoin/client 1.1.10 → 1.1.12

package/dist/bitcoind/managed-bitcoind-service-lifecycle.js

@@ -9,7 +9,7 @@ import { attachOrStartManagedBitcoindRuntime, probeManagedBitcoindRuntime } from
 import { createRpcClient, validateNodeConfigForTesting } from "./node.js";
 import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
 import { DEFAULT_MANAGED_BITCOIND_FOLLOW_POLL_INTERVAL_MS, } from "./types.js";
-import { buildManagedServiceArgsForTesting, LOCAL_HOST, resolveManagedBitcoindRuntimeConfig, SUPPORTED_BITCOIND_VERSION, verifyManagedBitcoindVersion, writeBitcoinConfForTesting, } from "./managed-bitcoind-service-config.js";
+import { buildManagedServiceArgsForTesting, LOCAL_HOST, resolveManagedBitcoindRuntimeConfig, SUPPORTED_BITCOIND_VERSION, verifyManagedBitcoindVersion, writeManagedBitcoindRuntimeConfigFile, writeManagedBitcoindRuntimeConfigFileFromStatus, writeBitcoinConfForTesting, } from "./managed-bitcoind-service-config.js";
 import { DEFAULT_MANAGED_BITCOIND_SHUTDOWN_TIMEOUT_MS, DEFAULT_MANAGED_BITCOIND_STARTUP_TIMEOUT_MS, FileLockBusyError, acquireManagedBitcoindFileLockWithRetry, isManagedBitcoindProcessAlive, waitForManagedBitcoindProcessExit, sleep, } from "./managed-bitcoind-service-process.js";
 import { createManagedWalletReplica, loadManagedWalletReplicaIfPresent, } from "./managed-bitcoind-service-replica.js";
 import { clearManagedBitcoindRuntimeArtifacts, createBitcoindServiceStatus, createManagedBitcoindNodeHandle, probeManagedBitcoindStatusCandidate, refreshManagedBitcoindStatus, waitForManagedBitcoindRpcReady, writeManagedBitcoindStatus, } from "./managed-bitcoind-service-status.js";
@@ -109,6 +109,7 @@ async function tryAttachExistingManagedBitcoindService(options) {
         return null;
     }
     const refreshed = await refreshManagedBitcoindStatus(probe.status, paths, options);
+    await writeManagedBitcoindRuntimeConfigFileFromStatus(paths.bitcoindRuntimeConfigPath, refreshed);
     return createManagedBitcoindNodeHandle({
         status: refreshed,
         paths,
@@ -207,42 +208,47 @@ export async function attachOrStartManagedBitcoindService(options) {
                     }
                     const nowUnixMs = Date.now();
                     const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, startOptions.walletRootId, startOptions.dataDir);
-                    return createBitcoindServiceStatus({
-                        binaryVersion,
-                        serviceInstanceId: randomBytes(16).toString("hex"),
-                        state: "ready",
-                        processId: child.pid ?? null,
-                        walletRootId: startOptions.walletRootId,
-                        chain: startOptions.chain,
-                        dataDir: startOptions.dataDir,
-                        runtimeRoot: paths.walletRuntimeRoot,
-                        startHeight: startOptions.startHeight,
-                        rpc: rpcConfig,
-                        zmq: zmqConfig,
-                        p2pPort: runtimeConfig.p2pPort,
-                        getblockArchiveEndHeight: runtimeConfig.getblockArchiveEndHeight ?? null,
-                        getblockArchiveSha256: runtimeConfig.getblockArchiveSha256 ?? null,
-                        walletReplica,
-                        startedAtUnixMs: nowUnixMs,
-                        heartbeatAtUnixMs: nowUnixMs,
-                        lastError: walletReplica.message ?? null,
-                    });
+                    return {
+                        runtimeConfig,
+                        status: createBitcoindServiceStatus({
+                            binaryVersion,
+                            serviceInstanceId: randomBytes(16).toString("hex"),
+                            state: "ready",
+                            processId: child.pid ?? null,
+                            walletRootId: startOptions.walletRootId,
+                            chain: startOptions.chain,
+                            dataDir: startOptions.dataDir,
+                            runtimeRoot: paths.walletRuntimeRoot,
+                            startHeight: startOptions.startHeight,
+                            rpc: rpcConfig,
+                            zmq: zmqConfig,
+                            p2pPort: runtimeConfig.p2pPort,
+                            getblockArchiveEndHeight: runtimeConfig.getblockArchiveEndHeight ?? null,
+                            getblockArchiveSha256: runtimeConfig.getblockArchiveSha256 ?? null,
+                            walletReplica,
+                            startedAtUnixMs: nowUnixMs,
+                            heartbeatAtUnixMs: nowUnixMs,
+                            lastError: walletReplica.message ?? null,
+                        }),
+                    };
                 };
+                let runtimeConfig;
                 let status;
                 try {
-                    status = await startManagedProcess(runtimeOptions);
+                    ({ runtimeConfig, status } = await startManagedProcess(runtimeOptions));
                 }
                 catch (error) {
                     if (runtimeOptions.getblockArchivePath === undefined || runtimeOptions.getblockArchivePath === null) {
                         throw error;
                     }
-                    status = await startManagedProcess({
+                    ({ runtimeConfig, status } = await startManagedProcess({
                         ...runtimeOptions,
                         getblockArchivePath: null,
                         getblockArchiveEndHeight: null,
                         getblockArchiveSha256: null,
-                    });
+                    }));
                 }
+                await writeManagedBitcoindRuntimeConfigFile(paths.bitcoindRuntimeConfigPath, runtimeConfig);
                 await writeManagedBitcoindStatus(paths, status);
                 return createManagedBitcoindNodeHandle({
                     status,

package/dist/bitcoind/managed-bitcoind-service-status.js

@@ -83,14 +83,6 @@ export async function writeManagedBitcoindStatus(paths, status) {
     await writeFileAtomic(paths.bitcoindPidPath, `${status.processId ?? ""}\n`, { mode: 0o600 });
     await writeFileAtomic(paths.bitcoindReadyPath, `${status.updatedAtUnixMs}\n`, { mode: 0o600 });
     await writeRuntimeStatusFile(paths.bitcoindWalletStatusPath, status.walletReplica ?? createMissingManagedWalletReplicaStatus(status.walletRootId, "Managed Core wallet replica is missing."));
-    await writeRuntimeStatusFile(paths.bitcoindRuntimeConfigPath, {
-        chain: status.chain,
-        rpc: status.rpc,
-        zmqPort: status.zmq.port,
-        p2pPort: status.p2pPort,
-        getblockArchiveEndHeight: status.getblockArchiveEndHeight,
-        getblockArchiveSha256: status.getblockArchiveSha256,
-    });
 }
 export async function clearManagedBitcoindRuntimeArtifacts(paths) {
     await rm(paths.bitcoindStatusPath, { force: true }).catch(() => undefined);

package/dist/bitcoind/rpc.d.ts

@@ -1,4 +1,4 @@
-import type { RpcBlock, RpcBlockchainInfo, RpcChainStatesResponse, RpcCreateWalletResult, RpcDecodedPsbt, RpcDescriptorInfo, RpcEstimateSmartFeeResult, RpcFinalizePsbtResult, RpcImportDescriptorRequest, RpcImportDescriptorResult, RpcListUnspentEntry, RpcMempoolEntry, RpcMempoolInfo, RpcRawMempoolVerbose, RpcListDescriptorsResult, RpcLockedUnspent, RpcLoadTxOutSetResult, RpcLoadWalletResult, RpcNetworkInfo, RpcTestMempoolAcceptResult, RpcWalletInfo, RpcWalletCreateFundedPsbtResult, RpcWalletProcessPsbtResult, RpcTransaction, RpcWalletTransaction, RpcZmqNotification } from "./types.js";
+import type { RpcBlock, RpcBlockchainInfo, RpcChainStatesResponse, RpcCreateWalletResult, RpcDecodedPsbt, RpcDescriptorInfo, RpcEstimateSmartFeeResult, RpcFinalizePsbtResult, RpcImportDescriptorRequest, RpcImportDescriptorResult, RpcListUnspentEntry, RpcMempoolEntry, RpcMempoolInfo, RpcRawMempoolVerbose, RpcRawMempoolEntries, RpcListDescriptorsResult, RpcLockedUnspent, RpcLoadTxOutSetResult, RpcLoadWalletResult, RpcNetworkInfo, RpcTestMempoolAcceptResult, RpcWalletInfo, RpcWalletCreateFundedPsbtResult, RpcWalletProcessPsbtResult, RpcTransaction, RpcWalletTransaction, RpcZmqNotification } from "./types.js";
 interface RpcRequestPayload {
     readonly body: string;
     readonly headers: Record<string, string>;
@@ -62,6 +62,7 @@ export declare class BitcoinRpcClient {
     sendRawTransaction(hex: string): Promise<string>;
     getRawMempool(): Promise<string[]>;
     getRawMempoolVerbose(): Promise<RpcRawMempoolVerbose>;
+    getRawMempoolEntries(): Promise<RpcRawMempoolEntries>;
     getMempoolInfo(): Promise<RpcMempoolInfo>;
     getMempoolEntry(txid: string): Promise<RpcMempoolEntry>;
     estimateSmartFee(confirmTarget: number, mode: "conservative" | "economical"): Promise<RpcEstimateSmartFeeResult>;

package/dist/bitcoind/rpc.js

@@ -351,6 +351,9 @@ export class BitcoinRpcClient {
     getRawMempoolVerbose() {
         return this.call("getrawmempool", [false, true]);
     }
+    getRawMempoolEntries() {
+        return this.call("getrawmempool", [true]);
+    }
     getMempoolInfo() {
         return this.call("getmempoolinfo");
     }

package/dist/bitcoind/types.d.ts

@@ -313,6 +313,7 @@ export interface RpcRawMempoolVerbose {
     txids: string[];
     mempool_sequence: string | number;
 }
+export type RpcRawMempoolEntries = Record<string, RpcMempoolEntry>;
 export interface RpcWalletTransaction {
     txid: string;
     walletconflicts?: string[];

package/dist/cli/mining-format.js

@@ -1,3 +1,4 @@
+import { resolveWaitingProviderNote } from "../wallet/mining/projection.js";
 function formatMaybeIso(unixMs) {
     return unixMs === null ? "none" : new Date(unixMs).toISOString();
 }
@@ -33,7 +34,11 @@ function resolveInsufficientFundsNextStep() {
 function resolveMiningRuntimeNote(mining) {
     return mining.runtime.currentPublishDecision === "publish-paused-insufficient-funds"
         ? "Insufficient BTC to mine."
-        : mining.runtime.note;
+        : mining.runtime.note !== null
+            ? mining.runtime.note
+            : mining.runtime.currentPhase === "waiting-provider"
+                ? resolveWaitingProviderNote(mining.runtime.providerState)
+                : null;
 }
 export function formatMiningSummaryLine(mining) {
     const provider = mining.provider.configured

package/dist/cli/wallet-format/balance.js

@@ -34,7 +34,7 @@ function renderBalanceArtCard(context) {
             return renderBalanceArtLine(line, "Funding address:", ` ${fundingAddress}`);
         }
         if (line.includes("Bitcoin Balance:")) {
-            return renderBalanceArtLine(line, "Bitcoin Balance:", ` ${formatBitcoinAmount(context.fundingSpendableSats ?? null)}`);
+            return renderBalanceArtLine(line, "Bitcoin Balance:", ` ${formatBitcoinAmount(context.fundingDisplaySats ?? null)}`);
         }
         if (line.includes("Cogcoin Balance:")) {
             return renderBalanceArtLine(line, "Cogcoin Balance:", ` ${formatCogAmount(spendableCog)}`);

package/dist/client/default-client.d.ts

@@ -1,10 +1,12 @@
 import type { BitcoinBlock, GenesisParameters, IndexerState } from "@cogcoin/indexer/types";
-import type { ApplyBlockResult, Client, ClientCheckpoint, ClientStoreAdapter, ClientTip } from "../types.js";
+import type { ApplyBlockResult, Client, ClientCheckpoint, ClientMirrorDelta, ClientMirrorSnapshot, ClientStoreAdapter, ClientTip } from "../types.js";
 export declare class DefaultClient implements Client {
     #private;
     constructor(store: ClientStoreAdapter, genesisParameters: GenesisParameters, state: IndexerState, tip: ClientTip | null, snapshotInterval: number, blockRecordRetention: number);
     getTip(): Promise<ClientTip | null>;
     getState(): Promise<IndexerState>;
+    readMirrorSnapshot(): Promise<ClientMirrorSnapshot>;
+    readMirrorDelta(afterHeight: number): Promise<ClientMirrorDelta>;
     applyBlock(block: BitcoinBlock): Promise<ApplyBlockResult>;
     rewindToHeight(height: number): Promise<ClientTip | null>;
     restoreCheckpoint(checkpoint: ClientCheckpoint): Promise<ClientTip>;

package/dist/client/default-client.js

@@ -26,6 +26,28 @@ export class DefaultClient {
         await this.#queue;
         return this.#state;
     }
+    async readMirrorSnapshot() {
+        return this.#enqueue(async () => {
+            this.#assertOpen();
+            return {
+                tip: this.#tip === null ? null : { ...this.#tip },
+                stateBytes: serializeIndexerState(this.#state),
+            };
+        });
+    }
+    async readMirrorDelta(afterHeight) {
+        return this.#enqueue(async () => {
+            this.#assertOpen();
+            const blockRecords = await this.#store.loadBlockRecordsAfter(afterHeight);
+            return {
+                tip: this.#tip === null ? null : { ...this.#tip },
+                blockRecords: blockRecords.map((record) => ({
+                    ...record,
+                    recordBytes: new Uint8Array(record.recordBytes),
+                })),
+            };
+        });
+    }
     async applyBlock(block) {
         return this.#enqueue(async () => {
             this.#assertOpen();

package/dist/types.d.ts

@@ -19,6 +19,18 @@ export interface StoredBlockRecord {
     recordBytes: Uint8Array;
     createdAt: number;
 }
+export interface ClientMirrorSnapshot {
+    tip: ClientTip | null;
+    stateBytes: Uint8Array;
+}
+export interface ClientMirrorDelta {
+    tip: ClientTip | null;
+    blockRecords: StoredBlockRecord[];
+}
+export interface ClientMirrorReader {
+    readMirrorSnapshot(): Promise<ClientMirrorSnapshot>;
+    readMirrorDelta(afterHeight: number): Promise<ClientMirrorDelta>;
+}
 export interface WriteAppliedBlockEntry {
     tip: ClientTip | null;
     stateBytes: Uint8Array | null;
@@ -48,7 +60,7 @@ export interface ApplyBlockResult {
     checkpoint: ClientCheckpoint | null;
     applied: AppliedBlock;
 }
-export interface Client {
+export interface Client extends ClientMirrorReader {
     getTip(): Promise<ClientTip | null>;
     getState(): Promise<IndexerState>;
     applyBlock(block: BitcoinBlock): Promise<ApplyBlockResult>;

package/dist/wallet/fs/atomic.d.ts

@@ -1,6 +1,15 @@
+import { rename, rm } from "node:fs/promises";
 export interface AtomicWriteOptions {
     mode?: number;
     encoding?: BufferEncoding;
 }
-export declare function writeFileAtomic(filePath: string, data: string | Uint8Array, options?: AtomicWriteOptions): Promise<void>;
-export declare function writeJsonFileAtomic(filePath: string, value: unknown, options?: AtomicWriteOptions): Promise<void>;
+export interface AtomicWriteDependencies {
+    platform?: NodeJS.Platform;
+    rename?: typeof rename;
+    rm?: typeof rm;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}
+export declare function replaceFileAtomicWithRetryForTesting(tempPath: string, filePath: string, dependencies?: AtomicWriteDependencies): Promise<void>;
+export declare function writeFileAtomic(filePath: string, data: string | Uint8Array, options?: AtomicWriteOptions, dependencies?: AtomicWriteDependencies): Promise<void>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown, options?: AtomicWriteOptions, dependencies?: AtomicWriteDependencies): Promise<void>;

package/dist/wallet/fs/atomic.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, open, rename } from "node:fs/promises";
+import { mkdir, open, rename, rm } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+const WINDOWS_REPLACE_RETRY_DELAY_MS = 25;
+const WINDOWS_REPLACE_RETRY_TIMEOUT_MS = 1_000;
 async function fsyncDirectory(directoryPath) {
     try {
         const directoryHandle = await open(directoryPath, "r");
@@ -21,7 +23,39 @@ async function fsyncDirectory(directoryPath) {
         throw error;
     }
 }
-export async function writeFileAtomic(filePath, data, options = {}) {
+function isRetryableWindowsReplaceError(error) {
+    if (!(error instanceof Error) || !("code" in error)) {
+        return false;
+    }
+    const code = error.code;
+    return code === "EPERM" || code === "EACCES" || code === "EBUSY";
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function replaceFileAtomicWithRetryForTesting(tempPath, filePath, dependencies = {}) {
+    const renameImpl = dependencies.rename ?? rename;
+    if ((dependencies.platform ?? process.platform) !== "win32") {
+        await renameImpl(tempPath, filePath);
+        return;
+    }
+    const nowImpl = dependencies.now ?? Date.now;
+    const sleepImpl = dependencies.sleep ?? sleep;
+    const deadline = nowImpl() + WINDOWS_REPLACE_RETRY_TIMEOUT_MS;
+    while (true) {
+        try {
+            await renameImpl(tempPath, filePath);
+            return;
+        }
+        catch (error) {
+            if (!isRetryableWindowsReplaceError(error) || nowImpl() >= deadline) {
+                throw error;
+            }
+            await sleepImpl(WINDOWS_REPLACE_RETRY_DELAY_MS);
+        }
+    }
+}
+export async function writeFileAtomic(filePath, data, options = {}, dependencies = {}) {
     const directoryPath = dirname(filePath);
     const tempPath = join(directoryPath, `${basename(filePath)}.tmp-${randomUUID()}`);
     await mkdir(directoryPath, { recursive: true });
@@ -38,9 +72,15 @@ export async function writeFileAtomic(filePath, data, options = {}) {
     finally {
         await handle.close();
     }
-    await rename(tempPath, filePath);
+    try {
+        await replaceFileAtomicWithRetryForTesting(tempPath, filePath, dependencies);
+    }
+    catch (error) {
+        await (dependencies.rm ?? rm)(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
     await fsyncDirectory(directoryPath);
 }
-export async function writeJsonFileAtomic(filePath, value, options = {}) {
-    await writeFileAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`, options);
+export async function writeJsonFileAtomic(filePath, value, options = {}, dependencies = {}) {
+    await writeFileAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`, options, dependencies);
 }

package/dist/wallet/mining/competitiveness.d.ts

@@ -1,6 +1,10 @@
 import { assaySentences } from "@cogcoin/scoring";
 import type { WalletReadContext } from "../read/index.js";
 import type { CompetitivenessDecision, MiningCandidate, MiningCooperativeYield, MiningRpcClient } from "./engine-types.js";
+interface MiningGateWarmupProgress {
+    processed: number;
+    total: number;
+}
 export declare function clearMiningGateCache(walletRootId: string | null | undefined): void;
 export declare function topologicallyOrderAncestorTxidsForTesting(options: {
     txid: string;
@@ -20,4 +24,6 @@ export declare function runCompetitivenessGate(options: {
     cooperativeYield?: MiningCooperativeYield;
     cooperativeYieldEvery?: number;
     throwIfStopping?: () => void;
+    onWarmupProgress?: (progress: MiningGateWarmupProgress) => Promise<void> | void;
 }): Promise<CompetitivenessDecision>;
+export {};

package/dist/wallet/mining/competitiveness.js

@@ -6,6 +6,8 @@ import { extractOpReturnPayloadFromScriptHex } from "../tx/register.js";
 import { compareLexicographically, numberToSats, resolveBip39WordsFromIndices, rootDomain, tieBreakHash, } from "./engine-utils.js";
 import { getIndexerTruthKey } from "./candidate.js";
 const MINING_MEMPOOL_COOPERATIVE_YIELD_EVERY = 25;
+const MINING_MEMPOOL_RAW_TX_FETCH_CONCURRENCY = 8;
+const MINING_MEMPOOL_PROGRESS_REPORT_EVERY = 25;
 const miningGateCache = new Map();
 function defaultMiningCooperativeYield() {
     return new Promise((resolve) => {
@@ -19,6 +21,98 @@ async function maybeYieldDuringMempoolScan(options) {
     }
     await (options.cooperativeYield ?? defaultMiningCooperativeYield)();
 }
+function getOrCreateMiningGateCacheState(walletRootId) {
+    const existing = miningGateCache.get(walletRootId);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const created = {
+        rawTxContexts: new Map(),
+        decisionReuse: null,
+    };
+    miningGateCache.set(walletRootId, created);
+    return created;
+}
+function pruneRawTxContextsToVisibleTxids(options) {
+    const visibleSet = new Set(options.visibleTxids);
+    for (const txid of [...options.rawTxContexts.keys()]) {
+        if (!visibleSet.has(txid)) {
+            options.rawTxContexts.delete(txid);
+        }
+    }
+}
+function resolveEffectiveFeeRate(mempoolEntry) {
+    return Number([
+        mempoolEntry.vsize > 0 ? (numberToSats(mempoolEntry.fees.base) / BigInt(mempoolEntry.vsize)) : 0n,
+        (mempoolEntry.ancestorsize ?? 0) > 0
+            ? (numberToSats(mempoolEntry.fees.ancestor) / BigInt(mempoolEntry.ancestorsize ?? 1))
+            : 0n,
+        (mempoolEntry.descendantsize ?? 0) > 0
+            ? (numberToSats(mempoolEntry.fees.descendant) / BigInt(mempoolEntry.descendantsize ?? 1))
+            : 0n,
+    ].reduce((best, candidate) => (candidate > best ? candidate : best), 0n));
+}
+async function warmMissingRawTxContexts(options) {
+    const missingTxids = options.visibleTxids.filter((txid) => !options.rawTxContexts.has(txid));
+    if (missingTxids.length === 0) {
+        return;
+    }
+    let completed = 0;
+    let nextIndex = 0;
+    let lastReportedProcessed = -1;
+    let reportPromise = Promise.resolve();
+    const reportProgress = async (processed, force = false) => {
+        if (options.onWarmupProgress === undefined) {
+            return;
+        }
+        if (!force && processed !== missingTxids.length && (processed % MINING_MEMPOOL_PROGRESS_REPORT_EVERY) !== 0) {
+            return;
+        }
+        if (processed === lastReportedProcessed) {
+            return;
+        }
+        lastReportedProcessed = processed;
+        reportPromise = reportPromise.then(async () => {
+            await options.onWarmupProgress?.({
+                processed,
+                total: missingTxids.length,
+            });
+        });
+        await reportPromise;
+    };
+    await reportProgress(0, true);
+    const workerCount = Math.min(MINING_MEMPOOL_RAW_TX_FETCH_CONCURRENCY, missingTxids.length);
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const iteration = nextIndex;
+            if (iteration >= missingTxids.length) {
+                return;
+            }
+            nextIndex += 1;
+            await maybeYieldDuringMempoolScan({
+                iteration,
+                cooperativeYield: options.cooperativeYield,
+                cooperativeYieldEvery: options.cooperativeYieldEvery,
+            });
+            options.throwIfStopping?.();
+            const txid = missingTxids[iteration];
+            const tx = await options.rpc.getRawTransaction(txid, true).catch(() => null);
+            options.throwIfStopping?.();
+            if (tx !== null) {
+                const payloadHex = tx.vout.find((entry) => entry.scriptPubKey?.hex?.startsWith("6a") === true)?.scriptPubKey?.hex;
+                options.rawTxContexts.set(txid, {
+                    txid,
+                    senderScriptHex: tx.vin[0]?.prevout?.scriptPubKey?.hex ?? null,
+                    rawTransaction: tx,
+                    payload: payloadHex === undefined ? null : extractOpReturnPayloadFromScriptHex(payloadHex),
+                });
+            }
+            completed += 1;
+            await reportProgress(completed, completed === missingTxids.length);
+        }
+    });
+    await Promise.all(workers);
+}
 export function clearMiningGateCache(walletRootId) {
     if (walletRootId === null || walletRootId === undefined) {
         miningGateCache.clear();
@@ -368,9 +462,25 @@ export async function runCompetitivenessGate(options) {
         options.candidate.canonicalBlend.toString(),
         options.candidate.sender.scriptPubKeyHex,
     ].join(":");
+    const cacheState = getOrCreateMiningGateCacheState(walletRootId);
+    const setDecisionReuse = (decision) => {
+        cacheState.decisionReuse = {
+            indexerDaemonInstanceId: indexerTruthKey?.daemonInstanceId ?? "none",
+            indexerSnapshotSeq: indexerTruthKey?.snapshotSeq ?? "none",
+            referencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
+            localAssayTupleKey,
+            excludedTxidsKey: excludedTxids.join(","),
+            mempoolSequence,
+            decision,
+        };
+    };
     let mempoolVerbose;
+    let mempoolEntries;
     try {
-        mempoolVerbose = await options.rpc.getRawMempoolVerbose();
+        [mempoolVerbose, mempoolEntries] = await Promise.all([
+            options.rpc.getRawMempoolVerbose(),
+            options.rpc.getRawMempoolEntries(),
+        ]);
         options.throwIfStopping?.();
     }
     catch {
@@ -379,17 +489,17 @@ export async function runCompetitivenessGate(options) {
         });
     }
     const mempoolSequence = String(mempoolVerbose.mempool_sequence);
-    const cached = miningGateCache.get(walletRootId);
-    const cachedTruthMatches = cached !== undefined
+    const cached = cacheState.decisionReuse;
+    const cachedTruthMatches = cached !== null
         && indexerTruthKey !== null
         && cached.indexerDaemonInstanceId === indexerTruthKey.daemonInstanceId
         && cached.indexerSnapshotSeq === indexerTruthKey.snapshotSeq;
-    const cachedReferencedBlockMatches = cached !== undefined
+    const cachedReferencedBlockMatches = cached !== null
         && cached.referencedBlockHashDisplay === options.candidate.referencedBlockHashDisplay;
-    if (cached !== undefined && (!cachedTruthMatches || !cachedReferencedBlockMatches)) {
-        clearMiningGateCache(walletRootId);
+    if (cached !== null && (!cachedTruthMatches || !cachedReferencedBlockMatches)) {
+        cacheState.decisionReuse = null;
     }
-    if (cached !== undefined
+    if (cached !== null
         && cachedTruthMatches
         && cachedReferencedBlockMatches
         && cached.localAssayTupleKey === localAssayTupleKey
@@ -402,47 +512,19 @@ export async function runCompetitivenessGate(options) {
     }
     const referencedPrefix = Buffer.from(options.candidate.referencedBlockHashInternal.subarray(0, 4)).toString("hex");
     const visibleTxids = mempoolVerbose.txids.filter((txid) => !excludedTxids.includes(txid));
-    const txContexts = cachedTruthMatches && cachedReferencedBlockMatches
-        ? (cached?.txContexts ?? new Map())
-        : new Map();
-    for (const txid of [...txContexts.keys()]) {
-        if (!visibleTxids.includes(txid)) {
-            txContexts.delete(txid);
-        }
-    }
-    for (let index = 0; index < visibleTxids.length; index += 1) {
-        await maybeYieldDuringMempoolScan({
-            iteration: index,
-            cooperativeYield: options.cooperativeYield,
-            cooperativeYieldEvery: options.cooperativeYieldEvery,
-        });
-        options.throwIfStopping?.();
-        const txid = visibleTxids[index];
-        if (txContexts.has(txid)) {
-            continue;
-        }
-        const [tx, mempoolEntry] = await Promise.all([
-            options.rpc.getRawTransaction(txid, true).catch(() => null),
-            options.rpc.getMempoolEntry(txid).catch(() => null),
-        ]);
-        options.throwIfStopping?.();
-        if (tx === null || mempoolEntry === null) {
-            continue;
-        }
-        const effectiveFeeRate = Number([
-            mempoolEntry.vsize > 0 ? (numberToSats(mempoolEntry.fees.base) / BigInt(mempoolEntry.vsize)) : 0n,
-            (mempoolEntry.ancestorsize ?? 0) > 0 ? (numberToSats(mempoolEntry.fees.ancestor) / BigInt(mempoolEntry.ancestorsize ?? 1)) : 0n,
-            (mempoolEntry.descendantsize ?? 0) > 0 ? (numberToSats(mempoolEntry.fees.descendant) / BigInt(mempoolEntry.descendantsize ?? 1)) : 0n,
-        ].reduce((best, candidate) => (candidate > best ? candidate : best), 0n));
-        const payloadHex = tx.vout.find((entry) => entry.scriptPubKey?.hex?.startsWith("6a") === true)?.scriptPubKey?.hex;
-        txContexts.set(txid, {
-            txid,
-            effectiveFeeRate,
-            senderScriptHex: tx.vin[0]?.prevout?.scriptPubKey?.hex ?? null,
-            rawTransaction: tx,
-            payload: payloadHex === undefined ? null : extractOpReturnPayloadFromScriptHex(payloadHex),
-        });
-    }
+    pruneRawTxContextsToVisibleTxids({
+        rawTxContexts: cacheState.rawTxContexts,
+        visibleTxids,
+    });
+    await warmMissingRawTxContexts({
+        rpc: options.rpc,
+        rawTxContexts: cacheState.rawTxContexts,
+        visibleTxids,
+        cooperativeYield: options.cooperativeYield,
+        cooperativeYieldEvery: options.cooperativeYieldEvery,
+        throwIfStopping: options.throwIfStopping,
+        onWarmupProgress: options.onWarmupProgress,
+    });
     const entries = new Map();
     for (let index = 0; index < visibleTxids.length; index += 1) {
         await maybeYieldDuringMempoolScan({
@@ -452,8 +534,9 @@ export async function runCompetitivenessGate(options) {
         });
         options.throwIfStopping?.();
         const txid = visibleTxids[index];
-        const context = txContexts.get(txid);
-        if (context === undefined || context.payload === null || context.senderScriptHex === null) {
+        const context = cacheState.rawTxContexts.get(txid);
+        const mempoolEntry = mempoolEntries[txid];
+        if (context === undefined || context.payload === null || context.senderScriptHex === null || mempoolEntry === undefined) {
             continue;
         }
         const decoded = decodeMinePayload(context.payload);
@@ -463,7 +546,7 @@ export async function runCompetitivenessGate(options) {
         const overlayDomain = await resolveOverlayAuthorizedMiningDomain({
             readContext: options.readContext,
             txid,
-            txContexts,
+            txContexts: cacheState.rawTxContexts,
             domainId: decoded.domainId,
             senderScriptHex: context.senderScriptHex,
         });
@@ -475,17 +558,7 @@ export async function runCompetitivenessGate(options) {
                 mempoolSequenceCacheStatus: "refreshed",
                 lastMempoolSequence: mempoolSequence,
             });
-            miningGateCache.set(walletRootId, {
-                indexerDaemonInstanceId: indexerTruthKey?.daemonInstanceId ?? "none",
-                indexerSnapshotSeq: indexerTruthKey?.snapshotSeq ?? "none",
-                referencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
-                localAssayTupleKey,
-                excludedTxidsKey: excludedTxids.join(","),
-                mempoolSequence,
-                txids: [...visibleTxids],
-                txContexts,
-                decision,
-            });
+            setDecisionReuse(decision);
             return decision;
         }
         if (overlayDomain === null || overlayDomain.name === null || !rootDomain(overlayDomain.name)) {
@@ -499,7 +572,7 @@ export async function runCompetitivenessGate(options) {
         }
         entries.set(txid, {
             txid,
-            effectiveFeeRate: context.effectiveFeeRate,
+            effectiveFeeRate: resolveEffectiveFeeRate(mempoolEntry),
             domainId: decoded.domainId,
             domainName: overlayDomain.name,
             sentence: Buffer.from(decoded.sentenceBytes).toString("utf8"),
@@ -631,16 +704,6 @@ export async function runCompetitivenessGate(options) {
             });
         }
     }
-    miningGateCache.set(walletRootId, {
-        indexerDaemonInstanceId: indexerTruthKey?.daemonInstanceId ?? "none",
-        indexerSnapshotSeq: indexerTruthKey?.snapshotSeq ?? "none",
-        referencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
-        localAssayTupleKey,
-        excludedTxidsKey: excludedTxids.join(","),
-        mempoolSequence,
-        txids: [...visibleTxids],
-        txContexts,
-        decision,
-    });
+    setDecisionReuse(decision);
     return decision;
 }