@ninebix/nmt-system 1.0.0

package/dist/src/core/merkle-engine.js

@@ -0,0 +1,528 @@
+/**
+ * Merkle Engine - Tree construction and verification
+ *
+ * Extended features:
+ * - Tree diff computation
+ * - Batch proofs for multiple leaves
+ * - Range proofs for consecutive leaves
+ * - Versioned trees
+ *
+ * @module core/merkle-engine
+ */
+import { hash, hashPair } from '../utils/hash.js';
+/**
+ * MerkleEngine class for tree operations
+ */
+export class MerkleEngine {
+    /**
+     * Build a Merkle tree from leaf hashes
+     * @param leaves - Array of leaf hashes
+     * @returns Complete Merkle tree structure
+     */
+    buildTree(leaves) {
+        if (leaves.length === 0) {
+            throw new Error('Cannot build Merkle tree from empty leaves');
+        }
+        const originalLeaves = [...leaves];
+        // Pad to power of 2 by duplicating last leaf
+        const paddedLeaves = [...leaves];
+        while (!this.isPowerOfTwo(paddedLeaves.length)) {
+            paddedLeaves.push(paddedLeaves[paddedLeaves.length - 1]);
+        }
+        // Build levels from bottom to top
+        const levels = [paddedLeaves];
+        let currentLevel = paddedLeaves;
+        while (currentLevel.length > 1) {
+            const nextLevel = [];
+            for (let i = 0; i < currentLevel.length; i += 2) {
+                const left = currentLevel[i];
+                const right = currentLevel[i + 1];
+                const parent = hashPair(left, right);
+                nextLevel.push(parent);
+            }
+            levels.push(nextLevel);
+            currentLevel = nextLevel;
+        }
+        return {
+            root: currentLevel[0],
+            levels,
+            leafCount: originalLeaves.length,
+            originalLeaves
+        };
+    }
+    /**
+     * Build Merkle tree from raw data buffers
+     * @param data - Array of data buffers
+     * @returns Merkle tree with hashed leaves
+     */
+    buildTreeFromData(data) {
+        const leaves = data.map(d => hash(d));
+        return this.buildTree(leaves);
+    }
+    /**
+     * Generate inclusion proof for a leaf
+     * @param tree - Merkle tree
+     * @param leafIndex - Index of leaf to prove
+     * @returns Merkle proof
+     */
+    generateProof(tree, leafIndex) {
+        if (leafIndex < 0 || leafIndex >= tree.leafCount) {
+            throw new Error(`Invalid leaf index: ${leafIndex}`);
+        }
+        const siblings = [];
+        const directions = [];
+        // Handle padding - if index is beyond padded leaves, use last leaf
+        let currentIndex = Math.min(leafIndex, tree.levels[0].length - 1);
+        // Traverse from leaf to root
+        for (let level = 0; level < tree.levels.length - 1; level++) {
+            const currentLevel = tree.levels[level];
+            const isLeft = currentIndex % 2 === 0;
+            const siblingIndex = isLeft ? currentIndex + 1 : currentIndex - 1;
+            // Ensure sibling exists
+            if (siblingIndex >= 0 && siblingIndex < currentLevel.length) {
+                siblings.push(currentLevel[siblingIndex]);
+                directions.push(isLeft);
+            }
+            // Move to parent index
+            currentIndex = Math.floor(currentIndex / 2);
+        }
+        return {
+            leaf: tree.levels[0][Math.min(leafIndex, tree.levels[0].length - 1)],
+            leafIndex,
+            siblings,
+            directions,
+            root: tree.root
+        };
+    }
+    /**
+     * Verify a Merkle proof
+     * @param proof - Proof to verify
+     * @returns true if proof is valid
+     */
+    verifyProof(proof) {
+        let currentHash = proof.leaf;
+        for (let i = 0; i < proof.siblings.length; i++) {
+            const sibling = proof.siblings[i];
+            const isLeft = proof.directions[i];
+            if (isLeft) {
+                currentHash = hashPair(currentHash, sibling);
+            }
+            else {
+                currentHash = hashPair(sibling, currentHash);
+            }
+        }
+        return currentHash === proof.root;
+    }
+    /**
+     * Verify proof with explicit root and leaf
+     * @param proof - Proof structure
+     * @param root - Expected root hash
+     * @param leaf - Expected leaf hash
+     * @returns true if valid
+     */
+    verifyProofWithValues(proof, root, leaf) {
+        return proof.root === root && proof.leaf === leaf && this.verifyProof(proof);
+    }
+    /**
+     * Compute the root hash directly from leaves
+     * @param leaves - Leaf hashes
+     * @returns Root hash
+     */
+    computeRoot(leaves) {
+        return this.buildTree(leaves).root;
+    }
+    /**
+     * Update a leaf in the tree (returns new tree)
+     * @param tree - Original tree
+     * @param index - Leaf index to update
+     * @param newLeaf - New leaf hash
+     * @returns Updated tree
+     */
+    updateLeaf(tree, index, newLeaf) {
+        if (index < 0 || index >= tree.leafCount) {
+            throw new Error(`Invalid leaf index: ${index}`);
+        }
+        // Create new original leaves array
+        const newOriginalLeaves = [...tree.originalLeaves];
+        newOriginalLeaves[index] = newLeaf;
+        // Rebuild tree with new leaves
+        return this.buildTree(newOriginalLeaves);
+    }
+    /**
+     * Add a new leaf to the tree
+     * @param tree - Original tree
+     * @param newLeaf - New leaf hash
+     * @returns Updated tree
+     */
+    addLeaf(tree, newLeaf) {
+        const newLeaves = [...tree.originalLeaves, newLeaf];
+        return this.buildTree(newLeaves);
+    }
+    /**
+     * Get the height of the tree
+     * @param tree - Merkle tree
+     * @returns Tree height (number of levels)
+     */
+    getHeight(tree) {
+        return tree.levels.length;
+    }
+    /**
+     * Get all nodes at a specific level
+     * @param tree - Merkle tree
+     * @param level - Level index (0 = leaves)
+     * @returns Array of hashes at that level
+     */
+    getLevel(tree, level) {
+        if (level < 0 || level >= tree.levels.length) {
+            throw new Error(`Invalid level: ${level}`);
+        }
+        return [...tree.levels[level]];
+    }
+    /**
+     * Serialize tree to JSON-friendly format
+     */
+    serialize(tree) {
+        return {
+            root: tree.root,
+            levels: tree.levels,
+            leafCount: tree.leafCount,
+            originalLeaves: tree.originalLeaves
+        };
+    }
+    /**
+     * Deserialize tree from JSON
+     */
+    deserialize(data) {
+        return {
+            root: data.root,
+            levels: data.levels,
+            leafCount: data.leafCount,
+            originalLeaves: data.originalLeaves
+        };
+    }
+    // ==================== EXTENDED FEATURES ====================
+    /**
+     * Compute the difference between two Merkle trees
+     *
+     * @param oldTree - Original tree
+     * @param newTree - Updated tree
+     * @returns TreeDiff with added, removed, and modified leaves
+     *
+     * @example
+     * ```typescript
+     * const tree1 = engine.buildTree(['a', 'b', 'c']);
+     * const tree2 = engine.buildTree(['a', 'b', 'd']);
+     * const diff = engine.computeDiff(tree1, tree2);
+     * // diff.modified = [{ index: 2, oldHash: 'c', newHash: 'd' }]
+     * ```
+     */
+    computeDiff(oldTree, newTree) {
+        const added = [];
+        const removed = [];
+        const modified = [];
+        const oldLeaves = oldTree.originalLeaves;
+        const newLeaves = newTree.originalLeaves;
+        // Find modified and removed
+        for (let i = 0; i < oldLeaves.length; i++) {
+            if (i < newLeaves.length) {
+                if (oldLeaves[i] !== newLeaves[i]) {
+                    modified.push({
+                        index: i,
+                        oldHash: oldLeaves[i],
+                        newHash: newLeaves[i],
+                    });
+                }
+            }
+            else {
+                removed.push(oldLeaves[i]);
+            }
+        }
+        // Find added
+        for (let i = oldLeaves.length; i < newLeaves.length; i++) {
+            added.push(newLeaves[i]);
+        }
+        return {
+            added,
+            removed,
+            modified,
+            oldRoot: oldTree.root,
+            newRoot: newTree.root,
+        };
+    }
+    /**
+     * Check if two trees have the same content
+     */
+    treesEqual(tree1, tree2) {
+        return tree1.root === tree2.root;
+    }
+    /**
+     * Generate a batch proof for multiple leaves at once
+     *
+     * More efficient than generating individual proofs as siblings are deduplicated.
+     *
+     * @param tree - Merkle tree
+     * @param indices - Array of leaf indices to prove
+     * @returns BatchMerkleProof with deduplicated siblings
+     *
+     * @example
+     * ```typescript
+     * const batchProof = engine.generateBatchProof(tree, [0, 2, 5]);
+     * const valid = engine.verifyBatchProof(batchProof);
+     * ```
+     */
+    generateBatchProof(tree, indices) {
+        if (indices.length === 0) {
+            throw new Error('Cannot generate batch proof for empty indices');
+        }
+        // Validate indices
+        for (const index of indices) {
+            if (index < 0 || index >= tree.leafCount) {
+                throw new Error(`Invalid leaf index: ${index}`);
+            }
+        }
+        const leaves = [];
+        const siblings = {};
+        // Collect leaves
+        for (const index of indices) {
+            const actualIndex = Math.min(index, tree.levels[0].length - 1);
+            leaves.push({
+                index,
+                hash: tree.levels[0][actualIndex],
+            });
+        }
+        // For each level, track which nodes we need vs which we can compute
+        const nodesNeeded = new Set();
+        // Mark all leaf nodes we have
+        for (const index of indices) {
+            const actualIndex = Math.min(index, tree.levels[0].length - 1);
+            nodesNeeded.add(`0:${actualIndex}`);
+        }
+        // Traverse up the tree to find all needed siblings
+        for (let level = 0; level < tree.levels.length - 1; level++) {
+            const currentLevel = tree.levels[level];
+            const parentNodesNeeded = new Set();
+            // Find siblings we need for this level
+            for (const nodeKey of nodesNeeded) {
+                const [lvl, idx] = nodeKey.split(':').map(Number);
+                if (lvl !== level)
+                    continue;
+                const isLeft = idx % 2 === 0;
+                const siblingIndex = isLeft ? idx + 1 : idx - 1;
+                // If sibling exists and we don't already have it, add to siblings
+                if (siblingIndex >= 0 && siblingIndex < currentLevel.length) {
+                    const siblingKey = `${level}:${siblingIndex}`;
+                    if (!nodesNeeded.has(siblingKey)) {
+                        siblings[siblingKey] = currentLevel[siblingIndex];
+                    }
+                }
+                // Mark parent as needed
+                const parentIndex = Math.floor(idx / 2);
+                parentNodesNeeded.add(`${level + 1}:${parentIndex}`);
+            }
+            // Add parent nodes to needed set
+            for (const key of parentNodesNeeded) {
+                nodesNeeded.add(key);
+            }
+        }
+        return {
+            leaves,
+            siblings,
+            root: tree.root,
+        };
+    }
+    /**
+     * Verify a batch proof
+     *
+     * @param proof - BatchMerkleProof to verify
+     * @returns true if all leaves are proven to be in the tree
+     */
+    verifyBatchProof(proof) {
+        if (proof.leaves.length === 0) {
+            return false;
+        }
+        // Build a map of known node hashes
+        const knownNodes = new Map();
+        // Add leaves
+        for (const { index, hash } of proof.leaves) {
+            knownNodes.set(`0:${index}`, hash);
+        }
+        // Add siblings
+        for (const [key, hash] of Object.entries(proof.siblings)) {
+            knownNodes.set(key, hash);
+        }
+        // Find the maximum level we need to compute
+        const maxLevel = Math.ceil(Math.log2(Math.max(...proof.leaves.map(l => l.index + 1)))) + 1;
+        // Compute up the tree
+        for (let level = 0; level < maxLevel; level++) {
+            const indices = new Set();
+            for (const key of knownNodes.keys()) {
+                const [lvl, idx] = key.split(':').map(Number);
+                if (lvl === level) {
+                    indices.add(Math.floor(idx / 2));
+                }
+            }
+            for (const parentIndex of indices) {
+                const leftKey = `${level}:${parentIndex * 2}`;
+                const rightKey = `${level}:${parentIndex * 2 + 1}`;
+                const left = knownNodes.get(leftKey);
+                const right = knownNodes.get(rightKey);
+                if (left && right) {
+                    const parentHash = hashPair(left, right);
+                    knownNodes.set(`${level + 1}:${parentIndex}`, parentHash);
+                }
+            }
+        }
+        // Find the root (should be at 0 index of highest level)
+        for (const [key, hash] of knownNodes.entries()) {
+            if (key.endsWith(':0') && hash === proof.root) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Generate a range proof for consecutive leaves
+     *
+     * Useful for proving a subset of the tree without full proofs for each leaf.
+     *
+     * @param tree - Merkle tree
+     * @param startIndex - Start index (inclusive)
+     * @param endIndex - End index (exclusive)
+     * @returns RangeProof
+     */
+    generateRangeProof(tree, startIndex, endIndex) {
+        if (startIndex < 0 || startIndex >= tree.leafCount) {
+            throw new Error(`Invalid start index: ${startIndex}`);
+        }
+        if (endIndex <= startIndex || endIndex > tree.leafCount) {
+            throw new Error(`Invalid end index: ${endIndex}`);
+        }
+        // Get leaves in range
+        const leaves = tree.originalLeaves.slice(startIndex, endIndex);
+        // Generate boundary proofs
+        const leftProof = startIndex > 0
+            ? this.generateProof(tree, startIndex)
+            : null;
+        const rightProof = endIndex < tree.leafCount
+            ? this.generateProof(tree, endIndex - 1)
+            : null;
+        return {
+            startIndex,
+            endIndex,
+            leaves,
+            leftProof,
+            rightProof,
+            root: tree.root,
+        };
+    }
+    /**
+     * Verify a range proof
+     *
+     * @param proof - RangeProof to verify
+     * @returns true if the range is valid
+     */
+    verifyRangeProof(proof) {
+        // Verify boundary proofs if they exist
+        if (proof.leftProof) {
+            if (proof.leftProof.root !== proof.root) {
+                return false;
+            }
+            if (!this.verifyProof(proof.leftProof)) {
+                return false;
+            }
+            // Check that the left boundary leaf matches
+            if (proof.leftProof.leaf !== proof.leaves[0]) {
+                return false;
+            }
+        }
+        if (proof.rightProof) {
+            if (proof.rightProof.root !== proof.root) {
+                return false;
+            }
+            if (!this.verifyProof(proof.rightProof)) {
+                return false;
+            }
+            // Check that the right boundary leaf matches
+            if (proof.rightProof.leaf !== proof.leaves[proof.leaves.length - 1]) {
+                return false;
+            }
+        }
+        // Verify the range is contiguous
+        if (proof.endIndex - proof.startIndex !== proof.leaves.length) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Create a versioned tree from an existing tree
+     *
+     * @param tree - Source tree
+     * @param parentRoot - Parent version root (null for initial)
+     * @returns VersionedMerkleTree
+     */
+    createVersion(tree, parentRoot = null) {
+        return {
+            ...tree,
+            version: parentRoot ? 1 : 0, // Version increments handled externally
+            parentRoot,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Create a new version from changes
+     *
+     * @param currentVersion - Current versioned tree
+     * @param newTree - New tree state
+     * @returns New VersionedMerkleTree with diff
+     */
+    createNewVersion(currentVersion, newTree) {
+        const diff = this.computeDiff(currentVersion, newTree);
+        return {
+            ...newTree,
+            version: currentVersion.version + 1,
+            parentRoot: currentVersion.root,
+            timestamp: new Date().toISOString(),
+            diff,
+        };
+    }
+    /**
+     * Serialize a versioned tree
+     */
+    serializeVersioned(tree) {
+        return {
+            ...this.serialize(tree),
+            version: tree.version,
+            parentRoot: tree.parentRoot,
+            timestamp: tree.timestamp,
+            diff: tree.diff,
+        };
+    }
+    /**
+     * Deserialize a versioned tree
+     */
+    deserializeVersioned(data) {
+        return {
+            root: data.root,
+            levels: data.levels,
+            leafCount: data.leafCount,
+            originalLeaves: data.originalLeaves,
+            version: data.version,
+            parentRoot: data.parentRoot,
+            timestamp: data.timestamp,
+            diff: data.diff,
+        };
+    }
+    /**
+     * Check if number is power of 2
+     */
+    isPowerOfTwo(n) {
+        return n > 0 && (n & (n - 1)) === 0;
+    }
+}
+/**
+ * Create a MerkleEngine instance
+ */
+export function createMerkleEngine() {
+    return new MerkleEngine();
+}
+//# sourceMappingURL=merkle-engine.js.map

package/dist/src/core/merkle-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkle-engine.js","sourceRoot":"","sources":["../../../src/core/merkle-engine.ts"],"names":[],"mappings":"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"}

package/dist/src/core/neuron-graph.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Neuron Graph Manager - Graph operations and traversal
+ * @module core/neuron-graph
+ */
+import type { UUID, NeuronNode, Synapse, SynapseType, Embedding384, TraversalStrategy, NeuronPath, INeuronStore } from '../types/index.js';
+import { HNSWIndex } from './hnsw-index.js';
+/**
+ * Neuron Graph Manager options
+ */
+export interface NeuronGraphOptions {
+    neuronStore: INeuronStore;
+    hnswIndex: HNSWIndex;
+    semanticThreshold?: number;
+    maxTraversalDepth?: number;
+}
+/**
+ * Create neuron input
+ */
+export interface CreateNeuronInput {
+    embedding: Embedding384;
+    chunkHashes: string[];
+    merkleRoot: string;
+    sourceType?: string;
+    tags?: string[];
+    autoConnect?: boolean;
+    connectionThreshold?: number;
+}
+/**
+ * Traversal result
+ */
+export interface TraversalResult {
+    paths: NeuronPath[];
+    visited: Set<UUID>;
+    totalWeight: number;
+}
+/**
+ * Neuron Graph Manager
+ * Handles neuron creation, connection, and graph traversal
+ */
+export declare class NeuronGraphManager {
+    private store;
+    private index;
+    private semanticThreshold;
+    private maxTraversalDepth;
+    constructor(options: NeuronGraphOptions);
+    /**
+     * Create a new neuron
+     */
+    createNeuron(input: CreateNeuronInput): Promise<NeuronNode>;
+    /**
+     * Get a neuron by ID
+     */
+    getNeuron(id: UUID): Promise<NeuronNode | null>;
+    /**
+     * Get a neuron by Merkle root
+     */
+    getNeuronByMerkleRoot(merkleRoot: string): Promise<NeuronNode | null>;
+    /**
+     * Delete a neuron
+     */
+    deleteNeuron(id: UUID): Promise<boolean>;
+    /**
+     * Connect two neurons with a synapse
+     */
+    connect(sourceId: UUID, targetId: UUID, type: SynapseType, weight?: number, bidirectional?: boolean): Promise<Synapse | null>;
+    /**
+     * Disconnect two neurons
+     */
+    disconnect(synapseId: UUID): Promise<boolean>;
+    /**
+     * Find similar neurons using HNSW index
+     */
+    findSimilar(embedding: Embedding384, k?: number, ef?: number): Promise<Array<{
+        neuron: NeuronNode;
+        score: number;
+    }>>;
+    /**
+     * Find similar neurons to an existing neuron
+     */
+    findSimilarTo(neuronId: UUID, k?: number): Promise<Array<{
+        neuron: NeuronNode;
+        score: number;
+    }>>;
+    /**
+     * Auto-connect neuron to similar neurons
+     */
+    autoConnect(neuronId: UUID, threshold?: number): Promise<Synapse[]>;
+    /**
+     * Get connection between two neurons
+     */
+    getConnection(sourceId: UUID, targetId: UUID): Promise<Synapse | null>;
+    /**
+     * Traverse the graph from a starting neuron
+     */
+    traverse(startId: UUID, strategy?: TraversalStrategy, maxDepth?: number, filter?: (neuron: NeuronNode, synapse: Synapse) => boolean): Promise<TraversalResult>;
+    /**
+     * Find shortest path between two neurons
+     */
+    findPath(sourceId: UUID, targetId: UUID, maxDepth?: number): Promise<NeuronPath | null>;
+    /**
+     * Get graph statistics
+     */
+    getStats(): Promise<{
+        neuronCount: number;
+        synapseCount: number;
+        indexStats: {
+            totalNodes: number;
+            layerDistribution: Map<number, number>;
+            maxLayer: number;
+        };
+    }>;
+    /**
+     * Get connected components
+     */
+    getConnectedComponents(): Promise<Set<UUID>[]>;
+    /**
+     * Strengthen synapse (Hebbian learning)
+     */
+    strengthenSynapse(synapseId: UUID, amount?: number): Promise<Synapse | null>;
+    /**
+     * Weaken synapse
+     */
+    weakenSynapse(synapseId: UUID, amount?: number): Promise<Synapse | null>;
+    private bfsTraverse;
+    private dfsTraverse;
+    private weightedTraverse;
+    private randomWalkTraverse;
+    private getNeuronsForPath;
+}
+/**
+ * Create a NeuronGraphManager instance
+ */
+export declare function createNeuronGraphManager(options: NeuronGraphOptions): NeuronGraphManager;
+//# sourceMappingURL=neuron-graph.d.ts.map

package/dist/src/core/neuron-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neuron-graph.d.ts","sourceRoot":"","sources":["../../../src/core/neuron-graph.ts"],"names":[],"mappings":"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"}