@hashtree/nostr 0.1.3 → 0.1.5

package/dist/webrtc/store.js

@@ -14,14 +14,15 @@
  * - 'other' pool: Everyone else (randos)
  * Each pool has its own connection limits.
  */
-import { SimplePool } from 'nostr-tools';
-import { toHex } from '@hashtree/core';
-import { PeerId, generateUuid, } from './types.js';
+import { SimplePool, verifyEvent } from 'nostr-tools';
+import { fromHex, sha256, toHex } from '@hashtree/core';
+import { PeerId, createMeshNostrEventFrame, validateMeshNostrFrame, MESH_EVENT_POLICY, } from './types.js';
+import { decrementHTLWithPolicy, shouldForwardHTL } from './protocol.js';
+import { PeerSelector, buildHedgedWavePlan, normalizeDispatchConfig, syncSelectorPeers, } from './peerSelector.js';
 import { Peer } from './peer.js';
 export const DEFAULT_RELAYS = [
     'wss://relay.damus.io',
     'wss://relay.primal.net',
-    'wss://nos.lol',
     'wss://relay.nostr.band',
     'wss://temp.iris.to',
     'wss://relay.snort.social',
@@ -31,8 +32,21 @@ export const DEFAULT_RELAYS = [
 // Directed messages use #p tag with gift wrap
 const SIGNALING_KIND = 25050;
 const HELLO_TAG = 'hello';
+const SEEN_FRAME_CAP = 4096;
+const SEEN_FRAME_TTL_MS = 120_000;
+const SEEN_EVENT_CAP = 8192;
+const SEEN_EVENT_TTL_MS = 600_000;
+const PEER_METADATA_POINTER_SLOT_KEY = 'hashtree-webrtc/peer-metadata/latest/v1';
+const DEFAULT_REQUEST_DISPATCH = {
+    initialFanout: 2,
+    hedgeFanout: 1,
+    maxFanout: 8,
+    hedgeIntervalMs: 120,
+};
 export class WebRTCStore {
     config;
+    routing;
+    peerSelector;
     pools;
     peerClassifier;
     getFollowedPubkeys;
@@ -60,13 +74,20 @@ export class WebRTCStore {
     blossomFetches = 0;
     // Track current hello subscription authors for change detection
     currentHelloAuthors = null;
+    // Relayless mesh dedupe
+    seenFrameIds = new Map();
+    seenEventIds = new Map();
+    // Relayless mesh stats
+    meshReceived = 0;
+    meshForwarded = 0;
+    meshDroppedDuplicate = 0;
     constructor(config) {
         this.signer = config.signer;
         this.encrypt = config.encrypt;
         this.decrypt = config.decrypt;
         this.giftWrap = config.giftWrap;
         this.giftUnwrap = config.giftUnwrap;
-        this.myPeerId = new PeerId(config.pubkey, generateUuid());
+        this.myPeerId = new PeerId(config.pubkey);
         // Default classifier: everyone is 'other' unless classifier provided
         this.peerClassifier = config.peerClassifier ?? (() => 'other');
         // Function to get followed pubkeys for subscription filtering
@@ -87,7 +108,7 @@ export class WebRTCStore {
             };
         }
         this.config = {
-            helloInterval: config.helloInterval ?? 10000,
+            helloInterval: config.helloInterval ?? 3000,
             messageTimeout: config.messageTimeout ?? 60000, // 60 seconds for relay propagation
             requestTimeout: config.requestTimeout ?? 500,
             peerQueryDelay: config.peerQueryDelay ?? 500,
@@ -96,6 +117,21 @@ export class WebRTCStore {
             fallbackStores: config.fallbackStores ?? [],
             debug: config.debug ?? false,
         };
+        const dispatch = config.requestDispatch ?? (config.peerQueryDelay !== undefined
+            ? {
+                initialFanout: 1,
+                hedgeFanout: 1,
+                maxFanout: Number.MAX_SAFE_INTEGER,
+                hedgeIntervalMs: Math.max(0, config.peerQueryDelay),
+            }
+            : DEFAULT_REQUEST_DISPATCH);
+        this.routing = {
+            selectionStrategy: config.requestSelectionStrategy ?? 'titForTat',
+            fairnessEnabled: config.requestFairnessEnabled ?? true,
+            dispatch,
+        };
+        this.peerSelector = PeerSelector.withStrategy(this.routing.selectionStrategy);
+        this.peerSelector.setFairness(this.routing.fairnessEnabled);
         this.pool = new SimplePool();
     }
     log(...args) {
@@ -193,11 +229,14 @@ export class WebRTCStore {
         }
         this.subscriptions = [];
         // Close all peer connections
-        for (const { peer } of this.peers.values()) {
+        for (const [peerId, { peer }] of this.peers.entries()) {
+            this.peerSelector.removePeer(peerId);
             peer.close();
         }
         this.peers.clear();
         this.pendingOtherPubkeys.clear();
+        this.seenFrameIds.clear();
+        this.seenEventIds.clear();
     }
     /**
      * Set relays and reconnect. Useful for runtime relay configuration changes.
@@ -214,7 +253,8 @@ export class WebRTCStore {
             }
             this.subscriptions = [];
             // Clear existing peers (they were discovered via old relays)
-            for (const { peer } of this.peers.values()) {
+            for (const [peerId, { peer }] of this.peers.entries()) {
+                this.peerSelector.removePeer(peerId);
                 peer.close();
             }
             this.peers.clear();
@@ -345,9 +385,8 @@ export class WebRTCStore {
         // Check if this is a hello message (#l: hello tag)
         const lTag = event.tags.find(t => t[0] === 'l')?.[1];
         if (lTag === HELLO_TAG) {
-            const peerIdTag = event.tags.find(t => t[0] === 'peerId')?.[1];
-            if (peerIdTag) {
-                await this.handleHello(peerIdTag, event.pubkey);
+            if (event.tags.some((tag) => tag[0] === 'peerId' && typeof tag[1] === 'string')) {
+                await this.handleHello(event.pubkey);
             }
             return;
         }
@@ -369,26 +408,32 @@ export class WebRTCStore {
         }
     }
     async handleSignalingMessage(msg, senderPubkey) {
+        const targetPeerId = PeerId.fromString(msg.targetPeerId).toString();
         // Directed message - check if it's for us
-        if (msg.targetPeerId !== this.myPeerId.toString()) {
+        if (targetPeerId !== this.myPeerId.toString()) {
             return;
         }
-        const peerId = new PeerId(senderPubkey, msg.peerId);
+        const peerId = new PeerId(senderPubkey);
         const peerIdStr = peerId.toString();
-        if (msg.type === 'offer') {
-            await this.handleOffer(peerId, msg);
+        const normalizedMsg = {
+            ...msg,
+            peerId: peerIdStr,
+            targetPeerId,
+        };
+        if (normalizedMsg.type === 'offer') {
+            await this.handleOffer(peerId, normalizedMsg);
         }
         else {
             // answer or candidate
             const peerInfo = this.peers.get(peerIdStr);
             if (peerInfo) {
-                await peerInfo.peer.handleSignaling(msg);
+                await peerInfo.peer.handleSignaling(normalizedMsg);
             }
         }
     }
-    async handleHello(peerUuid, senderPubkey) {
-        const peerId = new PeerId(senderPubkey, peerUuid);
-        // Skip self (exact same peerId = same session)
+    async handleHello(senderPubkey) {
+        const peerId = new PeerId(senderPubkey);
+        // Skip self
         if (peerId.toString() === this.myPeerId.toString()) {
             return;
         }
@@ -459,26 +504,30 @@ export class WebRTCStore {
         // Clean up existing connection if any
         const existing = this.peers.get(peerIdStr);
         if (existing) {
+            this.peerSelector.removePeer(peerIdStr);
             existing.peer.close();
             this.peers.delete(peerIdStr);
         }
         const peer = new Peer({
             peerId,
-            myPeerId: this.myPeerId.uuid,
+            myPeerId: this.myPeerId.toString(),
             direction: 'inbound',
             localStore: this.config.localStore,
-            sendSignaling: (m) => this.sendSignaling(m, peerId.pubkey),
+            sendSignaling: (m) => this.dispatchSignaling(m, peerId.pubkey),
             onClose: () => this.handlePeerClose(peerIdStr),
             onConnected: () => {
                 this.emit({ type: 'peer-connected', peerId: peerIdStr });
                 this.emit({ type: 'update' });
+                this.maybeSendHello();
                 this.tryPendingReqs(peer);
             },
             onForwardRequest: (hash, exclude, htl) => this.forwardRequest(hash, exclude, htl),
+            onMeshFrame: (fromPeerId, frame) => this.handleMeshFrame(fromPeerId, frame),
             requestTimeout: this.config.requestTimeout,
             debug: this.config.debug,
         });
         this.peers.set(peerIdStr, { peer, pool });
+        this.peerSelector.addPeer(peerIdStr);
         // Clear pending now that peer is in the map
         this.pendingOtherPubkeys.delete(peerId.pubkey);
         await peer.handleSignaling(msg);
@@ -491,70 +540,149 @@ export class WebRTCStore {
         this.log('Initiating connection to', peerId.short(), 'pool:', pool);
         const peer = new Peer({
             peerId,
-            myPeerId: this.myPeerId.uuid,
+            myPeerId: this.myPeerId.toString(),
             direction: 'outbound',
             localStore: this.config.localStore,
-            sendSignaling: (m) => this.sendSignaling(m, peerId.pubkey),
+            sendSignaling: (m) => this.dispatchSignaling(m, peerId.pubkey),
             onClose: () => this.handlePeerClose(peerIdStr),
             onConnected: () => {
                 this.emit({ type: 'peer-connected', peerId: peerIdStr });
                 this.emit({ type: 'update' });
+                this.maybeSendHello();
                 this.tryPendingReqs(peer);
             },
             onForwardRequest: (hash, exclude, htl) => this.forwardRequest(hash, exclude, htl),
+            onMeshFrame: (fromPeerId, frame) => this.handleMeshFrame(fromPeerId, frame),
             requestTimeout: this.config.requestTimeout,
             debug: this.config.debug,
         });
         this.peers.set(peerIdStr, { peer, pool });
+        this.peerSelector.addPeer(peerIdStr);
         await peer.connect();
     }
     handlePeerClose(peerIdStr) {
+        this.peerSelector.removePeer(peerIdStr);
         this.peers.delete(peerIdStr);
         this.emit({ type: 'peer-disconnected', peerId: peerIdStr });
         this.emit({ type: 'update' });
     }
-    /**
-     * Forward a request to other peers (excluding the requester)
-     * Called by Peer when it receives a request it can't fulfill locally
-     * Uses sequential queries with delays between attempts
-     * @param htl - Hops To Live (already decremented by calling peer)
-     */
-    async forwardRequest(hash, excludePeerId, htl) {
-        // Try all connected peers except the one who requested
-        const otherPeers = Array.from(this.peers.values())
-            .filter(({ peer }) => peer.isConnected && peer.peerId !== excludePeerId);
-        // Sort: follows first
-        otherPeers.sort((a, b) => {
+    orderedConnectedPeers(excludePeerId) {
+        const connectedAll = Array.from(this.peers.values())
+            .filter(({ peer }) => peer.isConnected);
+        if (connectedAll.length === 0)
+            return [];
+        const currentPeerIds = connectedAll.map(({ peer }) => peer.peerId);
+        syncSelectorPeers(this.peerSelector, currentPeerIds);
+        const connected = connectedAll
+            .filter(({ peer }) => !excludePeerId || peer.peerId !== excludePeerId);
+        const order = this.peerSelector.selectPeers();
+        const rank = new Map(order.map((peerId, idx) => [peerId, idx]));
+        connected.sort((a, b) => {
             if (a.pool === 'follows' && b.pool !== 'follows')
                 return -1;
             if (a.pool !== 'follows' && b.pool === 'follows')
                 return 1;
-            return 0;
+            return (rank.get(a.peer.peerId) ?? Number.MAX_SAFE_INTEGER) -
+                (rank.get(b.peer.peerId) ?? Number.MAX_SAFE_INTEGER);
         });
-        // Query peers sequentially with delay between attempts
-        for (let i = 0; i < otherPeers.length; i++) {
-            const { peer } = otherPeers[i];
-            // Start request to this peer with the decremented HTL
-            const requestPromise = peer.request(hash, htl);
-            // Race between request completing and delay timeout
-            const result = await Promise.race([
-                requestPromise.then(data => ({ type: 'data', data })),
-                this.delay(this.config.peerQueryDelay).then(() => ({ type: 'timeout' })),
-            ]);
-            if (result.type === 'data' && result.data) {
-                // Got data from this peer
+        return connected.map(({ peer }) => peer);
+    }
+    createInFlightPeerRequest(peer, hash, htl) {
+        const startedAt = Date.now();
+        this.peerSelector.recordRequest(peer.peerId, 40);
+        const promise = peer.request(hash, htl).then((data) => ({
+            peerId: peer.peerId,
+            data,
+            elapsedMs: Math.max(1, Date.now() - startedAt),
+        })).catch(() => ({
+            peerId: peer.peerId,
+            data: null,
+            elapsedMs: Math.max(1, Date.now() - startedAt),
+        }));
+        return { peerId: peer.peerId, settled: false, promise };
+    }
+    async waitForNextPeerResult(inFlight, waitMs) {
+        const active = inFlight.filter((task) => !task.settled);
+        if (active.length === 0 || waitMs <= 0)
+            return null;
+        const timeout = this.delay(waitMs).then(() => null);
+        const outcome = await Promise.race([
+            timeout,
+            ...active.map((task) => task.promise.then((result) => ({
+                task,
+                data: result.data,
+                elapsedMs: result.elapsedMs,
+            }))),
+        ]);
+        if (!outcome)
+            return null;
+        outcome.task.settled = true;
+        return outcome;
+    }
+    async queryPeersWithDispatch(hash, orderedPeers, triedPeers, htl) {
+        if (orderedPeers.length === 0)
+            return null;
+        const dispatch = normalizeDispatchConfig(this.routing.dispatch, orderedPeers.length);
+        const wavePlan = buildHedgedWavePlan(orderedPeers.length, dispatch);
+        if (wavePlan.length === 0)
+            return null;
+        const deadline = Date.now() + this.config.requestTimeout;
+        const inFlight = [];
+        let nextPeerIdx = 0;
+        const expectedHashHex = toHex(hash);
+        for (let waveIdx = 0; waveIdx < wavePlan.length; waveIdx++) {
+            const waveSize = wavePlan[waveIdx];
+            const from = nextPeerIdx;
+            const to = Math.min(from + waveSize, orderedPeers.length);
+            nextPeerIdx = to;
+            for (const peer of orderedPeers.slice(from, to)) {
+                triedPeers.add(peer.peerId);
+                inFlight.push(this.createInFlightPeerRequest(peer, hash, htl));
+            }
+            const isLastWave = waveIdx === wavePlan.length - 1 || nextPeerIdx >= orderedPeers.length;
+            const windowEnd = isLastWave
+                ? deadline
+                : Math.min(deadline, Date.now() + dispatch.hedgeIntervalMs);
+            while (Date.now() < windowEnd) {
+                const remaining = windowEnd - Date.now();
+                const result = await this.waitForNextPeerResult(inFlight, remaining);
+                if (!result)
+                    break;
+                if (!result.data) {
+                    this.peerSelector.recordTimeout(result.task.peerId);
+                    continue;
+                }
+                const computedHash = await sha256(result.data);
+                if (toHex(computedHash) !== expectedHashHex) {
+                    this.peerSelector.recordFailure(result.task.peerId);
+                    continue;
+                }
+                this.peerSelector.recordSuccess(result.task.peerId, result.elapsedMs, result.data.length);
                 if (this.config.localStore) {
                     await this.config.localStore.put(hash, result.data);
                 }
                 return result.data;
             }
-            // If timeout, continue to next peer
-            if (result.type === 'timeout') {
-                this.log('Forward: peer', peer.peerId.slice(0, 12), 'timeout, trying next');
-            }
+            if (Date.now() >= deadline)
+                break;
+        }
+        for (const task of inFlight) {
+            if (!task.settled)
+                this.peerSelector.recordTimeout(task.peerId);
         }
         return null;
     }
+    /**
+     * Forward a request to other peers (excluding the requester)
+     * Called by Peer when it receives a request it can't fulfill locally
+     * Uses selector ordering + staged hedged dispatch
+     * @param htl - Hops To Live (already decremented by calling peer)
+     */
+    async forwardRequest(hash, excludePeerId, htl) {
+        const triedPeers = new Set();
+        const orderedPeers = this.orderedConnectedPeers(excludePeerId);
+        return this.queryPeersWithDispatch(hash, orderedPeers, triedPeers, htl);
+    }
     /**
      * Send data to all peers who have requested this hash
      * Called when we receive data that peers may be waiting for
@@ -571,10 +699,101 @@ export class WebRTCStore {
         }
         return sendCount;
     }
+    pruneSeenSet(seen, ttlMs, cap) {
+        const now = Date.now();
+        for (const [key, ts] of seen) {
+            if (now - ts >= ttlMs) {
+                seen.delete(key);
+            }
+        }
+        while (seen.size > cap) {
+            const oldest = seen.keys().next().value;
+            if (!oldest)
+                break;
+            seen.delete(oldest);
+        }
+    }
+    markSeenFrameId(frameId) {
+        this.pruneSeenSet(this.seenFrameIds, SEEN_FRAME_TTL_MS, SEEN_FRAME_CAP);
+        if (this.seenFrameIds.has(frameId))
+            return false;
+        this.seenFrameIds.set(frameId, Date.now());
+        return true;
+    }
+    markSeenEventId(eventId) {
+        this.pruneSeenSet(this.seenEventIds, SEEN_EVENT_TTL_MS, SEEN_EVENT_CAP);
+        if (this.seenEventIds.has(eventId))
+            return false;
+        this.seenEventIds.set(eventId, Date.now());
+        return true;
+    }
+    forwardMeshFrame(frame, excludePeerId) {
+        let forwarded = 0;
+        for (const { peer } of this.peers.values()) {
+            if (!peer.isConnected)
+                continue;
+            if (excludePeerId && peer.peerId === excludePeerId)
+                continue;
+            const nextHtl = decrementHTLWithPolicy(frame.htl, MESH_EVENT_POLICY, peer.getHTLConfig());
+            if (!shouldForwardHTL(nextHtl))
+                continue;
+            const outbound = {
+                ...frame,
+                htl: nextHtl,
+            };
+            if (peer.sendMeshFrameText(outbound)) {
+                forwarded++;
+            }
+        }
+        return forwarded;
+    }
+    async handleMeshFrame(fromPeerId, frame) {
+        const validationError = validateMeshNostrFrame(frame);
+        if (validationError) {
+            return;
+        }
+        if (!this.markSeenFrameId(frame.frame_id)) {
+            this.meshDroppedDuplicate++;
+            return;
+        }
+        const event = frame.payload.event;
+        if (!this.markSeenEventId(event.id)) {
+            this.meshDroppedDuplicate++;
+            return;
+        }
+        if (!verifyEvent(event)) {
+            return;
+        }
+        this.meshReceived++;
+        await this.handleSignalingEvent(event);
+        const forwarded = this.forwardMeshFrame(frame, fromPeerId);
+        if (forwarded > 0) {
+            this.meshForwarded += forwarded;
+        }
+    }
+    async dispatchSignaling(msg, recipientPubkey) {
+        const event = await this.sendSignaling(msg, recipientPubkey);
+        if (!event) {
+            return;
+        }
+        const frame = createMeshNostrEventFrame(event, this.myPeerId.toString(), MESH_EVENT_POLICY.maxHtl);
+        if (!this.markSeenFrameId(frame.frame_id)) {
+            this.meshDroppedDuplicate++;
+            return;
+        }
+        if (!this.markSeenEventId(frame.payload.event.id)) {
+            this.meshDroppedDuplicate++;
+            return;
+        }
+        const forwarded = this.forwardMeshFrame(frame);
+        if (forwarded > 0) {
+            this.meshForwarded += forwarded;
+        }
+    }
     async sendSignaling(msg, recipientPubkey) {
         // Fill in our peer ID
         if ('peerId' in msg && msg.peerId === '') {
-            msg.peerId = this.myPeerId.uuid;
+            msg.peerId = this.myPeerId.toString();
         }
         if (recipientPubkey) {
             // Directed message (offer, answer, candidate, candidates)
@@ -586,6 +805,7 @@ export class WebRTCStore {
             };
             const wrappedEvent = await this.giftWrap(innerEvent, recipientPubkey);
             await this.pool.publish(this.config.relays, wrappedEvent);
+            return wrappedEvent;
         }
         else {
             // Hello message - broadcast for peer discovery (kind 25050 with #l: hello)
@@ -603,6 +823,7 @@ export class WebRTCStore {
             };
             const event = await this.signer(eventTemplate);
             await this.pool.publish(this.config.relays, event);
+            return event;
         }
     }
     /**
@@ -622,9 +843,9 @@ export class WebRTCStore {
         if (followsSatisfied && otherSatisfied) {
             return;
         }
-        this.sendSignaling({
+        void this.dispatchSignaling({
             type: 'hello',
-            peerId: this.myPeerId.uuid,
+            peerId: this.myPeerId.toString(),
         });
     }
     cleanupConnections() {
@@ -636,6 +857,7 @@ export class WebRTCStore {
             if (state === 'failed' || state === 'closed' || state === 'disconnected' || isStale) {
                 this.log('Cleaning up', state, 'connection', isStale ? '(stale)' : '');
                 peer.close();
+                this.peerSelector.removePeer(peerIdStr);
                 this.peers.delete(peerIdStr);
                 this.emit({ type: 'update' });
             }
@@ -672,6 +894,7 @@ export class WebRTCStore {
             if (peerInfo.peer.pubkey === pubkey) {
                 this.log('Disconnecting blocked peer:', pubkey.slice(0, 8));
                 peerInfo.peer.close();
+                this.peerSelector.removePeer(peerIdStr);
                 this.peers.delete(peerIdStr);
                 this.emit({ type: 'peer-disconnected', peerId: peerIdStr });
             }
@@ -679,10 +902,10 @@ export class WebRTCStore {
         this.emit({ type: 'update' });
     }
     /**
-     * Get my peer ID (uuid part only)
+     * Get my endpoint ID
      */
     getMyPeerId() {
-        return this.myPeerId.uuid;
+        return this.myPeerId.toString();
     }
     /**
      * Check if store is satisfied (has enough connections in all pools)
@@ -737,6 +960,55 @@ export class WebRTCStore {
     getPoolConfig() {
         return { ...this.pools };
     }
+    async peerMetadataPointerHash() {
+        return sha256(new TextEncoder().encode(PEER_METADATA_POINTER_SLOT_KEY));
+    }
+    /**
+     * Persist selector metadata snapshot to local store.
+     * Returns the snapshot hash, or null when local storage is unavailable.
+     */
+    async persistPeerMetadata() {
+        if (!this.config.localStore)
+            return null;
+        const snapshot = this.peerSelector.exportPeerMetadataSnapshot();
+        const bytes = new TextEncoder().encode(JSON.stringify(snapshot));
+        const snapshotHash = await sha256(bytes);
+        await this.config.localStore.put(snapshotHash, bytes);
+        const pointerHash = await this.peerMetadataPointerHash();
+        await this.config.localStore.delete(pointerHash);
+        await this.config.localStore.put(pointerHash, new TextEncoder().encode(toHex(snapshotHash)));
+        return snapshotHash;
+    }
+    /**
+     * Load selector metadata snapshot from local store, if available.
+     */
+    async loadPeerMetadata() {
+        if (!this.config.localStore)
+            return false;
+        const pointerHash = await this.peerMetadataPointerHash();
+        const pointerBytes = await this.config.localStore.get(pointerHash);
+        if (!pointerBytes)
+            return false;
+        const pointerHex = new TextDecoder().decode(pointerBytes).trim();
+        if (pointerHex.length !== 64)
+            return false;
+        const snapshotHash = fromHex(pointerHex);
+        if (snapshotHash.length !== 32)
+            return false;
+        const snapshotBytes = await this.config.localStore.get(snapshotHash);
+        if (!snapshotBytes)
+            return false;
+        let snapshot;
+        try {
+            snapshot = JSON.parse(new TextDecoder().decode(snapshotBytes));
+        }
+        catch {
+            return false;
+        }
+        this.peerSelector.importPeerMetadataSnapshot(snapshot);
+        syncSelectorPeers(this.peerSelector, Array.from(this.peers.keys()));
+        return true;
+    }
     /**
      * Get fallback stores count
      */
@@ -762,6 +1034,9 @@ export class WebRTCStore {
             bytesSent: 0,
             bytesReceived: 0,
             bytesForwarded: 0,
+            meshReceived: this.meshReceived,
+            meshForwarded: this.meshForwarded,
+            meshDroppedDuplicate: this.meshDroppedDuplicate,
         };
         const perPeer = new Map();
         for (const [peerIdStr, { peer, pool }] of this.peers) {
@@ -836,45 +1111,11 @@ export class WebRTCStore {
      * Internal method to fetch data from peers (separated for deduplication)
      */
     async fetchFromPeers(hash) {
-        // Get currently connected peers (prioritize follows pool)
         const triedPeers = new Set();
-        const allPeers = Array.from(this.peers.values())
-            .filter(({ peer }) => peer.isConnected);
-        // Sort: follows first, then others
-        allPeers.sort((a, b) => {
-            if (a.pool === 'follows' && b.pool !== 'follows')
-                return -1;
-            if (a.pool !== 'follows' && b.pool === 'follows')
-                return 1;
-            return 0;
-        });
-        // Query peers sequentially with delay between attempts
-        for (let i = 0; i < allPeers.length; i++) {
-            const { peer } = allPeers[i];
-            triedPeers.add(peer.peerId);
-            // Start request to this peer
-            const requestPromise = peer.request(hash);
-            // Race between request completing and delay timeout
-            // If request completes within delay, we're done
-            // If delay passes first, start next peer while still waiting
-            const result = await Promise.race([
-                requestPromise.then(data => ({ type: 'data', data })),
-                this.delay(this.config.peerQueryDelay).then(() => ({ type: 'timeout' })),
-            ]);
-            if (result.type === 'data' && result.data) {
-                // Got data from this peer
-                if (this.config.localStore) {
-                    await this.config.localStore.put(hash, result.data);
-                }
-                return result.data;
-            }
-            // If timeout, continue to next peer but also await the original request
-            // in case it eventually returns data
-            if (result.type === 'timeout') {
-                // Fire-and-forget: if this peer eventually responds, we'll miss it
-                // but that's fine - we're trying the next peer
-                this.log('Peer', peer.peerId.slice(0, 12), 'timeout after', this.config.peerQueryDelay, 'ms, trying next');
-            }
+        const orderedPeers = this.orderedConnectedPeers();
+        const webRtcData = await this.queryPeersWithDispatch(hash, orderedPeers, triedPeers);
+        if (webRtcData) {
+            return webRtcData;
         }
         // All WebRTC peers failed - try fallback stores in order
         if (this.config.fallbackStores.length > 0) {
@@ -942,10 +1183,8 @@ export class WebRTCStore {
         const reqs = this.pendingReqs.get(hash);
         if (!reqs || reqs.length === 0)
             return;
-        // Get all connected peers
-        const connectedPeers = Array.from(this.peers.values())
-            .filter(({ peer }) => peer.isConnected)
-            .map(({ peer }) => peer);
+        const connectedPeers = this.orderedConnectedPeers();
+        const expectedHashHex = toHex(hash);
         for (const peer of connectedPeers) {
             const peerIdStr = peer.peerId;
             // Find requests that haven't tried this peer yet
@@ -957,8 +1196,16 @@ export class WebRTCStore {
                 r.triedPeers.add(peerIdStr);
             }
             this.log('Trying pending req from connected peer:', hash.slice(0, 16));
+            const startedAt = Date.now();
+            this.peerSelector.recordRequest(peerIdStr, 40);
             const data = await peer.request(hash);
             if (data) {
+                const computedHash = await sha256(data);
+                if (toHex(computedHash) !== expectedHashHex) {
+                    this.peerSelector.recordFailure(peerIdStr);
+                    continue;
+                }
+                this.peerSelector.recordSuccess(peerIdStr, Math.max(1, Date.now() - startedAt), data.length);
                 // Store locally
                 if (this.config.localStore) {
                     await this.config.localStore.put(hash, data);
@@ -975,6 +1222,7 @@ export class WebRTCStore {
                 this.log('Resolved pending req:', hash.slice(0, 16));
                 return;
             }
+            this.peerSelector.recordTimeout(peerIdStr);
         }
     }
     /**
@@ -997,7 +1245,10 @@ export class WebRTCStore {
      */
     async tryPendingReqs(peer) {
         const peerIdStr = peer.peerId;
+        const expectedByHash = new Map();
         for (const [hash, reqs] of this.pendingReqs.entries()) {
+            const hashKey = toHex(hash);
+            expectedByHash.set(hashKey, hashKey);
             // Find requests that haven't tried this peer yet
             const untried = reqs.filter(r => !r.triedPeers.has(peerIdStr));
             if (untried.length === 0)
@@ -1006,8 +1257,17 @@ export class WebRTCStore {
             for (const r of untried) {
                 r.triedPeers.add(peerIdStr);
             }
+            const startedAt = Date.now();
+            this.peerSelector.recordRequest(peerIdStr, 40);
             const data = await peer.request(hash);
             if (data) {
+                const computedHash = await sha256(data);
+                const expectedHashHex = expectedByHash.get(hashKey);
+                if (toHex(computedHash) !== expectedHashHex) {
+                    this.peerSelector.recordFailure(peerIdStr);
+                    continue;
+                }
+                this.peerSelector.recordSuccess(peerIdStr, Math.max(1, Date.now() - startedAt), data.length);
                 // Store locally
                 if (this.config.localStore) {
                     await this.config.localStore.put(hash, data);
@@ -1020,6 +1280,9 @@ export class WebRTCStore {
                 this.pendingReqs.delete(hash);
                 this.log('Resolved pending req:', hash.slice(0, 16));
             }
+            else {
+                this.peerSelector.recordTimeout(peerIdStr);
+            }
         }
     }
     async has(hash) {