Remove merkleTree.js in favor of merkletreejs dependency (#2578)

test/helpers/merkleTree.js

@@ -1,135 +0,0 @@
-const { keccak256, keccakFromString, bufferToHex } = require('ethereumjs-util');
-
-class MerkleTree {
-  constructor (elements) {
-    // Filter empty strings and hash elements
-    this.elements = elements.filter(el => el).map(el => keccakFromString(el));
-
-    // Sort elements
-    this.elements.sort(Buffer.compare);
-    // Deduplicate elements
-    this.elements = this.bufDedup(this.elements);
-
-    // Create layers
-    this.layers = this.getLayers(this.elements);
-  }
-
-  getLayers (elements) {
-    if (elements.length === 0) {
-      return [['']];
-    }
-
-    const layers = [];
-    layers.push(elements);
-
-    // Get next layer until we reach the root
-    while (layers[layers.length - 1].length > 1) {
-      layers.push(this.getNextLayer(layers[layers.length - 1]));
-    }
-
-    return layers;
-  }
-
-  getNextLayer (elements) {
-    return elements.reduce((layer, el, idx, arr) => {
-      if (idx % 2 === 0) {
-        // Hash the current element with its pair element
-        layer.push(this.combinedHash(el, arr[idx + 1]));
-      }
-
-      return layer;
-    }, []);
-  }
-
-  combinedHash (first, second) {
-    if (!first) { return second; }
-    if (!second) { return first; }
-
-    return keccak256(this.sortAndConcat(first, second));
-  }
-
-  getRoot () {
-    return this.layers[this.layers.length - 1][0];
-  }
-
-  getHexRoot () {
-    return bufferToHex(this.getRoot());
-  }
-
-  getProof (el) {
-    let idx = this.bufIndexOf(el, this.elements);
-
-    if (idx === -1) {
-      throw new Error('Element does not exist in Merkle tree');
-    }
-
-    return this.layers.reduce((proof, layer) => {
-      const pairElement = this.getPairElement(idx, layer);
-
-      if (pairElement) {
-        proof.push(pairElement);
-      }
-
-      idx = Math.floor(idx / 2);
-
-      return proof;
-    }, []);
-  }
-
-  getHexProof (el) {
-    const proof = this.getProof(el);
-
-    return this.bufArrToHexArr(proof);
-  }
-
-  getPairElement (idx, layer) {
-    const pairIdx = idx % 2 === 0 ? idx + 1 : idx - 1;
-
-    if (pairIdx < layer.length) {
-      return layer[pairIdx];
-    } else {
-      return null;
-    }
-  }
-
-  bufIndexOf (el, arr) {
-    let hash;
-
-    // Convert element to 32 byte hash if it is not one already
-    if (el.length !== 32 || !Buffer.isBuffer(el)) {
-      hash = keccakFromString(el);
-    } else {
-      hash = el;
-    }
-
-    for (let i = 0; i < arr.length; i++) {
-      if (hash.equals(arr[i])) {
-        return i;
-      }
-    }
-
-    return -1;
-  }
-
-  bufDedup (elements) {
-    return elements.filter((el, idx) => {
-      return idx === 0 || !elements[idx - 1].equals(el);
-    });
-  }
-
-  bufArrToHexArr (arr) {
-    if (arr.some(el => !Buffer.isBuffer(el))) {
-      throw new Error('Array is not an array of buffers');
-    }
-
-    return arr.map(el => '0x' + el.toString('hex'));
-  }
-
-  sortAndConcat (...args) {
-    return Buffer.concat([...args].sort(Buffer.compare));
-  }
-}
-
-module.exports = {
-  MerkleTree,
-};

test/utils/cryptography/MerkleProof.test.js

@@ -1,7 +1,7 @@
 require('@openzeppelin/test-helpers');
 
-const { MerkleTree } = require('../../helpers/merkleTree.js');
-const { keccakFromString, bufferToHex } = require('ethereumjs-util');
+const { MerkleTree } = require('merkletreejs');
+const keccak256 = require('keccak256');
 
 const { expect } = require('chai');
 
@@ -15,43 +15,43 @@ contract('MerkleProof', function (accounts) {
   describe('verify', function () {
     it('returns true for a valid Merkle proof', async function () {
       const elements = ['a', 'b', 'c', 'd'];
-      const merkleTree = new MerkleTree(elements);
+      const merkleTree = new MerkleTree(elements, keccak256, { hashLeaves: true });
 
       const root = merkleTree.getHexRoot();
 
-      const proof = merkleTree.getHexProof(elements[0]);
+      const leaf = keccak256(elements[0]);
 
-      const leaf = bufferToHex(keccakFromString(elements[0]));
+      const proof = merkleTree.getHexProof(leaf);
 
       expect(await this.merkleProof.verify(proof, root, leaf)).to.equal(true);
     });
 
     it('returns false for an invalid Merkle proof', async function () {
       const correctElements = ['a', 'b', 'c'];
-      const correctMerkleTree = new MerkleTree(correctElements);
+      const correctMerkleTree = new MerkleTree(correctElements, keccak256, { hashLeaves: true });
 
       const correctRoot = correctMerkleTree.getHexRoot();
 
-      const correctLeaf = bufferToHex(keccakFromString(correctElements[0]));
+      const correctLeaf = keccak256(correctElements[0]);
 
       const badElements = ['d', 'e', 'f'];
       const badMerkleTree = new MerkleTree(badElements);
 
-      const badProof = badMerkleTree.getHexProof(badElements[0]);
+      const badProof = badMerkleTree.getHexProof(badElements[0], keccak256, { hashLeaves: true });
 
       expect(await this.merkleProof.verify(badProof, correctRoot, correctLeaf)).to.equal(false);
     });
 
     it('returns false for a Merkle proof of invalid length', async function () {
       const elements = ['a', 'b', 'c'];
-      const merkleTree = new MerkleTree(elements);
+      const merkleTree = new MerkleTree(elements, keccak256, { hashLeaves: true });
 
       const root = merkleTree.getHexRoot();
 
-      const proof = merkleTree.getHexProof(elements[0]);
-      const badProof = proof.slice(0, proof.length - 5);
+      const leaf = keccak256(elements[0]);
 
-      const leaf = bufferToHex(keccakFromString(elements[0]));
+      const proof = merkleTree.getHexProof(leaf);
+      const badProof = proof.slice(0, proof.length - 5);
 
       expect(await this.merkleProof.verify(badProof, root, leaf)).to.equal(false);
     });