zkjson 0.6.1 → 1.0.2

package/solidity/README.md

@@ -0,0 +1,13 @@
+# Sample Hardhat Project
+
+This project demonstrates a basic Hardhat use case. It comes with a sample contract, a test for that contract, and a script that deploys that contract.
+
+Try running some of the following tasks:
+
+```shell
+npx hardhat help
+npx hardhat test
+REPORT_GAS=true npx hardhat test
+npx hardhat node
+npx hardhat run scripts/deploy.js
+```

package/solidity/arguments.js

@@ -0,0 +1,4 @@
+module.exports = [
+  "0x13c75AbF4544b45B402B7Fc15FF70A752A3181Ef",
+  "0x078694d69426112c7df330732e28F5117B02727A",
+]

package/solidity/contracts/NORollup.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+import "./ZKQuery.sol";
+
+contract NORollup is ZKQuery {
+  function _validateQuery(uint[] memory zkp, uint size_path, uint size_val) internal view returns(uint[] memory){
+    require(zkp[8] == 1, "value doesn't exist");
+    uint[] memory value = new uint[](size_val);
+    for(uint i = 9 + size_path; i < 9 + size_path + size_val; i++) value[i - (9 + size_path)] = zkp[i];
+    return toArr(value);
+  }
+}

package/solidity/contracts/OPRollup.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+import "./ZKRollup.sol";
+
+
+contract OPRollup is ZKRollup {
+  
+  function commitRoot (uint _root) public returns (uint) {
+    require(msg.sender == committer, "sender is not committer");
+    root = _root;
+    return root;
+  }
+}

package/solidity/contracts/ZKIPFS.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+import "./ZKQuery.sol";
+
+interface VerifierIPFS {
+  function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[43] calldata _pubSignals) external view returns (bool);
+}
+
+contract ZKIPFS is ZKQuery{
+  uint constant SIZE_PATH = 5;
+  uint constant SIZE_VAL = 5;
+  address public verifierIPFS;
+  bytes constant ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  
+  function charArrayToString(bytes1[46] memory charArray) public pure returns (string memory) {
+    bytes memory byteArray = new bytes(charArray.length);
+    for(uint i = 0; i < charArray.length; i++) {
+      byteArray[i] = charArray[i];
+    }
+    return string(byteArray);
+  }
+
+  function concat(string memory a, string memory b) public pure returns (string memory) {
+    return string(abi.encodePacked(a, b));
+  }
+  
+  function uriEqual(string memory a, string memory b) public pure returns (bool) {
+    return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
+  }
+  
+  function toCID(uint[34] memory source) public pure returns (string memory) {
+    uint zeroes = 0;
+    uint length = 0;
+    uint pbegin = 0;
+    uint pend = source.length;
+    while (pbegin != pend && source[pbegin] == 0) {
+      pbegin++;
+      zeroes++;
+    }
+    uint size = 46;
+    uint[46] memory b58;
+    while (pbegin != pend) {
+      uint carry = source[pbegin];
+      uint i = 0;
+      for ( uint it1 = size - 1; (carry != 0 || i < length); it1-- ) {
+	carry += (256 * b58[it1]);
+	b58[it1] = carry % 58;
+	carry = (carry / 58);
+	i++;
+	if(it1 == 0) break;
+      }
+      length = i;
+      pbegin++;
+    }
+    uint it2 = size - length;
+    while (it2 != size && b58[it2] == 0) it2++;
+    bytes1[46] memory str;
+    uint i = 0;
+    for (; it2 < size; ++it2){
+      str[i] = ALPHABET[b58[it2]];
+      i++;
+    }
+    return charArrayToString(str);
+  }
+  
+  function ipfsURI(uint[34] memory source) public pure returns (string memory) {
+    return concat("ipfs://", toCID(source));
+  }
+  
+  function _validateQueryIPFS(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");
+    uint len = 41;
+    for(uint i = len; i < len + size_path; i++){
+      require((path.length <= i - len && zkp[i] == 0) || path[i - len] == zkp[i], "wrong path");
+    }
+    uint[] memory value = new uint[](size_val);
+    for(uint i = len + size_path; i < len + size_path + size_val; i++){
+      value[i - (len + size_val)] = zkp[i];
+    }
+    return toArr(value);
+  }
+  
+  function validateQuery(string memory URI, uint[] memory path, uint[] memory zkp) internal view returns(uint[] memory){
+    uint[34] memory hash;
+    hash[0] = 18;
+    hash[1] = 32;
+    for(uint i = 9; i < 41; i++) hash[i - 7] = zkp[i];
+    string memory CID = ipfsURI(hash);
+    require(uriEqual(CID,URI), "wrong CID");
+    verify(zkp, VerifierIPFS.verifyProof.selector, verifierIPFS);
+    return _validateQueryIPFS(path, zkp, SIZE_PATH, SIZE_VAL);
+  }
+
+}

package/solidity/contracts/ZKJson.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+import "./ZKQuery.sol";
+
+contract ZKJson is ZKQuery{
+  address public verifierJSON;
+
+  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 < 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_path)] = zkp[i];
+    }
+    return toArr(value);
+  }
+
+}

package/solidity/contracts/ZKQuery.sol

@@ -0,0 +1,286 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract ZKQuery {
+
+  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 (_path, 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
+      }
+      if eq(_type, 2) {
+	len := 3
+      }
+      if eq(_type, 3) {
+	len := add(mload(add(json, mul(i, 0x20))), 1)
+      }
+      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 (_val, i);
+  }
+  
+  function getVal(uint[] memory path, uint[] memory _json) private pure returns(uint[] memory){
+    require (_json[0] == 4, "not raw value");
+    uint[] memory path2 = toArr(path);
+    uint i = 1;
+    while(i < _json.length){
+      (uint[] memory _path, uint i2) = getPath(i, _json);
+      (uint[] memory _val2, uint i3) = _getVal(i2, _json);
+      i = i3;
+      uint path_match = 1;
+      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) return _val2;
+    }
+    require(false, "value not found");
+  }
+  
+  function toArr(uint[] memory json) internal pure returns(uint[] memory){
+    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 // 0 = first, 1 = off, 2 = on, 3 = is9, 4 = to set zero, 5 = zero
+	  let cur := 0
+	  let len := 0
+	  let num := 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 iszero(_on){
+	      on := 1
+	    }
+	    if and(eq(_on, 1), iszero(n)) {
+	        on := 4
+	    }
+    	    if eq(_on, 4) {
+	        on := 5
+		len := n
+	    }	
+	    if and(eq(_on, 1), gt(n, 0)) {
+	      if eq(n, 9) {
+		len := 8
+	        on := 3       
+	      }
+	      if and(iszero(iszero(n)), iszero(eq(n,9))) {
+	        on := 2
+		len := n  
+	      }
+              cur := 0
+	    }
+	    if gt(_on, 1) {
+	      if eq(_on, 5){
+		mstore(add(_json0, ji), n)
+		len := sub(len, 1)
+		ji := add(ji, 0x20)
+		if iszero(len) {
+		  cur := 0
+		  on := 1
+		  len := 0
+		  num := 0
+		}
+	      }
+	      if iszero(eq(_on, 5)){
+                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(_on, 3) {
+                    prev := add(prev, num)
+                  }
+	          if iszero(eq(_on, 3)) {
+                    num := add(num, prev)
+                    prev := 0
+		    mstore(add(_json0, ji), num)
+                    ji := add(ji, 0x20)
+                  }
+                  cur := 0
+                  on := 1
+                  len := 0
+                  num := 0
+                }
+	      }
+            }
+	    x := sub(x, mul(exp(10, sub(p, 1)), n))
+	    p := sub(p, 1)
+	  }
+	}
+      }
+      mstore(_json, div(ji, 0x20))
+      mstore(0x40, add(_json, add(0x20, ji)))
+    }
+    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] != 0, "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 _qCond (uint[] memory value, uint[] memory cond) internal pure returns (bool) {
+    uint[] memory _cond = toArr(cond);
+    require(value.length == _cond.length, "wrong query");
+    for(uint i = 0; i < value.length; i++)  require(_cond[i] == value[i], "wrong query");
+    return true;
+  }
+  
+  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) internal pure returns (string memory) {
+    uint[] memory value = getVal(path, raw);
+    _qString(value);
+  }
+
+  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) 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/solidity/contracts/ZKRollup.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+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 committer;
+  uint public root;
+  
+  function _validateQueryRU(uint[] memory path, uint[] memory zkp, uint size_path, uint size_val) internal view returns(uint[] memory){
+    require(zkp[size_path + size_val + 9] == 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");
+    require(zkp[8] == 1, "value doesn't exist");
+    require(path.length <= size_path + size_val, "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_val);
+    for(uint i = 9 + size_path; i < 9 + size_path + size_val; i++) value[i - (9 + size_path)] = zkp[i];
+    return toArr(value);
+  }
+
+  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];
+    verify(zkp,VerifierRU.verifyProof.selector, verifierRU);
+    return root;
+  }
+}

package/solidity/contracts/apps/NORU.sol

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../NORollup.sol";
+
+interface VerifierDB {
+  function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[16] calldata _pubSignals) view external returns (bool);
+}
+
+contract NORU is NORollup {
+  uint constant SIZE_PATH = 4;
+  uint constant SIZE_VAL = 8;
+  address public verifierDB;
+
+  constructor (address _verifierDB, address _committer){
+    verifierDB = _verifierDB;
+    committer = _committer;
+  }
+  
+  function validateQuery(uint[] memory zkp) private view returns(uint[] memory){
+    verify(zkp, VerifierDB.verifyProof.selector, verifierDB);
+    return _validateQuery(zkp, SIZE_PATH, SIZE_VAL);    
+  }
+
+  function qInt (uint[] memory zkp) public view returns (int) {
+    uint[] memory value = validateQuery(zkp);
+    return _qInt(value);
+  }
+
+  function qFloat (uint[] memory zkp) public view returns (uint[3] memory) {
+    uint[] memory value = validateQuery(zkp);
+    return _qFloat(value);
+  }
+
+  function qRaw (uint[] memory zkp) public view returns (uint[] memory) {
+    uint[] memory value = validateQuery(zkp);
+    return _qRaw(value);
+  }
+  
+  function qString (uint[] memory zkp) public view returns (string memory) {
+    uint[] memory value = validateQuery(zkp);
+    return _qString(value);
+  }
+
+  function qBool (uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(zkp);
+    return _qBool(value);
+  }
+  
+  function qNull (uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(zkp);
+    return _qNull(value);
+  }
+
+  function qCond (uint[] memory cond, uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(zkp);
+    return _qCond(value, cond);
+  }
+
+  function qCustom (uint[] memory path, uint[] memory zkp) public view returns (int) {
+    uint[] memory value = validateQuery(zkp);
+    return getInt(path, value);
+  }
+  
+}

package/solidity/contracts/apps/SimpleJSON.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../ZKJson.sol";
+
+interface VerifierJSON {
+  function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[14] calldata _pubSignals) view external returns (bool);
+}
+
+contract SimpleJSON is ZKJson {
+  uint constant SIZE_PATH = 4;
+  uint constant SIZE_VAL = 8;
+  
+  constructor (address _verifierJSON){
+    verifierJSON = _verifierJSON;
+  }
+
+  function validateQuery(uint[] memory path, uint[] memory zkp) private view returns(uint[] memory){
+    verify(zkp, VerifierJSON.verifyProof.selector, verifierJSON);
+    return _validateQueryJSON(path, zkp, SIZE_PATH, SIZE_VAL);
+  }
+
+  function qInt (uint[] memory path, uint[] memory zkp) public view returns (int) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qInt(value);
+  }
+
+  function qFloat (uint[] memory path, uint[] memory zkp) public view returns (uint[3] memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qFloat(value);
+  }
+
+  function qRaw (uint[] memory path, uint[] memory zkp) public view returns (uint[] memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qRaw(value);
+  }
+  
+  function qString (uint[] memory path, uint[] memory zkp) public view returns (string memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qString(value);
+  }
+
+  function qBool (uint[] memory path, uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qBool(value);
+  }
+  
+  function qNull (uint[] memory path, uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qNull(value);
+  }
+  
+  function qCond (uint[] memory path, uint[] memory cond, uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qCond(value, cond);
+  }
+
+  function qCustom (uint[] memory path, uint[] memory path2, uint[] memory zkp) public view returns (int) {
+    uint[] memory value = validateQuery(path, zkp);
+    return getInt(path2, value);
+  }
+  
+}

package/solidity/contracts/apps/SimpleOPRU.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../OPRollup.sol";
+
+interface VerifierDB {
+  function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[16] calldata _pubSignals) view external returns (bool);
+}
+
+contract SimpleOPRU is OPRollup {
+  uint constant SIZE_PATH = 4;
+  uint constant SIZE_VAL = 8;
+  address public verifierDB;
+
+  constructor (address _verifierRU, address _verifierDB, address _committer){
+    verifierRU = _verifierRU;
+    verifierDB = _verifierDB;
+    committer = _committer;
+  }
+  
+  function validateQuery(uint[] memory path, uint[] memory zkp) private view returns(uint[] memory){
+    verify(zkp, VerifierDB.verifyProof.selector, verifierDB);
+    return _validateQueryRU(path, zkp, SIZE_PATH, SIZE_VAL);    
+  }
+
+  function qInt (uint[] memory path, uint[] memory zkp) public view returns (int) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qInt(value);
+  }
+
+  function qFloat (uint[] memory path, uint[] memory zkp) public view returns (uint[3] memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qFloat(value);
+  }
+
+  function qRaw (uint[] memory path, uint[] memory zkp) public view returns (uint[] memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qRaw(value);
+  }
+  
+  function qString (uint[] memory path, uint[] memory zkp) public view returns (string memory) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qString(value);
+  }
+
+  function qBool (uint[] memory path, uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qBool(value);
+  }
+  
+  function qNull (uint[] memory path, uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qNull(value);
+  }
+
+  function qCond (uint[] memory path, uint[] memory cond, uint[] memory zkp) public view returns (bool) {
+    uint[] memory value = validateQuery(path, zkp);
+    return _qCond(value, cond);
+  }
+
+  function qCustom (uint[] memory path, uint[] memory path2, uint[] memory zkp) public view returns (int) {
+    uint[] memory value = validateQuery(path, zkp);
+    return getInt(path2, value);
+  }
+  
+}