@bitsocial/pubsub-voting 0.1.1 → 0.1.3

package/dist/transport/integration/harness.d.ts

@@ -6,7 +6,7 @@ import type { VoteCrdt } from "../../crdt/types.js";
 import { type VerdictCache } from "../../verify/cache.js";
 import { type RootChaser } from "../chase.js";
 import type { PubsubService, VoteTransport } from "../types.js";
-import { type RootRecord } from "../messages.js";
+import { type FetchRootRecord, type RootRecord } from "../messages.js";
 /** The gossipsub peer-score methods used for assertions — on the concrete class, not the interface. */
 interface ScoreOps {
     getScore(peer: string): number;
@@ -41,13 +41,37 @@ export interface VoteNode {
     /** Replace the injected verifier (e.g. a rejecter, or a slow one, for a specific assertion). */
     setVerifier(verify: (bundle: VotesBundle) => Promise<BundleVerdict>): void;
     /** Encode this node's current winner-set to a checkpoint (blocks written to its blockstore). */
-    checkpointRootRecord(): Promise<RootRecord>;
+    checkpointRootRecord(): Promise<FetchRootRecord>;
+    /**
+     * Pull `from`'s root record over the REAL libp2p fetch protocol — the cold-start pull a
+     * joiner makes before chasing (voter.ts `#fetchRootWithRetry`). `undefined` when the peer
+     * serves nothing for the key.
+     */
+    fetchRootRecord(from: VoteNode): Promise<FetchRootRecord | undefined>;
     /** Publish this node's own root record on the topic (a heartbeat). */
     publishOwnRoot(): Promise<void>;
     /** Seed a bundle straight into this node's state (store block + CRDT merge), no network. */
     admitBundle(bundle: VotesBundle): Promise<void>;
     stop(): Promise<void>;
 }
+/**
+ * One real loopback libp2p + Helia node carrying gossipsub (topic-scoped score params) and
+ * `@libp2p/fetch` — the raw host node with nothing else wired. {@link makeVoteNode} builds the
+ * harness transport on top of it; the three-node relay test instead hands it straight to the
+ * REAL `PubsubVoter` as the injected host node (the `PubsubVoterOptions.helia` seam).
+ */
+export declare function makeBareNode(topic: string): Promise<{
+    libp2p: Libp2p<{
+        identify: import("@libp2p/identify").Identify;
+        fetch: import("@libp2p/fetch").Fetch;
+        pubsub: import("@libp2p/gossipsub").GossipSub;
+    }>;
+    helia: Helia<Libp2p<{
+        identify: import("@libp2p/identify").Identify;
+        fetch: import("@libp2p/fetch").Fetch;
+        pubsub: import("@libp2p/gossipsub").GossipSub;
+    }>>;
+}>;
 /** Build one real node with the full forward-gate wired to real gossipsub. */
 export declare function makeVoteNode(topic: string, options?: VoteNodeOptions): Promise<VoteNode>;
 /**

package/dist/transport/integration/harness.js

@@ -17,7 +17,7 @@ import { encodeCheckpoint } from "../../checkpoint/codec.js";
 import { makeGossipGate } from "../gossip-validator.js";
 import { makeRootChaser, toChaseSession } from "../chase.js";
 import { makeVoteTransport } from "../transport.js";
-import { decodeVoteMessage, maxBundleMessageBytes, MAX_ROOT_MESSAGE_BYTES, ROOT_RECORD_VERSION } from "../messages.js";
+import { decodeVoteMessage, decodeRootRecord, encodeRootRecord, maxBundleMessageBytes, rootFetchKey, MAX_ROOT_MESSAGE_BYTES, ROOT_RECORD_VERSION } from "../messages.js";
 /**
  * Test harness for the two-node gossipsub integration test. It stands up ONE real libp2p +
  * Helia node carrying `@libp2p/gossipsub` (>= 15.0.23, the CVE-2026-46679 floor) and
@@ -38,9 +38,13 @@ const BLOCKS_PER_BUCKET = 43_200;
 const VOTE_EXPIRY_BUCKETS = 30;
 /** A permissive default verifier; individual tests swap it via {@link VoteNode.setVerifier}. */
 const okVerifier = () => ({ valid: true, ruleScore: 1n, resolvedNames: {} });
-/** Build one real node with the full forward-gate wired to real gossipsub. */
-export async function makeVoteNode(topic, options = {}) {
-    const timeoutMs = options.timeoutMs ?? 10_000;
+/**
+ * One real loopback libp2p + Helia node carrying gossipsub (topic-scoped score params) and
+ * `@libp2p/fetch` — the raw host node with nothing else wired. {@link makeVoteNode} builds the
+ * harness transport on top of it; the three-node relay test instead hands it straight to the
+ * REAL `PubsubVoter` as the injected host node (the `PubsubVoterOptions.helia` seam).
+ */
+export async function makeBareNode(topic) {
     const libp2p = await createLibp2p({
         addresses: { listen: ["/ip4/127.0.0.1/tcp/0"] },
         transports: [tcp()],
@@ -87,6 +91,12 @@ export async function makeVoteNode(topic, options = {}) {
         }
     });
     const helia = await createHelia({ libp2p });
+    return { libp2p, helia };
+}
+/** Build one real node with the full forward-gate wired to real gossipsub. */
+export async function makeVoteNode(topic, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 10_000;
+    const { libp2p, helia } = await makeBareNode(topic);
     const pubsub = libp2p.services.pubsub;
     // Adapt Helia's async-generator `get` to the library's Promise-returning BlockstoreLike, the
     // same bridge `requireHeliaServices` applies to an injected host node.
@@ -117,16 +127,30 @@ export async function makeVoteNode(topic, options = {}) {
     let matchedOwnRoot = false;
     async function checkpointRootRecord() {
         const winners = crdt.current(CURRENT_BUCKET);
-        const { root, blocks } = await encodeCheckpoint(winners);
+        const { root, chunks, blocks } = await encodeCheckpoint(winners);
         for (const block of blocks)
             await blockstore.put(block.cid, block.bytes);
         return {
             version: ROOT_RECORD_VERSION,
             root,
+            chunks,
             count: winners.length,
             sizeBytes: blocks.reduce((total, block) => total + block.bytes.length, 0)
         };
     }
+    // Mirror the production fetch responder (voter.ts `#rootLookup`): answer `<topic>/root` with
+    // this node's current root record, encoded on demand — the surface a cold joiner pulls
+    // before chasing. `@libp2p/fetch` hands the lookup the requested key as raw bytes.
+    libp2p.services.fetch.registerLookupFunction(topic, async (keyBytes) => {
+        if (new TextDecoder().decode(keyBytes) !== rootFetchKey(topic))
+            return undefined;
+        try {
+            return encodeRootRecord(await checkpointRootRecord());
+        }
+        catch {
+            return undefined;
+        }
+    });
     const openedSessions = [];
     const chaseLimit = pLimit(2);
     const chaser = makeRootChaser({
@@ -228,6 +252,10 @@ export async function makeVoteNode(topic, options = {}) {
             verifyImpl = verify;
         },
         checkpointRootRecord,
+        fetchRootRecord: async (from) => {
+            const bytes = await libp2p.services.fetch.fetch(from.libp2p.peerId, rootFetchKey(topic));
+            return bytes == null ? undefined : decodeRootRecord(bytes);
+        },
         publishOwnRoot: async () => {
             await transport.publishRootRecord(await checkpointRootRecord());
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitsocial/pubsub-voting",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Trustless pubsub voting over a shared libp2p/Helia node.",
   "type": "module",
   "license": "GPL-3.0-or-later",