zkjson 0.6.0 → 1.0.2

package/circom/json/test.js

@@ -0,0 +1,100 @@
+const chai = require("chai")
+const { join } = require("path")
+const wasm_tester = require("circom_tester").wasm
+const gen = require("./gen")
+const gen2 = require("./gen2")
+const json = {
+  num: 5,
+  str: "str",
+  bool: false,
+  bool2: true,
+  null: null,
+  arr: [1, 2, 3],
+  arr2: [null, 1.5, false, "str"],
+}
+const cases = [
+  ["num", ["$eq", 5]],
+  ["num", ["$gt", 4]],
+  ["num", ["$lt", 6]],
+  ["num", ["$gte", 5]],
+  ["num", ["$lte", 5]],
+  ["num", ["$ne", 6]],
+  ["num", ["$in", [5, 6]]],
+  ["num", ["$nin", [6, 7]]],
+
+  ["num", ["$eq", 4], true],
+  ["num", ["$gt", 5], true],
+  ["num", ["$lt", 4], true],
+  ["num", ["$gte", 6], true],
+  ["num", ["$lte", 4], true],
+  ["num", ["$ne", 5], true],
+  ["num", ["$in", [6, 7]], true],
+  ["num", ["$nin", [5, 6, 7]], true],
+
+  ["str", ["$eq", "str"]],
+  ["str", ["$gt", "sta"]],
+  ["str", ["$lt", "str2"]],
+  ["str", ["$gte", "str"]],
+  ["str", ["$lte", "str"]],
+  ["str", ["$ne", "st"]],
+
+  ["bool", ["$eq", false]],
+  ["bool2", ["$gt", false]],
+  ["bool", ["$lt", true]],
+  ["bool", ["$gte", false]],
+  ["bool", ["$lte", false]],
+  ["bool", ["$ne", true]],
+
+  ["arr", ["$contains", 2]],
+  ["arr", ["$contains", 0], true],
+  ["arr", ["$contains_any", [0, 2]]],
+  ["arr", ["$contains_any", [0, 5]], true],
+  ["arr", ["$contains_all", [1, 2]]],
+  ["arr", ["$contains_all", [1, 2, 5]], true],
+  ["arr", ["$contains_none", [0, 4, 5]]],
+  ["arr", ["$contains_none", [0, 2, 4, 5]], true],
+
+  ["arr2", ["$contains", null]],
+  ["arr2", ["$contains", 1.5]],
+  ["arr2", ["$contains", false]],
+  ["arr2", ["$contains", "str"]],
+  ["arr2", ["$contains", true], true],
+  ["arr2", ["$contains_any", [1.2, "str"]]],
+  ["arr2", ["$contains_any", [0, true]], true],
+  ["arr2", ["$contains_all", [null, false]]],
+  ["arr2", ["$contains_all", [null, false, 5]], true],
+  ["arr2", ["$contains_none", ["str2", true, 1.4]]],
+  ["arr2", ["$contains_none", [1.4, "str2", null]], true],
+]
+describe("JSON circuit", function () {
+  let circuit
+  this.timeout(0)
+
+  before(async () => {
+    circuit = await wasm_tester(join(__dirname, "index.circom"))
+    await circuit.loadSymbols()
+  })
+
+  it.only("should insert docs", async () => {
+    const { inputs } = await gen({})
+    const w = await circuit.calculateWitness(inputs, true)
+    await circuit.checkConstraints(w)
+    await circuit.assertOut(w, { exist: 1 })
+
+    for (let v of cases) {
+      console.log(v)
+      const { inputs } = await gen2({ json, path: v[0], query: v[1] })
+      try {
+        const w = await circuit.calculateWitness(inputs, true)
+        await circuit.checkConstraints(w)
+        await circuit.assertOut(w, { exist: 1 })
+        if (v[2]) throw Error("should throw error")
+      } catch (e) {
+        if (!v[2]) {
+          console.log(e)
+          throw Error("should not throw error")
+        }
+      }
+    }
+  })
+})

package/circom/json/verifier.sol

@@ -0,0 +1,247 @@
+// SPDX-License-Identifier: GPL-3.0
+/*
+    Copyright 2021 0KIMS association.
+
+    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
+
+    snarkJS is a free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    snarkJS is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+    License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract Groth16Verifier {
+    // Scalar field size
+    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+    // Verification Key data
+    uint256 constant alphax  = 7332885377758315278340183047560982420908393795468599595091895974752420296340;
+    uint256 constant alphay  = 332255058049377868589021735422241784808251989994698755461004804814851540428;
+    uint256 constant betax1  = 14918511796604743115529252945397806548811923425844505517068409231790256866971;
+    uint256 constant betax2  = 211413574403138532859071680094500506786935898681671422463746292741380691281;
+    uint256 constant betay1  = 19126853899579995366417647673795374157635727056721981778430611935842415927913;
+    uint256 constant betay2  = 19131403844100444556608656382423150552404085133882015610549223179149801306375;
+    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant deltax1 = 8778953153895167140801159972138887693000611366500157505127608636174382054606;
+    uint256 constant deltax2 = 7156402624745626817088873620667212892373193048534817918048444344582127808199;
+    uint256 constant deltay1 = 15409977163028627745606562064378045641943443717311465348895192400331775112959;
+    uint256 constant deltay2 = 6127749910612865802775348493533411564760857202041068074885879457830771131731;
+
+    
+    uint256 constant IC0x = 14149961698706401474756013637219762589886084844706330955521170102253661785782;
+    uint256 constant IC0y = 12234408390949945565728151697713577721072768882766707772269268661650572015929;
+    
+    uint256 constant IC1x = 15287398227625205558818431588910290770512662117774041546723640633129931357061;
+    uint256 constant IC1y = 16012938837910940678360804184951691699846514147461899602384360632673883428896;
+    
+    uint256 constant IC2x = 9418709953143181098924564786961115384655969340686778743507647523173886049039;
+    uint256 constant IC2y = 11367527508005828024999408976465266676043307816796847517725311003575198690479;
+    
+    uint256 constant IC3x = 6030863567192013675941022755318414592630768333244345100569879259036699787359;
+    uint256 constant IC3y = 14659074011411032793161383706226526849424995839698828898401936143049675949239;
+    
+    uint256 constant IC4x = 19963179709991794771873805927403251489690353439768757800630946653626635161707;
+    uint256 constant IC4y = 1470766587651703535085614791279830514388462305603574340659937640856761424395;
+    
+    uint256 constant IC5x = 14659390081523554628219805325675728281784994838522534096490755865319885123083;
+    uint256 constant IC5y = 11287441218915253838012709899838816796039024083285099779106808382644409454441;
+    
+    uint256 constant IC6x = 16250390867585764345415023080703876700586439759793624872982224204111668882485;
+    uint256 constant IC6y = 8035681254387642287763926439378674113266797781140623660108466958190513530084;
+    
+    uint256 constant IC7x = 16179522891432586899572983586580199373249206719523536115810454935385979852482;
+    uint256 constant IC7y = 21493117163996505943733751819663993908203969619214657020729691663220708780018;
+    
+    uint256 constant IC8x = 10514168627673971656312201849246481479452043276699188440350351264194471133025;
+    uint256 constant IC8y = 20133917426168149360907990301877459703907720340598371306707853823386928860250;
+    
+    uint256 constant IC9x = 6266965211637046181111806809564867246649620928402563041803484933568280189957;
+    uint256 constant IC9y = 7946958101666049254953231611540370717046038943359039062825104454493066303159;
+    
+    uint256 constant IC10x = 19760592053490991883913906245948207730828356105180720589710426327543408434351;
+    uint256 constant IC10y = 2794087805839231510776045227837416461273508102639790771777910214138852571223;
+    
+    uint256 constant IC11x = 18199503593569846044109884213575086619142399095780120064324920465410206678544;
+    uint256 constant IC11y = 19237589446350435847357191463973661320008591906666182081064297336131201934242;
+    
+    uint256 constant IC12x = 19573137937282925164552262830726242817408707332199773844604230285268555301250;
+    uint256 constant IC12y = 2662418044136441320926682626787705028452732305078998815313537787219417917203;
+    
+ 
+    // Memory data
+    uint16 constant pVk = 0;
+    uint16 constant pPairing = 128;
+
+    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) {
+        assembly {
+            function checkField(v) {
+                if iszero(lt(v, q)) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+            
+            // G1 function to multiply a G1 value(x,y) to value in an address
+            function g1_mulAccC(pR, x, y, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, x)
+                mstore(add(mIn, 32), y)
+                mstore(add(mIn, 64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+
+                mstore(add(mIn, 64), mload(pR))
+                mstore(add(mIn, 96), mload(add(pR, 32)))
+
+                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+
+            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
+                let _pPairing := add(pMem, pPairing)
+                let _pVk := add(pMem, pVk)
+
+                mstore(_pVk, IC0x)
+                mstore(add(_pVk, 32), IC0y)
+
+                // Compute the linear combination vk_x
+                
+                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
+                
+                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
+                
+                g1_mulAccC(_pVk, IC3x, IC3y, calldataload(add(pubSignals, 64)))
+                
+                g1_mulAccC(_pVk, IC4x, IC4y, calldataload(add(pubSignals, 96)))
+                
+                g1_mulAccC(_pVk, IC5x, IC5y, calldataload(add(pubSignals, 128)))
+                
+                g1_mulAccC(_pVk, IC6x, IC6y, calldataload(add(pubSignals, 160)))
+                
+                g1_mulAccC(_pVk, IC7x, IC7y, calldataload(add(pubSignals, 192)))
+                
+                g1_mulAccC(_pVk, IC8x, IC8y, calldataload(add(pubSignals, 224)))
+                
+                g1_mulAccC(_pVk, IC9x, IC9y, calldataload(add(pubSignals, 256)))
+                
+                g1_mulAccC(_pVk, IC10x, IC10y, calldataload(add(pubSignals, 288)))
+                
+                g1_mulAccC(_pVk, IC11x, IC11y, calldataload(add(pubSignals, 320)))
+                
+                g1_mulAccC(_pVk, IC12x, IC12y, calldataload(add(pubSignals, 352)))
+                
+
+                // -A
+                mstore(_pPairing, calldataload(pA))
+                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
+
+                // B
+                mstore(add(_pPairing, 64), calldataload(pB))
+                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
+                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
+                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
+
+                // alpha1
+                mstore(add(_pPairing, 192), alphax)
+                mstore(add(_pPairing, 224), alphay)
+
+                // beta2
+                mstore(add(_pPairing, 256), betax1)
+                mstore(add(_pPairing, 288), betax2)
+                mstore(add(_pPairing, 320), betay1)
+                mstore(add(_pPairing, 352), betay2)
+
+                // vk_x
+                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
+                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
+
+
+                // gamma2
+                mstore(add(_pPairing, 448), gammax1)
+                mstore(add(_pPairing, 480), gammax2)
+                mstore(add(_pPairing, 512), gammay1)
+                mstore(add(_pPairing, 544), gammay2)
+
+                // C
+                mstore(add(_pPairing, 576), calldataload(pC))
+                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
+
+                // delta2
+                mstore(add(_pPairing, 640), deltax1)
+                mstore(add(_pPairing, 672), deltax2)
+                mstore(add(_pPairing, 704), deltay1)
+                mstore(add(_pPairing, 736), deltay2)
+
+
+                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
+
+                isOk := and(success, mload(_pPairing))
+            }
+
+            let pMem := mload(0x40)
+            mstore(0x40, add(pMem, pLastMem))
+
+            // Validate that all evaluations ∈ F
+            
+            checkField(calldataload(add(_pubSignals, 0)))
+            
+            checkField(calldataload(add(_pubSignals, 32)))
+            
+            checkField(calldataload(add(_pubSignals, 64)))
+            
+            checkField(calldataload(add(_pubSignals, 96)))
+            
+            checkField(calldataload(add(_pubSignals, 128)))
+            
+            checkField(calldataload(add(_pubSignals, 160)))
+            
+            checkField(calldataload(add(_pubSignals, 192)))
+            
+            checkField(calldataload(add(_pubSignals, 224)))
+            
+            checkField(calldataload(add(_pubSignals, 256)))
+            
+            checkField(calldataload(add(_pubSignals, 288)))
+            
+            checkField(calldataload(add(_pubSignals, 320)))
+            
+            checkField(calldataload(add(_pubSignals, 352)))
+            
+            checkField(calldataload(add(_pubSignals, 384)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }

package/circom/query/compile.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+circom index.circom --r1cs --wasm --sym --c \
+&& cd index_js \
+&& node generate_witness.js index.wasm ../input.json witness.wtns \
+&& cd .. \
+&& snarkjs groth16 setup index.r1cs ../pot12_final.ptau index_0000.zkey \
+&& snarkjs zkey contribute index_0000.zkey index_0001.zkey --name="zkJSON" -v \
+&& snarkjs zkey export verificationkey index_0001.zkey verification_key.json \
+&& snarkjs groth16 prove index_0001.zkey index_js/witness.wtns proof.json public.json \
+&& snarkjs groth16 verify verification_key.json public.json proof.json;

package/circom/query/gen.js

@@ -0,0 +1,28 @@
+const { DB } = require("../../sdk")
+
+const gen = async ({
+  size_val = 256,
+  size_path = 256,
+  size_json = 256,
+  level = 168,
+  level_col = 8,
+}) => {
+  const db = new DB({ size_val, size_path, size_json, level, level_col })
+  await db.init()
+  const col1 = await db.addCollection()
+  const col2 = await db.addCollection()
+  await db.insert(col2, "docB", { b: 2 })
+  await db.insert(col1, "docB", { b: 2 })
+  await db.insert(col1, "docC", { c: 3 })
+  await db.insert(col1, "docA", { c: 4 })
+  return {
+    db,
+    inputs: await db.getQueryInputs({
+      col_id: col1,
+      id: "docA",
+      json: { a: 5 },
+    }),
+  }
+}
+
+module.exports = gen

package/circom/query/generateInput.js

@@ -0,0 +1,11 @@
+const gen = require("./gen")
+
+const { writeFileSync } = require("fs")
+const { resolve } = require("path")
+
+const main = async () => {
+  const { inputs } = await gen({})
+  writeFileSync(resolve(__dirname, "input.json"), JSON.stringify(inputs))
+}
+
+main()

package/circom/query/index.circom

@@ -0,0 +1,4 @@
+pragma circom 2.1.5;
+include "./query.circom";
+
+component main {public [oldRoot]} = Query(8, 168, 256);

package/circom/query/query.circom

@@ -0,0 +1,58 @@
+pragma circom 2.1.5;
+include "../../node_modules/circomlib/circuits/smt/smtprocessor.circom";
+include "../../node_modules/circomlib/circuits/poseidon.circom";
+
+template Query (level_col, level, size_json) {
+    signal input siblings[level];
+    signal input json[size_json];
+    signal input newRoot;
+    signal input newKey;
+    signal input oldRoot;
+    signal input isOld0;
+    signal input oldValue;
+    signal input oldKey;
+    signal input oldRoot_db;
+    signal input oldKey_db;
+    signal input oldValue_db;
+    signal input isOld0_db;
+    signal input fnc[2];
+    signal input siblings_db[level_col];
+    signal input newKey_db;
+        
+    signal output new_root;
+    
+    component colVerifier = SMTProcessor(level);
+    component all_hash = Poseidon(16);
+    component _hash[16];
+    for(var i = 0; i < 16; i++){
+      _hash[i] = Poseidon(16);
+      for(var i2 = 0; i2 < 16; i2++){
+        _hash[i].inputs[i2] <== json[i * 16 + i2];
+      }
+      all_hash.inputs[i] <== _hash[i].out;
+    } 
+    colVerifier.fnc[0] <== fnc[0];
+    colVerifier.fnc[1] <== fnc[1];
+    colVerifier.oldRoot <== oldRoot;
+    colVerifier.oldKey <== oldKey;
+    colVerifier.oldValue <== oldValue;
+    colVerifier.isOld0 <== isOld0;
+    colVerifier.siblings <== siblings;
+    colVerifier.newKey <== newKey;
+    colVerifier.newValue <== all_hash.out;
+    component hash2 = Poseidon(1);
+    hash2.inputs[0] <== colVerifier.newRoot;
+    component dbVerifier = SMTProcessor(level_col);
+    var any = fnc[0] + fnc[1];    
+    dbVerifier.fnc[0] <== 0;
+    dbVerifier.fnc[1] <== any * 1;
+    dbVerifier.oldRoot <== oldRoot_db;
+    dbVerifier.oldKey <== oldKey_db;
+    dbVerifier.oldValue <== oldValue_db;
+    dbVerifier.isOld0 <== isOld0_db;
+    dbVerifier.siblings <== siblings_db;
+    dbVerifier.newKey <== newKey_db;
+    dbVerifier.newValue <== hash2.out;
+    new_root <== dbVerifier.newRoot;
+    new_root === newRoot;   
+}

package/circom/query/test.js

@@ -0,0 +1,20 @@
+const chai = require("chai")
+const path = require("path")
+const wasm_tester = require("circom_tester").wasm
+const gen = require("./gen")
+describe("query circuit", function () {
+  let circuit
+  this.timeout(1000000000)
+
+  before(async () => {
+    circuit = await wasm_tester(path.join(__dirname, "index.circom"))
+    await circuit.loadSymbols()
+  })
+
+  it("should insert docs", async () => {
+    const { db, inputs } = await gen({})
+    const w = await circuit.calculateWitness(inputs, true)
+    await circuit.checkConstraints(w)
+    await circuit.assertOut(w, { new_root: db.tree.F.toObject(db.tree.root) })
+  })
+})

package/circom/query/verifier.sol

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: GPL-3.0
+/*
+    Copyright 2021 0KIMS association.
+
+    This file is generated with [snarkJS](https://github.com/iden3/snarkjs).
+
+    snarkJS is a free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    snarkJS is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+    or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
+    License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with snarkJS. If not, see <https://www.gnu.org/licenses/>.
+*/
+
+pragma solidity >=0.7.0 <0.9.0;
+
+contract Groth16Verifier {
+    // Scalar field size
+    uint256 constant r    = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
+    // Base field size
+    uint256 constant q   = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
+
+    // Verification Key data
+    uint256 constant alphax  = 7332885377758315278340183047560982420908393795468599595091895974752420296340;
+    uint256 constant alphay  = 332255058049377868589021735422241784808251989994698755461004804814851540428;
+    uint256 constant betax1  = 14918511796604743115529252945397806548811923425844505517068409231790256866971;
+    uint256 constant betax2  = 211413574403138532859071680094500506786935898681671422463746292741380691281;
+    uint256 constant betay1  = 19126853899579995366417647673795374157635727056721981778430611935842415927913;
+    uint256 constant betay2  = 19131403844100444556608656382423150552404085133882015610549223179149801306375;
+    uint256 constant gammax1 = 11559732032986387107991004021392285783925812861821192530917403151452391805634;
+    uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781;
+    uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531;
+    uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930;
+    uint256 constant deltax1 = 6704900427955721678758249586638916368303811029141592603225412697299455304124;
+    uint256 constant deltax2 = 7353370855884931878069291728168185650437182775914092542980559495866480496664;
+    uint256 constant deltay1 = 11993435523663888440828749392165960602415880311508676804499497708067210110962;
+    uint256 constant deltay2 = 6647277312542926665214557020539072978288588959904606351601139925324959408075;
+
+    
+    uint256 constant IC0x = 15289253754091277893525318954574291839301483693173283906134742452767902470222;
+    uint256 constant IC0y = 21846493062663745247147161219210004718490873346242532444087558099461060079247;
+    
+    uint256 constant IC1x = 1066269071380619866827478946725442020082923214111010110980211378031199352747;
+    uint256 constant IC1y = 21715751807275805052602634140853298892411968663460947996382374612101110991602;
+    
+    uint256 constant IC2x = 13253810294448854222388704169143440151357962805508403809356153136174677926728;
+    uint256 constant IC2y = 12010731304231692950197793520089992987779171074691595369454035297053991871556;
+    
+ 
+    // Memory data
+    uint16 constant pVk = 0;
+    uint16 constant pPairing = 128;
+
+    uint16 constant pLastMem = 896;
+
+    function verifyProof(uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC, uint[2] calldata _pubSignals) public view returns (bool) {
+        assembly {
+            function checkField(v) {
+                if iszero(lt(v, q)) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+            
+            // G1 function to multiply a G1 value(x,y) to value in an address
+            function g1_mulAccC(pR, x, y, s) {
+                let success
+                let mIn := mload(0x40)
+                mstore(mIn, x)
+                mstore(add(mIn, 32), y)
+                mstore(add(mIn, 64), s)
+
+                success := staticcall(sub(gas(), 2000), 7, mIn, 96, mIn, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+
+                mstore(add(mIn, 64), mload(pR))
+                mstore(add(mIn, 96), mload(add(pR, 32)))
+
+                success := staticcall(sub(gas(), 2000), 6, mIn, 128, pR, 64)
+
+                if iszero(success) {
+                    mstore(0, 0)
+                    return(0, 0x20)
+                }
+            }
+
+            function checkPairing(pA, pB, pC, pubSignals, pMem) -> isOk {
+                let _pPairing := add(pMem, pPairing)
+                let _pVk := add(pMem, pVk)
+
+                mstore(_pVk, IC0x)
+                mstore(add(_pVk, 32), IC0y)
+
+                // Compute the linear combination vk_x
+                
+                g1_mulAccC(_pVk, IC1x, IC1y, calldataload(add(pubSignals, 0)))
+                
+                g1_mulAccC(_pVk, IC2x, IC2y, calldataload(add(pubSignals, 32)))
+                
+
+                // -A
+                mstore(_pPairing, calldataload(pA))
+                mstore(add(_pPairing, 32), mod(sub(q, calldataload(add(pA, 32))), q))
+
+                // B
+                mstore(add(_pPairing, 64), calldataload(pB))
+                mstore(add(_pPairing, 96), calldataload(add(pB, 32)))
+                mstore(add(_pPairing, 128), calldataload(add(pB, 64)))
+                mstore(add(_pPairing, 160), calldataload(add(pB, 96)))
+
+                // alpha1
+                mstore(add(_pPairing, 192), alphax)
+                mstore(add(_pPairing, 224), alphay)
+
+                // beta2
+                mstore(add(_pPairing, 256), betax1)
+                mstore(add(_pPairing, 288), betax2)
+                mstore(add(_pPairing, 320), betay1)
+                mstore(add(_pPairing, 352), betay2)
+
+                // vk_x
+                mstore(add(_pPairing, 384), mload(add(pMem, pVk)))
+                mstore(add(_pPairing, 416), mload(add(pMem, add(pVk, 32))))
+
+
+                // gamma2
+                mstore(add(_pPairing, 448), gammax1)
+                mstore(add(_pPairing, 480), gammax2)
+                mstore(add(_pPairing, 512), gammay1)
+                mstore(add(_pPairing, 544), gammay2)
+
+                // C
+                mstore(add(_pPairing, 576), calldataload(pC))
+                mstore(add(_pPairing, 608), calldataload(add(pC, 32)))
+
+                // delta2
+                mstore(add(_pPairing, 640), deltax1)
+                mstore(add(_pPairing, 672), deltax2)
+                mstore(add(_pPairing, 704), deltay1)
+                mstore(add(_pPairing, 736), deltay2)
+
+
+                let success := staticcall(sub(gas(), 2000), 8, _pPairing, 768, _pPairing, 0x20)
+
+                isOk := and(success, mload(_pPairing))
+            }
+
+            let pMem := mload(0x40)
+            mstore(0x40, add(pMem, pLastMem))
+
+            // Validate that all evaluations ∈ F
+            
+            checkField(calldataload(add(_pubSignals, 0)))
+            
+            checkField(calldataload(add(_pubSignals, 32)))
+            
+            checkField(calldataload(add(_pubSignals, 64)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }

package/circom/rollup/compile.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+circom index.circom --r1cs --wasm --sym --c \
+&& cd index_js \
+&& node generate_witness.js index.wasm ../input.json witness.wtns \
+&& cd .. \
+&& snarkjs groth16 setup index.r1cs ../pot12_final.ptau index_0000.zkey \
+&& snarkjs zkey contribute index_0000.zkey index_0001.zkey --name="zkJSON" -v \
+&& snarkjs zkey export verificationkey index_0001.zkey verification_key.json \
+&& snarkjs groth16 prove index_0001.zkey index_js/witness.wtns proof.json public.json \
+&& snarkjs groth16 verify verification_key.json public.json proof.json;