@bitsocial/pubsub-voting 0.2.1 → 0.3.0

package/dist/verify/gate-result-cache.js

@@ -1,91 +0,0 @@
-const memKeyFor = (wallet, sampleBlock) => `${wallet.toLowerCase()}:${sampleBlock}`;
-/**
- * An in-memory {@link GateResultCache} bounded to `maxEntries` with FIFO eviction. Eviction is
- * safe because a score is deterministic — an evicted entry only ever costs a re-read, never a
- * wrong answer; without a bound, a flood of fresh wallets is a memory-exhaustion vector (see
- * DESIGN.md "Can valid votes clog the topic?").
- */
-export function makeGateResultCache(maxEntries = 4096) {
-    const byKey = new Map();
-    const order = [];
-    return {
-        get: async (wallet, sampleBlock) => byKey.get(memKeyFor(wallet, sampleBlock)),
-        set: (wallet, sampleBlock, score) => {
-            const k = memKeyFor(wallet, sampleBlock);
-            if (byKey.has(k))
-                return; // idempotent: never refresh position or overwrite a pinned score
-            byKey.set(k, score);
-            order.push(k);
-            if (order.length > maxEntries) {
-                const evicted = order.shift();
-                if (evicted !== undefined)
-                    byKey.delete(evicted);
-            }
-        }
-    };
-}
-/** The persistent gate store's key. `ruleHash` disambiguates: the shared store spans every
- * contest on the voter, and one wallet can hold different scores under different gate rules
- * (or the same rule at different chainIds). Same score under the same rule is what lets two
- * contests over one gate (a 5chan-style directory) share each other's reads. */
-const storeKeyFor = (ruleHash, wallet, sampleBlock) => `${ruleHash}:${wallet.toLowerCase()}:${sampleBlock}`;
-/**
- * A {@link GateResultCache} layered over the voter's persistent store: an in-memory FIFO front
- * (the hot path — steady-state gossip hits it synchronously) with read-through to the store on
- * a miss and fire-and-forget write-through on `set`. Scores travel as decimal strings (JSON has
- * no bigint). A broken store read or write degrades to a live chain read — never an error into
- * the verify pipeline — because everything here is a pure function of pinned historical state.
- */
-export function makePersistentGateResultCache(opts) {
-    const { store, ruleHash } = opts;
-    const mem = makeGateResultCache(opts.maxMemEntries);
-    return {
-        async get(wallet, sampleBlock) {
-            const cached = await mem.get(wallet, sampleBlock);
-            if (cached !== undefined)
-                return cached;
-            let persisted;
-            try {
-                persisted = await store.getItem(storeKeyFor(ruleHash, wallet, sampleBlock));
-            }
-            catch {
-                return undefined;
-            }
-            if (typeof persisted !== "string" || !/^\d+$/.test(persisted))
-                return undefined;
-            const score = BigInt(persisted);
-            mem.set(wallet, sampleBlock, score);
-            return score;
-        },
-        set(wallet, sampleBlock, score) {
-            mem.set(wallet, sampleBlock, score);
-            void store.setItem(storeKeyFor(ruleHash, wallet, sampleBlock), score.toString()).catch(() => {
-                // a failed persist costs a future re-read, never a wrong answer
-            });
-        }
-    };
-}
-/**
- * Deterministic expiry purge for one rule's persisted gate results — better than LRU here
- * because staleness is *provable*: a score at bucket B's sample block is only ever consulted
- * while bundles from B are admissible (within `voteExpiryBuckets` of head), so anything older
- * than the oldest admissible sample block can never be read again. Run per contest whenever a
- * head read advances the expiry boundary (see the engine's `#maybePurgeGateResults`); the
- * store's LRU bound stays as the backstop for rules never purged.
- */
-export async function purgeExpiredGateResults(opts) {
-    const prefix = `${opts.ruleHash}:`;
-    try {
-        for (const key of await opts.store.keys()) {
-            if (!key.startsWith(prefix))
-                continue;
-            const sampleBlock = Number(key.slice(key.lastIndexOf(":") + 1));
-            if (Number.isFinite(sampleBlock) && sampleBlock < opts.oldestSampleBlock) {
-                await opts.store.removeItem(key);
-            }
-        }
-    }
-    catch {
-        // purge is best-effort; the store's LRU bound is the correctness-free backstop
-    }
-}