@osmura/merkletreejs 0.6.0

package/dist/Base.js

@@ -0,0 +1,379 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+const buffer_1 = require("buffer");
+const crypto_js_1 = __importDefault(require("crypto-js"));
+class Base {
+    /**
+     * print
+     * @desc Prints out a visual representation of the merkle tree.
+     * @example
+     *```js
+     *tree.print()
+     *```
+     */
+    print() {
+        Base.print(this);
+    }
+    /**
+     * bufferIndexOf
+     * @desc Returns the first index of which given buffer is found in array.
+     * @param {Buffer[]} haystack - Array of buffers.
+     * @param {Buffer} needle - Buffer to find.
+     * @return {Number} - Index number
+     *
+     * @example
+     * ```js
+     *const index = tree.bufferIndexOf(haystack, needle)
+     *```
+     */
+    bufferIndexOf(array, element, isSorted = false) {
+        if (isSorted) {
+            return this.binarySearch(array, element, buffer_1.Buffer.compare);
+        }
+        const eqChecker = (buffer1, buffer2) => buffer1.equals(buffer2);
+        return this.linearSearch(array, element, eqChecker);
+    }
+    /**
+     * binarySearch
+     * @desc Returns the first index of which given item is found in array using binary search.
+     * @param {Buffer[]} array - Array of items.
+     * @param {Buffer} element - Item to find.
+     * @param {Function} compareFunction
+     * @return {Number} - Index number
+     *
+     * @example
+     * ```js
+     *const index = MerkleTree.binarySearch(array, element, Buffer.compare)
+     *```
+     */
+    static binarySearch(array, element, compareFunction) {
+        let start = 0;
+        let end = array.length - 1;
+        // Iterate while start not meets end
+        while (start <= end) {
+            // Find the mid index
+            const mid = Math.floor((start + end) / 2);
+            // Check if the mid value is greater than, equal to, or less than search element.
+            const ordering = compareFunction(array[mid], element);
+            // If element is present at mid, start iterating for searching first appearance.
+            if (ordering === 0) {
+                // Linear reverse iteration until the first matching item index is found.
+                for (let i = mid - 1; i >= 0; i--) {
+                    if (compareFunction(array[i], element) === 0)
+                        continue;
+                    return i + 1;
+                }
+                return 0;
+            } /* Else look in left or right half accordingly */
+            else if (ordering < 0) {
+                start = mid + 1;
+            }
+            else {
+                end = mid - 1;
+            }
+        }
+        return -1;
+    }
+    /**
+     * binarySearch
+     * @desc Returns the first index of which given item is found in array using binary search.
+     * @param {Buffer[]} array - Array of items.
+     * @param {Buffer} element - Item to find.
+     * @param {Function} compareFunction
+     * @return {Number} - Index number
+     *
+     * @example
+     * ```js
+     *const index = tree.binarySearch(array, element, Buffer.compare)
+     *```
+     */
+    binarySearch(array, element, compareFunction) {
+        return Base.binarySearch(array, element, compareFunction);
+    }
+    /**
+     * linearSearch
+     * @desc Returns the first index of which given item is found in array using linear search.
+     * @param {Buffer[]} array - Array of items.
+     * @param {Buffer} element - Item to find.
+     * @param {Function} eqChecker
+     * @return {Number} - Index number
+     *
+     * @example
+     * ```js
+     *const index = MerkleTree.linearSearch(array, element, (a, b) => a === b)
+     *```
+     */
+    static linearSearch(array, element, eqChecker) {
+        for (let i = 0; i < array.length; i++) {
+            if (eqChecker(array[i], element)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /**
+     * linearSearch
+     * @desc Returns the first index of which given item is found in array using linear search.
+     * @param {Buffer[]} array - Array of items.
+     * @param {Buffer} element - Item to find.
+     * @param {Function} eqChecker
+     * @return {Number} - Index number
+     *
+     * @example
+     * ```js
+     *const index = tree.linearSearch(array, element, (a, b) => a === b)
+     *```
+     */
+    linearSearch(array, element, eqChecker) {
+        return Base.linearSearch(array, element, eqChecker);
+    }
+    /**
+     * bufferify
+     * @desc Returns a buffer type for the given value.
+     * @param {String|Number|Object|Buffer|ArrayBuffer} value
+     * @return {Buffer}
+     *
+     * @example
+     * ```js
+     *const buf = MerkleTree.bufferify('0x1234')
+     *```
+     */
+    static bufferify(value) {
+        if (!buffer_1.Buffer.isBuffer(value)) {
+            // crypto-js support
+            if (typeof value === 'object' && value.words) {
+                return buffer_1.Buffer.from(value.toString(crypto_js_1.default.enc.Hex), 'hex');
+            }
+            else if (Base.isHexString(value)) {
+                const hexString = value.replace('0x', '');
+                const paddedHexString = hexString.length % 2 ? '0' + hexString : hexString;
+                return buffer_1.Buffer.from(paddedHexString, 'hex');
+            }
+            else if (typeof value === 'string') {
+                return buffer_1.Buffer.from(value);
+            }
+            else if (typeof value === 'bigint') {
+                const hexString = value.toString(16).length % 2 ? '0' + value.toString(16) : value.toString(16);
+                return buffer_1.Buffer.from(hexString, 'hex');
+            }
+            else if (value instanceof Uint8Array) {
+                return buffer_1.Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+            }
+            else if (typeof value === 'number') {
+                let s = value.toString();
+                if (s.length % 2) {
+                    s = `0${s}`;
+                }
+                return buffer_1.Buffer.from(s, 'hex');
+            }
+            else if (ArrayBuffer.isView(value)) {
+                return buffer_1.Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+            }
+        }
+        return value;
+    }
+    /**
+     * bufferifyFn
+     * @desc Returns a function that will bufferify the return value.
+     * @param {Function}
+     * @return {Function}
+     *
+     * @example
+     * ```js
+     *const fn = MerkleTree.bufferifyFn((value) => sha256(value))
+     *```
+     */
+    static bufferifyFn(f) {
+        if (typeof f !== 'function') {
+            throw new Error(`bufferifyFn expects a function, received: ${typeof f}`);
+        }
+        return (value) => {
+            const v = f(value);
+            if (buffer_1.Buffer.isBuffer(v)) {
+                return v;
+            }
+            if (Base.isHexString(v)) {
+                const hexString = v.replace('0x', '');
+                const paddedHexString = hexString.length % 2 ? '0' + hexString : hexString;
+                return buffer_1.Buffer.from(paddedHexString, 'hex');
+            }
+            if (typeof v === 'string') {
+                return buffer_1.Buffer.from(v);
+            }
+            if (typeof v === 'bigint') {
+                const hexString = v.toString(16).length % 2 ? '0' + v.toString(16) : v.toString(16);
+                return buffer_1.Buffer.from(hexString, 'hex');
+            }
+            if (ArrayBuffer.isView(v)) {
+                return buffer_1.Buffer.from(v.buffer, v.byteOffset, v.byteLength);
+            }
+            // crypto-js support
+            return buffer_1.Buffer.from(f(crypto_js_1.default.enc.Hex.parse(value.toString('hex'))).toString(crypto_js_1.default.enc.Hex), 'hex');
+        };
+    }
+    bigNumberify(value) {
+        return Base.bigNumberify(value);
+    }
+    static bigNumberify(value) {
+        if (typeof value === 'bigint') {
+            return value;
+        }
+        if (typeof value === 'string') {
+            if (value.startsWith('0x') && Base.isHexString(value)) {
+                // Remove '0x' and ensure even-length hex string
+                const hexString = value.replace('0x', '');
+                const paddedHexString = hexString.length % 2 ? '0' + hexString : (hexString || '0');
+                return BigInt('0x' + paddedHexString);
+            }
+            return BigInt(value);
+        }
+        if (buffer_1.Buffer.isBuffer(value)) {
+            // Convert buffer to hex string and ensure even-length hex string
+            const hexString = value.toString('hex');
+            const paddedHexString = hexString.length % 2 ? '0' + hexString : (hexString || '0');
+            return BigInt('0x' + paddedHexString);
+        }
+        if (value instanceof Uint8Array) {
+            // Convert Uint8Array to hex string and ensure even-length hex string
+            const hexString = buffer_1.Buffer.from(value).toString('hex');
+            const paddedHexString = hexString.length % 2 ? '0' + hexString : (hexString || '0');
+            return BigInt('0x' + paddedHexString);
+        }
+        if (typeof value === 'number') {
+            return BigInt(value);
+        }
+        throw new Error('cannot bigNumberify');
+    }
+    /**
+     * isHexString
+     * @desc Returns true if value is a hex string.
+     * @param {String} value
+     * @return {Boolean}
+     *
+     * @example
+     * ```js
+     *console.log(MerkleTree.isHexString('0x1234'))
+     *```
+     */
+    static isHexString(v) {
+        return typeof v === 'string' && /^(0x)?[0-9A-Fa-f]*$/.test(v);
+    }
+    /**
+     * print
+     * @desc Prints out a visual representation of the given merkle tree.
+     * @param {Object} tree - Merkle tree instance.
+     * @return {String}
+     * @example
+     *```js
+     *MerkleTree.print(tree)
+     *```
+     */
+    static print(tree) {
+        console.log(tree.toString());
+    }
+    /**
+     * bufferToHex
+     * @desc Returns a hex string with 0x prefix for given buffer.
+     * @param {Buffer} value
+     * @return {String}
+     * @example
+     *```js
+     *const hexStr = tree.bufferToHex(Buffer.from('A'))
+     *```
+     */
+    bufferToHex(value, withPrefix = true) {
+        return Base.bufferToHex(value, withPrefix);
+    }
+    /**
+     * bufferToHex
+     * @desc Returns a hex string with 0x prefix for given buffer.
+     * @param {Buffer} value
+     * @return {String}
+     * @example
+     *```js
+     *const hexStr = MerkleTree.bufferToHex(Buffer.from('A'))
+     *```
+     */
+    static bufferToHex(value, withPrefix = true) {
+        return `${withPrefix ? '0x' : ''}${(value || buffer_1.Buffer.alloc(0)).toString('hex')}`;
+    }
+    /**
+     * bufferify
+     * @desc Returns a buffer type for the given value.
+     * @param {String|Number|Object|Buffer} value
+     * @return {Buffer}
+     *
+     * @example
+     * ```js
+     *const buf = tree.bufferify('0x1234')
+     *```
+     */
+    bufferify(value) {
+        return Base.bufferify(value);
+    }
+    /**
+     * bufferifyFn
+     * @desc Returns a function that will bufferify the return value.
+     * @param {Function}
+     * @return {Function}
+     *
+     * @example
+     * ```js
+     *const fn = tree.bufferifyFn((value) => sha256(value))
+     *```
+     */
+    bufferifyFn(f) {
+        return Base.bufferifyFn(f);
+    }
+    /**
+     * isHexString
+     * @desc Returns true if value is a hex string.
+     * @param {String} value
+     * @return {Boolean}
+     *
+     * @example
+     * ```js
+     *console.log(MerkleTree.isHexString('0x1234'))
+     *```
+     */
+    isHexString(value) {
+        return Base.isHexString(value);
+    }
+    /**
+     * log2
+     * @desc Returns the log2 of number.
+     * @param {Number} value
+     * @return {Number}
+     */
+    log2(n) {
+        return n === 1 ? 0 : 1 + this.log2((n / 2) | 0);
+    }
+    /**
+     * zip
+     * @desc Returns true if value is a hex string.
+     * @param {String[]|Number[]|Buffer[]} a - first array
+     * @param {String[]|Number[]|Buffer[]} b -  second array
+     * @return {String[][]|Number[][]|Buffer[][]}
+     *
+     * @example
+     * ```js
+     *const zipped = tree.zip(['a', 'b'],['A', 'B'])
+     *console.log(zipped) // [ [ 'a', 'A' ], [ 'b', 'B' ] ]
+     *```
+     */
+    zip(a, b) {
+        return a.map((e, i) => [e, b[i]]);
+    }
+    static hexZeroPad(hexStr, length) {
+        return '0x' + hexStr.replace('0x', '').padStart(length, '0');
+    }
+    bufferArrayIncludes(bufferArray, targetBuffer) {
+        return bufferArray.some(buffer => buffer.equals(targetBuffer !== null && targetBuffer !== void 0 ? targetBuffer : buffer_1.Buffer.alloc(0)));
+    }
+}
+exports.Base = Base;
+exports.default = Base;

package/dist/IncrementalMerkleTree.d.ts

@@ -0,0 +1,36 @@
+import Base from './Base';
+export interface Options {
+    depth?: number;
+    arity?: number;
+    zeroValue?: any;
+}
+export declare class IncrementalMerkleTree extends Base {
+    private depth?;
+    private arity?;
+    private zeroes?;
+    private root?;
+    private nodes?;
+    private hashFn;
+    private zeroValue;
+    constructor(hashFn: any, options: Options);
+    getRoot(): any;
+    getHexRoot(): string;
+    insert(leaf: any): void;
+    delete(index: number): void;
+    update(index: number, newLeaf: any): void;
+    getDepth(): number;
+    getArity(): number;
+    getMaxLeaves(): number;
+    indexOf(leaf: any): number;
+    getLeaves(): bigint[];
+    copyList(list: any[]): bigint[];
+    getLayers(): any[];
+    getHexLayers(): string[];
+    getLayersAsObject(): any;
+    computeRoot(): any;
+    getProof(index: number): any;
+    verify(proof: any): boolean;
+    toString(): string;
+    protected toTreeString(): string;
+}
+export default IncrementalMerkleTree;

package/dist/IncrementalMerkleTree.js

@@ -0,0 +1,252 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncrementalMerkleTree = void 0;
+const Base_1 = __importDefault(require("./Base"));
+const treeify_1 = __importDefault(require("treeify"));
+class IncrementalMerkleTree extends Base_1.default {
+    constructor(hashFn, options) {
+        super();
+        this.hashFn = hashFn;
+        if (options.depth) {
+            this.depth = options.depth;
+        }
+        if (options.arity) {
+            this.arity = options.arity;
+        }
+        if (this.depth < 1) {
+            throw new Error('depth must be greater than 0');
+        }
+        if (this.arity < 1) {
+            throw new Error('arity must be greater than 0');
+        }
+        const nodes = [];
+        let zeroValue = options.zeroValue;
+        this.zeroValue = zeroValue;
+        this.zeroes = [];
+        if (this.depth) {
+            for (let i = 0; i < this.depth; i++) {
+                this.zeroes.push(zeroValue);
+                nodes[i] = [];
+                zeroValue = this.hashFn(Array(this.arity).fill(zeroValue));
+            }
+        }
+        this.nodes = nodes;
+        this.root = zeroValue;
+    }
+    getRoot() {
+        return this.root;
+    }
+    getHexRoot() {
+        return this.bufferToHex(this.bufferify(this.getRoot()));
+    }
+    insert(leaf) {
+        if (this.depth && this.arity) {
+            if (this.nodes[0].length >= this.getMaxLeaves()) {
+                throw new Error('tree is full');
+            }
+        }
+        let node = leaf;
+        let index = this.nodes[0].length;
+        for (let level = 0; level < this.depth; level += 1) {
+            const position = index % this.arity;
+            const levelStartIndex = index - position;
+            const levelEndIndex = levelStartIndex + this.arity;
+            const children = [];
+            this.nodes[level][index] = node;
+            for (let i = levelStartIndex; i < levelEndIndex; i += 1) {
+                if (i < this.nodes[level].length) {
+                    children.push(this.nodes[level][i]);
+                }
+                else {
+                    children.push(this.zeroes[level]);
+                }
+            }
+            node = this.hashFn(children);
+            index = Math.floor(index / this.arity);
+        }
+        this.root = node;
+    }
+    delete(index) {
+        this.update(index, this.zeroValue);
+    }
+    update(index, newLeaf) {
+        if (index < 0 || index >= this.nodes[0].length) {
+            throw new Error('out of bounds');
+        }
+        let node = newLeaf;
+        for (let level = 0; level < this.depth; level += 1) {
+            const position = index % this.arity;
+            const levelStartIndex = index - position;
+            const levelEndIndex = levelStartIndex + this.arity;
+            const children = [];
+            this.nodes[level][index] = node;
+            for (let i = levelStartIndex; i < levelEndIndex; i += 1) {
+                if (i < this.nodes[level].length) {
+                    children.push(this.nodes[level][i]);
+                }
+                else {
+                    children.push(this.zeroes[level]);
+                }
+            }
+            node = this.hashFn(children);
+            index = Math.floor(index / this.arity);
+        }
+        this.root = node;
+    }
+    getDepth() {
+        return this.depth;
+    }
+    getArity() {
+        return this.arity;
+    }
+    getMaxLeaves() {
+        return Math.pow(this.depth, this.arity);
+    }
+    indexOf(leaf) {
+        return this.nodes[0].indexOf(leaf);
+    }
+    getLeaves() {
+        const leaves = this.copyList(this.nodes[0]);
+        const index = this.nodes[0].length;
+        for (let i = index; i < this.getMaxLeaves(); i++) {
+            leaves[i] = this.zeroValue;
+        }
+        return leaves;
+    }
+    copyList(list) {
+        return list.map((x) => BigInt(x));
+    }
+    getLayers() {
+        const layers = [];
+        for (const list of this.nodes) {
+            layers.push(this.copyList(list));
+        }
+        if (layers[0].length < this.getMaxLeaves()) {
+            let index = layers[0].length;
+            for (let i = index; i < this.getMaxLeaves(); i++) {
+                layers[0][i] = this.zeroValue;
+            }
+            for (let level = 0; level < this.depth; level++) {
+                const position = index % this.arity;
+                const levelStartIndex = index - position;
+                const levelEndIndex = levelStartIndex + this.arity;
+                for (let i = levelStartIndex; i < levelEndIndex; i++) {
+                    if (i >= layers[level].length) {
+                        layers[level][i] = this.zeroes[level];
+                    }
+                }
+                index = Math.floor(index / this.arity);
+            }
+        }
+        layers.push([this.root]);
+        return layers;
+    }
+    getHexLayers() {
+        return this.getLayers().reduce((acc, item) => {
+            if (Array.isArray(item)) {
+                acc.push(item.map(layer => this.bufferToHex(this.bufferify(layer))));
+            }
+            else {
+                acc.push(item);
+            }
+            return acc;
+        }, []);
+    }
+    getLayersAsObject() {
+        const layers = this.getLayers().map((layer) => layer.map((value) => this.bufferToHex(this.bufferify(value), false)));
+        const objs = [];
+        for (let i = 0; i < layers.length; i++) {
+            const arr = [];
+            for (let j = 0; j < layers[i].length; j++) {
+                const obj = { [layers[i][j]]: null };
+                if (objs.length) {
+                    obj[layers[i][j]] = {};
+                    const a = objs.shift();
+                    const akey = Object.keys(a)[0];
+                    obj[layers[i][j]][akey] = a[akey];
+                    if (objs.length) {
+                        const b = objs.shift();
+                        const bkey = Object.keys(b)[0];
+                        obj[layers[i][j]][bkey] = b[bkey];
+                    }
+                }
+                arr.push(obj);
+            }
+            objs.push(...arr);
+        }
+        return objs[0];
+    }
+    computeRoot() {
+        let node;
+        let index = this.nodes[0].length;
+        for (let level = 0; level < this.depth; level += 1) {
+            const position = index % this.arity;
+            const levelStartIndex = index - position;
+            const levelEndIndex = levelStartIndex + this.arity;
+            const children = [];
+            for (let i = levelStartIndex; i < levelEndIndex; i += 1) {
+                if (i < this.nodes[level].length) {
+                    children.push(this.nodes[level][i]);
+                }
+                else {
+                    children.push(this.zeroes[level]);
+                }
+            }
+            node = this.hashFn(children);
+            index = Math.floor(index / this.arity);
+        }
+        return node;
+    }
+    getProof(index) {
+        if (index < 0 || index >= this.nodes[0].length) {
+            throw new Error('The leaf does not exist in this tree');
+        }
+        const siblings = [];
+        const pathIndices = [];
+        const leafIndex = index;
+        for (let level = 0; level < this.depth; level += 1) {
+            const position = index % this.arity;
+            const levelStartIndex = index - position;
+            const levelEndIndex = levelStartIndex + this.arity;
+            pathIndices[level] = position;
+            siblings[level] = [];
+            for (let i = levelStartIndex; i < levelEndIndex; i += 1) {
+                if (i !== index) {
+                    if (i < this.nodes[level].length) {
+                        siblings[level].push(this.nodes[level][i]);
+                    }
+                    else {
+                        siblings[level].push(this.zeroes[level]);
+                    }
+                }
+            }
+            index = Math.floor(index / this.arity);
+        }
+        return { root: this.root, leaf: this.nodes[0][leafIndex], pathIndices, siblings };
+    }
+    verify(proof) {
+        let node = proof.leaf;
+        for (let i = 0; i < proof.siblings.length; i += 1) {
+            const children = proof.siblings[i].slice();
+            children.splice(proof.pathIndices[i], 0, node);
+            node = this.hashFn(children);
+        }
+        return proof.root === node;
+    }
+    toString() {
+        return this.toTreeString();
+    }
+    toTreeString() {
+        const obj = this.getLayersAsObject();
+        return treeify_1.default.asTree(obj, true);
+    }
+}
+exports.IncrementalMerkleTree = IncrementalMerkleTree;
+if (typeof window !== 'undefined') {
+    ;
+    window.IncrementalMerkleTree = IncrementalMerkleTree;
+}
+exports.default = IncrementalMerkleTree;