zkjson 0.6.0 → 1.0.2

package/circom/ipfs/sha256.circom

@@ -0,0 +1,99 @@
+pragma circom 2.1.5;
+
+include "../../node_modules/circomlib/circuits/sha256/constants.circom";
+include "../../node_modules/circomlib/circuits/sha256/sha256compression.circom";
+include "../../node_modules/circomlib/circuits/comparators.circom";
+include "./calculate_total.circom";
+
+/*
+SHA256 Unsafe
+    Calculates the SHA256 hash of the input, using a signal to select the output round corresponding to the number of
+    non-empty input blocks. This implementation is referred to as "unsafe", as it relies upon the caller to ensure that
+    the input is padded correctly, and to ensure that the tBlock input corresponds to the actual terminating data block.
+    Crafted inputs could result in Length Extension Attacks.
+
+    Construction Parameters:
+    - nBlocks: Maximum number of 512-bit blocks for payload input
+    Inputs:
+    - in:     An array of blocks exactly nBlocks in length, each block containing an array of exactly 512 bits.
+              Padding of the input according to RFC4634 Section 4.1 is left to the caller.
+              Blocks following tBlock must be supplied, and *should* contain all zeroes
+    - tBlock: An integer corresponding to the terminating block of the input, which contains the message padding
+    Outputs:
+    - out:    An array of 256 bits corresponding to the SHA256 output as of the terminating block
+*/
+template Sha256_unsafe(nBlocks) {
+    signal input in[nBlocks][512];
+    signal input tBlock;
+    
+    signal output out[256];
+
+    component ha0 = H(0);
+    component hb0 = H(1);
+    component hc0 = H(2);
+    component hd0 = H(3);
+    component he0 = H(4);
+    component hf0 = H(5);
+    component hg0 = H(6);
+    component hh0 = H(7);
+
+    component sha256compression[nBlocks];
+
+    for(var i=0; i < nBlocks; i++) {
+
+        sha256compression[i] = Sha256compression();
+
+        if (i==0) {
+            for(var k = 0; k < 32; k++) {
+                sha256compression[i].hin[0*32+k] <== ha0.out[k];
+                sha256compression[i].hin[1*32+k] <== hb0.out[k];
+                sha256compression[i].hin[2*32+k] <== hc0.out[k];
+                sha256compression[i].hin[3*32+k] <== hd0.out[k];
+                sha256compression[i].hin[4*32+k] <== he0.out[k];
+                sha256compression[i].hin[5*32+k] <== hf0.out[k];
+                sha256compression[i].hin[6*32+k] <== hg0.out[k];
+                sha256compression[i].hin[7*32+k] <== hh0.out[k];
+}
+        } else {
+            for(var k = 0; k < 32; k++) {
+                sha256compression[i].hin[32*0+k] <== sha256compression[i-1].out[32*0+31-k];
+                sha256compression[i].hin[32*1+k] <== sha256compression[i-1].out[32*1+31-k];
+                sha256compression[i].hin[32*2+k] <== sha256compression[i-1].out[32*2+31-k];
+                sha256compression[i].hin[32*3+k] <== sha256compression[i-1].out[32*3+31-k];
+                sha256compression[i].hin[32*4+k] <== sha256compression[i-1].out[32*4+31-k];
+                sha256compression[i].hin[32*5+k] <== sha256compression[i-1].out[32*5+31-k];
+                sha256compression[i].hin[32*6+k] <== sha256compression[i-1].out[32*6+31-k];
+                sha256compression[i].hin[32*7+k] <== sha256compression[i-1].out[32*7+31-k];
+            }
+        }
+
+        for (var k = 0; k < 512; k++) {
+            sha256compression[i].inp[k] <== in[i][k];
+        }
+    }
+    
+    // Collapse the hashing result at the terminating data block
+    // A modified Quin Selector allows us to select the block based on the tBlock signal
+    component calcTotal[256];
+    component eqs[256][nBlocks];
+
+    // For each bit of the output
+    for(var k = 0; k < 256; k++) {
+        calcTotal[k] = CalculateTotal(nBlocks);
+        
+        // For each possible block
+        for (var i = 0; i < nBlocks; i++) {
+            // Determine if the given block index is equal to the terminating data block index
+            eqs[k][i] = IsEqual();
+            eqs[k][i].in[0] <== i;
+            eqs[k][i].in[1] <== tBlock - 1;
+
+            // eqs[k][i].out is 1 if the index matches. As such, at most one input to calcTotal is not 0.
+            // The bit corresponding to the terminating data block will be raised
+            calcTotal[k].nums[i] <== eqs[k][i].out * sha256compression[i].out[k];
+        }
+        
+        out[k] <== calcTotal[k].sum;
+    }
+
+}

package/circom/ipfs/test.js

@@ -0,0 +1,167 @@
+const { expect } = require("chai")
+const { push, arr, toArray } = require("../../sdk/uint")
+const { pad, path, val } = require("../../sdk/encoder")
+const chai = require("chai")
+const { join } = require("path")
+const wasm_tester = require("circom_tester").wasm
+const crypto = require("crypto")
+const { parse } = require("../../sdk/parse")
+
+function bitArray2buffer(a) {
+  const len = Math.floor((a.length - 1) / 8) + 1
+  const b = new Buffer.alloc(len)
+
+  for (let i = 0; i < a.length; i++) {
+    const p = Math.floor(i / 8)
+    b[p] = b[p] | (Number(a[i]) << (7 - (i % 8)))
+  }
+  return b
+}
+
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") return o
+  if (o instanceof ArrayBuffer) return new Uint8Array(o)
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength)
+  }
+  throw new Error("Unknown type, must be binary type")
+}
+
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+const BASE = ALPHABET.length
+const LEADER = ALPHABET.charAt(0)
+const FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up
+const iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up
+
+function toCID2(source) {
+  var zeroes = 0
+  var length = 0
+  var pbegin = 0
+  var pend = source.length
+  while (pbegin !== pend && source[pbegin] === 0) {
+    pbegin++
+    zeroes++
+  }
+  var size = 47
+  var b58 = new Uint8Array(size)
+  while (pbegin !== pend) {
+    var carry = source[pbegin]
+    var i = 0
+    for (
+      var it1 = size - 1;
+      (carry !== 0 || i < length) && it1 !== -1;
+      it1--, i++
+    ) {
+      carry += (256 * b58[it1]) >>> 0
+      b58[it1] = carry % 58 >>> 0
+      carry = (carry / 58) >>> 0
+    }
+    length = i
+    pbegin++
+  }
+  var it2 = size - length
+  while (it2 !== size && b58[it2] === 0) it2++
+  var str = LEADER.repeat(zeroes)
+  for (; it2 < size; ++it2) str += ALPHABET.charAt(b58[it2])
+  return str
+}
+
+function toCID(source) {
+  // @ts-ignore
+  if (source instanceof Uint8Array);
+  else if (ArrayBuffer.isView(source)) {
+    source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
+  } else if (Array.isArray(source)) {
+    source = Uint8Array.from(source)
+  }
+  if (!(source instanceof Uint8Array)) {
+    throw new TypeError("Expected Uint8Array")
+  }
+  if (source.length === 0) {
+    return ""
+  }
+  // Skip & count leading zeroes.
+  var zeroes = 0
+  var length = 0
+  var pbegin = 0
+  var pend = source.length
+  while (pbegin !== pend && source[pbegin] === 0) {
+    pbegin++
+    zeroes++
+  }
+  // Allocate enough space in big-endian base58 representation.
+  var size = ((pend - pbegin) * iFACTOR + 1) >>> 0
+  var b58 = new Uint8Array(size)
+  // Process the bytes.
+  while (pbegin !== pend) {
+    var carry = source[pbegin]
+    // Apply "b58 = b58 * 256 + ch".
+    var i = 0
+    for (
+      var it1 = size - 1;
+      (carry !== 0 || i < length) && it1 !== -1;
+      it1--, i++
+    ) {
+      carry += (256 * b58[it1]) >>> 0
+      b58[it1] = carry % BASE >>> 0
+      carry = (carry / BASE) >>> 0
+    }
+    if (carry !== 0) {
+      throw new Error("Non-zero carry")
+    }
+    length = i
+    pbegin++
+  }
+  // Skip leading zeroes in base58 result.
+  var it2 = size - length
+  while (it2 !== size && b58[it2] === 0) {
+    it2++
+  }
+  // Translate the result into a string.
+  var str = LEADER.repeat(zeroes)
+  for (; it2 < size; ++it2) {
+    str += ALPHABET.charAt(b58[it2])
+  }
+  return str
+}
+
+describe("JSON circuit", function () {
+  let circuit
+  this.timeout(0)
+
+  before(async () => {
+    circuit = await wasm_tester(join(__dirname, "index.circom"))
+    await circuit.loadSymbols()
+  })
+
+  it("should insert docs", async () => {
+    const json = {
+      str: "Hello World!",
+      int: 123,
+      bool: true,
+      null: null,
+      float: 1.23,
+      arr: [1, 2, 3],
+    }
+    const str = new TextEncoder().encode(JSON.stringify(json))
+    const hash = coerce(crypto.createHash("sha256").update(str).digest())
+
+    let encoded = arr(256)
+    for (let v of Array.from(str)) encoded = push(encoded, 256, 76, v)
+    const enc = parse(encoded, 256, 76)
+    const _path = pad(path("str"), 5)
+    const _val = pad(val(json["str"]), 5)
+
+    const w = await circuit.calculateWitness(
+      { encoded: encoded, path: _path, val: _val },
+      true,
+    )
+    await circuit.checkConstraints(w)
+    await circuit.assertOut(w, { exist: 1 })
+    const _arr2 = w.slice(2, 34).map(n => Number(n))
+    const cid2 = toCID2(new Uint8Array([18, hash.length, ..._arr2]))
+    const cid = toCID(new Uint8Array([18, hash.length, ...Array.from(hash)]))
+    expect(cid).to.eql(cid2)
+    return
+  })
+})

package/circom/ipfs/verifier.sol

@@ -0,0 +1,261 @@
+// 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 = 16108517980506854297849182541741553709725147068726502437460795221662934054392;
+    uint256 constant deltax2 = 11108122055952200981463380103442015838004112520282166325679324656261172289310;
+    uint256 constant deltay1 = 15540443534206155738973728487806979316634787078945919829097599147377062022852;
+    uint256 constant deltay2 = 21379352474752452421616166568647842540503269819420348102486102247380909072561;
+
+    
+    uint256 constant IC0x = 21491549690759898325084849607299564336640876765821749498156862035601257576731;
+    uint256 constant IC0y = 7673274862583779134920456438013707521756656044641568042313054191508669514090;
+    
+    uint256 constant IC1x = 7384807594330870281878199565618965338344331100873316262082027153266713199801;
+    uint256 constant IC1y = 14876621143313435278104193218580147792502814126320367012799180884583971278043;
+    
+    uint256 constant IC2x = 14168855774320618160297871496225220542802525303313492506646049444075434034461;
+    uint256 constant IC2y = 2468759921621309671933672856806282408346496190229767650695758108046431009056;
+    
+    uint256 constant IC3x = 20882499572322978549523449110104123650836957036545445021640442961988931511616;
+    uint256 constant IC3y = 10781231220582947841663615195913878935048287628839154817279937306701845963832;
+    
+    uint256 constant IC4x = 3551014538515980043254241443826671153636028870428071676154749646867482617102;
+    uint256 constant IC4y = 17513115597425155133040003702455782665905020659681301812064653011904364586605;
+    
+    uint256 constant IC5x = 105515585129844888605937953967649955568230431552746130229062574355263145521;
+    uint256 constant IC5y = 20200666388807201898426694143171918805989526661219556885905461961107161411873;
+    
+    uint256 constant IC6x = 19504246290594149902008126941831109015032250944240332802409169333280249886793;
+    uint256 constant IC6y = 17699531383222577195964406519381055857401242060823677129203944848736284577334;
+    
+    uint256 constant IC7x = 15254965952105123078324026560946378979667618649209045648866104810507209861613;
+    uint256 constant IC7y = 3641619426903900212193517444566552500256221100745411003347851827295876272315;
+    
+    uint256 constant IC8x = 4499605970446611025648671992837865142426045383246510513270735661446224104646;
+    uint256 constant IC8y = 15341853963424215265359126787955887881741741004410294373221073774379489499288;
+    
+    uint256 constant IC9x = 4636178543162541151831226653997316232974453000168920950316536975489566766643;
+    uint256 constant IC9y = 2799228255066264685511548900627321262829537276926174168686910780679641714598;
+    
+    uint256 constant IC10x = 6388673479423994256307474279305289225670011140384557756459873981364992797681;
+    uint256 constant IC10y = 15445971588389648358240399113305305960608235393782465515171348639813010141589;
+    
+    uint256 constant IC11x = 16999109717455015622767449319493463705406770611876428205363721384440112529191;
+    uint256 constant IC11y = 8675643256310098492425698438900503035238176419524618195032951410590093388339;
+    
+    uint256 constant IC12x = 16871502461507515213546155066931373929841527789003952441940247163262482018578;
+    uint256 constant IC12y = 4970662515578058992947951260883675496659331271578004380224271812057151496904;
+    
+    uint256 constant IC13x = 13968526389162956068739649724104930691708514396451450078611693259360926530004;
+    uint256 constant IC13y = 8822824035572686629738946181419338699884848605068510614565951757702861630826;
+    
+    uint256 constant IC14x = 13433257895962314784382997146377098286327147717667015994113571363174981683976;
+    uint256 constant IC14y = 16316358056856673776145141235445376046620537375366520262647177307024013423430;
+    
+ 
+    // 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[14] 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)))
+                
+                g1_mulAccC(_pVk, IC13x, IC13y, calldataload(add(pubSignals, 384)))
+                
+                g1_mulAccC(_pVk, IC14x, IC14y, calldataload(add(pubSignals, 416)))
+                
+
+                // -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)))
+            
+            checkField(calldataload(add(_pubSignals, 416)))
+            
+            checkField(calldataload(add(_pubSignals, 448)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }

package/circom/json/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/json/gen.js

@@ -0,0 +1,22 @@
+const { Doc } = require("../../sdk")
+
+const gen = async ({ size_val = 8, size_path = 4, size_json = 256 }) => {
+  const doc = new Doc({ size_val, size_path, size_json })
+  const json = {
+    num: 1,
+    float: 1.23,
+    str: "string",
+    bool: true,
+    null: null,
+    array: [1, 2, 3],
+  }
+
+  return {
+    inputs: await doc.getInputs({
+      json,
+      path: "array",
+    }),
+  }
+}
+
+module.exports = gen

package/circom/json/gen2.js

@@ -0,0 +1,21 @@
+const { Doc, fromSignal } = require("../../sdk")
+
+const gen2 = async ({
+  size_val = 256,
+  size_path = 256,
+  size_json = 256,
+  json,
+  path,
+  query,
+}) => {
+  const doc = new Doc({ size_val, size_path, size_json })
+  return {
+    inputs: await doc.getInputs({
+      json: json ?? { c: [1, 2, 3, false], b: 3 },
+      path: path ?? "c",
+      query: query ?? ["$contains_none", [4, 5, 6, true]],
+    }),
+  }
+}
+
+module.exports = gen2

package/circom/json/generateInput.js

@@ -0,0 +1,20 @@
+const { Doc } = require("../../sdk")
+const { writeFileSync } = require("fs")
+const { resolve } = require("path")
+const gen = require("./gen")
+
+let {
+  input = resolve(__dirname, "input.json"),
+  size_val = 5,
+  size_path = 5,
+  size_json = 256,
+} = require("yargs")(process.argv.slice(2)).options({
+  size: { type: "number" },
+  size_json: { type: "number" },
+}).argv
+
+const main = async () => {
+  const { inputs } = await gen({ size_json, size_val, size_path })
+  writeFileSync(input, JSON.stringify(inputs))
+}
+main()

package/circom/json/index.circom

@@ -0,0 +1,4 @@
+pragma circom 2.1.5;
+include "./json.circom";
+
+component main {public [path, val]} = JSON(256, 4, 8);

package/circom/json/json.circom

@@ -0,0 +1,81 @@
+pragma circom 2.1.5;
+
+include "../utils/utils.circom";
+include "../../node_modules/circomlib/circuits/poseidon.circom";
+
+template JSON (size_json, size_path, size_val) {  
+    signal input json[size_json];  
+    signal input path[size_path];
+    signal input val[size_val];
+    signal output exist;
+    signal output hash;
+    signal ex;
+
+    var _json_[9] = [0, size_json, 0,0,0,0,0,0,0];
+ 
+    var contains[101];
+    var nomatch = 0;
+    var _val_[9] = [0, size_val, 0,0,0,0,0,0,0];
+    _val_ = g(val, _val_);
+    var op = _val_[0];
+    var _exists = op == 21 ? 1 : 0;
+    var partial[9] = [0, size_val, 0,0,0,0,0,0,0];
+    var count = 0;
+
+    var _path_[9] = [0, size_path, 0,0,0,0,0,0,0];
+
+    while(_json_[5] == 0){ 
+        _json_ = g(json, _json_);
+        var _path_start[9] = _json_;
+        _json_ = getPath(json, _json_, 1);
+        var pi = _json_[6];
+         _json_ = g(json, _json_);
+        var _val_start[9] = _json_;
+        _json_ = getVal(json, _json_);
+        var vi = _json_[6];
+        var match[2] = checkPathMatch(json, path, _path_start, size_path, pi);
+        var path_match = match[0];
+        var path_partial_match = match[1];
+        var plus = op >= 10 ? 1 : 0;
+        if(path_match == 1){
+            var _val_match = 1;
+            if(op >= 12 && op <= 15){
+                _val_match = checkGtLt(op, _val_, _val_start, json, val, _val_match);
+            } else if(op == 16 || op == 17){
+                _val_match = checkInNin(op, _val_, _val_start, json, val, vi, _val_match);
+            } else {
+                _val_match = checkValMatch (json, val, _val_start, plus, size_val, vi, _val_match);
+            }
+            if(_val_match == 1){
+                if(op != 11) _exists = 1;
+            }else {
+                if(op == 11) _exists = 1;
+            }
+        }else if(path_partial_match == 1 && ((op == 21 && _exists == 1) || (op != 21 && _exists == 0))){
+            if(op == 19 || op == 20 || op == 21){
+                contains = checkArrayContains(_exists, op, _val_, _val_start, vi, val, json, contains);
+                _exists = contains[100];
+            } else if (op == 18){
+                _exists = checkContains(_exists, size_val, val, _val_start, vi, json, plus);
+            } else {
+                count++;
+                partial = checkPartialMatch(_exists, size_path, size_val, path, _path_start, pi, val, _val_start, vi, json, partial, count);
+                if(partial[6] == 0) nomatch = 1;
+                if(partial[6] == 2 && nomatch == 0) _exists = 1;
+            }
+        }
+     }
+    ex <-- _exists;
+    exist <== ex * ex;
+
+    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;
+    } 
+    hash <== all_hash.out;
+}