remove mimc and snarkjs dependency

(cherry picked from commit c83a4a4dc0)

package.json

@@ -1,7 +1,8 @@
 {
   "name": "fixed-merkle-tree",
-  "version": "0.5.1",
+  "version": "1.0.0",
   "description": "Fixed depth merkle tree implementation with sequential inserts",
+  "repository": "https://github.com/tornadocash/fixed-merkle-tree.git",
   "main": "src/merkleTree.js",
   "scripts": {
     "test": "mocha",
@@ -17,10 +18,6 @@
   "files": [
     "src/*"
   ],
-  "dependencies": {
-    "snarkjs": "git+https://github.com/tornadocash/snarkjs.git#869181cfaf7526fe8972073d31655493a04326d5",
-    "circomlib": "git+https://github.com/tornadocash/circomlib.git#5beb6aee94923052faeecea40135d45b6ce6172c"
-  },
   "devDependencies": {
     "babel-eslint": "^10.1.0",
     "chai": "^4.2.0",

src/merkleTree.js

@@ -1,9 +1,5 @@
-// keccak256("tornado") % BN254_FIELD_SIZE
-const DEFAULT_ZERO = '21663839004416932945382355908790599225266501822907911457504978515578255421292'
-const defaultHash = require('./mimc')
-
+const defaultHash = require('./sha256')
 // todo ensure consistent types in tree and inserted elements?
-// todo make sha3 default hasher (and update tests) to get rid of mimc/snarkjs/circomlib dependency
 
 /**
  * @callback hashFunction
@@ -22,22 +18,21 @@ class MerkleTree {
    * @param {hashFunction} [options.hashFunction] Function used to hash 2 leaves
    * @param [options.zeroElement] Value for non-existent leaves
    */
-  constructor(levels, elements = [], { hashFunction, zeroElement = DEFAULT_ZERO } = {}) {
+  constructor(levels, elements = [], { hashFunction, zeroElement = 0 } = {}) {
     this.levels = levels
     this.capacity = 2 ** levels
-    this.zeroElement = zeroElement
-    this._hash = hashFunction || defaultHash
     if (elements.length > this.capacity) {
       throw new Error('Tree is full')
     }
-
+    this._hash = hashFunction || defaultHash
+    this.zeroElement = zeroElement
     this._zeros = []
-    this._layers = []
-    this._layers[0] = elements
-    this._zeros[0] = this.zeroElement
+    this._zeros[0] = zeroElement
     for (let i = 1; i <= levels; i++) {
       this._zeros[i] = this._hash(this._zeros[i - 1], this._zeros[i - 1])
     }
+    this._layers = []
+    this._layers[0] = elements.slice()
     this._rebuild()
   }
 
@@ -75,15 +70,30 @@ class MerkleTree {
   }
 
   /**
-   * Insert multiple elements into the tree. Tree will be fully rebuilt during this operation.
+   * Insert multiple elements into the tree.
    * @param {Array} elements Elements to insert
    */
   bulkInsert(elements) {
     if (this._layers[0].length + elements.length > this.capacity) {
       throw new Error('Tree is full')
     }
-    this._layers[0].push(...elements)
-    this._rebuild()
+    // First we insert all elements except the last one
+    // updating only full subtree hashes (all layers where inserted element has odd index)
+    // the last element will update the full path to the root making the tree consistent again
+    for (let i = 0; i < elements.length - 1; i++) {
+      this._layers[0].push(elements[i])
+      let level = 0
+      let index = this._layers[0].length - 1
+      while (index % 2 === 1) {
+        level++
+        index >>= 1
+        this._layers[level][index] = this._hash(
+          this._layers[level - 1][index * 2],
+          this._layers[level - 1][index * 2 + 1],
+        )
+      }
+    }
+    this.insert(elements[elements.length - 1])
   }
 
   /**
@@ -152,6 +162,14 @@ class MerkleTree {
     return this._layers[0].slice()
   }
 
+  /**
+   * Returns a copy of n-th zero elements array
+   * @returns {Object[]}
+   */
+  zeros() {
+    return this._zeros.slice()
+  }
+
   /**
    * Serialize entire tree state including intermediate layers into a plain object
    * Deserializing it back will not require to recompute any hashes

src/mimc.js

@@ -1,3 +0,0 @@
-const { mimcsponge } = require('circomlib')
-const { bigInt } = require('snarkjs')
-module.exports = (left, right) => mimcsponge.multiHash([bigInt(left), bigInt(right)]).toString()

src/sha256.js

@@ -0,0 +1,15 @@
+const crypto = require('crypto')
+
+function toBuffer256(number) {
+  return Buffer.from(number.toString(16).padStart(512, '0'), 'hex')
+}
+
+function sha256(left, right) {
+  return crypto
+    .createHash('sha256')
+    .update(toBuffer256(left))
+    .update(toBuffer256(right))
+    .digest('hex')
+}
+
+module.exports = sha256

test/merkleTree.test.js

@@ -71,6 +71,32 @@ describe('MerkleTree', () => {
       tree.root().should.equal('10132905325673518287563057607527946096399700874345297651940963130460267058606')
     })
 
+    it('should give the same result as sequental inserts', () => {
+      const initialArray = [
+        [1],
+        [1, 2],
+        [1, 2, 3],
+        [1, 2, 3, 4],
+      ]
+      const insertedArray = [
+        [11],
+        [11, 12],
+        [11, 12, 13],
+        [11, 12, 13, 14],
+      ]
+      for (const initial of initialArray) {
+        for (const inserted of insertedArray) {
+          const tree1 = new MerkleTree(10, initial)
+          const tree2 = new MerkleTree(10, initial)
+          tree1.bulkInsert(inserted)
+          for (const item of inserted) {
+            tree2.insert(item)
+          }
+          tree1.root().should.equal(tree2.root())
+        }
+      }
+    }).timeout(10000)
+
     it('should work with max elements', () => {
       const tree = new MerkleTree(2, [1, 2])
       tree.bulkInsert([3, 4])