zkjson 0.5.3 → 0.6.0

package/contracts/OPRollup.sol

@@ -1,31 +1,12 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity >=0.7.0 <0.9.0;
-import "./ZKQuery.sol";
+import "./ZKRollup.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 OPRollup is ZKQuery {
-  address public verifierRU;
-  address public committer;
-  uint public root;
+contract OPRollup is ZKRollup {
   
-  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");
-    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 _root) public returns (uint) {
+  function commitRoot (uint _root) public returns (uint) {
     require(msg.sender == committer, "sender is not committer");
     root = _root;
     return root;

package/contracts/ZKIPFS.sol

@@ -2,7 +2,6 @@
 
 pragma solidity >=0.7.0 <0.9.0;
 import "./ZKQuery.sol";
-import "hardhat/console.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);

package/contracts/ZKJson.sol

@@ -13,7 +13,7 @@ contract ZKJson is ZKQuery{
     }
     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];
+      value[i - (10 + size_path)] = zkp[i];
     }
     return toArr(value);
   }

package/contracts/ZKRollup.sol

@@ -14,7 +14,7 @@ contract ZKRollup is ZKQuery {
   uint public root;
   
   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 + 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");

package/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/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);
+  }
+  
+}

package/contracts/apps/SimpleRU.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+
+import "../ZKRollup.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 SimpleRU is ZKRollup {
+  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);
+  }
+  
+}

package/contracts/apps/Token.sol

@@ -0,0 +1,12 @@
+// contracts/GLDToken.sol
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract Token is ERC20 {
+  constructor() ERC20("Token", "TOKEN") {}
+  function mint(address to, uint amount) public {
+    _mint(to, amount);
+  }
+}

package/contracts/apps/ZKArweave.sol

@@ -0,0 +1,89 @@
+// 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 ZKArweave is ZKJson {
+  address public verifier;
+  address public validator;
+  uint constant SIZE_PATH = 4;
+  uint constant SIZE_VAL = 8;
+  
+  constructor (address _verifier, address _validator){
+    verifier = _verifier;
+    validator = _validator;
+  }
+  
+  function validateQuery(string memory txid, uint[] memory path, uint[] memory zkp, bytes memory sig) public view returns(uint[] memory){
+    verify(zkp, VerifierJSON.verifyProof.selector, verifier);
+    verifyMessage(txid, zkp[9], sig);
+    return _validateQueryJSON(path, zkp, SIZE_PATH, SIZE_VAL);
+  }
+
+  function qInt (string memory txid, uint[] memory path, uint[] memory zkp, bytes memory sig) public view returns (int) {
+    uint[] memory value = validateQuery(txid, path, zkp, sig);
+    return _qInt(value);
+  }
+
+  function qFloat (string memory txid, uint[] memory path, uint[] memory zkp, bytes memory sig) public view returns (uint[3] memory) {
+    uint[] memory value = validateQuery(txid, path, zkp, sig);
+    return _qFloat(value);
+  }
+
+  function qRaw (string memory txid, uint[] memory path, uint[] memory zkp, bytes memory sig) public view returns (uint[] memory) {
+    uint[] memory value = validateQuery(txid, path, zkp, sig);
+    return _qRaw(value);
+  }
+  
+  function qString (string memory txid, uint[] memory path, uint[] memory zkp, bytes memory sig) public view returns (string memory) {
+    uint[] memory value = validateQuery(txid, path, zkp, sig);
+    return _qString(value);
+  }
+
+  function qBool (string memory txid, uint[] memory path, uint[] memory zkp, bytes memory sig) public view returns (bool) {
+    uint[] memory value = validateQuery(txid, path, zkp, sig);
+    return _qBool(value);
+  }
+  
+  function qNull (string memory txid, uint[] memory path, uint[] memory zkp, bytes memory sig) public view returns (bool) {
+    uint[] memory value = validateQuery(txid, path, zkp, sig);
+    return _qNull(value);
+  }
+
+  function getMessageHash(string memory txid, uint hash) public pure returns (bytes32) {
+    return keccak256(abi.encodePacked(txid, hash));
+  }
+  
+  function getEthSignedMessageHash( bytes32 _messageHash ) private pure returns (bytes32) {
+    return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _messageHash));
+  }
+
+  function verifyMessage(string memory txid, uint _message, bytes memory signature) public view returns (bool) {
+    bytes32 messageHash = getMessageHash(txid,  _message);
+    bytes32 ethSignedMessageHash = getEthSignedMessageHash(messageHash);
+    return recoverSigner(ethSignedMessageHash, signature) == validator;
+  }
+  
+  function recoverSigner(
+			 bytes32 _ethSignedMessageHash,
+			 bytes memory _signature
+			 ) private pure returns (address) {
+    (bytes32 r, bytes32 s, uint8 v) = splitSignature(_signature);
+    return ecrecover(_ethSignedMessageHash, v, r, s);
+  }
+
+  function splitSignature(bytes memory sig) private pure returns (bytes32 r, bytes32 s, uint8 v) {
+    require(sig.length == 65, "invalid signature length");
+    assembly {
+    r := mload(add(sig, 32))
+	s := mload(add(sig, 64))
+	v := byte(0, mload(add(sig, 96)))
+	}
+  }
+}

package/contracts/apps/ZKBridge.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.7.0 <0.9.0;
+
+interface IZKDB {
+  
+  function qInt (uint[] memory path, uint[] memory zkp) external view returns (int);
+  
+  function qString ( uint[] memory path, uint[] memory zkp) external view returns (string memory);
+  
+}
+
+interface IERC20 {
+  function mint (address, uint) external;
+}
+  
+contract ZKBridge {
+  address public zkdb;
+  address public token;
+  mapping(uint => bool) public done;
+  constructor (address _zkdb, address _token){
+    zkdb = _zkdb;
+    token = _token;
+  }
+
+  function hexCharToByte(uint8 c) public pure returns (uint8) {
+    if (bytes1(c) >= bytes1('0') && bytes1(c) <= bytes1('9')) {
+      return c - uint8(bytes1('0'));
+    }
+    if (bytes1(c) >= bytes1('a') && bytes1(c) <= bytes1('f')) {
+      return 10 + c - uint8(bytes1('a'));
+    }
+    if (bytes1(c) >= bytes1('A') && bytes1(c) <= bytes1('F')) {
+      return 10 + c - uint8(bytes1('A'));
+    }
+    revert("Invalid hex character");
+  }
+
+  function toAddr(string memory s) public pure returns (address) {
+    bytes memory ss = bytes(s);
+    require(ss.length == 42, "Invalid length");
+        
+    uint256 r = 0;
+    for (uint256 i = 2; i < 42; i++) {
+      r = r * 16 + hexCharToByte(uint8(ss[i]));
+    }
+
+    return address(uint160(r));
+  }
+  
+  function char(bytes1 b) internal pure returns (bytes1 c) {
+    if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
+    else return bytes1(uint8(b) + 0x57);
+  }
+  
+  function bridge(uint col, uint doc, uint[] memory zkp, uint[] memory zkp2) public returns (address){
+    require(done[doc] == false, "already minted");
+    done[doc] = true;
+    uint[] memory path = new uint[](3);
+    path[0] = col;
+    path[1] = doc;
+    path[2] = 1111231163111;
+    uint[] memory path2 = new uint[](3);
+    path2[0] = col;
+    path2[1] = doc;
+    path2[2] = 1111629731093111311731103116;
+    string memory str = IZKDB(zkdb).qString(path, zkp);
+    address addr = toAddr(str);
+    int balance = IZKDB(zkdb).qInt(path2, zkp2);
+    IERC20(token).mint(addr, uint(balance));
+    return addr;
+  }
+  
+}

package/contracts/apps/ZKNFT.sol

@@ -0,0 +1,63 @@
+/// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "../ZKIPFS.sol";
+
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+import {ERC721URIStorage} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
+
+contract ZKNFT is ERC721URIStorage, ZKIPFS {
+  uint256 private _nextTokenId;
+  constructor(address _verifierIPFS) ERC721("ZKNFT", "ZKNFT") {
+    verifierIPFS = _verifierIPFS;
+  }
+
+  function mint(address to, string memory tokenURI)
+    public
+    returns (uint256)
+  {
+    uint256 tokenId = _nextTokenId++;
+    _mint(to, tokenId);
+    _setTokenURI(tokenId, tokenURI);
+
+    return tokenId;
+  }
+  
+  function _verify (uint tokenId, uint[] memory path, uint[] memory zkp) private view returns (uint[] memory) {
+    return validateQuery(tokenURI(tokenId), path, zkp);
+  }
+
+  function qString (uint tokenId, uint[] memory path, uint[] memory zkp) public view returns (string memory) {
+    return _qString(_verify(tokenId, path, zkp));
+  }
+  
+  function qInt (uint tokenId, uint[] memory path, uint[] memory zkp) public view returns (int) {
+    return _qInt(_verify(tokenId, path, zkp));
+  }
+
+  function qFloat (uint tokenId, uint[] memory path, uint[] memory zkp) public view returns (uint[3] memory) {
+    return _qFloat(_verify(tokenId, path, zkp));
+  }
+
+  function qBool (uint tokenId, uint[] memory path, uint[] memory zkp) public view returns (bool) {
+    return _qBool(_verify(tokenId, path, zkp));
+  }
+
+  function qNull (uint tokenId, uint[] memory path, uint[] memory zkp) public view returns (bool) {
+    return _qNull(_verify(tokenId, path, zkp));
+  }  
+
+  function qRaw (uint tokenId, uint[] memory path, uint[] memory zkp) internal view returns (uint[] memory) {
+    return _qRaw(_verify(tokenId, path, zkp));
+  }
+
+  function qCustom (uint tokenId, uint[] memory path, uint[] memory path2, uint[] memory zkp) public view returns (int) {
+    return getInt(path2, qRaw(tokenId, path, zkp));
+  }
+  
+  function qCond (uint tokenId, uint[] memory path, uint[] memory cond, uint[] memory zkp) public view returns (bool) {
+    return _qCond(_verify(tokenId, path, zkp), cond);
+  }  
+  
+}

package/contracts/verifiers/verifier_db.sol

@@ -37,56 +37,62 @@ contract Groth16VerifierDB {
     uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
     uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
     uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 4503582552430561212779022449004306860952515258252510730703342683904433748529;
-    uint256 constant deltax2 = 18425111920911215222332253146797783332823283746160018203034073853247125442993;
-    uint256 constant deltay1 = 4453946082216241594348271243333609134155973515870520791839116124952157106489;
-    uint256 constant deltay2 = 6299943403529237547647875143706632408243402531062446767696226637461756039372;
+    uint256 constant deltax1 = 566319682436850529692773273170461279524268577891150635825387390239831567882;
+    uint256 constant deltax2 = 18860268461005016027048821926573675096822806032916343944940397566918262972873;
+    uint256 constant deltay1 = 18469561290186198192930600182225641948070680663786775400869545881576215584097;
+    uint256 constant deltay2 = 16843711002267486950099400107694084564320643561117060725912074365097520873528;
 
     
-    uint256 constant IC0x = 21321207194104473227475304543920529140777253812445062785414102137810628823351;
-    uint256 constant IC0y = 17435301628228161373103753422842813332325503638744597201144754851019312998703;
+    uint256 constant IC0x = 15211415922364842912753184178425045511192002084183450091972766587897729031131;
+    uint256 constant IC0y = 15971336196196622349517605395705397293225200783943199092270415284510546939053;
     
-    uint256 constant IC1x = 12820400866256307684567623036475747952236795131426943895421353782394091927742;
-    uint256 constant IC1y = 60275713036652700837316478219950928712704126788272985582350169411243461644;
+    uint256 constant IC1x = 3464979308878298246776645144833226341117035087307090727251356729925690049544;
+    uint256 constant IC1y = 2701132742000937878189241109199334668029723964378951774716229117963684334785;
     
-    uint256 constant IC2x = 857253043166092910744552687303159485904872523742588131455423770248915368285;
-    uint256 constant IC2y = 14195849356583660474308242114329315396764028733952643683061195745221866004517;
+    uint256 constant IC2x = 17746992021893097019070205838284045039565036550366113750079443947456708932914;
+    uint256 constant IC2y = 20205302109688801012538493936661638426411524231619729625407218303411393971055;
     
-    uint256 constant IC3x = 21758746957477097206930100418195981232696693412252142756415630022251620498988;
-    uint256 constant IC3y = 13410227681809155220050013564476536866963972600821261716783794631827707904349;
+    uint256 constant IC3x = 12245350253809957962446325719420284548409481797652910572382809447209300296011;
+    uint256 constant IC3y = 2181944750218360909814361656088418665618898112511704294612292313825818583174;
     
-    uint256 constant IC4x = 863580107893288900828264046203999618333374859561603309534755206187548007845;
-    uint256 constant IC4y = 17276530052140799694039014154041098203841609580394223470304419489978941020095;
+    uint256 constant IC4x = 14272371780610106622173486440520433262823996106221430333841111091741849894946;
+    uint256 constant IC4y = 2651668025058914772481681251893270544825897012494799335931264036971472027402;
     
-    uint256 constant IC5x = 20860866781226655978193967912232894914994034954825205708931667985751271655154;
-    uint256 constant IC5y = 12177441101666309938978105246002445372089044967481369877555009124474329640505;
+    uint256 constant IC5x = 15368773499402856795009961960791288514014805980406357981082924459251021982345;
+    uint256 constant IC5y = 19702123112400711796073644885827586177870326559870904640843668152019488063904;
     
-    uint256 constant IC6x = 10253410591025171769139608115823458515554722863591962190480237037964222989835;
-    uint256 constant IC6y = 2300854166049230775727949815888955384104705675980904483480782073188875432218;
+    uint256 constant IC6x = 10677187776951951873630238944736414260225581042281553648384370976204183115940;
+    uint256 constant IC6y = 1992236736977150082653976323411946326010253872212815347510072691523085595255;
     
-    uint256 constant IC7x = 9245031860281158825371686872766118053567656180865626846873554393892189651843;
-    uint256 constant IC7y = 18513814971835729370836379685375481264692236826421466003977840558207277913353;
+    uint256 constant IC7x = 21415137280411204335091094503224446366978234376524115265045654108152006539895;
+    uint256 constant IC7y = 18542175761555436023959545358821820821282980394602494205800055757297012906764;
     
-    uint256 constant IC8x = 2754620511499804101010165108130638609126165250442796483020701485428889593474;
-    uint256 constant IC8y = 21543955085620310283456271839558892054215536683326587016759091514123004776495;
+    uint256 constant IC8x = 6283856560272202991953013809355758204828896535304136319974685636684888856128;
+    uint256 constant IC8y = 14499901693513608835779722317486164346309825524575154749627267356894076467615;
     
-    uint256 constant IC9x = 7226523333475405455471783299389388256960485582655675212929034730327278898093;
-    uint256 constant IC9y = 5056090250187692130221637329845012688890940869984044755973476873548610820578;
+    uint256 constant IC9x = 19685518566119573827093988474850506880006629001058664371716514877455244663914;
+    uint256 constant IC9y = 8481292601887397637049972433197231800580995340144247273832382075808559008848;
     
-    uint256 constant IC10x = 10107033883545633867195921318423461010318227740867478163570877213298959179572;
-    uint256 constant IC10y = 503817861296261242201817887974509587032687921855950877235697350857170430743;
+    uint256 constant IC10x = 223137936376193785345096638287096394886709464533117482694619505935732331537;
+    uint256 constant IC10y = 4193175916548019617597370686901033731734454606724750484807673453694700951952;
     
-    uint256 constant IC11x = 21035943047303381225570192698677598249462130417684515089990469613546011008550;
-    uint256 constant IC11y = 7261441348374767801093007257999121003733259642366629311136938544979253433119;
+    uint256 constant IC11x = 16453801468826605202509345195157388810770747557053039494013978418267763931861;
+    uint256 constant IC11y = 9875951739441984097810674555101191788888352673039488118805457327521421929503;
     
-    uint256 constant IC12x = 20453521999827294992536897361543222148394244433474196230498330885560620003829;
-    uint256 constant IC12y = 18476327162478621518583504728598744035870583497372084378654039079117097682;
+    uint256 constant IC12x = 21492667345885781313718619285662713900245557314551393448696666210356792295028;
+    uint256 constant IC12y = 13513771098803659055046650647390462300798249154666189755091027612809331818956;
     
-    uint256 constant IC13x = 15724968258919878061585416513119667249637764275276227548708222282031970422796;
-    uint256 constant IC13y = 15146709066947881278827713419811426264008528066434458265193671798769307857310;
+    uint256 constant IC13x = 4220313889112567763732397801925007682896952364521933389131895252279385675080;
+    uint256 constant IC13y = 4489372840961844505718038698916106673528658906928588565989450268053621743612;
     
-    uint256 constant IC14x = 9097393479338656770619464061691689490135837081335461486896937720741934261539;
-    uint256 constant IC14y = 3771549967344233937612853274190217413635208199629257189936808052809357297423;
+    uint256 constant IC14x = 14271407211698650570939162738932653937074499981772815895780302661786173648938;
+    uint256 constant IC14y = 19455923871335066470920134858740491433267919882177953263240475980057134848859;
+    
+    uint256 constant IC15x = 16133332441580541207424712869162600438872610254859964823012819022285880626496;
+    uint256 constant IC15y = 205394163904875832569231417271795177705566674339331369995643748855708511527;
+    
+    uint256 constant IC16x = 20041249883696113203488105074051660077326597780992987346896682994784878002567;
+    uint256 constant IC16y = 17581544103776691653953052153212138864315675260675640899993173889329216891748;
     
  
     // Memory data
@@ -95,7 +101,7 @@ contract Groth16VerifierDB {
 
     uint16 constant pLastMem = 896;
 
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[14] calldata _pubSignals) public view returns (bool) {
+    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[16] calldata _pubSignals) public view returns (bool) {
         assembly {
             function checkField(v) {
                 if iszero(lt(v, q)) {
@@ -167,6 +173,10 @@ contract Groth16VerifierDB {
                 
                 g1_mulAccC(_pVk, IC14x, IC14y, calldataload(add(pubSignals, 416)))
                 
+                g1_mulAccC(_pVk, IC15x, IC15y, calldataload(add(pubSignals, 448)))
+                
+                g1_mulAccC(_pVk, IC16x, IC16y, calldataload(add(pubSignals, 480)))
+                
 
                 // -A
                 mstore(_pPairing, calldataload(pA))
@@ -250,6 +260,10 @@ contract Groth16VerifierDB {
             
             checkField(calldataload(add(_pubSignals, 448)))
             
+            checkField(calldataload(add(_pubSignals, 480)))
+            
+            checkField(calldataload(add(_pubSignals, 512)))
+            
 
             // Validate all evaluations
             let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)

package/contracts/verifiers/verifier_ipfs.sol

@@ -37,10 +37,10 @@ contract Groth16VerifierIPFS {
     uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
     uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
     uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 146777209207054605867012766179094502537968350551215607925008955076263549067;
-    uint256 constant deltax2 = 2633871596100807401284925083226459189796882085586154321492118367916651237117;
-    uint256 constant deltay1 = 21012385740760062171685374025920180961146768579042536716146176459660919755825;
-    uint256 constant deltay2 = 609193939489547291159258179603724194177454651776958423928855714448170018063;
+    uint256 constant deltax1 = 16750032045563760710929521100859621241226846513668026156029771684316880404599;
+    uint256 constant deltax2 = 16898207697433710914864976772340912260166064601616416232383205018567189411131;
+    uint256 constant deltay1 = 3515011879290403013877934743012053356401335889951849763330532564325612883650;
+    uint256 constant deltay2 = 8625609472899458752119724414156732692585644842390067317870160518196882424997;
 
     
     uint256 constant IC0x = 14336108542425917447460243179215548887531443288921789758034763267112594821597;

package/contracts/verifiers/verifier_json.sol

@@ -37,10 +37,10 @@ contract Groth16VerifierJSON {
     uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
     uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
     uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 16323886806377948767625289345386923912488425685292264502851407533751890364893;
-    uint256 constant deltax2 = 15728036135898260810892479278030679906213338463446298332250898095140196532350;
-    uint256 constant deltay1 = 7311361608150524708643711937539709432213365833416427921151717898214981893794;
-    uint256 constant deltay2 = 5360237348765695204487062346058482342794521371770543578645384390456849442785;
+    uint256 constant deltax1 = 10548989649020101460514539324030972308502034681633392883991961616863130637984;
+    uint256 constant deltax2 = 1049946570122174039975801346728261460931086847141295177952236227197145479746;
+    uint256 constant deltay1 = 10558381744179704646192748283236903784158982943346653783344902335722321321384;
+    uint256 constant deltay2 = 16748276816739890599042583608461502899144793788720809401511640542800930620065;
 
     
     uint256 constant IC0x = 11086791052709537593958527982551466373543557342479473456486918346706557110272;
@@ -82,6 +82,12 @@ contract Groth16VerifierJSON {
     uint256 constant IC12x = 3003572233500184455318954446784006239696026573012811847295348627074111281539;
     uint256 constant IC12y = 6485361686957307324235352983357156310358934769793375149333110905137006337248;
     
+    uint256 constant IC13x = 2025484288051762304170760878169695013364214111997466862551524207031601382631;
+    uint256 constant IC13y = 7038960739366138059493181524660940249493960394838603142532679804397882049709;
+    
+    uint256 constant IC14x = 11387856957329089595489992260814785056704488293876837097183204151395206987719;
+    uint256 constant IC14y = 17844362785282169318131685916181008035618810588862118232161118858351706006467;
+    
  
     // Memory data
     uint16 constant pVk = 0;
@@ -89,7 +95,7 @@ contract Groth16VerifierJSON {
 
     uint16 constant pLastMem = 896;
 
-    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[12] calldata _pubSignals) public view returns (bool) {
+    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[14] calldata _pubSignals) public view returns (bool) {
         assembly {
             function checkField(v) {
                 if iszero(lt(v, q)) {
@@ -157,6 +163,10 @@ contract Groth16VerifierJSON {
                 
                 g1_mulAccC(_pVk, IC12x, IC12y, calldataload(add(pubSignals, 352)))
                 
+                g1_mulAccC(_pVk, IC13x, IC13y, calldataload(add(pubSignals, 384)))
+                
+                g1_mulAccC(_pVk, IC14x, IC14y, calldataload(add(pubSignals, 416)))
+                
 
                 // -A
                 mstore(_pPairing, calldataload(pA))
@@ -236,6 +246,10 @@ contract Groth16VerifierJSON {
             
             checkField(calldataload(add(_pubSignals, 384)))
             
+            checkField(calldataload(add(_pubSignals, 416)))
+            
+            checkField(calldataload(add(_pubSignals, 448)))
+            
 
             // Validate all evaluations
             let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)

package/contracts/verifiers/verifier_rollup.sol

@@ -37,47 +37,47 @@ contract Groth16VerifierRU {
     uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
     uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
     uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
-    uint256 constant deltax1 = 20503591479484091524389745903571071797103515451455738548515763475839920684921;
-    uint256 constant deltax2 = 5617943403828393228867947181181000280381763965560908736009901041763172427158;
-    uint256 constant deltay1 = 19083313989582849416852727426203922087129577621288485271208858162180563989517;
-    uint256 constant deltay2 = 6862756714407978275897080062526754044127957156216819881004695153747745594448;
+    uint256 constant deltax1 = 12826039923985305509172445548825630308307897385636638314103089050117034765807;
+    uint256 constant deltax2 = 5777316040111550683119122338100696671533578054713112313962719197468777904391;
+    uint256 constant deltay1 = 13100118653411399080908320939554734522926116642572965561618759712020115377487;
+    uint256 constant deltay2 = 4863992084126820334137644474127866316351574790993028000936897867731380377202;
 
     
-    uint256 constant IC0x = 8117166905692109919104291343856029475477412767491303376211389191152967038468;
-    uint256 constant IC0y = 9786515749803639719852807382408592347129424775311166090035686108630492765324;
+    uint256 constant IC0x = 6270950016247133466336754274326443126017687703801742756948638236534086892047;
+    uint256 constant IC0y = 20310453393525738917452540227487036745129047678621136376195858836563533911527;
     
-    uint256 constant IC1x = 8372619712685736857836778212277410061184000966061820660353663736436010324900;
-    uint256 constant IC1y = 7067497483771029122224543049910217766313555809959258482125432607420578209549;
+    uint256 constant IC1x = 1141343197515056438569346347535803858564689453833647046018791462772549149227;
+    uint256 constant IC1y = 16491780663163267442130703331018113562992698794258578658230547724337214632511;
     
-    uint256 constant IC2x = 8664544978528071254218294973797032588678014503773496766308416357733046318778;
-    uint256 constant IC2y = 1718370739886043626655047048989167081845643514431816517183086335106787323814;
+    uint256 constant IC2x = 5569694830107596991306292701850289725347601942273592203980263593485643232633;
+    uint256 constant IC2y = 5496875873369182800954050214612959091907601104963709673444966250025502326758;
     
-    uint256 constant IC3x = 17751478333748864683647456466294726036073972233143791990284780060329145813120;
-    uint256 constant IC3y = 5332438974111244723611637766367681701415489964863909660487320379077476391752;
+    uint256 constant IC3x = 856226396972901355666350894014284120170327945287396680478814592107007149805;
+    uint256 constant IC3y = 4080222902213037494283476857599202091267684100021446005131603140238216815391;
     
-    uint256 constant IC4x = 20742828080385750796683930560189396553036781354782278562302384256732853843949;
-    uint256 constant IC4y = 1351673933396889997409523595926983213620423546050525776383348532660582633773;
+    uint256 constant IC4x = 10764306455319897189590233363611208010675243280639689255137625645138943859385;
+    uint256 constant IC4y = 19346540917500920047750697423047140511552971607568238316315807020898102730868;
     
-    uint256 constant IC5x = 20503268205499473416904271262498573431374552398139117269682363052068963140978;
-    uint256 constant IC5y = 3732804412299701993142127591762498360367649767364421523113109866299226710165;
+    uint256 constant IC5x = 16857068565745876906748660361991141069946983257614833579471638734061485457112;
+    uint256 constant IC5y = 14632180805427053926564788976583761986580123762441719835724709161702471836981;
     
-    uint256 constant IC6x = 14257995503266038917376264725392135727319727614567664291464265707947560137941;
-    uint256 constant IC6y = 341674734661014039525000101720981104421961371042562178520683297866596707154;
+    uint256 constant IC6x = 12315747360356477219902572740218642460149278211574165192334271766621665438376;
+    uint256 constant IC6y = 1313234108449442273460693358644853644145068014633280121061495643296281134420;
     
-    uint256 constant IC7x = 8193832556543527639708689676411352413933876589415237015016698770441031255042;
-    uint256 constant IC7y = 6594427869611603078697503063082014095062802376771554910392397589449346189644;
+    uint256 constant IC7x = 15252212582859770288887248094717972825568314500168925087757606041256952964029;
+    uint256 constant IC7y = 19751607759272618647644406330677066920139018206963959740625861713276025168423;
     
-    uint256 constant IC8x = 13583345943944676979948187443700187050998549308300528606491967244177176520006;
-    uint256 constant IC8y = 4938411793249197289917720689106756285526796809363092891408044710943884674802;
+    uint256 constant IC8x = 8432690145128824085267914412714661508760195558814883868966832777728733350601;
+    uint256 constant IC8y = 20683188851611894785172396447809130386092126094512442322570355864144302756164;
     
-    uint256 constant IC9x = 11332284497411134754454830299053795514601435700763578724160974435166700044531;
-    uint256 constant IC9y = 13019000604073974366403109311897527900603263821666939992822627393063021671404;
+    uint256 constant IC9x = 19369987132771616043793275659835942692385855791064890369063891639761686156657;
+    uint256 constant IC9y = 8426683055759400985089789088504223062497842350159798813155638560974712761643;
     
-    uint256 constant IC10x = 14399226292391120536283418546213611923264868223599916657548457588778188745914;
-    uint256 constant IC10y = 15721807309515116598525148493431362514780681023570830598111469229105621080436;
+    uint256 constant IC10x = 20860096825664394339889589645802586392309097833727587594050802394079690409091;
+    uint256 constant IC10y = 17908147166318266417496260692526339764629505794576827802816790292654348457101;
     
-    uint256 constant IC11x = 9762413796519510440691741324561546062505760014187240868624893625208356342750;
-    uint256 constant IC11y = 16246137136591544636923946475468706707718504791810616178029498386514365251482;
+    uint256 constant IC11x = 7111525545052173450141644018481693095722931164254044734852844952175519360375;
+    uint256 constant IC11y = 14968059451881120855243147686628983750275388350316603656458857787322628363714;
     
  
     // Memory data

package/package.json

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