Merge pull request #36 from iden3/feauture/proof-json

Feauture/proof json

Author: vmidyllic

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@iden3/js-merkletree",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "javascript sparse merkle tree library",
   "typings": "dist/types/index.d.ts",
   "main": "dist/node/cjs/index.js",

package.json

@@ -54,54 +54,72 @@ export class Hash implements IHash {
     const bytes = swapEndianness(this.value);
     return BigInt(bytes2BinaryString(bytes));
   }
-}
-
-export const ZERO_HASH = new Hash();
 
-// returned bytes endianess will be big-endian
-export const newHashFromBigInt = (bigNum: bigint): Hash => {
-  if (!checkBigIntInField(bigNum)) {
-    throw 'NewBigIntFromHashBytes: Value not inside the Finite Field';
+  static fromString(s: string): Hash {
+    try {
+      return Hash.fromBigInt(BigInt(s));
+    } catch (e) {
+      const deserializedHash = JSON.parse(s);
+      const bytes = Uint8Array.from(Object.values(deserializedHash.bytes));
+      return new Hash(bytes);
+    }
   }
+  static fromBigInt(i: bigint): Hash {
+    if (!checkBigIntInField(i)) {
+      throw new Error('NewBigIntFromHashBytes: Value not inside the Finite Field')
+    }
 
-  const bytes = bigIntToUINT8Array(bigNum);
+    const bytes = bigIntToUINT8Array(i);
 
-  const hash = new Hash();
-  hash.value = bytes;
-  return hash;
-};
+    return new Hash(swapEndianness(bytes));
+  }
 
-export const newHashFromHex = (h: string): Hash => {
-  if (!h) {
-    return ZERO_HASH;
+  static fromHex(h: string | undefined): Hash {
+    if (!h) {
+      return ZERO_HASH;
+    }
+    return new Hash(Hex.decodeString(h));
   }
 
-  // TODO: add in field check
+  toJSON() {
+    return this.string();
+  }
+}
 
-  const hash = new Hash();
-  hash.value = swapEndianness(Hex.decodeString(h));
-  return hash;
-};
+export const ZERO_HASH = new Hash();
 
-// return object of class Hash from a decimal string
-export const newHashFromString = (decimalString: string): Hash => {
-  const bigNum = BigInt(decimalString);
+/**
+ * @deprecated The method should not be used and will be removed in the next major version,
+ * please use Hash.fromBigInt instead
+ */
+export const newHashFromBigInt = (bigNum: bigint): Hash => {
+  return Hash.fromBigInt(bigNum);
+};
 
-  if (!checkBigIntInField(bigNum)) {
-    throw 'NewBigIntFromHashBytes: Value not inside the Finite Field';
-  }
+/**
+ * @deprecated The method should not be used and will be removed in the next major version,
+ * please use Hash.fromBigInt instead
+ */
+export const newHashFromHex = (h: string): Hash => {
+  return Hash.fromHex(h);
+};
 
-  return newHashFromBigInt(bigNum);
+/**
+ * @deprecated The method should not be used and will be removed in the next major version,
+ * please use Hash.fromBigString instead
+ */
+export const newHashFromString = (decimalString: string): Hash => {
+  return Hash.fromString(decimalString);
 };
 
 export const hashElems = (e: Array<bigint>): Hash => {
   const hashBigInt = poseidon.hash(e);
-  return newHashFromBigInt(hashBigInt);
+  return Hash.fromBigInt(hashBigInt);
 };
 
 export const hashElemsKey = (k: bigint, e: Array<bigint>): Hash => {
   const hashBigInt = poseidon.hash([...e, k]);
-  return newHashFromBigInt(hashBigInt);
+  return Hash.fromBigInt(hashBigInt);
 };
 
 export const circomSiblingsFromSiblings = (siblings: Siblings, levels: number): Siblings => {

src/lib/hash/hash.ts

@@ -1,11 +1,11 @@
 import { ITreeStorage } from '../../types/storage';
-import { Hash, ZERO_HASH, circomSiblingsFromSiblings, newHashFromBigInt } from '../hash/hash';
+import { Hash, ZERO_HASH, circomSiblingsFromSiblings } from '../hash/hash';
 
 import { Node } from '../../types';
 import { NODE_TYPE_EMPTY, NODE_TYPE_LEAF, NODE_TYPE_MIDDLE } from '../../constants';
 import { NodeEmpty, NodeLeaf, NodeMiddle } from '../node/node';
-import { bytesEqual, getPath, setBitBigEndian } from '../utils';
-import { Siblings } from '../../types/merkletree';
+import { bytesEqual, getPath } from '../utils';
+import { NodeAux, Siblings } from '../../types/merkletree';
 import { checkBigIntInField } from '../utils/crypto';
 import { CircomProcessorProof, CircomVerifierProof } from './circom';
 import {
@@ -48,8 +48,8 @@ export class Merkletree {
     }
 
     this.#root = await this.root();
-    const kHash = newHashFromBigInt(k);
-    const vHash = newHashFromBigInt(v);
+    const kHash = Hash.fromBigInt(k);
+    const vHash = Hash.fromBigInt(v);
 
     const newNodeLeaf = new NodeLeaf(kHash, vHash);
     const path = getPath(this.maxLevels, kHash.value);
@@ -193,7 +193,7 @@ export class Merkletree {
   }
 
   async get(k: bigint): Promise<{ key: bigint; value: bigint; siblings: Siblings }> {
-    const kHash = newHashFromBigInt(k);
+    const kHash = Hash.fromBigInt(k);
     const path = getPath(this.maxLevels, kHash.value);
 
     let nextKey = await this.root();
@@ -254,8 +254,8 @@ export class Merkletree {
       throw 'key not inside the finite field';
     }
 
-    const kHash = newHashFromBigInt(k);
-    const vHash = newHashFromBigInt(v);
+    const kHash = Hash.fromBigInt(k);
+    const vHash = Hash.fromBigInt(v);
 
     const path = getPath(this.maxLevels, kHash.value);
 
@@ -352,7 +352,7 @@ export class Merkletree {
       throw ErrNotWritable;
     }
 
-    const kHash = newHashFromBigInt(k);
+    const kHash = Hash.fromBigInt(k);
     const path = getPath(this.maxLevels, kHash.value);
 
     let nextKey = this.#root;
@@ -442,8 +442,8 @@ export class Merkletree {
         break;
       case NODE_TYPE_MIDDLE:
         await f(n);
-        await this.walk((n as NodeMiddle).childL, f);
-        await this.walk((n as NodeMiddle).childR, f);
+        await this.recWalk((n as NodeMiddle).childL, f);
+        await this.recWalk((n as NodeMiddle).childR, f);
         break;
       default:
         throw ErrInvalidNodeFound;
@@ -454,7 +454,7 @@ export class Merkletree {
     if (bytesEqual(rootKey.value, ZERO_HASH.value)) {
       rootKey = await this.root();
     }
-    await this.walk(rootKey, f);
+    await this.recWalk(rootKey, f);
   }
 
   async generateCircomVerifierProof(k: bigint, rootKey: Hash): Promise<CircomVerifierProof> {
@@ -471,16 +471,16 @@ export class Merkletree {
     const { proof, value } = await this.generateProof(k, rootKey);
     const cp = new CircomVerifierProof();
     cp.root = rootKey;
-    cp.siblings = proof.siblings;
+    cp.siblings = proof.allSiblings();
     if (typeof proof.nodeAux !== 'undefined') {
       cp.oldKey = proof.nodeAux.key;
       cp.oldValue = proof.nodeAux.value;
     } else {
       cp.oldKey = ZERO_HASH;
       cp.oldValue = ZERO_HASH;
     }
-    cp.key = newHashFromBigInt(k);
-    cp.value = newHashFromBigInt(value);
+    cp.key = Hash.fromBigInt(k);
+    cp.value = Hash.fromBigInt(value);
 
     if (proof.existence) {
       cp.fnc = 0;
@@ -492,36 +492,62 @@ export class Merkletree {
   }
 
   async generateProof(k: bigint, rootKey?: Hash): Promise<{ proof: Proof; value: bigint }> {
-    const p = new Proof();
     let siblingKey: Hash;
 
-    const kHash = newHashFromBigInt(k);
+    const kHash = Hash.fromBigInt(k);
     const path = getPath(this.maxLevels, kHash.value);
     if (!rootKey) {
       rootKey = await this.root();
     }
     let nextKey = rootKey;
 
-    for (p.depth = 0; p.depth < this.maxLevels; p.depth += 1) {
+    let depth = 0;
+    let existence = false;
+    const siblings: Siblings = [];
+    let nodeAux: NodeAux | undefined;
+
+    for (depth = 0; depth < this.maxLevels; depth += 1) {
       const n = await this.getNode(nextKey);
       if (typeof n === 'undefined') {
         throw ErrNotFound;
       }
       switch (n.type) {
         case NODE_TYPE_EMPTY:
-          return { proof: p, value: BigInt('0') };
+          return {
+            proof: new Proof({
+              existence,
+              nodeAux,
+              siblings
+            }),
+            value: BigInt('0')
+          };
         case NODE_TYPE_LEAF:
           if (bytesEqual(kHash.value, (n as NodeLeaf).entry[0].value)) {
-            p.existence = true;
-            return { proof: p, value: (n as NodeLeaf).entry[1].bigInt() };
+            existence = true;
+
+            return {
+              proof: new Proof({
+                existence,
+                nodeAux,
+                siblings
+              }),
+              value: (n as NodeLeaf).entry[1].bigInt()
+            };
           }
-          p.nodeAux = {
+          nodeAux = {
             key: (n as NodeLeaf).entry[0],
             value: (n as NodeLeaf).entry[1]
           };
-          return { proof: p, value: (n as NodeLeaf).entry[1].bigInt() };
+          return {
+            proof: new Proof({
+              existence,
+              nodeAux,
+              siblings
+            }),
+            value: (n as NodeLeaf).entry[1].bigInt()
+          };
         case NODE_TYPE_MIDDLE:
-          if (path[p.depth]) {
+          if (path[depth]) {
             nextKey = (n as NodeMiddle).childR;
             siblingKey = (n as NodeMiddle).childL;
           } else {
@@ -532,11 +558,7 @@ export class Merkletree {
         default:
           throw ErrInvalidNodeFound;
       }
-
-      if (!bytesEqual(siblingKey.value, ZERO_HASH.value)) {
-        setBitBigEndian(p.notEmpties, p.depth);
-        p.siblings.push(siblingKey);
-      }
+      siblings.push(siblingKey);
     }
     throw ErrKeyNotFound;
   }
@@ -563,8 +585,8 @@ export class Merkletree {
       throw 'key/value undefined';
     }
 
-    cp.oldKey = newHashFromBigInt(key);
-    cp.oldValue = newHashFromBigInt(value);
+    cp.oldKey = Hash.fromBigInt(key);
+    cp.oldValue = Hash.fromBigInt(value);
 
     if (bytesEqual(cp.oldKey.value, ZERO_HASH.value)) {
       cp.isOld0 = true;
@@ -573,8 +595,8 @@ export class Merkletree {
     cp.siblings = circomSiblingsFromSiblings(siblings, this.maxLevels);
     await this.add(k, v);
 
-    cp.newKey = newHashFromBigInt(k);
-    cp.newValue = newHashFromBigInt(v);
+    cp.newKey = Hash.fromBigInt(k);
+    cp.newValue = Hash.fromBigInt(v);
     cp.newRoot = await this.root();
 
     return cp;