1  const { MerkleTree } = require('../utils/merkleTree.js');
  2  const MerkleMultiProofWrapper = require('Embark/contracts/MerkleMultiProofWrapper');
  3  
  4  const merkleTreeSize = 4096;
  5  const leafsSize = 10;
  6  const fuzzyProofChecks = 10;
  7  
  8  const elementsA = Array.from({length: merkleTreeSize}, (v,k) => ""+k);
  9  const merkleTreeA = new MerkleTree(elementsA);
 10  const leafsA = merkleTreeA.getElements(Array.from({length: leafsSize}, (v,k) => ""+k));
 11  const proofA = merkleTreeA.getMultiProof(leafsA);
 12  const flagsA = merkleTreeA.getProofFlags(leafsA, proofA);
 13  
 14  const elementsB = Array.from({length: merkleTreeSize}, (v,k) => ""+k*2);
 15  const merkleTreeB = new MerkleTree(elementsB);
 16  const leafsB = merkleTreeB.getElements(Array.from({length: leafsSize}, (v,k) => ""+k*2))
 17  const proofB = merkleTreeB.getMultiProof(leafsB);
 18  const flagsB = merkleTreeB.getProofFlags(leafsB, proofB);
 19  
 20  config({
 21    contracts: {
 22      deploy: {
 23        "MerkleMultiProofWrapper": {
 24        
 25        }
 26      }
 27    }
 28  }, (_err, web3_accounts) => {
 29    accounts = web3_accounts;
 30  });
 31  
 32  contract('MultiMerkleProof', function () {
 33     
 34    describe('calculateMultiMerkleRoot', function () {
 35      it('display cost of deploy MerkleMultiProofWrapper', async function () {
 36        await MerkleMultiProofWrapper.methods.foo().send();
 37      });
 38  
 39      it('calculate merkle root from leafs, proofs and flags', async function () {
 40        const result = await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
 41          leafsA, 
 42          proofA, 
 43          flagsA
 44        ).call()
 45        const result2 = await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
 46          leafsB, 
 47          proofB, 
 48          flagsB
 49        ).call()
 50        assert(result == merkleTreeA.getHexRoot());
 51        assert(result2 == merkleTreeB.getHexRoot());
 52      });
 53      
 54      it('calculate wrong merkle root from wrong proofs and flags', async function () {
 55        var invalid = false;
 56        try {
 57          invalid = merkleTreeA.getHexRoot() != await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
 58            leafsA, 
 59            proofB, 
 60            flagsB
 61          ).call()
 62        } catch(e) {
 63          invalid = true;
 64        }
 65        assert(invalid);
 66  
 67        try {
 68          invalid = merkleTreeA.getHexRoot() != await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
 69            leafsA, 
 70            proofB, 
 71            flagsA
 72          ).call()
 73        } catch(e) {
 74          invalid = true;
 75        }
 76        assert(invalid);
 77        
 78        try {
 79          invalid = merkleTreeB.getHexRoot() != await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
 80            leafsB, 
 81            proofA, 
 82            flagsB
 83          ).call();
 84        } catch(e) {
 85          invalid = true;
 86        }
 87  
 88        assert(invalid);
 89        try {
 90          invalid = merkleTreeB.getHexRoot() != await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
 91            leafsB, 
 92            proofA, 
 93            flagsA
 94          ).call() 
 95        } catch(e) {
 96          invalid = true;
 97        }
 98        assert(invalid);
 99      });
100    
101      it(`cost of calculate Tree A root for ${leafsA.length} leafs using ${proofA.length} proofs and ${flagsA.length} flags`, async function () {
102        await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
103          leafsA, 
104          proofA, 
105          flagsA,
106        ).send()
107      });
108  
109      it(`cost of calculate Tree B root for ${leafsB.length} leafs using ${proofB.length} proofs and ${flagsB.length} flags`, async function () {
110        await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
111          leafsB, 
112          proofB, 
113          flagsB,
114        ).send()
115      });
116  
117      it(`calculate ${fuzzyProofChecks} merkle root from leafs, proofs and flags (fuzzy)`, async function () {
118        this.timeout(500*fuzzyProofChecks);
119        for(let j = 0; j < fuzzyProofChecks; j++){
120          const leafsFuzzy = merkleTreeA.getElements(
121            Array.from({length: leafsSize}, () => elementsA[Math.floor(Math.random()*elementsA.length)] ).filter((value, index, self) => self.indexOf(value) === index)
122          );
123          const proofFuzzy = merkleTreeA.getMultiProof(leafsFuzzy);
124          const flagsFuzzy = merkleTreeA.getProofFlags(leafsFuzzy, proofFuzzy);
125          const result = await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
126            leafsFuzzy, 
127            proofFuzzy, 
128            flagsFuzzy
129          ).call();
130          assert(result == merkleTreeA.getHexRoot());
131        }
132      });
133  
134      it(`calculate ${fuzzyProofChecks} wrong merkle root from wrong proofs and flags (fuzzy)`, async function () {
135        this.timeout(500*fuzzyProofChecks);
136        for(let j = 0; j < fuzzyProofChecks; j++){
137          const leafsFuzzy = merkleTreeB.getElements(
138            Array.from({length: leafsSize}, () => elementsB[Math.floor(Math.random()*elementsB.length)] ).filter((value, index, self) => self.indexOf(value) === index)
139          );
140          const proofFuzzy = merkleTreeB.getMultiProof(leafsFuzzy);
141          const flagsFuzzy = merkleTreeB.getProofFlags(leafsFuzzy, proofFuzzy);
142          var invalid = false;
143          try {
144            invalid = merkleTreeA.getHexRoot() != await MerkleMultiProofWrapper.methods.calculateMultiMerkleRoot(
145              leafsFuzzy, 
146              proofFuzzy, 
147              flagsFuzzy
148            ).call();
149          } catch(e) {
150            invalid = true;
151          }
152          assert(invalid);
153        }
154      });
155    });
156  });