zkjson 0.1.13 → 0.1.15

package/contracts/ZKJson.sol

@@ -1,16 +1,20 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity >=0.7.0 <0.9.0;
-import "hardhat/console.sol";
 import "./ZKQuery.sol";
 
 contract ZKJson is ZKQuery{
+  address public verifierJSON;
 
-  function _validateQueryJSON(uint[] memory path, uint[] calldata zkp, uint size) public pure returns(uint[] memory){
+  function _validateQueryJSON(uint[] memory path, uint[] memory zkp, uint size_path, uint size_val) internal 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];
+    for(uint i = 10; i < 10 + size_path; i++){
+      require((path.length <= i - 10 && zkp[i] == 0) || path[i - 10] == zkp[i], "wrong path");
+    }
+    uint[] memory value = new uint[](size_val);
+    for(uint i = 10 + size_path; i < 10 + size_path + size_val; i++){
+      value[i - (10 + size_val)] = zkp[i];
+    }
     return toArr(value);
   }
 

package/contracts/ZKQuery.sol

@@ -1,260 +1,161 @@
 // 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++;
+  function getPath(uint i, uint[] memory _json) private pure returns(uint[] memory, uint){
+    uint[] memory _path;
+    assembly {
+      let json := add(_json, 0x20)
+      let len := mload(add(json, mul(i, 0x20)))
+      i := add(i, 1)
+      _path := msize()
+      mstore(_path, sub(mload(_json), i))
+      let _path0 := add(_path, 0x20)
+      mstore(_path0, len)
+      let pi := 0x20
+      for { let i2 := 0 } lt(i2, len) { i2 := add(i2, 1) } {
+	let plen := mload(add(json, mul(i, 0x20)))
+        mstore(add(_path0, pi), plen)
+	pi := add(pi, 0x20)
+	i := add(i, 1)
+	let plen2 := 1
+	if iszero(plen) {
+          if iszero(mload(add(json, mul(i, 0x20)))){
+	    plen2 := 2
+          }
+        }
+	for { let i3 := 0 } lt(i3, plen2) { i3 := add(i3, 1) } {
+	  mstore(add(_path0, pi), mload(add(json, mul(i, 0x20))))
+	  pi := add(pi, 0x20)
+	  i := add(i, 1)
+	}
+      }
+      mstore(_path, div(pi, 0x20))
+      mstore(0x40, add(_path, add(0x20, pi)))
     }
-    return p;
+    return (_path, i);
   }
 
-  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++;
-	}
+  function _getVal(uint i, uint[] memory _json) private pure returns(uint[] memory, uint){
+    uint[] memory _val;
+    assembly {
+      let json := add(_json, 0x20)
+      _val := msize()
+      mstore(_val, sub(mload(_json), i))
+      let _val0 := add(_val, 0x20)
+      let _type := mload(add(json, mul(i, 0x20)))
+      i := add(i, 1)
+      let vlen := 0x20
+      mstore(_val0, _type)
+      let len := 0	
+      if eq(_type, 1) {
+	len := 1
       }
-      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;
+      if eq(_type, 2) {
+	len := 3
       }
-      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 eq(_type, 3) {
+	len := add(mload(add(json, mul(i, 0x20))), 1)
       }
-      if(path_match == 1){
-	vallen = vlen;
-	break;
+      for { let i2 := 0 } lt(i2, len) { i2 := add(i2, 1) } {
+	mstore(add(_val0, vlen), mload(add(json, mul(i, 0x20))))	  
+	vlen := add(vlen, 0x20)
+        i := add(i, 1)
       }
+      mstore(_val, div(vlen, 0x20))
+      mstore(0x40, add(_val, add(0x20, vlen)))
     }
-    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;
+    return (_val, i);
   }
   
   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);
+    uint i = 1;
     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[] memory _path, uint i2) = getPath(i, _json);
+      (uint[] memory _val2, uint i3) = _getVal(i2, _json);
+      i = i3;
       uint path_match = 1;
-      if(pathlen != path2.length){
+      if(_path.length != 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--;
-	}
-      }
+      if(path_match == 1) return _val2;
     }
-    return (ji, jlen);
+    require(false, "value not found");
   }
   
   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;
+    uint[]  memory _json;
+    assembly {
+      let ji := 0x0
+      let prev := 0
+      let start := add(json, 0x20)
+      _json := msize()
+      mstore(_json, mload(json))
+      let _json0 := add(_json, 0x20)
+      for { let i := 0 } lt(i, mload(json)) { i := add(i, 1) } {
+	let v := mload(add(start, mul(i, 0x20)))
+	if gt(v,0) {  
+	  let p := 0
+	  let x := v
+	  let on := 0
+	  let cur := 0
+	  let len := 0
+	  let num := 0
+	  let is9 := 0
+          for { } gt(v, 0) { } {
+	    v := div(v, 10)
+            p := add(p, 1)
+          }
+	  for { } gt(p, 0) { } {
+	    let n := div(x, exp(10, sub(p, 1)))
+	    let _on := on  
+            if and(iszero(_on), gt(n, 0)) {
+              on := 1
+              if eq(n, 9) {
+                len := 8
+                is9 := 0
+              }
+	      if iszero(eq(n, 9)) {
+                len := n
+              }
+              cur := 0
+            }
+	    if eq(_on, 1) {
+	      num := add(num, mul(n, exp(10, sub(sub(len, cur), 1))))
+              cur := add(cur, 1)
+              if eq(cur, len) {
+                prev := mul(prev, exp(10, len))
+                if eq(is9, 1) {
+                  prev := add(prev, num)
+                }
+	        if iszero(eq(is9, 1)) {
+                  num := add(num, prev)
+                  prev := 0
+		  mstore(add(_json0, ji), num)
+                  ji := add(ji, 0x20)
+                }
+                cur := 0
+                on := 0
+                len := 0
+                num := 0
+                is9 := 0
+              }
+            }
+	    x := sub(x, mul(exp(10, sub(p, 1)), n))
+	    p := sub(p, 1)
 	  }
 	}
-	x -= 10 ** (p - 1) * n;
-	p--;
       }
+      mstore(_json, div(ji, 0x20))
+      mstore(0x40, add(_json, add(0x20, ji)))
     }
     return _json;
   }
@@ -302,37 +203,55 @@ contract ZKQuery {
     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) {
+  function getInt (uint[] memory path, uint[] memory raw) internal 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) {
+  function getString (uint[] memory path, uint[] memory raw) internal pure returns (string memory) {
     uint[] memory value = getVal(path, raw);
     _qString(value);
   }
 
-  function getBool (uint[] memory path, uint[] memory raw) public pure returns (bool) {
+  function getBool (uint[] memory path, uint[] memory raw) internal pure returns (bool) {
     uint[] memory value = getVal(path, raw);
     _qBool(value);
   }
 
-  function getNull (uint[] memory path, uint[] memory raw) public pure returns (bool) {
+  function getNull (uint[] memory path, uint[] memory raw) internal pure returns (bool) {
     uint[] memory value = getVal(path, raw);
     _qNull(value);
   }
-  
+  function verify(uint[] memory zkp, bytes4 selector, address addr) internal view returns (bool) {
+    uint size;
+    assembly {
+      size := extcodesize(addr)
+    }
+    require(size > 0, "contract doesn't exist");
+    bool valid;
+    assembly{
+      let callData := mload(0x40)
+      let zlen := mload(zkp)
+      let clen := add(0x4, mul(0x20, zlen))
+      mstore(callData, clen)
+      mstore(add(callData, 0x20), selector)
+      for { let i := 1 } lt(i, add(1, zlen)) { i := add(i, 1) } {
+	mstore(add(callData, add(0x4, mul(i, 0x20))), mload(add(zkp, mul(i, 0x20))))
+      }
+      let success := staticcall(
+        gas(),            
+        addr,
+	add(callData, 0x20), 
+	clen,   
+	callData,         
+	0x20          
+      )
+      if iszero(success) {
+        revert(0, 0)
+      }
+      valid := mload(callData)
+    }
+    require(valid, "invalid proof");
+    return true;
+  }
 }

package/contracts/ZKRollup.sol

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity >=0.7.0 <0.9.0;
-import "hardhat/console.sol";
 import "./ZKQuery.sol";
 
 interface VerifierRU {
@@ -14,21 +13,7 @@ contract ZKRollup is ZKQuery {
   address public committer;
   uint public root;
   
-  function _verifyRU(uint[] calldata zkp) private 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_path, uint size_val) internal view returns(uint[] memory){
+  function _validateQueryRU(uint[] memory path, uint[] memory zkp, uint size_path, uint size_val) internal view returns(uint[] memory){
     require(zkp[19] == root, "root mismatch");
     require(zkp[size_path + size_val + 10] == path[0], "wrong collection");
     require(zkp[size_path + size_val + 11] == path[1], "wrong doc");
@@ -40,15 +25,11 @@ contract ZKRollup is ZKQuery {
     return toArr(value);
   }
 
-  function commit (uint[] calldata zkp) public returns (uint) {
+  function commit (uint[] memory zkp) public returns (uint) {
     require (zkp[9] == root, "wrong merkle root");
     require(msg.sender == committer, "sender is not committer");
     root = zkp[8];
-    verifyRU(zkp);
+    verify(zkp,VerifierRU.verifyProof.selector, verifierRU);
     return root;
   }
-
-  function verifyRU(uint[] calldata zkp) private view returns (bool) {
-    return _verifyRU(zkp);
-  }
 }

package/db.js

@@ -1,15 +1,7 @@
 const newMemEmptyTrie = require("./circomlibjs").newMemEmptyTrie
 const snarkjs = require("snarkjs")
 const { range } = require("ramda")
-const {
-  pad,
-  toSignal,
-  str2val,
-  val2str,
-  id2str,
-  encode,
-  toIndex,
-} = require("./encoder")
+const { pad, toSignal, encode, toIndex } = require("./encoder")
 const Collection = require("./collection")
 
 class DB {
@@ -113,6 +105,40 @@ class DB {
       ...publicSignals,
     ]
   }
+
+  async query(col_id, id, path, json) {
+    const val = tar[path]
+    const inputs = await this.genProof({ col_id, id, json, path })
+    const sigs = inputs.slice(8)
+    const params = [[sigs[12], sigs[13], ...sigs.slice(1, 6)], inputs]
+    let type =
+      val === null
+        ? 0
+        : typeof val === "string"
+        ? 3
+        : typeof val === "boolean"
+        ? 1
+        : typeof val === "number"
+        ? Number.isInteger(val)
+          ? 2
+          : 2.5
+        : 4
+    switch (type) {
+      case 0:
+        return await this.zkdb.qNull(...params)
+      case 1:
+        return await this.zkdb.qBool(...params)
+      case 2:
+        return (await this.zkdb.qInt(...params)).toString() * 1
+      case 2.5:
+        return (await this.zkdb.qFloat(...params)).map(n => n.toString() * 1)
+      case 3:
+        return await this.zkdb.qString(...params)
+      case 4:
+        return (await this.zkdb.qRaw(...params)).map(n => n.toString() * 1)
+    }
+  }
+
   async getRollupInputs({ queries }) {
     let write, _json
     let oldRoot = []
@@ -159,7 +185,7 @@ class DB {
       const idb = this.parse(res2, this.tree, this.level_col)
       _res = idb
       const _newKey = toIndex(v[1])
-      json.push(pad(val2str(encode(_json)), this.size_json))
+      json.push(pad(toSignal(encode(_json)), this.size_json))
       const _newKey_db = v[0].toString()
       fnc.push(update ? [0, 1] : [1, 0])
       newRoot.push(idb.newRoot)

package/encoder.js

@@ -1,4 +1,17 @@
-const { splitEvery, flatten } = require("ramda")
+const { isNil, includes, splitEvery, flatten } = require("ramda")
+const ops = {
+  $eq: 10,
+  $ne: 11,
+  $gt: 12,
+  $gte: 13,
+  $lt: 14,
+  $lte: 15,
+  $in: 16,
+  $nin: 17,
+}
+const opMap = {}
+for (let k in ops) opMap[ops[k]] = k
+
 const base64Map = {
   A: "00",
   B: "01",
@@ -456,6 +469,19 @@ const fromIndex = id2str
 const path = p => toSignal(encodePath(p))
 const val = v => toSignal(encodeVal(v))
 
+function encodeQuery(v) {
+  if (!Array.isArray(v)) throw Error("query must be an array")
+  const op = v[0]
+  if (isNil(ops[op])) throw Error(`query not supported: ${op}`)
+  return [ops[op], ...encodeVal(v.slice(1))]
+}
+
+function decodeQuery(v) {
+  const op = opMap[v[0]]
+  if (isNil(op)) throw Error("op doens't exist")
+  return [op, ...decodeVal(v.slice(1))]
+}
+
 module.exports = {
   encode,
   decode,
@@ -476,4 +502,6 @@ module.exports = {
   fromIndex,
   path,
   val,
+  encodeQuery,
+  decodeQuery,
 }

package/index.js

@@ -1,7 +1,6 @@
 const encoder = require("./encoder")
 const DB = require("./db")
 const Doc = require("./doc")
-const Rollup = require("./rollup")
 const Collection = require("./collection")
 
-module.exports = { ...encoder, DB, Collection, Doc, Rollup }
+module.exports = { ...encoder, DB, Collection, Doc }

package/package.json

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

package/contracts/ZKDB.sol

@@ -1,70 +0,0 @@
-// 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);
-  }
-
-}