@ruvector/edge-net 0.4.0 → 0.4.1

package/firebase-signaling.js

@@ -95,13 +95,14 @@ export async function getFirebaseConfigAsync() {
 export const DEFAULT_FIREBASE_CONFIG = null;
 
 /**
- * Signaling paths in Firestore
+ * Signaling collection names in Firestore
+ * Each is a top-level collection (Firestore requires collection/document pairs)
  */
 export const SIGNALING_PATHS = {
-    peers: 'edge-net/peers',
-    signals: 'edge-net/signals',
-    rooms: 'edge-net/rooms',
-    ledger: 'edge-net/ledger',
+    peers: 'edgenet_peers',
+    signals: 'edgenet_signals',
+    rooms: 'edgenet_rooms',
+    ledger: 'edgenet_ledger',
 };
 
 // ============================================
@@ -167,26 +168,21 @@ export class FirebaseSignaling extends EventEmitter {
         try {
             // Dynamic import Firebase (tree-shakeable)
             const { initializeApp, getApps } = await import('firebase/app');
-            const { getFirestore, collection, doc, setDoc, onSnapshot, deleteDoc, query, where, orderBy, limit } = await import('firebase/firestore');
-            const { getDatabase, ref, set, onValue, onDisconnect, serverTimestamp } = await import('firebase/database');
+            const { getFirestore, collection, doc, setDoc, onSnapshot, deleteDoc, query, where, orderBy, limit, serverTimestamp } = await import('firebase/firestore');
 
-            // Store Firebase methods for later use
+            // Store Firebase methods for later use (Firestore only - no RTDB)
             this.firebase = {
-                collection, doc, setDoc, onSnapshot, deleteDoc, query, where, orderBy, limit,
-                ref, set, onValue, onDisconnect, serverTimestamp
+                collection, doc, setDoc, onSnapshot, deleteDoc, query, where, orderBy, limit, serverTimestamp
             };
 
             // Initialize or reuse existing app
             const apps = getApps();
             this.app = apps.length ? apps[0] : initializeApp(this.config);
 
-            // Initialize Firestore (for signaling)
+            // Initialize Firestore (for signaling AND presence - no RTDB needed)
             this.db = getFirestore(this.app);
 
-            // Initialize Realtime Database (for presence)
-            this.rtdb = getDatabase(this.app);
-
-            // Register presence
+            // Register presence in Firestore
             await this.registerPresence();
 
             // Listen for peers
@@ -196,7 +192,7 @@ export class FirebaseSignaling extends EventEmitter {
             this.subscribeToSignals();
 
             this.isConnected = true;
-            console.log('   ✅ Firebase signaling connected');
+            console.log('   ✅ Firebase signaling connected (Firestore)');
 
             this.emit('connected');
             return true;
@@ -209,54 +205,76 @@ export class FirebaseSignaling extends EventEmitter {
     }
 
     /**
-     * Register this peer's presence in Firebase
+     * Register this peer's presence in Firestore
      */
     async registerPresence() {
-        const { ref, set, onDisconnect, serverTimestamp } = this.firebase;
+        const { doc, setDoc, serverTimestamp } = this.firebase;
 
-        const presenceRef = ref(this.rtdb, `presence/${this.room}/${this.peerId}`);
+        const presenceRef = doc(this.db, SIGNALING_PATHS.peers, this.peerId);
 
-        // Set online status
-        await set(presenceRef, {
+        // Set online status in Firestore
+        await setDoc(presenceRef, {
             peerId: this.peerId,
             room: this.room,
             online: true,
             lastSeen: serverTimestamp(),
             capabilities: ['compute', 'storage', 'verify'],
-        });
+        }, { merge: true });
 
-        // Remove on disconnect
-        onDisconnect(presenceRef).remove();
+        // Set up heartbeat to maintain presence (Firestore doesn't have onDisconnect)
+        this._heartbeatInterval = setInterval(async () => {
+            try {
+                await setDoc(presenceRef, { lastSeen: serverTimestamp() }, { merge: true });
+            } catch (e) {
+                // Ignore heartbeat errors
+            }
+        }, 30000);
 
         console.log(`   📡 Registered presence: ${this.peerId.slice(0, 8)}...`);
     }
 
     /**
-     * Subscribe to peer presence updates
+     * Subscribe to peer presence updates (using Firestore)
      */
     subscribeToPeers() {
-        const { ref, onValue } = this.firebase;
-
-        const roomRef = ref(this.rtdb, `presence/${this.room}`);
-
-        const unsubscribe = onValue(roomRef, (snapshot) => {
-            const peers = snapshot.val() || {};
+        const { collection, query, where, onSnapshot } = this.firebase;
 
-            // Track new peers
-            for (const [peerId, data] of Object.entries(peers)) {
-                if (peerId !== this.peerId && !this.peers.has(peerId)) {
-                    this.peers.set(peerId, data);
-                    this.emit('peer-discovered', { peerId, ...data });
-                }
-            }
+        // Query peers in same room that were active in last 2 minutes
+        const peersRef = collection(this.db, SIGNALING_PATHS.peers);
+        const q = query(peersRef, where('room', '==', this.room));
 
-            // Track disconnected peers
-            for (const peerId of this.peers.keys()) {
-                if (!peers[peerId]) {
-                    this.peers.delete(peerId);
-                    this.emit('peer-left', { peerId });
+        const unsubscribe = onSnapshot(q, (snapshot) => {
+            const now = Date.now();
+            const staleThreshold = 2 * 60 * 1000; // 2 minutes
+
+            snapshot.docChanges().forEach((change) => {
+                const data = change.doc.data();
+                const peerId = change.doc.id;
+
+                if (peerId === this.peerId) return; // Skip self
+
+                if (change.type === 'added' || change.type === 'modified') {
+                    // Check if peer is still active (lastSeen within threshold)
+                    const lastSeen = data.lastSeen?.toMillis?.() || 0;
+                    if (now - lastSeen < staleThreshold) {
+                        if (!this.peers.has(peerId)) {
+                            this.peers.set(peerId, data);
+                            this.emit('peer-discovered', { peerId, ...data });
+                        }
+                    } else {
+                        // Peer is stale
+                        if (this.peers.has(peerId)) {
+                            this.peers.delete(peerId);
+                            this.emit('peer-left', { peerId });
+                        }
+                    }
+                } else if (change.type === 'removed') {
+                    if (this.peers.has(peerId)) {
+                        this.peers.delete(peerId);
+                        this.emit('peer-left', { peerId });
+                    }
                 }
-            }
+            });
         });
 
         this.unsubscribers.push(unsubscribe);
@@ -370,17 +388,27 @@ export class FirebaseSignaling extends EventEmitter {
      * Disconnect and cleanup
      */
     async disconnect() {
+        // Stop heartbeat
+        if (this._heartbeatInterval) {
+            clearInterval(this._heartbeatInterval);
+            this._heartbeatInterval = null;
+        }
+
         // Unsubscribe from all listeners
         for (const unsub of this.unsubscribers) {
             if (typeof unsub === 'function') unsub();
         }
         this.unsubscribers = [];
 
-        // Remove presence
-        if (this.rtdb && this.firebase) {
-            const { ref, set } = this.firebase;
-            const presenceRef = ref(this.rtdb, `presence/${this.room}/${this.peerId}`);
-            await set(presenceRef, null);
+        // Remove presence from Firestore
+        if (this.db && this.firebase) {
+            try {
+                const { doc, deleteDoc } = this.firebase;
+                const presenceRef = doc(this.db, SIGNALING_PATHS.peers, this.peerId);
+                await deleteDoc(presenceRef);
+            } catch (e) {
+                // Ignore cleanup errors
+            }
         }
 
         this.isConnected = false;

package/p2p.js

@@ -614,7 +614,7 @@ export class P2PNetwork extends EventEmitter {
      * Get current balance
      */
     getBalance() {
-        return this.ledger?.getBalance() || 0;
+        return this.ledger?.balance?.() ?? this.ledger?.getBalance?.() ?? 0;
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvector/edge-net",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "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",
@@ -189,14 +189,7 @@
   "dependencies": {
     "@ruvector/ruvllm": "^0.2.3",
     "@xenova/transformers": "^2.17.2",
+    "firebase": "^10.14.1",
     "ws": "^8.18.3"
-  },
-  "peerDependencies": {
-    "firebase": "^10.0.0"
-  },
-  "peerDependenciesMeta": {
-    "firebase": {
-      "optional": true
-    }
   }
 }