zkjson 0.1.6 → 0.1.8

package/circomlibjs.js

@@ -1,7 +1,7 @@
 "use strict"
 
 Object.defineProperty(exports, "__esModule", { value: true })
-
+const { splitEvery } = require("ramda")
 var ffjavascript = require("ffjavascript")
 var blake2b = require("blake2b")
 var createBlakeHash = require("blake-hash")
@@ -40201,9 +40201,18 @@ class SMT {
 
   async update(_key, _newValue) {
     const poseidon = await buildPoseidon()
+    let _hash_value = _newValue
+    if (_newValue.length === 256) {
+      _hash_value = []
+      for (let v of splitEvery(16, _newValue)) {
+        const poseidon = await buildPoseidon()
+        const value = poseidon(v)
+        _hash_value.push(value)
+      }
+    }
+    const newValue = poseidon(_hash_value)
     const F = this.F
     const key = F.e(_key)
-    const newValue = poseidon(_newValue)
     const resFind = await this.find(key)
     const res = {}
     res.oldRoot = this.root
@@ -40338,9 +40347,19 @@ class SMT {
 
   async insert(_key, _value) {
     const poseidon = await buildPoseidon()
+    let _hash_value = _value
+    if (_value.length === 256) {
+      _hash_value = []
+      for (let v of splitEvery(16, _value)) {
+        const poseidon = await buildPoseidon()
+        const value = poseidon(v)
+        _hash_value.push(value)
+      }
+    }
+
+    const value = poseidon(_hash_value)
     const F = this.F
     const key = F.e(_key)
-    const value = poseidon(_value)
     let addedOne = false
     const res = {}
     res.oldRoot = this.root

package/collection.js

@@ -3,11 +3,16 @@ const { pad, str2val, val2str, id2str, encode, str2id } = require("./encoder")
 const Doc = require("./doc")
 
 class Collection {
-  constructor({ size = 5, size_json = 16, level = 100 }) {
-    this.size = size
+  constructor({ size_val = 5, size_path = 5, size_json = 16, level = 100 }) {
+    this.size_val = size_val
+    this.size_path = size_path
     this.size_json = size_json
     this.level = level
-    this.doc = new Doc({ size: this.size, size_json: this.size_json })
+    this.doc = new Doc({
+      size_val: this.size_val,
+      size_path: this.size_path,
+      size_json: this.size_json,
+    })
   }
   async getInputs({ id, json, path, val }) {
     const doc_inputs = await this.doc.getInputs({ json, path, val })

package/contracts/ZKDB.sol

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+
+import "hardhat/console.sol";
+import "./ZKRollup.sol";
+
+interface VerifierDB {
+  function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[14] calldata _pubSignals) view external returns (bool);
+}
+
+contract ZKDB is ZKRollup {
+  uint constant public SIZE = 5;
+  address public verifierDB;
+  
+  constructor (address _verifierRU, address _verifierDB, address _comitter){
+    verifierRU = _verifierRU;
+    verifierDB = _verifierDB;
+    comitter = _comitter;
+  }
+  
+  function verify(uint[] calldata zkp) public view returns (bool) {
+    uint[SIZE * 2 + 4] memory sigs;
+    (
+       uint[2] memory _pA,
+       uint[2][2] memory _pB,
+       uint[2] memory _pC,
+       uint[] memory _sigs
+    ) = _parseZKP(zkp);
+    for(uint i = 0; i < sigs.length; i++) sigs[i] = _sigs[i];
+    require(VerifierDB(verifierDB).verifyProof(_pA, _pB, _pC, sigs), "invalid proof");
+    return true;
+  }
+
+  function validateQuery(uint[] memory path, uint[] calldata zkp) public view returns(uint[] memory){
+    verify(zkp);
+    return _validateQueryRU(path, zkp, SIZE);
+  }
+
+  function qInt (uint[] memory path, uint[] calldata zkp) public view returns (int) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qInt(value);
+  }
+
+  function qFloat (uint[] memory path, uint[] calldata zkp) public view returns (uint[3] memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qFloat(value);
+  }
+
+  function qRaw (uint[] memory path, uint[] calldata zkp) public view returns (uint[] memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qRaw(value);
+  }
+  
+  function qString (uint[] memory path, uint[] calldata zkp) public view returns (string memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qString(value);
+  }
+
+  function qBool (uint[] memory path, uint[] calldata zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qBool(value);
+  }
+  
+  function qNull (uint[] memory path, uint[] calldata zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qNull(value);
+  }
+
+}

package/contracts/ZKJson.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+import "hardhat/console.sol";
+import "./ZKQuery.sol";
+
+contract ZKJson is ZKQuery{
+
+  function _validateQueryJSON(uint[] memory path, uint[] calldata zkp, uint size) public pure returns(uint[] memory){
+    require(zkp[8] == 1, "value doesn't exist");
+    for(uint i = 10; i < 15; i++) require(path[i - 10] == zkp[i], "wrong path");
+    uint[] memory value = new uint[](size);
+    for(uint i = 15; i < 20; i++) value[i - 15] = zkp[i];
+    return toArr(value);
+  }
+
+}

package/contracts/ZKQuery.sol

@@ -0,0 +1,338 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+import "hardhat/console.sol";
+
+contract ZKQuery {
+
+  function digits (uint x) private pure returns(uint) {
+    uint p = 0;
+    while(x > 0){
+        x /= 10;
+        p++;
+    }
+    return p;
+  }
+
+  function getValLen(uint[] memory path, uint[] memory _json) private pure returns(uint, uint){
+    require (_json[0] == 4, "not raw value");
+    uint i = 1;
+    uint start;
+    uint[] memory path2 = toArr(path);
+    uint vallen;
+    while(i < _json.length){
+      start = i;
+      uint pathlen = getPathLen(i, _json);
+      uint[] memory _path = new uint[](pathlen);
+      uint len = _json[i];
+      i++;
+      _path[0] = len;
+      uint pi = 1;
+      for(uint i2=0;i2 < len; i2++){
+	uint plen = _json[i];
+	_path[pi] = plen;
+	pi++;
+	i++;
+	uint plen2 = plen;
+	if(plen == 0){
+	  plen2 = _json[i] == 0 ? 2 : 1;
+	}
+	for(uint i3 = 0; i3 < plen2; i3++){
+	  _path[pi] = _json[i];
+	  pi++;
+	  i++;
+	}
+      }
+      uint _type = _json[i];
+      i++;
+      uint vlen = 1;
+      if(_type == 1){
+	vlen++;
+	i++;
+      }else if (_type == 2){
+	vlen += 3;
+	i += 3;
+      }else if(_type == 3){
+	uint slen = _json[i];
+	vlen += slen + 1;
+	i += slen + 1;
+      }
+      uint path_match = 1;
+      if(pathlen != path2.length){
+	path_match = 0;
+      }else{
+	for(uint i4 = 0; i4 < path2.length; i4++){
+	  if(_path[i4] != path2[i4]) path_match = 0;
+	}
+      }
+      if(path_match == 1){
+	vallen = vlen;
+	break;
+      }
+    }
+    return (vallen, start);
+  }
+  
+  function getPathLen(uint i, uint[] memory _json) private pure returns(uint){
+    uint len = _json[i];
+    i++;
+    uint pi = 1;
+    for(uint i2=0;i2 < len; i2++){
+      uint plen = _json[i];
+      pi++;
+      i++;
+      uint plen2 = plen;
+      if(plen == 0) plen2 = _json[i] == 0 ? 2 : 1;
+      pi += plen2;
+      i += plen2;
+    }
+    return pi;
+  }
+  
+  function getVal(uint[] memory path, uint[] memory _json) private pure returns(uint[] memory){
+    require (_json[0] == 4, "not raw value");
+    (uint vallen, uint i) = getValLen(path, _json);
+    uint[] memory val = new uint[](vallen);
+    uint[] memory path2 = toArr(path);
+    while(i < _json.length){
+      uint pathlen = getPathLen(i, _json);
+      uint[] memory _path = new uint[](pathlen);
+      uint len = _json[i];
+      i++;
+      _path[0] = len;
+      uint pi = 1;
+      for(uint i2=0;i2 < len; i2++){
+	uint plen = _json[i];
+	_path[pi] = plen;
+	pi++;
+	i++;
+	uint plen2 = plen;
+	if(plen == 0){
+	  plen2 = _json[i] == 0 ? 2 : 1;
+	}
+	for(uint i3 = 0; i3 < plen2; i3++){
+	  _path[pi] = _json[i];
+	  pi++;
+	  i++;
+	}
+      }
+
+      uint _type = _json[i];
+      i++;
+      uint[] memory _val = new uint[](vallen);
+      _val[0] = _type;
+      if(_type == 1){
+	_val[1] = _json[i];
+	i++;
+      }else if (_type == 2){
+	_val[1] = _json[i];
+	i++;
+	_val[2] = _json[i];
+	i++;
+	_val[3] = _json[i];
+	i++;
+      }else if(_type == 3){
+	uint slen = _json[i];
+	_val[1] = slen;
+	i++;
+	for(uint i3 = 0;i3 < slen; i3++){
+	  _val[i3 + 2] = _json[i];
+	  i++;
+	}
+      }
+      uint path_match = 1;
+      if(pathlen != path2.length){
+	path_match = 0;
+      }else{
+	for(uint i4 = 0; i4 < path2.length; i4++){
+	  if(_path[i4] != path2[i4]) path_match = 0;
+	}
+      }
+      if(path_match == 1){
+	val = _val;
+	break;
+      }
+    }
+    return val;
+  }
+  
+  function getLen(uint[] memory json) private pure returns(uint, uint){
+    uint ji = 0;
+    uint prev = 0;
+    uint jlen = 0;
+    for(uint j = 0; j < json.length; j++){
+      if(json[j] > 0){
+	jlen = j + 1;
+	uint p = digits(json[j]);
+	uint x = json[j];
+	uint on = 0;
+	uint cur = 0;
+	uint len = 0;
+	uint num = 0;
+	uint is9 = 0;
+	while(p > 0){
+	  uint n = x / 10 ** (p - 1);
+	  if(on == 0 && n > 0){
+	    on = 1;
+	    if(n == 9){
+	      len = 8;
+	      is9 = 0;
+	    }else{
+	      len = n;
+	    }
+	    cur = 0;
+	  }else if(on == 1){
+	    num += n * 10 ** (len - cur - 1);
+	    cur++;
+	    if(cur == len){
+	      prev *= 10 ** len;
+	      if(is9 == 1){
+		prev += num;
+	      }else{
+		num += prev;
+		prev = 0;
+		ji++;
+	      }
+	      cur = 0;
+	      on = 0;
+	      len = 0;
+	      num = 0;
+	      is9 = 0;
+	    }
+	  }
+	  x -= 10 ** (p - 1) * n;
+	  p--;
+	}
+      }
+    }
+    return (ji, jlen);
+  }
+  
+  function toArr(uint[] memory json) internal pure returns(uint[] memory){
+    (uint _len, uint _jlen) = getLen(json);
+    uint[]  memory _json = new uint[](_len);
+    uint ji = 0;
+    uint prev = 0;
+    for(uint j = 0; j < _jlen; j++){
+      uint p = digits(json[j]);
+      uint x = json[j];
+      uint on = 0;
+      uint cur = 0;
+      uint len = 0;
+      uint num = 0;
+      uint is9 = 0;
+      while(p > 0){
+	uint n = x / 10 ** (p - 1);
+	if(on == 0 && n > 0){
+	  on = 1;
+	  if(n == 9){
+	    len = 8;
+	    is9 = 0;
+	  }else{
+	    len = n;
+	  }
+	  cur = 0;
+	}else if(on == 1){
+	  num += n * 10 ** (len - cur - 1);
+	  cur++;
+	  if(cur == len){
+	    prev *= 10 ** len;
+	    if(is9 == 1){
+	      prev += num;
+	    }else{
+	      num += prev;
+	      prev = 0;
+	      _json[ji] = num;
+	      ji++;
+	    }
+	    cur = 0;
+	    on = 0;
+	    len = 0;
+	    num = 0;
+	    is9 = 0;
+	  }
+	}
+	x -= 10 ** (p - 1) * n;
+	p--;
+      }
+    }
+    return _json;
+  }
+
+  function _toString(uint8[] memory charCodes) private pure returns (string memory) {
+    bytes memory stringBytes = new bytes(charCodes.length);
+    for (uint i = 0; i < charCodes.length; i++) stringBytes[i] = bytes1(charCodes[i]);
+    return string(stringBytes);
+  }
+
+  function _qInt (uint[] memory value) internal pure returns (int) {
+    require(value[0] == 2 && value[2] == 0, "not int");
+    return int(value[3]) * (value[1] == 1 ? int(1) : int(-1));
+  }
+  
+  function _qFloat (uint[] memory value) internal pure returns (uint[3] memory) {
+    require(value[0] == 2 && value[2] == 1, "not float");
+    uint[3] memory float;
+    float[0] = value[1];
+    float[1] = value[2];
+    float[2] = value[3];
+    return float;
+  }
+
+  function _qRaw (uint[] memory value) internal pure returns (uint[] memory) {
+    require(value[0] == 4, "not object or array");
+    return value;
+  }
+
+  function _qString (uint[] memory value) internal pure returns (string memory) {
+    require(value[0] == 3, "not string");
+    uint8[] memory charCodes = new uint8[](value[1]);
+    for(uint i = 0; i < value[1];i++) charCodes[i] = uint8(value[i+2]);
+    string memory str = _toString(charCodes);
+    return str;
+  }
+
+  function _qBool (uint[] memory value) internal pure returns (bool) {
+    require(value[0] == 1, "not bool");
+    return value[1] == 1 ? true : false;
+  }
+  
+  function _qNull (uint[] memory value) internal pure returns (bool) {
+    require(value[0] == 0, "not null");
+    return true;
+  }
+
+  function _parseZKP(uint[] calldata zkp) internal pure returns (uint[2] memory, uint[2][2] memory, uint[2] memory, uint[] memory) {
+    uint[2] memory _pA;
+    uint[2][2] memory _pB;
+    uint[2] memory _pC;
+    uint[] memory sigs = new uint[](zkp.length - 8);
+    for(uint i = 0; i < 2; i++) _pA[i] = zkp[i];
+    for(uint i = 2; i < 4; i++) _pB[0][i - 2] = zkp[i];
+    for(uint i = 4; i < 6; i++) _pB[1][i - 4] = zkp[i];
+    for(uint i = 6; i < 8; i++) _pC[i - 6] = zkp[i];
+    for(uint i = 8; i < zkp.length; i++) sigs[i - 8] = zkp[i];
+    return (_pA, _pB, _pC, sigs);
+  }
+
+  function getInt (uint[] memory path, uint[] memory raw) public pure returns (int) {
+    uint[] memory value = getVal(path, raw);
+    return _qInt(value);
+  }
+
+  function getString (uint[] memory path, uint[] memory raw) public pure returns (string memory) {
+    uint[] memory value = getVal(path, raw);
+    _qString(value);
+  }
+
+  function getBool (uint[] memory path, uint[] memory raw) public pure returns (bool) {
+    uint[] memory value = getVal(path, raw);
+    _qBool(value);
+  }
+
+  function getNull (uint[] memory path, uint[] memory raw) public pure returns (bool) {
+    uint[] memory value = getVal(path, raw);
+    _qNull(value);
+  }
+  
+}

package/contracts/ZKRollup.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+import "hardhat/console.sol";
+import "./ZKJson.sol";
+import "./ZKQuery.sol";
+
+interface VerifierRU {
+  function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[11] calldata _pubSignals) view external returns (bool);
+
+}
+
+contract ZKRollup is ZKQuery {
+  address public verifierRU;
+  address public comitter;
+  uint public root;
+  
+  function _verifyRU(uint[] calldata zkp) internal view returns (bool) {
+    uint[2] memory _pA;
+    uint[2][2] memory _pB;
+    uint[2] memory _pC;
+    uint[11] memory sigs;
+    for(uint i = 0; i < 2; i++) _pA[i] = zkp[i];
+    for(uint i = 2; i < 4; i++) _pB[0][i - 2] = zkp[i];
+    for(uint i = 4; i < 6; i++) _pB[1][i - 4] = zkp[i];
+    for(uint i = 6; i < 8; i++) _pC[i - 6] = zkp[i];
+    for(uint i = 8; i < 19; i++) sigs[i - 8] = zkp[i];
+    require(VerifierRU(verifierRU).verifyProof(_pA, _pB, _pC, sigs), "invalid proof");
+    return true;
+  }
+  
+  function _validateQueryRU(uint[] memory path, uint[] calldata zkp, uint size) internal view returns(uint[] memory){
+    require(zkp[19] == root, "root mismatch");
+    require(zkp[size * 2 + 10] == path[0], "wrong collection");
+    require(zkp[size * 2 + 11] == path[1], "wrong doc");
+    require(zkp[8] == 1, "value doesn't exist");
+    require(path.length <= size + 2, "path too long");
+    for(uint i = 9; i < 9 + path.length - 2; i++) require(path[i - 7] == zkp[i], "wrong path");
+    uint[] memory value = new uint[](size);
+    for(uint i = 9 + size; i < 9 + size * 2; i++) value[i - (9 + size)] = zkp[i];
+    return toArr(value);
+  }
+
+  function commit (uint[] calldata zkp) public returns (uint) {
+    require (zkp[9] == root, "wrong merkle root");
+    require(msg.sender == comitter, "sender is not comitter");
+    root = zkp[8];
+    verifyRU(zkp);
+    return root;
+    
+  }
+
+  function verifyRU(uint[] calldata zkp) public view returns (bool) {
+    return _verifyRU(zkp);
+  }
+
+}

package/db.js

@@ -12,19 +12,29 @@ const {
 const Collection = require("./collection")
 
 class DB {
-  constructor({ size = 5, level = 40, size_json = 16, size_txs = 10 }) {
-    this.size = size
+  constructor({
+    size_val = 5,
+    size_path = 5,
+    level = 100,
+    size_json = 256,
+    size_txs = 10,
+    level_col = 8,
+  }) {
+    this.level_col = level_col
+    this.size = size_val
+    this.size_path = size_path
     this.level = level
     this.size_json = size_json
     this.size_txs = size_txs
+    this.count = 0
   }
 
   async init() {
     this.tree = await newMemEmptyTrie()
-    this.cols = {}
+    this.cols = []
   }
 
-  parse(res, tree) {
+  parse(res, tree, level) {
     const isOld0 = res.isOld0 ? "1" : "0"
     const oldRoot = tree.F.toObject(res.oldRoot).toString()
     const newRoot = tree.F.toObject(res.newRoot).toString()
@@ -33,7 +43,7 @@ class DB {
     let siblings = res.siblings
     for (let i = 0; i < siblings.length; i++)
       siblings[i] = tree.F.toObject(siblings[i])
-    while (siblings.length < this.level) siblings.push(0)
+    while (siblings.length < level) siblings.push(0)
     siblings = siblings.map(s => s.toString())
     return { isOld0, oldRoot, oldKey, oldValue, siblings, newRoot }
   }
@@ -71,7 +81,7 @@ class DB {
         oldRoot_db.push(newRoot_db[i - 1])
         oldKey_db.push("0")
         oldValue_db.push("0")
-        siblings_db.push(range(0, this.level).map(() => "0"))
+        siblings_db.push(range(0, this.level_col).map(() => "0"))
         isOld0_db.push("0")
         newKey_db.push("0")
         newKey.push("0")
@@ -79,12 +89,12 @@ class DB {
       }
       _json = v[2]
       const { update, tree, col: res2, doc: res } = await this.insert(...v)
-      const icol = this.parse(res, tree)
-      const idb = this.parse(res2, this.tree)
+      const icol = this.parse(res, tree, this.level)
+      const idb = this.parse(res2, this.tree, this.level_col)
       _res = idb
       const _newKey = str2id(v[1])
       json.push(pad(val2str(encode(_json)), this.size_json))
-      const _newKey_db = str2id(v[0])
+      const _newKey_db = v[0]
       fnc.push(update ? [0, 1] : [1, 0])
       newRoot.push(idb.newRoot)
       oldRoot.push(icol.oldRoot)
@@ -128,10 +138,10 @@ class DB {
       col: res2,
       doc: res,
     } = await this.insert(col_id, id, json)
-    const icol = this.parse(res, tree)
-    const idb = this.parse(res2, this.tree)
+    const icol = this.parse(res, tree, this.level)
+    const idb = this.parse(res2, this.tree, this.level_col)
     const newKey = str2id(id)
-    const newKey_db = str2id(col_id)
+    const newKey_db = col_id
     return {
       fnc: update ? [0, 1] : [1, 0],
       oldRoot: icol.oldRoot,
@@ -158,9 +168,9 @@ class DB {
     let col_siblings = col_res.siblings
     for (let i = 0; i < col_siblings.length; i++)
       col_siblings[i] = this.tree.F.toObject(col_siblings[i])
-    while (col_siblings.length < this.level) col_siblings.push(0)
+    while (col_siblings.length < this.level_col) col_siblings.push(0)
     col_siblings = col_siblings.map(s => s.toString())
-    const col_key = str2id(col_id)
+    const col_key = col_id
     const col = this.getColTree(col_id)
     const col_inputs = await col.getInputs({ id, json, path, val })
     return {
@@ -176,19 +186,21 @@ class DB {
     }
   }
 
-  async addCollection(_key) {
-    const id = str2id(_key)
+  async addCollection() {
+    const id = this.count++
     const col = await this.tree.find(id)
     if (col.found) throw Error("collection exists")
     const _col = new Collection({
-      size: this.size,
+      size_val: this.size_val,
+      size_path: this.size_path,
       level: this.level,
       size_json: this.size_json,
     })
     await _col.init()
-    this.cols[_key] = _col
+    this.cols[id] = _col
     const root = _col.tree.F.toObject(_col.tree.root).toString()
     await this.tree.insert(id, [root])
+    return id
   }
   getColTree(col) {
     const _col = this.cols[col]
@@ -210,7 +222,7 @@ class DB {
   }
   async updateDB(_col, col) {
     const root = _col.tree.F.toObject(_col.tree.root).toString()
-    const colD = str2id(col)
+    const colD = col
     return await this.tree.update(colD, [root])
   }
   async update(col, _key, _val) {

package/doc.js

@@ -1,15 +1,54 @@
+const snarkjs = require("snarkjs")
+const { resolve } = require("path")
 const { pad, toSignal, encode, encodePath, encodeVal } = require("./encoder")
 
 module.exports = class Doc {
-  constructor({ size = 16, size_json = 100 }) {
-    this.size = size
+  constructor({ size_val = 5, size_path = 5, size_json = 256, wasm, zkey }) {
+    this.size_val = size_val
+    this.size_path = size_path
     this.size_json = size_json
+    this.wasm = wasm
+    this.zkey = zkey
   }
-  async getInputs({ json, path, val }) {
+  async getInputs({ json, path }) {
     return {
       json: pad(toSignal(encode(json)), this.size_json),
-      path: pad(toSignal(encodePath(path)), this.size),
-      val: pad(toSignal(encodeVal(val)), this.size),
+      path: pad(toSignal(encodePath(path)), this.size_path),
+      val: pad(toSignal(encodeVal(this.getVal(json, path))), this.size_val),
     }
   }
+  _getVal(j, p) {
+    if (p.length === 0) {
+      return j
+    } else {
+      const sp = p[0].split("[")
+      for (let v of sp) {
+        if (/]$/.test(v)) {
+          j = j[v.replace(/]$/, "") * 1]
+        } else {
+          j = j[v]
+        }
+      }
+      return this._getVal(j, p.slice(1))
+    }
+  }
+  getVal(j, p) {
+    if (p === "") return j
+    return this._getVal(j, p.split("."))
+  }
+  async genProof(json, path) {
+    const inputs = await this.getInputs(json, path)
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+      inputs,
+      this.wasm,
+      this.zkey
+    )
+    return [
+      ...proof.pi_a.slice(0, 2),
+      ...proof.pi_b[0].slice(0, 2).reverse(),
+      ...proof.pi_b[1].slice(0, 2).reverse(),
+      ...proof.pi_c.slice(0, 2),
+      ...publicSignals,
+    ]
+  }
 }

package/json.js

@@ -1,7 +1,7 @@
 const { pad, toSignal, encode, encodePath, encodeVal } = require("./encoder")
 
 module.exports = class Json {
-  constructor({ size = 16, size_json = 100 }) {
+  constructor({ size = 5, size_json = 256 }) {
     this.size = size
     this.size_json = size_json
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zkjson",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Zero Knowledge Provable JSON",
   "main": "index.js",
   "license": "MIT",