zkjson 0.1.14 → 0.1.15

package/contracts/ZKJson.sol

@@ -6,7 +6,7 @@ import "./ZKQuery.sol";
 contract ZKJson is ZKQuery{
   address public verifierJSON;
 
-  function _validateQueryJSON(uint[] memory path, uint[] calldata zkp, uint size_path, uint size_val) internal 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 < 10 + size_path; i++){
       require((path.length <= i - 10 && zkp[i] == 0) || path[i - 10] == zkp[i], "wrong path");

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,19 +203,6 @@ 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) internal pure returns (int) {
     uint[] memory value = getVal(path, raw);
     return _qInt(value);
@@ -334,5 +222,36 @@ contract ZKQuery {
     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,16 +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/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/package.json

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