@ruvector/edge-net 0.1.7 → 0.2.1

package/qdag.js

@@ -0,0 +1,621 @@
+/**
+ * @ruvector/edge-net QDAG (Quantum DAG) Implementation
+ *
+ * Directed Acyclic Graph for distributed consensus and task tracking
+ * Inspired by IOTA Tangle and DAG-based blockchains
+ *
+ * Features:
+ * - Tip selection algorithm
+ * - Proof of contribution verification
+ * - Transaction validation
+ * - Network synchronization
+ *
+ * @module @ruvector/edge-net/qdag
+ */
+
+import { EventEmitter } from 'events';
+import { randomBytes, createHash, createHmac } from 'crypto';
+
+// ============================================
+// TRANSACTION
+// ============================================
+
+/**
+ * QDAG Transaction
+ */
+export class Transaction {
+    constructor(data = {}) {
+        this.id = data.id || `tx-${randomBytes(16).toString('hex')}`;
+        this.timestamp = data.timestamp || Date.now();
+        this.type = data.type || 'generic'; // 'genesis', 'task', 'reward', 'transfer'
+
+        // Links to parent transactions (must reference 2 tips)
+        this.parents = data.parents || [];
+
+        // Transaction payload
+        this.payload = data.payload || {};
+
+        // Proof of contribution
+        this.proof = data.proof || null;
+
+        // Issuer
+        this.issuer = data.issuer || null;
+        this.signature = data.signature || null;
+
+        // Computed fields
+        this.hash = data.hash || this.computeHash();
+        this.weight = data.weight || 1;
+        this.cumulativeWeight = data.cumulativeWeight || 1;
+        this.confirmed = data.confirmed || false;
+        this.confirmedAt = data.confirmedAt || null;
+    }
+
+    /**
+     * Compute transaction hash
+     */
+    computeHash() {
+        const content = JSON.stringify({
+            id: this.id,
+            timestamp: this.timestamp,
+            type: this.type,
+            parents: this.parents,
+            payload: this.payload,
+            proof: this.proof,
+            issuer: this.issuer,
+        });
+
+        return createHash('sha256').update(content).digest('hex');
+    }
+
+    /**
+     * Sign transaction
+     */
+    sign(privateKey) {
+        const hmac = createHmac('sha256', privateKey);
+        hmac.update(this.hash);
+        this.signature = hmac.digest('hex');
+        return this.signature;
+    }
+
+    /**
+     * Verify signature
+     */
+    verify(publicKey) {
+        if (!this.signature) return false;
+
+        const hmac = createHmac('sha256', publicKey);
+        hmac.update(this.hash);
+        const expected = hmac.digest('hex');
+
+        return this.signature === expected;
+    }
+
+    /**
+     * Serialize transaction
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            timestamp: this.timestamp,
+            type: this.type,
+            parents: this.parents,
+            payload: this.payload,
+            proof: this.proof,
+            issuer: this.issuer,
+            signature: this.signature,
+            hash: this.hash,
+            weight: this.weight,
+            cumulativeWeight: this.cumulativeWeight,
+            confirmed: this.confirmed,
+            confirmedAt: this.confirmedAt,
+        };
+    }
+
+    /**
+     * Deserialize transaction
+     */
+    static fromJSON(json) {
+        return new Transaction(json);
+    }
+}
+
+// ============================================
+// QDAG (Quantum DAG)
+// ============================================
+
+/**
+ * QDAG - Directed Acyclic Graph for distributed consensus
+ */
+export class QDAG extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.id = options.id || `qdag-${randomBytes(8).toString('hex')}`;
+        this.nodeId = options.nodeId;
+
+        // Transaction storage
+        this.transactions = new Map();
+        this.tips = new Set();           // Unconfirmed transactions
+        this.confirmed = new Set();       // Confirmed transactions
+
+        // Indices
+        this.byIssuer = new Map();        // issuer -> Set<txId>
+        this.byType = new Map();          // type -> Set<txId>
+        this.children = new Map();        // txId -> Set<childTxId>
+
+        // Configuration
+        this.confirmationThreshold = options.confirmationThreshold || 5;
+        this.maxTips = options.maxTips || 100;
+        this.pruneAge = options.pruneAge || 24 * 60 * 60 * 1000; // 24 hours
+
+        // Stats
+        this.stats = {
+            transactions: 0,
+            confirmed: 0,
+            tips: 0,
+            avgConfirmationTime: 0,
+        };
+
+        // Create genesis if needed
+        if (options.createGenesis !== false) {
+            this.createGenesis();
+        }
+    }
+
+    /**
+     * Create genesis transaction
+     */
+    createGenesis() {
+        const genesis = new Transaction({
+            id: 'genesis',
+            type: 'genesis',
+            parents: [],
+            payload: {
+                message: 'QDAG Genesis',
+                timestamp: Date.now(),
+            },
+            issuer: 'system',
+        });
+
+        genesis.confirmed = true;
+        genesis.confirmedAt = Date.now();
+        genesis.cumulativeWeight = this.confirmationThreshold + 1;
+
+        this.transactions.set(genesis.id, genesis);
+        this.tips.add(genesis.id);
+        this.confirmed.add(genesis.id);
+
+        this.emit('genesis', genesis);
+
+        return genesis;
+    }
+
+    /**
+     * 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 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 ? Math.max(tx.cumulativeWeight, 1) : 1;
+        });
+
+        const totalWeight = weights.reduce((a, b) => a + b, 0);
+
+        // 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++) {
+                random -= weights[i];
+                if (random <= 0) {
+                    selected.add(tips[i]);
+                    break;
+                }
+            }
+            attempts++;
+        }
+
+        // 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 with detailed error
+        const validation = this.validateTransaction(tx, { returnError: true });
+        if (!validation.valid) {
+            throw new Error(`Invalid transaction: ${validation.error}`);
+        }
+
+        // Check for duplicates
+        if (this.transactions.has(tx.id)) {
+            return this.transactions.get(tx.id);
+        }
+
+        // Store transaction
+        this.transactions.set(tx.id, tx);
+        this.tips.add(tx.id);
+        this.stats.transactions++;
+
+        // Update indices
+        if (tx.issuer) {
+            if (!this.byIssuer.has(tx.issuer)) {
+                this.byIssuer.set(tx.issuer, new Set());
+            }
+            this.byIssuer.get(tx.issuer).add(tx.id);
+        }
+
+        if (!this.byType.has(tx.type)) {
+            this.byType.set(tx.type, new Set());
+        }
+        this.byType.get(tx.type).add(tx.id);
+
+        // Update parent references
+        for (const parentId of tx.parents) {
+            if (!this.children.has(parentId)) {
+                this.children.set(parentId, new Set());
+            }
+            this.children.get(parentId).add(tx.id);
+
+            // Remove parent from tips
+            this.tips.delete(parentId);
+        }
+
+        // Update weights
+        this.updateWeights(tx.id);
+
+        // Check for confirmations
+        this.checkConfirmations();
+
+        this.emit('transaction', tx);
+
+        return tx;
+    }
+
+    /**
+     * Create and add a new transaction
+     */
+    createTransaction(type, payload, options = {}) {
+        const parents = options.parents || this.selectTips(2);
+
+        const tx = new Transaction({
+            type,
+            payload,
+            parents,
+            issuer: options.issuer || this.nodeId,
+            proof: options.proof,
+        });
+
+        if (options.privateKey) {
+            tx.sign(options.privateKey);
+        }
+
+        return this.addTransaction(tx);
+    }
+
+    /**
+     * Validate transaction
+     * @returns {boolean|{valid: boolean, error: string}}
+     */
+    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) {
+            return fail('Missing transaction id');
+        }
+        if (!tx.timestamp) {
+            return fail('Missing transaction timestamp');
+        }
+        if (!tx.type) {
+            return fail('Missing transaction type');
+        }
+
+        // Genesis transactions don't need parents
+        if (tx.type === 'genesis') {
+            return pass();
+        }
+
+        // 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 or equal for simultaneous txs)
+        for (const parentId of tx.parents) {
+            const parent = this.transactions.get(parentId);
+            // Allow equal timestamps (transactions created at same time)
+            if (parent && parent.timestamp > tx.timestamp) {
+                return fail(`Parent ${parentId} has future timestamp`);
+            }
+        }
+
+        return pass();
+    }
+
+    /**
+     * Update cumulative weights
+     */
+    updateWeights(txId) {
+        const tx = this.transactions.get(txId);
+        if (!tx) return;
+
+        // Update weight of this transaction
+        tx.cumulativeWeight = tx.weight;
+
+        // Add weight of all children
+        const children = this.children.get(txId);
+        if (children) {
+            for (const childId of children) {
+                const child = this.transactions.get(childId);
+                if (child) {
+                    tx.cumulativeWeight += child.cumulativeWeight;
+                }
+            }
+        }
+
+        // Propagate to parents
+        for (const parentId of tx.parents) {
+            this.updateWeights(parentId);
+        }
+    }
+
+    /**
+     * Check for newly confirmed transactions
+     */
+    checkConfirmations() {
+        for (const [txId, tx] of this.transactions) {
+            if (!tx.confirmed && tx.cumulativeWeight >= this.confirmationThreshold) {
+                tx.confirmed = true;
+                tx.confirmedAt = Date.now();
+
+                this.confirmed.add(txId);
+                this.stats.confirmed++;
+
+                // Update average confirmation time
+                const confirmTime = tx.confirmedAt - tx.timestamp;
+                this.stats.avgConfirmationTime =
+                    (this.stats.avgConfirmationTime * (this.stats.confirmed - 1) + confirmTime) /
+                    this.stats.confirmed;
+
+                this.emit('confirmed', tx);
+            }
+        }
+
+        this.stats.tips = this.tips.size;
+    }
+
+    /**
+     * Get transaction by ID
+     */
+    getTransaction(txId) {
+        return this.transactions.get(txId);
+    }
+
+    /**
+     * Get transactions by issuer
+     */
+    getByIssuer(issuer) {
+        const txIds = this.byIssuer.get(issuer) || new Set();
+        return Array.from(txIds).map(id => this.transactions.get(id));
+    }
+
+    /**
+     * Get transactions by type
+     */
+    getByType(type) {
+        const txIds = this.byType.get(type) || new Set();
+        return Array.from(txIds).map(id => this.transactions.get(id));
+    }
+
+    /**
+     * Get current tips
+     */
+    getTips() {
+        return Array.from(this.tips).map(id => this.transactions.get(id));
+    }
+
+    /**
+     * Get confirmed transactions
+     */
+    getConfirmed() {
+        return Array.from(this.confirmed).map(id => this.transactions.get(id));
+    }
+
+    /**
+     * Prune old transactions
+     */
+    prune() {
+        const cutoff = Date.now() - this.pruneAge;
+        let pruned = 0;
+
+        for (const [txId, tx] of this.transactions) {
+            if (tx.type === 'genesis') continue;
+
+            if (tx.confirmed && tx.confirmedAt < cutoff) {
+                // Remove from storage
+                this.transactions.delete(txId);
+                this.confirmed.delete(txId);
+                this.tips.delete(txId);
+
+                // Clean up indices
+                if (tx.issuer && this.byIssuer.has(tx.issuer)) {
+                    this.byIssuer.get(tx.issuer).delete(txId);
+                }
+                if (this.byType.has(tx.type)) {
+                    this.byType.get(tx.type).delete(txId);
+                }
+
+                this.children.delete(txId);
+
+                pruned++;
+            }
+        }
+
+        if (pruned > 0) {
+            this.emit('pruned', { count: pruned });
+        }
+
+        return pruned;
+    }
+
+    /**
+     * Get QDAG statistics
+     */
+    getStats() {
+        return {
+            id: this.id,
+            ...this.stats,
+            size: this.transactions.size,
+            memoryUsage: process.memoryUsage?.().heapUsed,
+        };
+    }
+
+    /**
+     * Export QDAG for synchronization
+     */
+    export(since = 0) {
+        const transactions = [];
+
+        for (const [txId, tx] of this.transactions) {
+            if (tx.timestamp >= since) {
+                transactions.push(tx.toJSON());
+            }
+        }
+
+        return {
+            id: this.id,
+            timestamp: Date.now(),
+            transactions,
+        };
+    }
+
+    /**
+     * Import transactions from another node
+     */
+    import(data) {
+        let imported = 0;
+
+        // Sort by timestamp to maintain order
+        const sorted = data.transactions.sort((a, b) => a.timestamp - b.timestamp);
+
+        for (const txData of sorted) {
+            try {
+                const tx = Transaction.fromJSON(txData);
+                if (!this.transactions.has(tx.id)) {
+                    this.addTransaction(tx);
+                    imported++;
+                }
+            } catch (error) {
+                console.error('[QDAG] Import error:', error.message);
+            }
+        }
+
+        this.emit('imported', { count: imported, from: data.id });
+
+        return imported;
+    }
+
+    /**
+     * Merge with another QDAG
+     */
+    merge(other) {
+        return this.import(other.export());
+    }
+}
+
+// ============================================
+// TASK TRANSACTION HELPERS
+// ============================================
+
+/**
+ * Create a task submission transaction
+ */
+export function createTaskTransaction(qdag, task, options = {}) {
+    return qdag.createTransaction('task', {
+        taskId: task.id,
+        type: task.type,
+        data: task.data,
+        priority: task.priority || 'medium',
+        reward: task.reward || 0,
+        deadline: task.deadline,
+    }, options);
+}
+
+/**
+ * Create a task completion/reward transaction
+ */
+export function createRewardTransaction(qdag, taskTxId, result, options = {}) {
+    const taskTx = qdag.getTransaction(taskTxId);
+    if (!taskTx) throw new Error('Task transaction not found');
+
+    return qdag.createTransaction('reward', {
+        taskTxId,
+        result,
+        worker: options.worker,
+        reward: taskTx.payload.reward || 0,
+        completedAt: Date.now(),
+    }, {
+        ...options,
+        parents: [taskTxId, ...qdag.selectTips(1)],
+    });
+}
+
+/**
+ * Create a credit transfer transaction
+ */
+export function createTransferTransaction(qdag, from, to, amount, options = {}) {
+    return qdag.createTransaction('transfer', {
+        from,
+        to,
+        amount,
+        memo: options.memo,
+    }, options);
+}
+
+// ============================================
+// EXPORTS
+// ============================================
+
+export default QDAG;