@cogcoin/client 1.1.16 → 1.2.1

package/dist/wallet/mining/competitiveness.js

@@ -2,9 +2,9 @@ import { createHash } from "node:crypto";
 import { assaySentences, deriveBlendSeed } from "@cogcoin/scoring";
 import { lookupDomain, lookupDomainById } from "@cogcoin/indexer/queries";
 import { COG_OPCODES, COG_PREFIX } from "../cogop/constants.js";
-import { extractOpReturnPayloadFromScriptHex } from "../tx/register.js";
 import { compareLexicographically, numberToSats, resolveBip39WordsFromIndices, rootDomain, tieBreakHash, } from "./engine-utils.js";
 import { getIndexerTruthKey } from "./candidate.js";
+import { hydrateMiningMempoolIndex, } from "./mempool-index.js";
 const MINING_MEMPOOL_COOPERATIVE_YIELD_EVERY = 25;
 const MINING_MEMPOOL_RAW_TX_FETCH_CONCURRENCY = 8;
 const MINING_MEMPOOL_PROGRESS_REPORT_EVERY = 25;
@@ -52,6 +52,41 @@ function resolveEffectiveFeeRate(mempoolEntry) {
             : 0n,
     ].reduce((best, candidate) => (candidate > best ? candidate : best), 0n));
 }
+function createContextFromRawTransaction(txid, tx) {
+    const payloadHex = tx.vout.find((entry) => entry.scriptPubKey?.hex?.startsWith("6a") === true)?.scriptPubKey?.hex;
+    const payload = payloadHex === undefined ? null : Buffer.from(payloadHex, "hex");
+    const decodedPayload = payload === null || payload.length < 2 || payload[0] !== 0x6a
+        ? null
+        : (() => {
+            const opcode = payload[1];
+            if (opcode === undefined) {
+                return null;
+            }
+            if (opcode <= 75) {
+                const end = 2 + opcode;
+                return end === payload.length ? payload.subarray(2, end) : null;
+            }
+            if (opcode === 0x4c && payload.length >= 3) {
+                const length = payload[2];
+                const end = 3 + length;
+                return end === payload.length ? payload.subarray(3, end) : null;
+            }
+            return null;
+        })();
+    if (decodedPayload === null
+        || decodedPayload.length < 3
+        || decodedPayload[0] !== COG_PREFIX[0]
+        || decodedPayload[1] !== COG_PREFIX[1]
+        || decodedPayload[2] !== COG_PREFIX[2]) {
+        return null;
+    }
+    return {
+        txid,
+        senderScriptHex: tx.vin[0]?.prevout?.scriptPubKey?.hex ?? null,
+        inputTxids: tx.vin.map((input) => input.txid).filter((inputTxid) => inputTxid !== undefined),
+        payload: decodedPayload,
+    };
+}
 async function warmMissingRawTxContexts(options) {
     const missingTxids = options.visibleTxids.filter((txid) => !options.rawTxContexts.has(txid));
     if (missingTxids.length === 0) {
@@ -99,13 +134,10 @@ async function warmMissingRawTxContexts(options) {
             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),
-                });
+                const context = createContextFromRawTransaction(txid, tx);
+                if (context !== null) {
+                    options.rawTxContexts.set(txid, context);
+                }
             }
             completed += 1;
             await reportProgress(completed, completed === missingTxids.length);
@@ -217,9 +249,7 @@ function parseSupportedAncestorOperation(context) {
     return "unsupported";
 }
 function getAncestorTxids(context, txContexts) {
-    return context.rawTransaction.vin
-        .map((vin) => vin.txid ?? null)
-        .filter((txid) => txid !== null && txContexts.has(txid));
+    return context.inputTxids.filter((txid) => txContexts.has(txid));
 }
 function topologicallyOrderAncestorContexts(options) {
     const visited = new Map();
@@ -281,9 +311,17 @@ function topologicallyOrderAncestorContexts(options) {
     return ordered;
 }
 export function topologicallyOrderAncestorTxidsForTesting(options) {
+    const txContexts = new Map([...options.txContexts].map(([txid, context]) => [txid, {
+            txid: context.txid,
+            senderScriptHex: null,
+            inputTxids: context.rawTransaction.vin
+                .map((vin) => vin.txid)
+                .filter((inputTxid) => inputTxid !== undefined),
+            payload: null,
+        }]));
     const ordered = topologicallyOrderAncestorContexts({
         txid: options.txid,
-        txContexts: options.txContexts,
+        txContexts,
     });
     return ordered?.map((context) => context.txid) ?? null;
 }
@@ -439,6 +477,35 @@ function toSentenceBoardEntries(entries) {
         requiredWords: resolveBip39WordsFromIndices(entry.bip39WordIndices),
     }));
 }
+async function fetchIndexedMempoolEntries(options) {
+    const entries = {};
+    let nextIndex = 0;
+    const workerCount = Math.min(MINING_MEMPOOL_RAW_TX_FETCH_CONCURRENCY, options.txids.length);
+    const workers = Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const index = nextIndex;
+            if (index >= options.txids.length) {
+                return;
+            }
+            nextIndex += 1;
+            options.throwIfStopping?.();
+            const txid = options.txids[index];
+            const entry = await options.rpc.getMempoolEntry(txid).catch(() => null);
+            options.throwIfStopping?.();
+            if (entry === null) {
+                throw new Error("mining_mempool_index_entry_unavailable");
+            }
+            entries[txid] = entry;
+        }
+    });
+    try {
+        await Promise.all(workers);
+        return entries;
+    }
+    catch {
+        return null;
+    }
+}
 export async function runCompetitivenessGate(options) {
     const createDecision = (overrides) => ({
         allowed: overrides.allowed ?? false,
@@ -475,12 +542,8 @@ export async function runCompetitivenessGate(options) {
         };
     };
     let mempoolVerbose;
-    let mempoolEntries;
     try {
-        [mempoolVerbose, mempoolEntries] = await Promise.all([
-            options.rpc.getRawMempoolVerbose(),
-            options.rpc.getRawMempoolEntries(),
-        ]);
+        mempoolVerbose = await options.rpc.getRawMempoolVerbose();
         options.throwIfStopping?.();
     }
     catch {
@@ -512,19 +575,95 @@ 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));
-    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,
-    });
+    let rawTxContexts;
+    let mempoolEntries;
+    let gateCacheStatus = "refreshed";
+    if (options.mempoolIndex?.rawTxSupported === true) {
+        const indexed = await hydrateMiningMempoolIndex({
+            walletRootId,
+            serviceIdentity: options.mempoolIndex.serviceIdentity,
+            cachePath: options.mempoolIndex.cachePath,
+            rpc: options.rpc,
+            visibleTxids,
+            cooperativeYield: options.cooperativeYield,
+            cooperativeYieldEvery: options.cooperativeYieldEvery,
+            throwIfStopping: options.throwIfStopping,
+            onWarmupProgress: options.onWarmupProgress,
+        }).catch(() => null);
+        if (indexed !== null) {
+            rawTxContexts = indexed.contexts;
+            gateCacheStatus = indexed.cacheStatus;
+            const indexedTxids = visibleTxids.filter((txid) => rawTxContexts.has(txid));
+            const indexedEntries = await fetchIndexedMempoolEntries({
+                rpc: options.rpc,
+                txids: indexedTxids,
+                throwIfStopping: options.throwIfStopping,
+            });
+            if (indexedEntries === null) {
+                rawTxContexts = new Map();
+                mempoolEntries = {};
+                gateCacheStatus = "fallback-scan";
+            }
+            else {
+                mempoolEntries = indexedEntries;
+            }
+        }
+        else {
+            return createDecision({
+                competitivenessGateIndeterminate: true,
+                decision: "indeterminate-mempool-gate",
+                mempoolSequenceCacheStatus: "index-warming",
+                lastMempoolSequence: mempoolSequence,
+            });
+        }
+    }
+    else {
+        rawTxContexts = cacheState.rawTxContexts;
+        gateCacheStatus = options.mempoolIndex?.rawTxSupported === false ? "fallback-scan" : "refreshed";
+        const fallbackEntries = await options.rpc.getRawMempoolEntries().catch(() => null);
+        if (fallbackEntries === null) {
+            return createDecision({
+                competitivenessGateIndeterminate: true,
+            });
+        }
+        mempoolEntries = fallbackEntries;
+        pruneRawTxContextsToVisibleTxids({
+            rawTxContexts,
+            visibleTxids,
+        });
+        await warmMissingRawTxContexts({
+            rpc: options.rpc,
+            rawTxContexts,
+            visibleTxids,
+            cooperativeYield: options.cooperativeYield,
+            cooperativeYieldEvery: options.cooperativeYieldEvery,
+            throwIfStopping: options.throwIfStopping,
+            onWarmupProgress: options.onWarmupProgress,
+        });
+    }
+    if (gateCacheStatus === "fallback-scan" && rawTxContexts.size === 0 && Object.keys(mempoolEntries).length === 0) {
+        const fallbackEntries = await options.rpc.getRawMempoolEntries().catch(() => null);
+        if (fallbackEntries === null) {
+            return createDecision({
+                competitivenessGateIndeterminate: true,
+            });
+        }
+        mempoolEntries = fallbackEntries;
+        rawTxContexts = cacheState.rawTxContexts;
+        pruneRawTxContextsToVisibleTxids({
+            rawTxContexts,
+            visibleTxids,
+        });
+        await warmMissingRawTxContexts({
+            rpc: options.rpc,
+            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({
@@ -555,7 +694,7 @@ export async function runCompetitivenessGate(options) {
             const decision = createDecision({
                 competitivenessGateIndeterminate: true,
                 decision: "indeterminate-mempool-gate",
-                mempoolSequenceCacheStatus: "refreshed",
+                mempoolSequenceCacheStatus: gateCacheStatus,
                 lastMempoolSequence: mempoolSequence,
             });
             setDecisionReuse(decision);
@@ -625,7 +764,7 @@ export async function runCompetitivenessGate(options) {
             higherRankedCompetitorDomainCount: 1,
             dedupedCompetitorDomainCount: otherDomainBest.size,
             competitivenessGateIndeterminate: false,
-            mempoolSequenceCacheStatus: "refreshed",
+            mempoolSequenceCacheStatus: gateCacheStatus,
             lastMempoolSequence: mempoolSequence,
             visibleBoardEntries: toSentenceBoardEntries(visibleRankedEntries),
         });
@@ -669,7 +808,7 @@ export async function runCompetitivenessGate(options) {
                     higherRankedCompetitorDomainCount,
                     dedupedCompetitorDomainCount: otherDomainBest.size,
                     competitivenessGateIndeterminate: false,
-                    mempoolSequenceCacheStatus: "refreshed",
+                    mempoolSequenceCacheStatus: gateCacheStatus,
                     lastMempoolSequence: mempoolSequence,
                     visibleBoardEntries: toSentenceBoardEntries(visibleRankedEntries),
                     candidateRank,
@@ -683,7 +822,7 @@ export async function runCompetitivenessGate(options) {
                     higherRankedCompetitorDomainCount,
                     dedupedCompetitorDomainCount: otherDomainBest.size,
                     competitivenessGateIndeterminate: false,
-                    mempoolSequenceCacheStatus: "refreshed",
+                    mempoolSequenceCacheStatus: gateCacheStatus,
                     lastMempoolSequence: mempoolSequence,
                     visibleBoardEntries: toSentenceBoardEntries(visibleRankedEntries),
                     candidateRank,
@@ -698,7 +837,7 @@ export async function runCompetitivenessGate(options) {
                 higherRankedCompetitorDomainCount: 0,
                 dedupedCompetitorDomainCount: otherDomainBest.size,
                 competitivenessGateIndeterminate: true,
-                mempoolSequenceCacheStatus: "refreshed",
+                mempoolSequenceCacheStatus: gateCacheStatus,
                 lastMempoolSequence: mempoolSequence,
                 visibleBoardEntries: toSentenceBoardEntries(visibleRankedEntries),
             });

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

@@ -10,6 +10,7 @@ import { type MiningRuntimeLoopState } from "./engine-state.js";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { type MiningRuntimeStatusOverrides } from "./projection.js";
+import type { MiningMempoolIndexGateOptions } from "./mempool-index.js";
 export declare function runMiningPhaseMachine(options: {
     dataDir: string;
     databasePath: string;
@@ -33,6 +34,7 @@ export declare function runMiningPhaseMachine(options: {
     assaySentencesImpl?: typeof assaySentences;
     cooperativeYieldImpl?: MiningCooperativeYield;
     cooperativeYieldEvery?: number;
+    mempoolIndex?: MiningMempoolIndexGateOptions;
     nowImpl?: () => number;
     saveCycleStatus: (readContext: WalletReadContext, overrides: MiningRuntimeStatusOverrides) => Promise<MiningRuntimeStatusV1>;
     appendEvent: (event: MiningEventRecord) => Promise<void>;

package/dist/wallet/mining/cycle.js

@@ -350,6 +350,7 @@ export async function runMiningPhaseMachine(options) {
                     assaySentencesImpl: options.assaySentencesImpl,
                     cooperativeYield: options.cooperativeYieldImpl,
                     cooperativeYieldEvery: options.cooperativeYieldEvery,
+                    mempoolIndex: options.mempoolIndex,
                     throwIfStopping: options.throwIfStopping,
                     onWarmupProgress: async (progress) => {
                         if (progress.total <= 0) {

package/dist/wallet/mining/mempool-index.d.ts

@@ -0,0 +1,65 @@
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { MiningCooperativeYield, MiningRpcClient } from "./engine-types.js";
+export interface MiningMempoolTxContext {
+    txid: string;
+    senderScriptHex: string | null;
+    inputTxids: string[];
+    payload: Uint8Array | null;
+}
+export interface MiningMempoolIndexHydrationResult {
+    contexts: Map<string, MiningMempoolTxContext>;
+    cacheStatus: "indexed" | "index-warming";
+    hydratedCount: number;
+}
+export interface MiningMempoolIndexGateOptions {
+    rawTxSupported: boolean;
+    cachePath: string;
+    serviceIdentity: string;
+}
+interface RawTxSubscriberLike extends AsyncIterable<unknown> {
+    close(): void;
+    connect(endpoint: string): void;
+    subscribe(topic: string): void;
+}
+interface ZeroMqModuleLike {
+    Subscriber: new () => RawTxSubscriberLike;
+}
+interface ParsedRawTransactionIndexContext {
+    txid: string;
+    inputTxids: string[];
+    payload: Uint8Array | null;
+}
+export declare function resolveMiningMempoolIndexCachePath(paths: Pick<WalletRuntimePaths, "miningRoot">): string;
+export declare function resolveMiningMempoolServiceIdentity(options: {
+    dataDir: string;
+    pid: number | null;
+    zmqEndpoint: string;
+    rawTxTopic?: "rawtx";
+}): string;
+export declare function hydrateMiningMempoolIndex(options: {
+    walletRootId: string;
+    serviceIdentity: string;
+    cachePath: string;
+    rpc: Pick<MiningRpcClient, "getRawTransaction">;
+    visibleTxids: readonly string[];
+    cooperativeYield?: MiningCooperativeYield;
+    cooperativeYieldEvery?: number;
+    throwIfStopping?: () => void;
+    onWarmupProgress?: (progress: {
+        processed: number;
+        total: number;
+    }) => Promise<void> | void;
+}): Promise<MiningMempoolIndexHydrationResult>;
+declare function parseRawTransactionForIndex(rawHex: string): ParsedRawTransactionIndexContext | null;
+export declare function ensureMiningMempoolRawTxSubscriber(options: {
+    walletRootId: string;
+    serviceIdentity: string;
+    cachePath: string;
+    zmqEndpoint: string;
+    rawTxTopic?: "rawtx";
+    loadZeroMq?: () => Promise<ZeroMqModuleLike>;
+}): Promise<boolean>;
+export declare function closeMiningMempoolIndexSubscribersForTesting(): Promise<void>;
+export declare function clearMiningMempoolIndexCacheForTesting(): void;
+export declare const parseRawTransactionForMiningMempoolIndexTesting: typeof parseRawTransactionForIndex;
+export {};