@osmura/merkletreejs 0.6.0

package/dist/MerkleRadixTree.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleRadixTree = void 0;
+const Base_1 = __importDefault(require("./Base"));
+class MerkleRadixNode {
+    constructor(key = '', value = null, hashFn) {
+        this.key = key;
+        this.value = value;
+        this.children = new Map();
+        this.hashFn = hashFn;
+        this.hash = this.computeHash();
+    }
+    computeHash() {
+        let hash = this.hashFn('');
+        hash = Buffer.concat([hash, Base_1.default.bufferify(this.key), this.value != null ? Base_1.default.bufferify(this.value) : Buffer.alloc(0)]);
+        for (const child of this.children.values()) {
+            hash = Buffer.concat([hash, child.hash]);
+        }
+        const result = this.hashFn(hash);
+        return result;
+    }
+    updateHash() {
+        this.hash = this.computeHash();
+    }
+}
+class MerkleRadixTree extends Base_1.default {
+    constructor(hashFn) {
+        super();
+        this.hashFn = this.bufferifyFn(hashFn);
+        this.root = new MerkleRadixNode('', null, this.hashFn);
+    }
+    insert(key, value) {
+        let node = this.root;
+        let commonPrefixLength = 0;
+        while (key.length > 0) {
+            const child = [...node.children.values()].find(child => key.startsWith(child.key));
+            if (!child) {
+                node.children.set(key, new MerkleRadixNode(key, value, this.hashFn));
+                node.updateHash(); // Update the hash of the current node
+                return;
+            }
+            commonPrefixLength = this.commonPrefixLength(key, child.key);
+            if (commonPrefixLength === child.key.length) {
+                node = child;
+                key = key.slice(commonPrefixLength);
+            }
+            else {
+                const commonPrefix = key.slice(0, commonPrefixLength);
+                const childSuffix = child.key.slice(commonPrefixLength);
+                const newNode = new MerkleRadixNode(commonPrefix, null, this.hashFn);
+                node.children.delete(child.key);
+                node.children.set(commonPrefix, newNode);
+                newNode.children.set(childSuffix, child);
+                child.key = childSuffix;
+                if (commonPrefixLength < key.length) {
+                    const suffix = key.slice(commonPrefixLength);
+                    newNode.children.set(suffix, new MerkleRadixNode(suffix, value, this.hashFn));
+                }
+                else {
+                    newNode.value = value;
+                }
+                node.updateHash();
+                newNode.updateHash(); // Update the hash of the new node
+                return;
+            }
+        }
+        node.value = value;
+        node.updateHash(); // Update the hash of the node where the value was inserted
+    }
+    lookup(key) {
+        let node = this.root;
+        while (key.length > 0) {
+            const child = [...node.children.values()].find(child => key.startsWith(child.key));
+            if (!child) {
+                return null;
+            }
+            const commonPrefixLength = this.commonPrefixLength(key, child.key);
+            if (commonPrefixLength === child.key.length) {
+                node = child;
+                key = key.slice(commonPrefixLength);
+            }
+            else {
+                return null;
+            }
+        }
+        return node.value;
+    }
+    commonPrefixLength(str1, str2) {
+        let length = 0;
+        while (length < str1.length && length < str2.length && str1[length] === str2[length]) {
+            length++;
+        }
+        return length;
+    }
+    generateProof(key) {
+        let node = this.root;
+        const proof = [];
+        while (key.length > 0) {
+            const siblings = [];
+            for (const child of node.children.values()) {
+                if (child.key !== key) {
+                    siblings.push({
+                        key: child.key,
+                        hash: child.hash
+                    });
+                }
+            }
+            proof.push({
+                key: node.key,
+                hash: node.hash,
+                siblings
+            });
+            const child = [...node.children.values()].find(child => key.startsWith(child.key));
+            if (!child) {
+                return null;
+            }
+            const commonPrefixLength = this.commonPrefixLength(key, child.key);
+            if (commonPrefixLength === child.key.length) {
+                node = child;
+                key = key.slice(commonPrefixLength);
+            }
+            else {
+                return null;
+            }
+        }
+        proof.push({
+            key: node.key,
+            hash: node.hash,
+            siblings: []
+        });
+        return proof;
+    }
+    verifyProof(proof, rootHash) {
+        if (!proof || proof.length === 0) {
+            return false;
+        }
+        let currentHash = proof[proof.length - 1].hash;
+        for (let i = proof.length - 2; i >= 0; i--) {
+            const item = proof[i];
+            let concatenatedHash = Buffer.concat([this.hashFn(''), this.bufferify(item.key), currentHash]);
+            for (const sibling of item.siblings) {
+                concatenatedHash = Buffer.concat([concatenatedHash, sibling.hash]);
+            }
+            currentHash = this.hashFn(concatenatedHash);
+        }
+        return currentHash.equals(rootHash);
+    }
+}
+exports.MerkleRadixTree = MerkleRadixTree;

package/dist/MerkleSumTree.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { Base } from './Base';
+declare type TValue = Buffer | BigInt | string | number | null | undefined;
+declare type THashFn = (value: TValue) => Buffer;
+export declare class Bucket {
+    size: BigInt;
+    hashed: Buffer;
+    parent: Bucket | null;
+    left: Bucket | null;
+    right: Bucket | null;
+    constructor(size: BigInt | number, hashed: Buffer);
+}
+export declare class Leaf {
+    hashFn: THashFn;
+    rng: BigInt[];
+    data: Buffer | null;
+    constructor(hashFn: THashFn, rng: (number | BigInt)[], data: Buffer | null);
+    getBucket(): Bucket;
+}
+export declare class ProofStep {
+    bucket: Bucket;
+    right: boolean;
+    constructor(bucket: Bucket, right: boolean);
+}
+export declare class MerkleSumTree extends Base {
+    hashFn: THashFn;
+    leaves: Leaf[];
+    buckets: Bucket[];
+    root: Bucket;
+    constructor(leaves: Leaf[], hashFn: THashFn);
+    sizeToBuffer(size: BigInt): Buffer;
+    static checkConsecutive(leaves: Leaf[]): void;
+    getProof(index: number | BigInt): any[];
+    sum(arr: BigInt[]): bigint;
+    verifyProof(root: Bucket, leaf: Leaf, proof: ProofStep[]): boolean;
+}
+export default MerkleSumTree;

package/dist/MerkleSumTree.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleSumTree = exports.ProofStep = exports.Leaf = exports.Bucket = void 0;
+const Base_1 = require("./Base");
+class Bucket {
+    constructor(size, hashed) {
+        this.size = BigInt(size);
+        this.hashed = hashed;
+        // each node in the tree can have a parent, and a left or right sibling
+        this.parent = null;
+        this.left = null;
+        this.right = null;
+    }
+}
+exports.Bucket = Bucket;
+class Leaf {
+    constructor(hashFn, rng, data) {
+        this.hashFn = hashFn;
+        this.rng = rng.map(x => BigInt(x));
+        this.data = data;
+    }
+    getBucket() {
+        let hashed;
+        if (this.data) {
+            hashed = this.hashFn(this.data);
+        }
+        else {
+            hashed = Buffer.alloc(32);
+        }
+        return new Bucket(BigInt(this.rng[1]) - BigInt(this.rng[0]), hashed);
+    }
+}
+exports.Leaf = Leaf;
+class ProofStep {
+    constructor(bucket, right) {
+        this.bucket = bucket;
+        this.right = right; // whether the bucket hash should be appeded on the right side in this step (default is left
+    }
+}
+exports.ProofStep = ProofStep;
+class MerkleSumTree extends Base_1.Base {
+    constructor(leaves, hashFn) {
+        super();
+        this.leaves = leaves;
+        this.hashFn = hashFn;
+        MerkleSumTree.checkConsecutive(leaves);
+        this.buckets = [];
+        for (const l of leaves) {
+            this.buckets.push(l.getBucket());
+        }
+        let buckets = [];
+        for (const bucket of this.buckets) {
+            buckets.push(bucket);
+        }
+        while (buckets.length !== 1) {
+            const newBuckets = [];
+            while (buckets.length) {
+                if (buckets.length >= 2) {
+                    const b1 = buckets.shift();
+                    const b2 = buckets.shift();
+                    const size = b1.size + b2.size;
+                    const hashed = this.hashFn(Buffer.concat([this.sizeToBuffer(b1.size), this.bufferify(b1.hashed), this.sizeToBuffer(b2.size), this.bufferify(b2.hashed)]));
+                    const b = new Bucket(size, hashed);
+                    b2.parent = b;
+                    b1.parent = b2.parent;
+                    b1.right = b2;
+                    b2.left = b1;
+                    newBuckets.push(b);
+                }
+                else {
+                    newBuckets.push(buckets.shift());
+                }
+            }
+            buckets = newBuckets;
+        }
+        this.root = buckets[0];
+    }
+    sizeToBuffer(size) {
+        const buf = Buffer.alloc(8);
+        const view = new DataView(buf.buffer);
+        view.setBigInt64(0, BigInt(size), false); // true when little endian
+        return buf;
+    }
+    static checkConsecutive(leaves) {
+        let curr = BigInt(0);
+        for (const leaf of leaves) {
+            if (leaf.rng[0] !== curr) {
+                throw new Error('leaf ranges are invalid');
+            }
+            curr = BigInt(leaf.rng[1]);
+        }
+    }
+    // gets inclusion/exclusion proof of a bucket in the specified index
+    getProof(index) {
+        let curr = this.buckets[Number(index)];
+        const proof = [];
+        while (curr && curr.parent) {
+            const right = !!curr.right;
+            const bucket = curr.right ? curr.right : curr.left;
+            curr = curr.parent;
+            proof.push(new ProofStep(bucket, right));
+        }
+        return proof;
+    }
+    sum(arr) {
+        let total = BigInt(0);
+        for (const value of arr) {
+            total += BigInt(value);
+        }
+        return total;
+    }
+    // validates the suppplied proof for a specified leaf according to the root bucket
+    verifyProof(root, leaf, proof) {
+        const rng = [this.sum(proof.filter(x => !x.right).map(x => x.bucket.size)), BigInt(root.size) - this.sum(proof.filter(x => x.right).map(x => x.bucket.size))];
+        if (!(rng[0] === leaf.rng[0] && rng[1] === leaf.rng[1])) {
+            // supplied steps are not routing to the range specified
+            return false;
+        }
+        let curr = leaf.getBucket();
+        let hashed;
+        for (const step of proof) {
+            if (step.right) {
+                hashed = this.hashFn(Buffer.concat([this.sizeToBuffer(curr.size), this.bufferify(curr.hashed), this.sizeToBuffer(step.bucket.size), this.bufferify(step.bucket.hashed)]));
+            }
+            else {
+                hashed = this.hashFn(Buffer.concat([this.sizeToBuffer(step.bucket.size), this.bufferify(step.bucket.hashed), this.sizeToBuffer(curr.size), this.bufferify(curr.hashed)]));
+            }
+            curr = new Bucket(BigInt(curr.size) + BigInt(step.bucket.size), hashed);
+        }
+        return curr.size === root.size && curr.hashed.toString('hex') === root.hashed.toString('hex');
+    }
+}
+exports.MerkleSumTree = MerkleSumTree;
+if (typeof window !== 'undefined') {
+    ;
+    window.MerkleSumTree = MerkleSumTree;
+}
+exports.default = MerkleSumTree;