@ruvector/edge-net 0.2.0 → 0.3.0

package/p2p.js

@@ -0,0 +1,577 @@
+/**
+ * @ruvector/edge-net P2P Integration
+ *
+ * Unified P2P networking layer that integrates:
+ * - WebRTC for direct peer connections
+ * - DHT for decentralized peer discovery
+ * - Signaling for connection establishment
+ * - Sync for ledger synchronization
+ *
+ * @module @ruvector/edge-net/p2p
+ */
+
+import { EventEmitter } from 'events';
+import { randomBytes } from 'crypto';
+
+// Import P2P components
+import { WebRTCPeerManager, WEBRTC_CONFIG } from './webrtc.js';
+import { DHTNode, createDHTNode } from './dht.js';
+import { SignalingClient } from './signaling.js';
+import { SyncManager } from './sync.js';
+import { QDAG } from './qdag.js';
+import { Ledger } from './ledger.js';
+
+// ============================================
+// P2P NETWORK CONFIGURATION
+// ============================================
+
+export const P2P_CONFIG = {
+    // Auto-start components
+    autoStart: {
+        signaling: true,
+        webrtc: true,
+        dht: true,
+        sync: true,
+    },
+    // Connection settings
+    maxPeers: 50,
+    minPeers: 3,
+    // Reconnection
+    reconnectInterval: 5000,
+    maxReconnectAttempts: 10,
+    // DHT settings
+    dhtAnnounceInterval: 60000,
+    // Sync settings
+    syncInterval: 30000,
+};
+
+// ============================================
+// P2P NETWORK NODE
+// ============================================
+
+/**
+ * Unified P2P Network Node
+ *
+ * Connects all P2P components into a single interface:
+ * - Automatic peer discovery via DHT
+ * - WebRTC data channels for direct messaging
+ * - QDAG for distributed consensus
+ * - Ledger sync across devices
+ */
+export class P2PNetwork extends EventEmitter {
+    constructor(identity, options = {}) {
+        super();
+        this.identity = identity;
+        this.options = { ...P2P_CONFIG, ...options };
+
+        // Node ID
+        this.nodeId = identity?.piKey || identity?.nodeId || `node-${randomBytes(8).toString('hex')}`;
+
+        // Components (initialized on start)
+        this.signaling = null;
+        this.webrtc = null;
+        this.dht = null;
+        this.syncManager = null;
+        this.qdag = null;
+        this.ledger = null;
+
+        // State
+        this.state = 'stopped';
+        this.peers = new Map();
+        this.stats = {
+            startedAt: null,
+            peersConnected: 0,
+            messagesReceived: 0,
+            messagesSent: 0,
+            bytesTransferred: 0,
+        };
+    }
+
+    /**
+     * Start the P2P network
+     */
+    async start() {
+        if (this.state === 'running') return this;
+
+        console.log('\n🌐 Starting P2P Network...');
+        console.log(`   Node ID: ${this.nodeId.slice(0, 16)}...`);
+
+        this.state = 'starting';
+
+        try {
+            // Initialize QDAG
+            this.qdag = new QDAG({ nodeId: this.nodeId });
+            console.log('   ✅ QDAG initialized');
+
+            // Initialize Ledger
+            this.ledger = new Ledger({ nodeId: this.nodeId });
+            console.log('   ✅ Ledger initialized');
+
+            // Try signaling server first
+            if (this.options.autoStart.signaling) {
+                await this.startSignaling();
+            }
+
+            // Initialize WebRTC
+            if (this.options.autoStart.webrtc) {
+                await this.startWebRTC();
+            }
+
+            // Initialize DHT for peer discovery
+            if (this.options.autoStart.dht) {
+                await this.startDHT();
+            }
+
+            // Initialize sync
+            if (this.options.autoStart.sync && this.identity) {
+                await this.startSync();
+            }
+
+            // Wire up event handlers
+            this.setupEventHandlers();
+
+            // Announce presence
+            await this.announce();
+
+            this.state = 'running';
+            this.stats.startedAt = Date.now();
+
+            console.log('\n✅ P2P Network running');
+            console.log(`   Mode: ${this.getMode()}`);
+            console.log(`   Peers: ${this.peers.size}`);
+
+            this.emit('started', { nodeId: this.nodeId, mode: this.getMode() });
+
+            return this;
+
+        } catch (error) {
+            this.state = 'error';
+            console.error('❌ P2P Network start failed:', error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Stop the P2P network
+     */
+    async stop() {
+        console.log('\n🛑 Stopping P2P Network...');
+
+        this.state = 'stopping';
+
+        if (this.syncManager) this.syncManager.stop();
+        if (this.dht) this.dht.stop();
+        if (this.webrtc) this.webrtc.close();
+        if (this.signaling) this.signaling.disconnect();
+
+        this.peers.clear();
+        this.state = 'stopped';
+
+        this.emit('stopped');
+    }
+
+    /**
+     * Start signaling client
+     */
+    async startSignaling() {
+        try {
+            this.signaling = new SignalingClient({
+                serverUrl: this.options.signalingUrl || WEBRTC_CONFIG.signalingServers[0],
+                peerId: this.nodeId,
+            });
+
+            const connected = await this.signaling.connect();
+            if (connected) {
+                console.log('   ✅ Signaling connected');
+            } else {
+                console.log('   ⚠️  Signaling unavailable (will use DHT)');
+            }
+        } catch (err) {
+            console.log('   ⚠️  Signaling failed:', err.message);
+        }
+    }
+
+    /**
+     * Start WebRTC peer manager
+     */
+    async startWebRTC() {
+        try {
+            this.webrtc = new WebRTCPeerManager({
+                piKey: this.nodeId,
+                siteId: this.identity?.siteId || 'edge-net',
+            }, this.options.webrtc || {});
+
+            await this.webrtc.initialize();
+            console.log(`   ✅ WebRTC initialized (${this.webrtc.mode} mode)`);
+        } catch (err) {
+            console.log('   ⚠️  WebRTC failed:', err.message);
+        }
+    }
+
+    /**
+     * Start DHT for peer discovery
+     */
+    async startDHT() {
+        try {
+            if (this.webrtc) {
+                this.dht = await createDHTNode(this.webrtc, {
+                    id: this.nodeId,
+                });
+            } else {
+                this.dht = new DHTNode({ id: this.nodeId });
+                await this.dht.start();
+            }
+            console.log('   ✅ DHT initialized');
+        } catch (err) {
+            console.log('   ⚠️  DHT failed:', err.message);
+        }
+    }
+
+    /**
+     * Start sync manager
+     */
+    async startSync() {
+        try {
+            this.syncManager = new SyncManager(this.identity, this.ledger, {
+                enableP2P: !!this.webrtc,
+                enableFirestore: false, // Use P2P only for now
+            });
+
+            await this.syncManager.start();
+            console.log('   ✅ Sync initialized');
+        } catch (err) {
+            console.log('   ⚠️  Sync failed:', err.message);
+        }
+    }
+
+    /**
+     * Setup event handlers between components
+     */
+    setupEventHandlers() {
+        // WebRTC events
+        if (this.webrtc) {
+            this.webrtc.on('peer-connected', (peerId) => {
+                this.handlePeerConnected(peerId);
+            });
+
+            this.webrtc.on('peer-disconnected', (peerId) => {
+                this.handlePeerDisconnected(peerId);
+            });
+
+            this.webrtc.on('message', ({ from, message }) => {
+                this.handleMessage(from, message);
+            });
+        }
+
+        // Signaling events
+        if (this.signaling) {
+            this.signaling.on('peer-joined', ({ peerId }) => {
+                this.connectToPeer(peerId);
+            });
+
+            this.signaling.on('offer', async ({ from, offer }) => {
+                if (this.webrtc) {
+                    await this.webrtc.handleOffer({ from, offer });
+                }
+            });
+
+            this.signaling.on('answer', async ({ from, answer }) => {
+                if (this.webrtc) {
+                    await this.webrtc.handleAnswer({ from, answer });
+                }
+            });
+
+            this.signaling.on('ice-candidate', async ({ from, candidate }) => {
+                if (this.webrtc) {
+                    await this.webrtc.handleIceCandidate({ from, candidate });
+                }
+            });
+        }
+
+        // DHT events
+        if (this.dht) {
+            this.dht.on('peer-added', (peer) => {
+                this.connectToPeer(peer.id);
+            });
+        }
+
+        // Sync events
+        if (this.syncManager) {
+            this.syncManager.on('synced', (data) => {
+                this.emit('synced', data);
+            });
+        }
+
+        // QDAG events
+        if (this.qdag) {
+            this.qdag.on('transaction', (tx) => {
+                this.broadcastTransaction(tx);
+            });
+
+            this.qdag.on('confirmed', (tx) => {
+                this.emit('transaction-confirmed', tx);
+            });
+        }
+    }
+
+    /**
+     * Announce presence to the network
+     */
+    async announce() {
+        // Announce via signaling
+        if (this.signaling?.isConnected) {
+            this.signaling.send({
+                type: 'announce',
+                piKey: this.nodeId,
+                siteId: this.identity?.siteId,
+                capabilities: ['compute', 'storage', 'verify'],
+            });
+        }
+
+        // Announce via DHT
+        if (this.dht) {
+            await this.dht.announce('edge-net');
+        }
+    }
+
+    /**
+     * Connect to a peer
+     */
+    async connectToPeer(peerId) {
+        if (peerId === this.nodeId) return;
+        if (this.peers.has(peerId)) return;
+
+        try {
+            if (this.webrtc) {
+                await this.webrtc.connectToPeer(peerId);
+            }
+        } catch (err) {
+            console.warn(`[P2P] Failed to connect to ${peerId.slice(0, 8)}:`, err.message);
+        }
+    }
+
+    /**
+     * Handle peer connected
+     */
+    handlePeerConnected(peerId) {
+        this.peers.set(peerId, {
+            id: peerId,
+            connectedAt: Date.now(),
+            lastSeen: Date.now(),
+        });
+
+        this.stats.peersConnected++;
+
+        // Register with sync
+        if (this.syncManager && this.webrtc) {
+            const peer = this.webrtc.peers.get(peerId);
+            if (peer?.dataChannel) {
+                this.syncManager.registerPeer(peerId, peer.dataChannel);
+            }
+        }
+
+        this.emit('peer-connected', { peerId });
+        console.log(`   🔗 Connected to peer: ${peerId.slice(0, 8)}... (${this.peers.size} total)`);
+    }
+
+    /**
+     * Handle peer disconnected
+     */
+    handlePeerDisconnected(peerId) {
+        this.peers.delete(peerId);
+        this.emit('peer-disconnected', { peerId });
+    }
+
+    /**
+     * Handle incoming message
+     */
+    handleMessage(from, message) {
+        this.stats.messagesReceived++;
+
+        // Route by message type
+        switch (message.type) {
+            case 'qdag_transaction':
+                this.handleQDAGTransaction(from, message);
+                break;
+
+            case 'qdag_sync_request':
+                this.handleQDAGSyncRequest(from, message);
+                break;
+
+            case 'qdag_sync_response':
+                this.handleQDAGSyncResponse(from, message);
+                break;
+
+            default:
+                this.emit('message', { from, message });
+        }
+    }
+
+    /**
+     * Handle QDAG transaction
+     */
+    handleQDAGTransaction(from, message) {
+        if (message.transaction && this.qdag) {
+            try {
+                this.qdag.addTransaction(message.transaction);
+            } catch (err) {
+                // Duplicate or invalid transaction
+            }
+        }
+    }
+
+    /**
+     * Handle QDAG sync request
+     */
+    handleQDAGSyncRequest(from, message) {
+        if (this.qdag && this.webrtc) {
+            const transactions = this.qdag.export(message.since || 0);
+            this.webrtc.sendToPeer(from, {
+                type: 'qdag_sync_response',
+                transactions: transactions.transactions,
+            });
+        }
+    }
+
+    /**
+     * Handle QDAG sync response
+     */
+    handleQDAGSyncResponse(from, message) {
+        if (message.transactions && this.qdag) {
+            this.qdag.import({ transactions: message.transactions });
+        }
+    }
+
+    /**
+     * Broadcast a transaction to all peers
+     */
+    broadcastTransaction(tx) {
+        if (this.webrtc) {
+            this.webrtc.broadcast({
+                type: 'qdag_transaction',
+                transaction: tx.toJSON(),
+            });
+            this.stats.messagesSent++;
+        }
+    }
+
+    /**
+     * Send message to a specific peer
+     */
+    sendToPeer(peerId, message) {
+        if (this.webrtc) {
+            const sent = this.webrtc.sendToPeer(peerId, message);
+            if (sent) this.stats.messagesSent++;
+            return sent;
+        }
+        return false;
+    }
+
+    /**
+     * Broadcast message to all peers
+     */
+    broadcast(message) {
+        if (this.webrtc) {
+            const sent = this.webrtc.broadcast(message);
+            this.stats.messagesSent += sent;
+            return sent;
+        }
+        return 0;
+    }
+
+    /**
+     * Submit a task to the network
+     */
+    async submitTask(task) {
+        if (!this.qdag) throw new Error('QDAG not initialized');
+
+        const tx = this.qdag.createTransaction('task', {
+            taskId: task.id || randomBytes(8).toString('hex'),
+            type: task.type,
+            data: task.data,
+            reward: task.reward || 0,
+            priority: task.priority || 'medium',
+        }, {
+            issuer: this.nodeId,
+        });
+
+        return tx;
+    }
+
+    /**
+     * Credit the ledger
+     */
+    credit(amount, reason) {
+        if (!this.ledger) throw new Error('Ledger not initialized');
+        this.ledger.credit(amount, reason);
+
+        // Trigger sync
+        if (this.syncManager) {
+            this.syncManager.sync();
+        }
+    }
+
+    /**
+     * Get current balance
+     */
+    getBalance() {
+        return this.ledger?.getBalance() || 0;
+    }
+
+    /**
+     * Get connection mode
+     */
+    getMode() {
+        if (this.webrtc?.mode === 'webrtc' && this.signaling?.isConnected) {
+            return 'full-p2p';
+        }
+        if (this.webrtc?.mode === 'webrtc') {
+            return 'webrtc-dht';
+        }
+        if (this.dht) {
+            return 'dht-only';
+        }
+        return 'local';
+    }
+
+    /**
+     * Get network statistics
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            nodeId: this.nodeId,
+            state: this.state,
+            mode: this.getMode(),
+            peers: this.peers.size,
+            signalingConnected: this.signaling?.isConnected || false,
+            webrtcMode: this.webrtc?.mode || 'none',
+            dhtPeers: this.dht?.getPeers().length || 0,
+            qdagTransactions: this.qdag?.transactions.size || 0,
+            ledgerBalance: this.getBalance(),
+            uptime: this.stats.startedAt ? Date.now() - this.stats.startedAt : 0,
+        };
+    }
+
+    /**
+     * Get peer list
+     */
+    getPeers() {
+        return Array.from(this.peers.values());
+    }
+}
+
+/**
+ * Create and start a P2P network node
+ */
+export async function createP2PNetwork(identity, options = {}) {
+    const network = new P2PNetwork(identity, options);
+    await network.start();
+    return network;
+}
+
+// ============================================
+// EXPORTS
+// ============================================
+
+export default P2PNetwork;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvector/edge-net",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "description": "Distributed compute intelligence network with AI agents and workers - contribute browser compute, spawn distributed AI agents, earn credits. Features Time Crystal coordination, Neural DAG attention, P2P swarm intelligence, ONNX inference, WebRTC signaling, CRDT ledger, and multi-agent workflows.",
   "main": "ruvector_edge_net.js",
@@ -9,7 +9,8 @@
   "bin": {
     "edge-net": "./cli.js",
     "ruvector-edge": "./cli.js",
-    "edge-net-join": "./join.js"
+    "edge-net-join": "./join.js",
+    "edge-net-genesis": "./genesis.js"
   },
   "keywords": [
     "wasm",
@@ -43,7 +44,12 @@
     "signaling",
     "scheduler",
     "monitoring",
-    "qdag"
+    "qdag",
+    "dht",
+    "kademlia",
+    "genesis-node",
+    "turn-server",
+    "nat-traversal"
   ],
   "author": "RuVector Team <team@ruvector.dev>",
   "license": "MIT",
@@ -79,6 +85,9 @@
     "ledger.js",
     "scheduler.js",
     "monitor.js",
+    "dht.js",
+    "genesis.js",
+    "p2p.js",
     "README.md",
     "LICENSE"
   ],
@@ -128,6 +137,15 @@
     },
     "./monitor": {
       "import": "./monitor.js"
+    },
+    "./dht": {
+      "import": "./dht.js"
+    },
+    "./genesis": {
+      "import": "./genesis.js"
+    },
+    "./p2p": {
+      "import": "./p2p.js"
     }
   },
   "sideEffects": [
@@ -147,6 +165,9 @@
     "peers": "node join.js --peers",
     "history": "node join.js --history",
     "signaling": "node -e \"import('./signaling.js').then(m => new m.SignalingServer().start())\"",
+    "genesis": "node genesis.js",
+    "genesis:start": "node genesis.js --port 8787",
+    "p2p": "node -e \"import('./p2p.js').then(m => m.createP2PNetwork({ nodeId: 'test' }))\"",
     "monitor": "node -e \"import('./monitor.js').then(m => { const mon = new m.Monitor(); mon.start(); setInterval(() => console.log(JSON.stringify(mon.generateReport(), null, 2)), 5000); })\""
   },
   "dependencies": {