@ruvector/edge-net 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvector/edge-net",
-  "version": "0.2.0",
+  "version": "0.2.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",

package/qdag.js

@@ -193,26 +193,37 @@ export class QDAG extends EventEmitter {
      * Select tips for new transaction (weighted random walk)
      */
     selectTips(count = 2) {
+        // Ensure genesis exists
+        if (!this.transactions.has('genesis')) {
+            this.createGenesis();
+        }
+
         const tips = Array.from(this.tips);
 
+        // Fallback to genesis if no tips available
         if (tips.length === 0) {
             return ['genesis'];
         }
 
+        // Return all tips if we have fewer than requested
         if (tips.length <= count) {
-            return tips;
+            return [...tips]; // Return copy to prevent mutation issues
         }
 
         // Weighted random selection based on cumulative weight
         const selected = new Set();
         const weights = tips.map(tipId => {
             const tx = this.transactions.get(tipId);
-            return tx ? tx.cumulativeWeight : 1;
+            return tx ? Math.max(tx.cumulativeWeight, 1) : 1;
         });
 
         const totalWeight = weights.reduce((a, b) => a + b, 0);
 
-        while (selected.size < count && selected.size < tips.length) {
+        // Safety: prevent infinite loop
+        let attempts = 0;
+        const maxAttempts = count * 10;
+
+        while (selected.size < count && selected.size < tips.length && attempts < maxAttempts) {
             let random = Math.random() * totalWeight;
 
             for (let i = 0; i < tips.length; i++) {
@@ -222,18 +233,26 @@ export class QDAG extends EventEmitter {
                     break;
                 }
             }
+            attempts++;
         }
 
-        return Array.from(selected);
+        // Ensure we have at least one valid parent
+        const result = Array.from(selected);
+        if (result.length === 0) {
+            result.push(tips[0] || 'genesis');
+        }
+
+        return result;
     }
 
     /**
      * Add transaction to QDAG
      */
     addTransaction(tx) {
-        // Validate transaction
-        if (!this.validateTransaction(tx)) {
-            throw new Error('Invalid transaction');
+        // Validate transaction with detailed error
+        const validation = this.validateTransaction(tx, { returnError: true });
+        if (!validation.valid) {
+            throw new Error(`Invalid transaction: ${validation.error}`);
         }
 
         // Check for duplicates
@@ -304,35 +323,55 @@ export class QDAG extends EventEmitter {
 
     /**
      * Validate transaction
+     * @returns {boolean|{valid: boolean, error: string}}
      */
-    validateTransaction(tx) {
+    validateTransaction(tx, options = {}) {
+        const returnError = options.returnError || false;
+        const fail = (msg) => returnError ? { valid: false, error: msg } : false;
+        const pass = () => returnError ? { valid: true, error: null } : true;
+
         // Check required fields
-        if (!tx.id || !tx.timestamp || !tx.type) {
-            return false;
+        if (!tx.id) {
+            return fail('Missing transaction id');
+        }
+        if (!tx.timestamp) {
+            return fail('Missing transaction timestamp');
+        }
+        if (!tx.type) {
+            return fail('Missing transaction type');
         }
 
-        // Check parents exist (except genesis)
-        if (tx.type !== 'genesis') {
-            if (tx.parents.length === 0) {
-                return false;
-            }
+        // Genesis transactions don't need parents
+        if (tx.type === 'genesis') {
+            return pass();
+        }
 
-            for (const parentId of tx.parents) {
-                if (!this.transactions.has(parentId)) {
-                    return false;
-                }
+        // Ensure genesis exists before validating non-genesis transactions
+        if (!this.transactions.has('genesis')) {
+            this.createGenesis();
+        }
+
+        // Check parents exist
+        if (!tx.parents || tx.parents.length === 0) {
+            return fail('Non-genesis transaction must have at least one parent');
+        }
+
+        for (const parentId of tx.parents) {
+            if (!this.transactions.has(parentId)) {
+                return fail(`Parent transaction not found: ${parentId}`);
             }
         }
 
-        // Check no cycles (parents must be older)
+        // Check no cycles (parents must be older or equal for simultaneous txs)
         for (const parentId of tx.parents) {
             const parent = this.transactions.get(parentId);
-            if (parent && parent.timestamp >= tx.timestamp) {
-                return false;
+            // Allow equal timestamps (transactions created at same time)
+            if (parent && parent.timestamp > tx.timestamp) {
+                return fail(`Parent ${parentId} has future timestamp`);
             }
         }
 
-        return true;
+        return pass();
     }
 
     /**