@hashtree/core 0.1.3 → 0.1.4

package/dist/webrtc/store.js

@@ -1,1043 +0,0 @@
-/**
- * WebRTC-based distributed store for hashtree
- *
- * Implements the Store interface, fetching data from P2P network.
- * Uses Nostr relays for WebRTC signaling with perfect negotiation (both peers can initiate).
- *
- * Signaling protocol (all use ephemeral kind 25050):
- * - Hello messages: #l: "hello" tag, broadcast for peer discovery (unencrypted)
- * - Directed signaling (offer, answer, candidate, candidates): #p tag with
- *   recipient pubkey, NIP-17 style gift wrap for privacy
- *
- * Pool-based peer management:
- * - 'follows' pool: Users in your social graph (followed or followers)
- * - 'other' pool: Everyone else (randos)
- * Each pool has its own connection limits.
- */
-import { SimplePool } from 'nostr-tools';
-import { toHex } from '../types.js';
-import { PeerId, generateUuid, } from './types.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',
-];
-// All WebRTC signaling uses ephemeral kind 25050
-// Hello messages use #l tag for broadcast discovery
-// Directed messages use #p tag with gift wrap
-const SIGNALING_KIND = 25050;
-const HELLO_TAG = 'hello';
-export class WebRTCStore {
-    config;
-    pools;
-    peerClassifier;
-    getFollowedPubkeys;
-    isPeerBlocked;
-    signer;
-    encrypt;
-    decrypt;
-    giftWrap;
-    giftUnwrap;
-    myPeerId;
-    pool;
-    subscriptions = [];
-    helloSubscription = null;
-    peers = new Map();
-    // Track pubkeys we're currently connecting to in 'other' pool (prevents race conditions)
-    pendingOtherPubkeys = new Set();
-    helloInterval = null;
-    cleanupInterval = null;
-    eventHandlers = new Set();
-    running = false;
-    pendingReqs = new Map();
-    // Deduplicate concurrent get() calls for the same hash
-    pendingGets = new Map();
-    // Store-level stats (not per-peer)
-    blossomFetches = 0;
-    // Track current hello subscription authors for change detection
-    currentHelloAuthors = null;
-    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());
-        // Default classifier: everyone is 'other' unless classifier provided
-        this.peerClassifier = config.peerClassifier ?? (() => 'other');
-        // Function to get followed pubkeys for subscription filtering
-        this.getFollowedPubkeys = config.getFollowedPubkeys ?? null;
-        // Function to check if a peer is blocked
-        this.isPeerBlocked = config.isPeerBlocked ?? null;
-        // Use pool config if provided, otherwise fall back to legacy config or defaults
-        if (config.pools) {
-            this.pools = config.pools;
-        }
-        else {
-            // Legacy mode: single pool with old config values
-            const maxConn = config.maxConnections ?? 6;
-            const satConn = config.satisfiedConnections ?? 3;
-            this.pools = {
-                follows: { maxConnections: 0, satisfiedConnections: 0 }, // No follows pool in legacy
-                other: { maxConnections: maxConn, satisfiedConnections: satConn },
-            };
-        }
-        this.config = {
-            helloInterval: config.helloInterval ?? 10000,
-            messageTimeout: config.messageTimeout ?? 60000, // 60 seconds for relay propagation
-            requestTimeout: config.requestTimeout ?? 500,
-            peerQueryDelay: config.peerQueryDelay ?? 500,
-            relays: config.relays ?? DEFAULT_RELAYS,
-            localStore: config.localStore ?? null,
-            fallbackStores: config.fallbackStores ?? [],
-            debug: config.debug ?? false,
-        };
-        this.pool = new SimplePool();
-    }
-    log(...args) {
-        if (this.config.debug) {
-            console.log('[WebRTCStore]', ...args);
-        }
-    }
-    /**
-     * Get pool counts
-     */
-    getPoolCounts() {
-        const counts = {
-            follows: { connected: 0, total: 0 },
-            other: { connected: 0, total: 0 },
-        };
-        for (const { peer, pool } of this.peers.values()) {
-            counts[pool].total++;
-            if (peer.isConnected) {
-                counts[pool].connected++;
-            }
-        }
-        return counts;
-    }
-    /**
-     * Check if we can accept a peer in a given pool
-     */
-    canAcceptPeer(pool) {
-        const counts = this.getPoolCounts();
-        return counts[pool].total < this.pools[pool].maxConnections;
-    }
-    /**
-     * Check if a pool is satisfied
-     */
-    isPoolSatisfied(pool) {
-        const counts = this.getPoolCounts();
-        return counts[pool].connected >= this.pools[pool].satisfiedConnections;
-    }
-    /**
-     * Check if we already have a connection from a pubkey in the 'other' pool.
-     * In the 'other' pool, we only allow 1 instance per pubkey.
-     * Also checks pendingOtherPubkeys to prevent race conditions.
-     */
-    hasOtherPoolPubkey(pubkey) {
-        if (this.pendingOtherPubkeys.has(pubkey)) {
-            return true;
-        }
-        for (const { peer, pool } of this.peers.values()) {
-            if (pool === 'other' && peer.pubkey === pubkey) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Start the WebRTC store - connect to relays and begin peer discovery
-     */
-    start() {
-        if (this.running)
-            return;
-        this.running = true;
-        this.log('Starting with peerId:', this.myPeerId.short());
-        this.log('Pool config:', this.pools);
-        this.log('Relays:', this.config.relays);
-        // Subscribe to signaling messages
-        this.startSubscription();
-        // Send hello messages when not satisfied
-        this.helloInterval = setInterval(() => {
-            this.maybeSendHello();
-        }, this.config.helloInterval);
-        // Send initial hello
-        this.maybeSendHello();
-        // Cleanup stale connections
-        this.cleanupInterval = setInterval(() => {
-            this.cleanupConnections();
-        }, 5000);
-    }
-    /**
-     * Stop the WebRTC store
-     */
-    stop() {
-        if (!this.running)
-            return;
-        this.running = false;
-        this.log('Stopping');
-        if (this.helloInterval) {
-            clearInterval(this.helloInterval);
-            this.helloInterval = null;
-        }
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-        for (const sub of this.subscriptions) {
-            sub.close();
-        }
-        this.subscriptions = [];
-        // Close all peer connections
-        for (const { peer } of this.peers.values()) {
-            peer.close();
-        }
-        this.peers.clear();
-        this.pendingOtherPubkeys.clear();
-    }
-    /**
-     * Set relays and reconnect. Useful for runtime relay configuration changes.
-     * Closes existing subscriptions and starts new ones with the updated relays.
-     */
-    setRelays(relays) {
-        this.log('setRelays:', relays);
-        this.config.relays = relays;
-        // If running, restart subscriptions with new relays
-        if (this.running) {
-            // Close existing subscriptions
-            for (const sub of this.subscriptions) {
-                sub.close();
-            }
-            this.subscriptions = [];
-            // Clear existing peers (they were discovered via old relays)
-            for (const { peer } of this.peers.values()) {
-                peer.close();
-            }
-            this.peers.clear();
-            // Start new subscriptions with updated relays
-            this.startSubscription();
-            this.emit({ type: 'update' });
-        }
-    }
-    /**
-     * Add event listener
-     */
-    on(handler) {
-        this.eventHandlers.add(handler);
-        return () => this.eventHandlers.delete(handler);
-    }
-    emit(event) {
-        for (const handler of this.eventHandlers) {
-            handler(event);
-        }
-    }
-    startSubscription() {
-        const since = Math.floor((Date.now() - this.config.messageTimeout) / 1000);
-        const subHandler = {
-            onevent: (event) => {
-                this.handleSignalingEvent(event);
-            },
-            oneose: () => { },
-        };
-        // 1. Subscribe to hello messages based on pool configuration
-        this.setupHelloSubscription(since, subHandler);
-        // 2. Subscribe to directed signaling (kind 25050 with #p tag) for offers/answers/candidates
-        // Always subscribe to directed messages (needed to receive offers/answers)
-        this.subscriptions.push(this.pool.subscribe(this.config.relays, {
-            kinds: [SIGNALING_KIND],
-            '#p': [this.myPeerId.pubkey],
-            since,
-        }, subHandler));
-    }
-    /**
-     * Setup hello subscription based on pool configuration
-     * - If both pools are 0: don't subscribe to hellos
-     * - If other pool is disabled but follows is enabled: subscribe to followed pubkeys only
-     * - If other pool is enabled: subscribe to all hellos
-     */
-    setupHelloSubscription(since, subHandler) {
-        // Close existing hello subscription if any
-        if (this.helloSubscription) {
-            this.helloSubscription.close();
-            this.helloSubscription = null;
-        }
-        const followsMax = this.pools.follows.maxConnections;
-        const otherMax = this.pools.other.maxConnections;
-        // If both pools are disabled, don't subscribe to hellos at all
-        if (followsMax === 0 && otherMax === 0) {
-            this.log('Both pools disabled, not subscribing to hellos');
-            this.currentHelloAuthors = [];
-            return;
-        }
-        // If other pool is disabled but follows pool is enabled, only subscribe to followed users
-        if (otherMax === 0 && followsMax > 0) {
-            const followedPubkeys = this.getFollowedPubkeys?.() ?? [];
-            if (followedPubkeys.length === 0) {
-                this.log('Follows pool enabled but no followed users, not subscribing to hellos');
-                this.currentHelloAuthors = [];
-                return;
-            }
-            this.log('Other pool disabled, subscribing to hellos from', followedPubkeys.length, 'followed users');
-            this.currentHelloAuthors = [...followedPubkeys];
-            this.helloSubscription = this.pool.subscribe(this.config.relays, {
-                kinds: [SIGNALING_KIND],
-                '#l': [HELLO_TAG],
-                authors: followedPubkeys,
-                since,
-            }, subHandler);
-            return;
-        }
-        // Otherwise subscribe to all hellos
-        this.log('Subscribing to all hellos');
-        this.currentHelloAuthors = null; // null means all authors
-        this.helloSubscription = this.pool.subscribe(this.config.relays, {
-            kinds: [SIGNALING_KIND],
-            '#l': [HELLO_TAG],
-            since,
-        }, subHandler);
-    }
-    /**
-     * Update hello subscription when follows list changes
-     * Call this after social graph updates
-     */
-    updateHelloSubscription() {
-        if (!this.running)
-            return;
-        const followsMax = this.pools.follows.maxConnections;
-        const otherMax = this.pools.other.maxConnections;
-        // Only need to update if we're in follows-only mode
-        if (otherMax === 0 && followsMax > 0) {
-            const followedPubkeys = this.getFollowedPubkeys?.() ?? [];
-            const currentAuthors = this.currentHelloAuthors ?? [];
-            // Check if follows list changed
-            const changed = followedPubkeys.length !== currentAuthors.length ||
-                !followedPubkeys.every(pk => currentAuthors.includes(pk));
-            if (changed) {
-                const since = Math.floor((Date.now() - this.config.messageTimeout) / 1000);
-                const subHandler = {
-                    onevent: (event) => {
-                        this.handleSignalingEvent(event);
-                    },
-                    oneose: () => { },
-                };
-                this.setupHelloSubscription(since, subHandler);
-            }
-        }
-    }
-    async handleSignalingEvent(event) {
-        // Filter out old events (created more than messageTimeout ago)
-        const eventAge = Date.now() / 1000 - (event.created_at ?? 0);
-        if (eventAge > this.config.messageTimeout / 1000) {
-            return;
-        }
-        // Check expiration
-        const expirationTag = event.tags.find(t => t[0] === 'expiration');
-        if (expirationTag) {
-            const expiration = parseInt(expirationTag[1], 10);
-            if (expiration < Date.now() / 1000) {
-                return;
-            }
-        }
-        // 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);
-            }
-            return;
-        }
-        // Check if this is a directed message (#p tag pointing to us)
-        const pTag = event.tags.find(t => t[0] === 'p')?.[1];
-        if (pTag === this.myPeerId.pubkey) {
-            // Gift-wrapped signaling message - try to unwrap
-            try {
-                const inner = await this.giftUnwrap(event);
-                if (!inner) {
-                    return; // Can't decrypt - not for us
-                }
-                const msg = JSON.parse(inner.content);
-                await this.handleSignalingMessage(msg, inner.pubkey);
-            }
-            catch {
-                // Not for us or invalid - ignore silently
-            }
-        }
-    }
-    async handleSignalingMessage(msg, senderPubkey) {
-        // Directed message - check if it's for us
-        if (msg.targetPeerId !== this.myPeerId.toString()) {
-            return;
-        }
-        const peerId = new PeerId(senderPubkey, msg.peerId);
-        const peerIdStr = peerId.toString();
-        if (msg.type === 'offer') {
-            await this.handleOffer(peerId, msg);
-        }
-        else {
-            // answer or candidate
-            const peerInfo = this.peers.get(peerIdStr);
-            if (peerInfo) {
-                await peerInfo.peer.handleSignaling(msg);
-            }
-        }
-    }
-    async handleHello(peerUuid, senderPubkey) {
-        const peerId = new PeerId(senderPubkey, peerUuid);
-        // Skip self (exact same peerId = same session)
-        if (peerId.toString() === this.myPeerId.toString()) {
-            return;
-        }
-        // Skip blocked peers
-        if (this.isPeerBlocked?.(senderPubkey)) {
-            this.log('Ignoring hello from blocked peer:', senderPubkey.slice(0, 8));
-            return;
-        }
-        // Check if we already have this peer
-        if (this.peers.has(peerId.toString())) {
-            return;
-        }
-        // Classify the peer
-        let pool;
-        try {
-            pool = this.peerClassifier(senderPubkey);
-        }
-        catch (e) {
-            this.log('Error classifying peer:', e);
-            pool = 'other';
-        }
-        // Check if we can accept this peer in their pool
-        if (!this.canAcceptPeer(pool)) {
-            return;
-        }
-        // In 'other' pool, only allow 1 instance per pubkey
-        if (pool === 'other' && this.hasOtherPoolPubkey(senderPubkey)) {
-            return;
-        }
-        // Perfect negotiation: both peers initiate
-        // Collision is handled by Peer class (polite peer rolls back)
-        // Mark as pending before async operation to prevent race conditions
-        if (pool === 'other') {
-            this.pendingOtherPubkeys.add(senderPubkey);
-        }
-        try {
-            await this.connectToPeer(peerId, pool);
-        }
-        finally {
-            this.pendingOtherPubkeys.delete(senderPubkey);
-        }
-    }
-    async handleOffer(peerId, msg) {
-        // Skip self (exact same peerId)
-        if (peerId.toString() === this.myPeerId.toString()) {
-            return;
-        }
-        // Skip blocked peers
-        if (this.isPeerBlocked?.(peerId.pubkey)) {
-            this.log('Ignoring offer from blocked peer:', peerId.pubkey.slice(0, 8));
-            return;
-        }
-        const peerIdStr = peerId.toString();
-        // Classify the peer
-        const pool = this.peerClassifier(peerId.pubkey);
-        // Check if we can accept (unless we already have this peer)
-        if (!this.peers.has(peerIdStr) && !this.canAcceptPeer(pool)) {
-            return;
-        }
-        // In 'other' pool, only allow 1 instance per pubkey (unless we already have this exact peer)
-        if (!this.peers.has(peerIdStr) && pool === 'other' && this.hasOtherPoolPubkey(peerId.pubkey)) {
-            return;
-        }
-        // Mark as pending before any async gaps to prevent race conditions
-        if (pool === 'other' && !this.peers.has(peerIdStr)) {
-            this.pendingOtherPubkeys.add(peerId.pubkey);
-        }
-        // Clean up existing connection if any
-        const existing = this.peers.get(peerIdStr);
-        if (existing) {
-            existing.peer.close();
-            this.peers.delete(peerIdStr);
-        }
-        const peer = new Peer({
-            peerId,
-            myPeerId: this.myPeerId.uuid,
-            direction: 'inbound',
-            localStore: this.config.localStore,
-            sendSignaling: (m) => this.sendSignaling(m, peerId.pubkey),
-            onClose: () => this.handlePeerClose(peerIdStr),
-            onConnected: () => {
-                this.emit({ type: 'peer-connected', peerId: peerIdStr });
-                this.emit({ type: 'update' });
-                this.tryPendingReqs(peer);
-            },
-            onForwardRequest: (hash, exclude, htl) => this.forwardRequest(hash, exclude, htl),
-            requestTimeout: this.config.requestTimeout,
-            debug: this.config.debug,
-        });
-        this.peers.set(peerIdStr, { peer, pool });
-        // Clear pending now that peer is in the map
-        this.pendingOtherPubkeys.delete(peerId.pubkey);
-        await peer.handleSignaling(msg);
-    }
-    async connectToPeer(peerId, pool) {
-        const peerIdStr = peerId.toString();
-        if (this.peers.has(peerIdStr)) {
-            return;
-        }
-        this.log('Initiating connection to', peerId.short(), 'pool:', pool);
-        const peer = new Peer({
-            peerId,
-            myPeerId: this.myPeerId.uuid,
-            direction: 'outbound',
-            localStore: this.config.localStore,
-            sendSignaling: (m) => this.sendSignaling(m, peerId.pubkey),
-            onClose: () => this.handlePeerClose(peerIdStr),
-            onConnected: () => {
-                this.emit({ type: 'peer-connected', peerId: peerIdStr });
-                this.emit({ type: 'update' });
-                this.tryPendingReqs(peer);
-            },
-            onForwardRequest: (hash, exclude, htl) => this.forwardRequest(hash, exclude, htl),
-            requestTimeout: this.config.requestTimeout,
-            debug: this.config.debug,
-        });
-        this.peers.set(peerIdStr, { peer, pool });
-        await peer.connect();
-    }
-    handlePeerClose(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) => {
-            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 < 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
-                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');
-            }
-        }
-        return null;
-    }
-    /**
-     * Send data to all peers who have requested this hash
-     * Called when we receive data that peers may be waiting for
-     */
-    sendToInterestedPeers(hash, data) {
-        let sendCount = 0;
-        for (const { peer } of this.peers.values()) {
-            if (peer.isConnected && peer.sendData(hash, data)) {
-                sendCount++;
-            }
-        }
-        if (sendCount > 0) {
-            this.log('Sent data to', sendCount, 'interested peers for hash:', toHex(hash).slice(0, 16));
-        }
-        return sendCount;
-    }
-    async sendSignaling(msg, recipientPubkey) {
-        // Fill in our peer ID
-        if ('peerId' in msg && msg.peerId === '') {
-            msg.peerId = this.myPeerId.uuid;
-        }
-        if (recipientPubkey) {
-            // Directed message (offer, answer, candidate, candidates)
-            // Use NIP-17 style gift wrap with kind 25050
-            const innerEvent = {
-                kind: SIGNALING_KIND,
-                content: JSON.stringify(msg),
-                tags: [],
-            };
-            const wrappedEvent = await this.giftWrap(innerEvent, recipientPubkey);
-            await this.pool.publish(this.config.relays, wrappedEvent);
-        }
-        else {
-            // Hello message - broadcast for peer discovery (kind 25050 with #l: hello)
-            const expiration = Math.floor((Date.now() + 5 * 60 * 1000) / 1000); // 5 minutes
-            const tags = [
-                ['l', HELLO_TAG],
-                ['peerId', msg.peerId],
-                ['expiration', expiration.toString()],
-            ];
-            const eventTemplate = {
-                kind: SIGNALING_KIND,
-                created_at: Math.floor(Date.now() / 1000),
-                tags,
-                content: '',
-            };
-            const event = await this.signer(eventTemplate);
-            await this.pool.publish(this.config.relays, event);
-        }
-    }
-    /**
-     * Force send a hello message (useful for testing after pool config changes)
-     */
-    sendHello() {
-        if (!this.running)
-            return;
-        this.maybeSendHello();
-    }
-    maybeSendHello() {
-        if (!this.running)
-            return;
-        // Check if both pools are satisfied
-        const followsSatisfied = this.isPoolSatisfied('follows');
-        const otherSatisfied = this.isPoolSatisfied('other');
-        if (followsSatisfied && otherSatisfied) {
-            return;
-        }
-        this.sendSignaling({
-            type: 'hello',
-            peerId: this.myPeerId.uuid,
-        });
-    }
-    cleanupConnections() {
-        const now = Date.now();
-        const connectionTimeout = 15000; // 15 seconds to establish connection
-        for (const [peerIdStr, { peer }] of this.peers) {
-            const state = peer.state;
-            const isStale = state === 'new' && (now - peer.createdAt) > connectionTimeout;
-            if (state === 'failed' || state === 'closed' || state === 'disconnected' || isStale) {
-                this.log('Cleaning up', state, 'connection', isStale ? '(stale)' : '');
-                peer.close();
-                this.peers.delete(peerIdStr);
-                this.emit({ type: 'update' });
-            }
-        }
-    }
-    /**
-     * Get number of connected peers
-     */
-    getConnectedCount() {
-        return Array.from(this.peers.values())
-            .filter(({ peer }) => peer.isConnected).length;
-    }
-    /**
-     * Get all peer statuses
-     */
-    getPeers() {
-        return Array.from(this.peers.values()).map(({ peer, pool }) => ({
-            peerId: peer.peerId,
-            pubkey: peer.pubkey,
-            state: peer.state,
-            direction: peer.direction,
-            connectedAt: peer.connectedAt,
-            isSelf: peer.pubkey === this.myPeerId.pubkey,
-            pool,
-            isConnected: peer.isConnected, // Includes data channel state
-        }));
-    }
-    /**
-     * Disconnect all peers with a given pubkey
-     * Used when blocking a peer to immediately disconnect them
-     */
-    disconnectPeerByPubkey(pubkey) {
-        for (const [peerIdStr, peerInfo] of this.peers) {
-            if (peerInfo.peer.pubkey === pubkey) {
-                this.log('Disconnecting blocked peer:', pubkey.slice(0, 8));
-                peerInfo.peer.close();
-                this.peers.delete(peerIdStr);
-                this.emit({ type: 'peer-disconnected', peerId: peerIdStr });
-            }
-        }
-        this.emit({ type: 'update' });
-    }
-    /**
-     * Get my peer ID (uuid part only)
-     */
-    getMyPeerId() {
-        return this.myPeerId.uuid;
-    }
-    /**
-     * Check if store is satisfied (has enough connections in all pools)
-     */
-    isSatisfied() {
-        return this.isPoolSatisfied('follows') && this.isPoolSatisfied('other');
-    }
-    /**
-     * Update peer classifier (e.g., when social graph updates)
-     */
-    setPeerClassifier(classifier) {
-        this.peerClassifier = classifier;
-        // Re-classify existing peers (they keep their connections, just update pool assignment)
-        for (const [peerIdStr, peerInfo] of this.peers) {
-            const newPool = classifier(peerInfo.peer.pubkey);
-            if (newPool !== peerInfo.pool) {
-                this.log('Reclassified peer', peerIdStr.slice(0, 16), 'from', peerInfo.pool, 'to', newPool);
-                peerInfo.pool = newPool;
-            }
-        }
-        this.emit({ type: 'update' });
-    }
-    /**
-     * Update pool configuration (e.g., from settings)
-     */
-    setPoolConfig(pools) {
-        const oldOtherMax = this.pools.other.maxConnections;
-        const oldFollowsMax = this.pools.follows.maxConnections;
-        this.pools = pools;
-        this.log('Pool config updated:', pools);
-        // Check if subscription mode needs to change
-        const newOtherMax = pools.other.maxConnections;
-        const newFollowsMax = pools.follows.maxConnections;
-        const subscriptionModeChanged = (oldOtherMax === 0) !== (newOtherMax === 0) ||
-            (oldFollowsMax === 0) !== (newFollowsMax === 0);
-        if (subscriptionModeChanged && this.running) {
-            const since = Math.floor((Date.now() - this.config.messageTimeout) / 1000);
-            const subHandler = {
-                onevent: (event) => {
-                    this.handleSignalingEvent(event);
-                },
-                oneose: () => { },
-            };
-            this.setupHelloSubscription(since, subHandler);
-        }
-        // Existing connections remain, but new limits apply for future connections
-        this.emit({ type: 'update' });
-    }
-    /**
-     * Get current pool configuration
-     */
-    getPoolConfig() {
-        return { ...this.pools };
-    }
-    /**
-     * Get fallback stores count
-     */
-    getFallbackStoresCount() {
-        return this.config.fallbackStores.length;
-    }
-    /**
-     * Get WebRTC stats (aggregate and per-peer)
-     */
-    getStats() {
-        // Aggregate stats from all peers + store-level stats
-        const aggregate = {
-            requestsSent: 0,
-            requestsReceived: 0,
-            responsesSent: 0,
-            responsesReceived: 0,
-            receiveErrors: 0,
-            blossomFetches: this.blossomFetches,
-            fragmentsSent: 0,
-            fragmentsReceived: 0,
-            fragmentTimeouts: 0,
-            reassembliesCompleted: 0,
-            bytesSent: 0,
-            bytesReceived: 0,
-            bytesForwarded: 0,
-        };
-        const perPeer = new Map();
-        for (const [peerIdStr, { peer, pool }] of this.peers) {
-            const peerStats = peer.getStats();
-            aggregate.requestsSent += peerStats.requestsSent;
-            aggregate.requestsReceived += peerStats.requestsReceived;
-            aggregate.responsesSent += peerStats.responsesSent;
-            aggregate.responsesReceived += peerStats.responsesReceived;
-            aggregate.receiveErrors += peerStats.receiveErrors;
-            aggregate.fragmentsSent += peerStats.fragmentsSent;
-            aggregate.fragmentsReceived += peerStats.fragmentsReceived;
-            aggregate.fragmentTimeouts += peerStats.fragmentTimeouts;
-            aggregate.reassembliesCompleted += peerStats.reassembliesCompleted;
-            aggregate.bytesSent += peerStats.bytesSent;
-            aggregate.bytesReceived += peerStats.bytesReceived;
-            aggregate.bytesForwarded += peerStats.bytesForwarded;
-            perPeer.set(peerIdStr, {
-                pubkey: peer.pubkey,
-                pool,
-                stats: peerStats,
-            });
-        }
-        return { aggregate, perPeer };
-    }
-    // Store interface implementation
-    async put(hash, data) {
-        // Write to local store if available
-        const success = this.config.localStore
-            ? await this.config.localStore.put(hash, data)
-            : false;
-        // Send to any peers who have requested this hash
-        this.sendToInterestedPeers(hash, data);
-        // Fire-and-forget writes to fallback stores (e.g. blossom servers)
-        // Don't await - let them complete in background
-        for (const store of this.config.fallbackStores) {
-            store.put(hash, data).catch(() => {
-                // Silently ignore failures - fallback stores are best-effort
-            });
-        }
-        return success;
-    }
-    async get(hash) {
-        // Guard against undefined hash
-        if (!hash)
-            return null;
-        // Try local store first
-        if (this.config.localStore) {
-            const local = await this.config.localStore.get(hash);
-            if (local)
-                return local;
-        }
-        // Deduplicate: if there's already a pending request for this hash, wait for it
-        const hashHex = toHex(hash);
-        const pendingGet = this.pendingGets.get(hashHex);
-        if (pendingGet) {
-            return pendingGet;
-        }
-        // Create the actual fetch promise
-        const fetchPromise = this.fetchFromPeers(hash);
-        // Store it for deduplication
-        this.pendingGets.set(hashHex, fetchPromise);
-        // Clean up when done
-        try {
-            const result = await fetchPromise;
-            return result;
-        }
-        finally {
-            this.pendingGets.delete(hashHex);
-        }
-    }
-    /**
-     * 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');
-            }
-        }
-        // All WebRTC peers failed - try fallback stores in order
-        if (this.config.fallbackStores.length > 0) {
-            for (const store of this.config.fallbackStores) {
-                try {
-                    const data = await store.get(hash);
-                    if (data) {
-                        this.blossomFetches++;
-                        if (this.config.localStore) {
-                            await this.config.localStore.put(hash, data);
-                        }
-                        return data;
-                    }
-                }
-                catch (e) {
-                    this.log('Fallback store error:', e);
-                }
-            }
-        }
-        // If running and either:
-        // 1. Not satisfied (still seeking more peers), OR
-        // 2. We haven't tried any peers yet (no peers connected, but might connect soon)
-        // Then add to pending reqs and wait for new peers
-        if (this.running && (!this.isSatisfied() || triedPeers.size === 0)) {
-            return this.waitForHash(hash, triedPeers);
-        }
-        return null;
-    }
-    /**
-     * Helper to create a delay promise
-     */
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Add hash to pending requests list and wait for it to be resolved by peers
-     * Also immediately tries any connected peers that weren't tried yet
-     */
-    waitForHash(hash, triedPeers) {
-        return new Promise((resolve) => {
-            // Use longer timeout for pending requests - we need to wait for peers to connect
-            const reqTimeout = Math.max(this.config.requestTimeout * 6, 30000);
-            const timeout = setTimeout(() => {
-                this.removePendingReq(hash, req);
-                resolve(null);
-            }, reqTimeout);
-            const req = { resolve, timeout, triedPeers };
-            const existing = this.pendingReqs.get(hash);
-            if (existing) {
-                existing.push(req);
-            }
-            else {
-                this.pendingReqs.set(hash, [req]);
-            }
-            this.log('Added to pending reqs:', hash.slice(0, 16), 'tried', triedPeers.size, 'peers');
-            // Immediately try any connected peers that weren't tried yet
-            // This handles the race condition where peers connect while we're setting up the request
-            this.tryConnectedPeersForHash(hash);
-        });
-    }
-    /**
-     * Try all currently connected peers for a specific hash in the pending requests
-     */
-    async tryConnectedPeersForHash(hash) {
-        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);
-        for (const peer of connectedPeers) {
-            const peerIdStr = peer.peerId;
-            // Find requests that haven't tried this peer yet
-            const untried = reqs.filter(r => !r.triedPeers.has(peerIdStr));
-            if (untried.length === 0)
-                continue;
-            // Mark as tried
-            for (const r of untried) {
-                r.triedPeers.add(peerIdStr);
-            }
-            this.log('Trying pending req from connected peer:', hash.slice(0, 16));
-            const data = await peer.request(hash);
-            if (data) {
-                // Store locally
-                if (this.config.localStore) {
-                    await this.config.localStore.put(hash, data);
-                }
-                // Resolve all waiting requests
-                const currentReqs = this.pendingReqs.get(hash);
-                if (currentReqs) {
-                    for (const r of currentReqs) {
-                        clearTimeout(r.timeout);
-                        r.resolve(data);
-                    }
-                    this.pendingReqs.delete(hash);
-                }
-                this.log('Resolved pending req:', hash.slice(0, 16));
-                return;
-            }
-        }
-    }
-    /**
-     * Remove a pending request from the list
-     */
-    removePendingReq(hash, req) {
-        const reqs = this.pendingReqs.get(hash);
-        if (!reqs)
-            return;
-        const idx = reqs.indexOf(req);
-        if (idx !== -1) {
-            reqs.splice(idx, 1);
-            if (reqs.length === 0) {
-                this.pendingReqs.delete(hash);
-            }
-        }
-    }
-    /**
-     * Try pending requests with a newly connected peer
-     */
-    async tryPendingReqs(peer) {
-        const peerIdStr = peer.peerId;
-        for (const [hash, reqs] of this.pendingReqs.entries()) {
-            // Find requests that haven't tried this peer yet
-            const untried = reqs.filter(r => !r.triedPeers.has(peerIdStr));
-            if (untried.length === 0)
-                continue;
-            // Mark as tried
-            for (const r of untried) {
-                r.triedPeers.add(peerIdStr);
-            }
-            const data = await peer.request(hash);
-            if (data) {
-                // Store locally
-                if (this.config.localStore) {
-                    await this.config.localStore.put(hash, data);
-                }
-                // Resolve all waiting requests
-                for (const r of reqs) {
-                    clearTimeout(r.timeout);
-                    r.resolve(data);
-                }
-                this.pendingReqs.delete(hash);
-                this.log('Resolved pending req:', hash.slice(0, 16));
-            }
-        }
-    }
-    async has(hash) {
-        // Check local store
-        if (this.config.localStore) {
-            const hasLocal = await this.config.localStore.has(hash);
-            if (hasLocal)
-                return true;
-        }
-        // Could query peers, but for now just check locally
-        return false;
-    }
-    async delete(hash) {
-        // Only delete from local store
-        if (this.config.localStore) {
-            return this.config.localStore.delete(hash);
-        }
-        return false;
-    }
-}
-//# sourceMappingURL=store.js.map