@claw-network/node 0.2.0

package/dist/index.js

@@ -0,0 +1,795 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+const require = createRequire(import.meta.url);
+const PKG_VERSION = require('../package.json').version;
+import { privateKeyFromProtobuf } from '@libp2p/crypto/keys';
+import { createEd25519PeerId, createFromProtobuf, exportToProtobuf } from '@libp2p/peer-id-factory';
+import { bytesToUtf8, canonicalizeBytes, createKeyRecord, DEFAULT_P2P_CONFIG, DEFAULT_SNAPSHOT_POLICY, didFromPublicKey, ensureConfig, ensureStorageDirs, eventHashHex, EventStore, LevelStore, listKeyRecords, multibaseDecode, P2PNode, resolveStoragePaths, saveKeyRecord, signSnapshot, SnapshotScheduler, SnapshotStore, TOPIC_EVENTS, TOPIC_MARKETS, } from '@claw-network/core';
+import { CONTENT_TYPE, encodeP2PEnvelopeBytes, InfoContentStore, isMarketEventEnvelope, MarketSearchStore, MemoryContractStore, MemoryDaoStore, MemoryReputationStore, signP2PEnvelope, } from '@claw-network/protocol';
+import { P2PSync } from './p2p/sync.js';
+import { ApiServer } from './api/server.js';
+import { ContractProvider } from './services/index.js';
+import { WalletService } from './services/wallet-service.js';
+import { IdentityService } from './services/identity-service.js';
+import { ReputationService } from './services/reputation-service.js';
+import { ContractsService } from './services/contracts-service.js';
+import { DaoService } from './services/dao-service.js';
+import { IndexerStore, EventIndexer, IndexerQuery } from './indexer/index.js';
+import { ApiKeyStore } from './api/api-key-store.js';
+export const DEFAULT_SYNC_RUNTIME_CONFIG = {
+    rangeIntervalMs: 30_000,
+    snapshotIntervalMs: 5 * 60_000,
+    requestRangeOnStart: true,
+    requestSnapshotOnStart: true,
+};
+export const DEFAULT_NODE_RUNTIME_CONFIG = {
+    sync: { ...DEFAULT_SYNC_RUNTIME_CONFIG },
+    api: { host: '127.0.0.1', port: 9528, enabled: true },
+};
+export class ClawNetNode {
+    config;
+    p2p;
+    sync;
+    eventDb;
+    stateDb;
+    eventStore;
+    snapshotStore;
+    snapshotScheduler;
+    contractStore;
+    reputationStore;
+    daoStore;
+    marketSearchStore;
+    infoContentStore;
+    rangeTimer;
+    snapshotTimer;
+    meshAmplifierTimer;
+    apiServer;
+    contractProvider;
+    indexerStore;
+    eventIndexer;
+    indexerQuery;
+    walletService;
+    identityService;
+    reputationService;
+    contractsService;
+    daoService;
+    apiKeyStore;
+    peerId;
+    peerPrivateKey;
+    startedAt;
+    persistedConfig;
+    starting;
+    stopping;
+    cachedDid;
+    constructor(config = {}) {
+        this.config = {
+            ...DEFAULT_NODE_RUNTIME_CONFIG,
+            ...config,
+            sync: {
+                ...DEFAULT_SYNC_RUNTIME_CONFIG,
+                ...config.sync,
+            },
+            api: {
+                ...DEFAULT_NODE_RUNTIME_CONFIG.api,
+                ...config.api,
+            },
+        };
+    }
+    async start() {
+        if (this.starting) {
+            return this.starting;
+        }
+        this.starting = this.startInternal();
+        return this.starting;
+    }
+    async startInternal() {
+        if (this.p2p) {
+            return;
+        }
+        // Init order: config -> storage -> p2p -> sync -> api
+        const paths = resolveStoragePaths(this.config.dataDir);
+        await ensureStorageDirs(paths);
+        const persisted = await ensureConfig(paths);
+        this.persistedConfig = persisted;
+        const peerId = await this.loadOrCreatePeerId(paths.keys);
+        const privateKey = this.extractPeerPrivateKey(peerId);
+        // Auto-create identity key record if none exists and passphrase is available
+        await this.ensureIdentityKeyRecord(paths, peerId);
+        // Cache DID for synchronous access
+        this.cachedDid = (await this.resolveLocalDid()) ?? undefined;
+        // Convert PeerId's protobuf private key to PrivateKey object for libp2p v3
+        const libp2pPrivateKey = peerId.privateKey
+            ? privateKeyFromProtobuf(peerId.privateKey)
+            : undefined;
+        const p2pConfig = {
+            ...DEFAULT_P2P_CONFIG,
+            ...this.config.p2p,
+            listen: this.config.p2p?.listen ?? persisted.p2p?.listen ?? DEFAULT_P2P_CONFIG.listen,
+            bootstrap: this.config.p2p?.bootstrap ?? persisted.p2p?.bootstrap ?? DEFAULT_P2P_CONFIG.bootstrap,
+        };
+        try {
+            this.eventDb = new LevelStore({ path: paths.eventsDb });
+            this.stateDb = new LevelStore({ path: paths.stateDb });
+            this.eventStore = new EventStore(this.eventDb);
+            this.snapshotStore = new SnapshotStore(paths);
+            await this.initContractStore();
+            await this.initReputationStore();
+            await this.initDaoStore();
+            await this.initMarketSearchStore();
+            await this.initInfoContentStore();
+            if (this.config.snapshotBuilder) {
+                this.snapshotScheduler = new SnapshotScheduler(this.eventStore, this.snapshotStore, {
+                    ...DEFAULT_SNAPSHOT_POLICY,
+                    ...(this.config.snapshotPolicy ?? {}),
+                });
+            }
+            this.p2p = new P2PNode(p2pConfig, libp2pPrivateKey, peerId);
+            await this.p2p.start();
+            this.peerId = peerId;
+            this.peerPrivateKey = privateKey;
+            if (!this.startedAt) {
+                this.startedAt = Date.now();
+            }
+            const syncOptions = { ...(this.config.sync ?? {}) };
+            delete syncOptions.rangeIntervalMs;
+            delete syncOptions.snapshotIntervalMs;
+            delete syncOptions.requestRangeOnStart;
+            delete syncOptions.requestSnapshotOnStart;
+            this.sync = new P2PSync(this.p2p, this.eventStore, this.snapshotStore, {
+                peerId: peerId.toString(),
+                peerPrivateKey: privateKey,
+                resolvePeerPublicKey: (id) => this.p2p?.getPeerPublicKey(id) ?? Promise.resolve(null),
+                resolveControllerPublicKey: this.config.resolveControllerPublicKey,
+                onEventApplied: (envelope) => this.applyEventStores(envelope),
+                ...syncOptions,
+            });
+            await this.sync.start();
+            await this.startSyncLoops();
+            // Actively discover peers beyond bootstrap to form a full-mesh topology
+            this.startMeshAmplifier();
+            if (this.config.api?.enabled !== false) {
+                // ── On-chain infrastructure (optional) ─────────────────────────
+                if (this.config.chain) {
+                    const storagePaths = resolveStoragePaths(this.config.dataDir);
+                    const dbPath = join(storagePaths.root, 'indexer.sqlite');
+                    this.contractProvider = new ContractProvider(this.config.chain);
+                    this.indexerStore = new IndexerStore(dbPath);
+                    this.indexerQuery = new IndexerQuery(this.indexerStore.database);
+                    this.walletService = new WalletService(this.contractProvider, this.indexerQuery);
+                    this.identityService = new IdentityService(this.contractProvider, this.indexerQuery);
+                    this.reputationService = new ReputationService(this.contractProvider, this.indexerQuery);
+                    this.contractsService = new ContractsService(this.contractProvider, this.indexerQuery);
+                    this.daoService = new DaoService(this.contractProvider, this.indexerQuery);
+                    this.eventIndexer = new EventIndexer(this.contractProvider, this.indexerStore, this.config.indexer);
+                    // Start indexer in background (non-blocking).
+                    void this.eventIndexer.start();
+                }
+                // ── API Key store ────────────────────────────────────────────
+                {
+                    const storagePaths2 = resolveStoragePaths(this.config.dataDir);
+                    const apiKeysDbPath = join(storagePaths2.root, 'api-keys.sqlite');
+                    this.apiKeyStore = new ApiKeyStore(apiKeysDbPath);
+                }
+                const apiConfig = {
+                    host: this.config.api?.host ?? '127.0.0.1',
+                    port: this.config.api?.port ?? 9528,
+                    dataDir: this.config.dataDir,
+                    network: this.config.network ?? persisted.network,
+                };
+                this.apiServer = new ApiServer(apiConfig, {
+                    publishEvent: (envelope) => this.publishEvent(envelope),
+                    eventStore: this.eventStore,
+                    contractStore: this.contractStore,
+                    reputationStore: this.reputationStore,
+                    daoStore: this.daoStore,
+                    marketStore: this.marketSearchStore,
+                    infoContentStore: this.infoContentStore,
+                    walletService: this.walletService,
+                    identityService: this.identityService,
+                    reputationService: this.reputationService,
+                    contractsService: this.contractsService,
+                    daoService: this.daoService,
+                    searchMarkets: (query) => {
+                        if (!this.marketSearchStore) {
+                            throw new Error('market search unavailable');
+                        }
+                        return this.marketSearchStore.search(query);
+                    },
+                    getNodeStatus: () => this.buildNodeStatus(),
+                    getNodePeers: () => this.buildNodePeers(),
+                    getNodeConfig: () => this.buildNodeConfig(),
+                    apiKeyStore: this.apiKeyStore,
+                });
+                await this.apiServer.start();
+            }
+        }
+        catch (error) {
+            console.error('[clawnetd] Startup failed:', error?.message ?? error);
+            await this.stop();
+            throw error;
+        }
+        finally {
+            this.starting = undefined;
+        }
+    }
+    async stop() {
+        if (this.stopping) {
+            return this.stopping;
+        }
+        this.stopping = this.stopInternal();
+        return this.stopping;
+    }
+    async stopInternal() {
+        // Shutdown order: api -> sync -> p2p -> storage
+        this.stopSyncLoops();
+        this.stopMeshAmplifier();
+        const tasks = [
+            async () => this.apiServer?.stop(),
+            async () => this.eventIndexer?.stop(),
+            async () => this.contractProvider?.destroy(),
+            async () => this.sync?.stop(),
+            async () => this.p2p?.stop(),
+            async () => this.eventDb?.close(),
+            async () => this.stateDb?.close(),
+        ];
+        for (const task of tasks) {
+            try {
+                await task();
+            }
+            catch {
+                // Best-effort shutdown; keep going to release remaining resources.
+            }
+        }
+        // Synchronous cleanup (SQLite)
+        try {
+            this.indexerStore?.close();
+        }
+        catch { /* ignore */ }
+        try {
+            this.apiKeyStore?.close();
+        }
+        catch { /* ignore */ }
+        this.apiServer = undefined;
+        this.sync = undefined;
+        this.p2p = undefined;
+        this.eventDb = undefined;
+        this.stateDb = undefined;
+        this.eventStore = undefined;
+        this.snapshotStore = undefined;
+        this.snapshotScheduler = undefined;
+        this.reputationStore = undefined;
+        this.marketSearchStore = undefined;
+        this.contractProvider = undefined;
+        this.indexerStore = undefined;
+        this.apiKeyStore = undefined;
+        this.eventIndexer = undefined;
+        this.indexerQuery = undefined;
+        this.walletService = undefined;
+        this.identityService = undefined;
+        this.reputationService = undefined;
+        this.contractsService = undefined;
+        this.daoService = undefined;
+        this.peerId = undefined;
+        this.peerPrivateKey = undefined;
+        this.stopping = undefined;
+    }
+    getPeerId() {
+        if (!this.peerId) {
+            return null;
+        }
+        return this.peerId.toString();
+    }
+    /** Return the node's DID (synchronous, cached after start). */
+    getDid() {
+        return this.cachedDid ?? null;
+    }
+    getHealth() {
+        const p2p = Boolean(this.p2p);
+        const sync = Boolean(this.sync);
+        const eventStore = Boolean(this.eventStore);
+        const apiExpected = this.config.api?.enabled !== false;
+        const api = apiExpected ? Boolean(this.apiServer) : true;
+        const ok = p2p && sync && eventStore && api;
+        return { ok, checks: { p2p, sync, eventStore, api } };
+    }
+    async buildNodeStatus() {
+        const did = await this.resolveLocalDid();
+        // In chain-enabled mode, expose indexed chain height (authoritative for API clients).
+        // Fall back to event log length for pure P2P/off-chain mode.
+        const blockHeight = this.indexerStore?.lastIndexedBlock ??
+            (this.eventStore ? await this.eventStore.getLogLength() : 0);
+        const peers = this.p2p?.getPeers().length ?? 0;
+        const connections = this.p2p?.getConnections().length ?? 0;
+        const network = this.resolveNetwork();
+        const uptime = this.startedAt ? Math.floor((Date.now() - this.startedAt) / 1000) : 0;
+        return {
+            did: did ?? '',
+            peerId: this.p2p?.getPeerId() ?? this.peerId?.toString() ?? '',
+            synced: Boolean(this.p2p),
+            blockHeight,
+            peers,
+            connections,
+            network,
+            version: process.env.CLAWNET_VERSION ?? PKG_VERSION,
+            uptime,
+        };
+    }
+    async buildNodePeers() {
+        const peerIds = this.p2p?.getPeers() ?? [];
+        const connectionPeerIds = this.p2p?.getConnections() ?? [];
+        const allPeerIds = [...new Set([...peerIds, ...connectionPeerIds])];
+        return {
+            peers: allPeerIds.map((peerId) => ({
+                peerId,
+                pubsub: peerIds.includes(peerId),
+                connected: connectionPeerIds.includes(peerId),
+            })),
+            total: allPeerIds.length,
+        };
+    }
+    async buildNodeConfig() {
+        const dataDir = resolveStoragePaths(this.config.dataDir).root;
+        const network = this.resolveNetwork();
+        const p2pPort = this.resolveP2PPort();
+        const apiPort = this.config.api?.port ?? 9528;
+        const apiEnabled = this.config.api?.enabled !== false;
+        return {
+            dataDir,
+            network,
+            p2pPort,
+            apiPort,
+            apiEnabled,
+        };
+    }
+    async publishEvent(envelope) {
+        if (!this.p2p || !this.eventStore || !this.peerId || !this.peerPrivateKey) {
+            throw new Error('node not started');
+        }
+        if (!envelope.sig) {
+            throw new Error('event signature missing');
+        }
+        const hash = typeof envelope.hash === 'string' && envelope.hash.length
+            ? envelope.hash
+            : eventHashHex(envelope);
+        const canonical = canonicalizeBytes(envelope);
+        await this.eventStore.appendEvent(hash, canonical);
+        await this.applyEventStores(envelope);
+        const p2pEnvelope = await signP2PEnvelope({
+            v: 1,
+            topic: TOPIC_EVENTS,
+            sender: this.peerId.toString(),
+            ts: BigInt(Date.now()),
+            contentType: CONTENT_TYPE,
+            payload: canonical,
+        }, this.peerPrivateKey);
+        const bytes = encodeP2PEnvelopeBytes(p2pEnvelope);
+        await this.p2p.publish(TOPIC_EVENTS, bytes);
+        if (isMarketEventEnvelope(envelope)) {
+            const marketEnvelope = await signP2PEnvelope({
+                v: 1,
+                topic: TOPIC_MARKETS,
+                sender: this.peerId.toString(),
+                ts: BigInt(Date.now()),
+                contentType: CONTENT_TYPE,
+                payload: canonical,
+            }, this.peerPrivateKey);
+            const marketBytes = encodeP2PEnvelopeBytes(marketEnvelope);
+            await this.p2p.publish(TOPIC_MARKETS, marketBytes);
+        }
+        return hash;
+    }
+    async initReputationStore() {
+        if (!this.eventStore) {
+            return;
+        }
+        const store = new MemoryReputationStore();
+        let cursor = null;
+        while (true) {
+            const { events, cursor: next } = await this.eventStore.getEventLogRange(cursor, 200);
+            if (!events.length) {
+                break;
+            }
+            for (const bytes of events) {
+                const envelope = this.parseEventEnvelope(bytes);
+                if (!envelope) {
+                    continue;
+                }
+                try {
+                    await store.applyEvent(envelope);
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!next) {
+                break;
+            }
+            cursor = next;
+        }
+        this.reputationStore = store;
+    }
+    async initContractStore() {
+        if (!this.eventStore) {
+            return;
+        }
+        const store = new MemoryContractStore();
+        let cursor = null;
+        while (true) {
+            const { events, cursor: next } = await this.eventStore.getEventLogRange(cursor, 200);
+            if (!events.length) {
+                break;
+            }
+            for (const bytes of events) {
+                const envelope = this.parseEventEnvelope(bytes);
+                if (!envelope) {
+                    continue;
+                }
+                try {
+                    await store.applyEvent(envelope);
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!next) {
+                break;
+            }
+            cursor = next;
+        }
+        this.contractStore = store;
+    }
+    async initDaoStore() {
+        if (!this.eventStore) {
+            return;
+        }
+        const store = new MemoryDaoStore();
+        let cursor = null;
+        while (true) {
+            const { events, cursor: next } = await this.eventStore.getEventLogRange(cursor, 200);
+            if (!events.length) {
+                break;
+            }
+            for (const bytes of events) {
+                const envelope = this.parseEventEnvelope(bytes);
+                if (!envelope) {
+                    continue;
+                }
+                try {
+                    await store.applyEvent(envelope);
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!next) {
+                break;
+            }
+            cursor = next;
+        }
+        this.daoStore = store;
+    }
+    async initMarketSearchStore() {
+        if (!this.eventStore || !this.stateDb) {
+            return;
+        }
+        const store = new MarketSearchStore(this.stateDb);
+        try {
+            await store.loadFromStore();
+            await store.syncFromEventLog(this.eventStore);
+        }
+        catch {
+            await store.rebuildFromEventLog(this.eventStore);
+        }
+        this.marketSearchStore = store;
+    }
+    async initInfoContentStore() {
+        if (!this.eventStore || !this.stateDb) {
+            return;
+        }
+        const store = new InfoContentStore(this.stateDb);
+        try {
+            await store.loadFromStore();
+            await store.syncFromEventLog(this.eventStore);
+        }
+        catch {
+            await store.rebuildFromEventLog(this.eventStore);
+        }
+        this.infoContentStore = store;
+    }
+    async applyEventStores(envelope) {
+        if (this.contractStore) {
+            try {
+                await this.contractStore.applyEvent(envelope);
+            }
+            catch {
+                // Ignore malformed events for contract aggregation.
+            }
+        }
+        if (this.reputationStore) {
+            try {
+                await this.reputationStore.applyEvent(envelope);
+            }
+            catch {
+                // Ignore malformed events for reputation aggregation.
+            }
+        }
+        if (this.daoStore) {
+            try {
+                await this.daoStore.applyEvent(envelope);
+            }
+            catch {
+                // Ignore malformed events for DAO aggregation.
+            }
+        }
+        if (this.marketSearchStore) {
+            try {
+                await this.marketSearchStore.applyEvent(envelope);
+            }
+            catch {
+                // Ignore malformed events for market indexing.
+            }
+        }
+        if (this.infoContentStore) {
+            try {
+                await this.infoContentStore.applyEvent(envelope);
+            }
+            catch {
+                // Ignore malformed events for info content linking.
+            }
+        }
+    }
+    parseEventEnvelope(bytes) {
+        try {
+            return JSON.parse(bytesToUtf8(bytes));
+        }
+        catch {
+            return null;
+        }
+    }
+    resolveNetwork() {
+        return this.config.network ?? this.persistedConfig?.network ?? 'devnet';
+    }
+    resolveP2PPort() {
+        const listen = this.config.p2p?.listen ?? this.persistedConfig?.p2p?.listen ?? DEFAULT_P2P_CONFIG.listen;
+        for (const addr of listen) {
+            const match = addr.match(/\/tcp\/(\d+)/);
+            if (match) {
+                return Number.parseInt(match[1], 10);
+            }
+        }
+        return 9527;
+    }
+    async resolveLocalDid() {
+        try {
+            const paths = resolveStoragePaths(this.config.dataDir);
+            const records = await listKeyRecords(paths);
+            if (!records.length) {
+                return null;
+            }
+            const sorted = records
+                .map((record) => ({ record, createdAt: Date.parse(record.createdAt ?? '') }))
+                .sort((a, b) => {
+                const left = Number.isFinite(a.createdAt) ? a.createdAt : Number.MAX_SAFE_INTEGER;
+                const right = Number.isFinite(b.createdAt) ? b.createdAt : Number.MAX_SAFE_INTEGER;
+                return left - right;
+            });
+            const primary = sorted[0]?.record;
+            if (!primary?.publicKey) {
+                return null;
+            }
+            const publicKeyBytes = multibaseDecode(primary.publicKey);
+            return didFromPublicKey(publicKeyBytes);
+        }
+        catch {
+            return null;
+        }
+    }
+    async startSyncLoops() {
+        if (!this.sync || !this.eventStore) {
+            return;
+        }
+        const syncConfig = this.config.sync ?? {};
+        const requestSnapshotOnStart = syncConfig.requestSnapshotOnStart ?? true;
+        const requestRangeOnStart = syncConfig.requestRangeOnStart ?? true;
+        if (requestSnapshotOnStart) {
+            const latest = await this.snapshotStore?.loadLatestSnapshot();
+            await this.sync.requestSnapshot(latest?.hash ?? '');
+        }
+        if (requestRangeOnStart) {
+            const latestHash = await this.eventStore.getLatestEventHash();
+            await this.sync.requestRange(latestHash ?? '');
+        }
+        if (syncConfig.rangeIntervalMs && syncConfig.rangeIntervalMs > 0) {
+            this.rangeTimer = setInterval(() => {
+                void this.requestRangeTick();
+            }, syncConfig.rangeIntervalMs);
+        }
+        if (syncConfig.snapshotIntervalMs && syncConfig.snapshotIntervalMs > 0) {
+            this.snapshotTimer = setInterval(() => {
+                void this.requestSnapshotTick();
+            }, syncConfig.snapshotIntervalMs);
+        }
+    }
+    stopSyncLoops() {
+        if (this.rangeTimer) {
+            clearInterval(this.rangeTimer);
+            this.rangeTimer = undefined;
+        }
+        if (this.snapshotTimer) {
+            clearInterval(this.snapshotTimer);
+            this.snapshotTimer = undefined;
+        }
+    }
+    /**
+     * Persistent connection watchdog with two phases:
+     *
+     *   Phase 1 (0–60 s): Aggressive mesh amplification every 5 s.
+     *                       Discovers peers via DHT random-walk + peerStore dial.
+     *   Phase 2 (60 s+):   Every 30 s, check connection count. If below
+     *                       `minConnections` (1), re-dial bootstrap peers and
+     *                       run another amplify cycle to rejoin the mesh.
+     *
+     * This replaces the old one-shot amplifier that stopped permanently after 60 s
+     * and left the node unable to reconnect after transient network disruptions.
+     */
+    startMeshAmplifier() {
+        let attempts = 0;
+        const aggressiveAttempts = 12; // 12 × 5 s = 60 s
+        const aggressiveIntervalMs = 5_000;
+        const watchdogIntervalMs = 30_000;
+        const amplify = async () => {
+            attempts++;
+            try {
+                const n = await this.p2p?.amplifyMesh() ?? 0;
+                if (n > 0) {
+                    console.log(`[mesh] +${n} new peer(s) discovered via DHT walk`);
+                }
+            }
+            catch {
+                // best-effort
+            }
+            if (attempts === aggressiveAttempts) {
+                // Transition from aggressive phase to watchdog phase
+                if (this.meshAmplifierTimer) {
+                    clearInterval(this.meshAmplifierTimer);
+                }
+                const conns = this.p2p?.getConnections().length ?? 0;
+                console.log(`[mesh] aggressive phase complete — ${conns} peer connection(s), switching to watchdog`);
+                this.meshAmplifierTimer = setInterval(() => void watchdog(), watchdogIntervalMs);
+            }
+        };
+        const watchdog = async () => {
+            const conns = this.p2p?.getConnections().length ?? 0;
+            if (conns > 0)
+                return; // mesh is healthy
+            console.log(`[mesh] 0 connections detected — attempting reconnect`);
+            try {
+                const bootstrapCount = await this.p2p?.reconnectBootstrap() ?? 0;
+                if (bootstrapCount > 0) {
+                    console.log(`[mesh] reconnected to ${bootstrapCount} bootstrap peer(s)`);
+                }
+                // Also try DHT walk to discover non-bootstrap peers
+                const n = await this.p2p?.amplifyMesh() ?? 0;
+                if (n > 0) {
+                    console.log(`[mesh] +${n} additional peer(s) via DHT walk`);
+                }
+                if (bootstrapCount === 0 && n === 0) {
+                    console.log(`[mesh] reconnect failed — will retry in ${watchdogIntervalMs / 1000}s`);
+                }
+            }
+            catch {
+                // best-effort reconnect
+            }
+        };
+        // First attempt immediately, then every 5 s for the aggressive phase
+        void amplify();
+        this.meshAmplifierTimer = setInterval(() => void amplify(), aggressiveIntervalMs);
+    }
+    stopMeshAmplifier() {
+        if (this.meshAmplifierTimer) {
+            clearInterval(this.meshAmplifierTimer);
+            this.meshAmplifierTimer = undefined;
+        }
+    }
+    async requestRangeTick() {
+        if (!this.sync || !this.eventStore) {
+            return;
+        }
+        const latestHash = await this.eventStore.getLatestEventHash();
+        await this.sync.requestRange(latestHash ?? '');
+    }
+    async requestSnapshotTick() {
+        if (!this.sync || !this.snapshotStore) {
+            return;
+        }
+        const latest = await this.snapshotStore.loadLatestSnapshot();
+        await this.sync.requestSnapshot(latest?.hash ?? '');
+        await this.maybeCreateSnapshot();
+    }
+    async maybeCreateSnapshot() {
+        if (!this.snapshotScheduler || !this.snapshotStore || !this.eventStore) {
+            return;
+        }
+        if (!this.config.snapshotBuilder) {
+            return;
+        }
+        const should = await this.snapshotScheduler.shouldSnapshot();
+        if (!should) {
+            return;
+        }
+        const lastSnapshot = await this.snapshotStore.loadLatestSnapshot();
+        const base = await this.config.snapshotBuilder({
+            eventStore: this.eventStore,
+            snapshotStore: this.snapshotStore,
+            lastSnapshot,
+        });
+        if (!base) {
+            return;
+        }
+        if (!this.peerPrivateKey || !this.peerId) {
+            return;
+        }
+        const signed = await signSnapshot(base, this.peerId.toString(), this.peerPrivateKey);
+        await this.snapshotStore.saveSnapshot(signed);
+    }
+    async loadOrCreatePeerId(keysDir) {
+        const path = join(keysDir, 'peer-id.bin');
+        try {
+            const data = await readFile(path);
+            return createFromProtobuf(new Uint8Array(data));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+        const peerId = await createEd25519PeerId();
+        const protobuf = exportToProtobuf(peerId);
+        await writeFile(path, protobuf);
+        return peerId;
+    }
+    async ensureIdentityKeyRecord(paths, peerId) {
+        const passphrase = this.config.passphrase;
+        if (!passphrase) {
+            throw new Error('CLAW_PASSPHRASE is required. Without it the node cannot create an identity (DID) ' +
+                'and will be unable to sign transactions, join markets, or operate a wallet. ' +
+                'Set it via --passphrase <str> or the CLAW_PASSPHRASE environment variable.');
+        }
+        const existing = await listKeyRecords(paths);
+        if (existing.length > 0) {
+            return; // Identity already exists
+        }
+        if (!peerId.privateKey) {
+            return;
+        }
+        // Extract Ed25519 key pair from PeerId
+        const libp2pKey = privateKeyFromProtobuf(peerId.privateKey);
+        const privKeyRaw = libp2pKey.raw.length >= 32 ? libp2pKey.raw.slice(0, 32) : libp2pKey.raw;
+        const pubKeyRaw = libp2pKey.publicKey.raw;
+        const record = createKeyRecord(pubKeyRaw, privKeyRaw, passphrase);
+        await saveKeyRecord(paths, record);
+    }
+    extractPeerPrivateKey(peerId) {
+        if (!peerId?.privateKey) {
+            throw new Error('PeerId missing private key');
+        }
+        const privateKey = privateKeyFromProtobuf(peerId.privateKey);
+        if (privateKey.type !== 'Ed25519') {
+            throw new Error(`Unsupported peer key type ${privateKey.type}`);
+        }
+        const raw = privateKey.raw;
+        if (raw.length === 32) {
+            return raw;
+        }
+        if (raw.length >= 32) {
+            return raw.slice(0, 32);
+        }
+        throw new Error('Invalid peer private key length');
+    }
+}
+export { DEFAULT_P2P_SYNC_CONFIG } from './p2p/sync.js';
+export * from './p2p/sync.js';
+export { ApiKeyStore } from './api/api-key-store.js';
+export { getApiKeyAuth } from './api/auth.js';
+//# sourceMappingURL=index.js.map