zkjson 0.6.0 → 1.0.2

package/circom/db/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/ipfs/calculate_total.circom

@@ -0,0 +1,17 @@
+pragma circom 2.0.0;
+
+// This circuit returns the sum of the inputs.
+// n must be greater than 0.
+template CalculateTotal(n) {
+    signal input nums[n];
+    signal output sum;
+
+    signal sums[n];
+    sums[0] <== nums[0];
+
+    for (var i=1; i < n; i++) {
+        sums[i] <== sums[i - 1] + nums[i];
+    }
+
+    sum <== sums[n - 1];
+}

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

@@ -0,0 +1,18 @@
+const { str, push, arr, toArray } = require("../../sdk/uint")
+const { pad, path, val } = require("../../sdk/encoder")
+const { parse } = require("../../sdk/parse")
+const gen = async ({ size_val = 8, size_path = 4, size_json = 256 }) => {
+  const json = { hello: "world" }
+  const _str = new TextEncoder().encode(JSON.stringify(json))
+
+  let encoded = arr(256)
+  for (let v of Array.from(_str)) encoded = push(encoded, 256, 76, v)
+  const enc = parse(encoded, 256)
+  const _path = pad(path("hello"), size_path)
+  const _val = pad(path("world"), size_val)
+  return {
+    inputs: { encoded: str(encoded), path: _path, val: _val },
+  }
+}
+
+module.exports = gen

package/circom/ipfs/generateInput.js

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

package/circom/ipfs/index.circom

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

package/circom/ipfs/ipfs.circom

@@ -0,0 +1,62 @@
+pragma circom 2.1.5;
+include "../utils/uint.circom";
+include "./parse.circom";
+include "./sha256.circom";
+include "../json/json.circom";
+
+function packBits(bits) {
+  var packed[32];
+  for (var i = 0; i < 32; i++) {
+    for (var i2 = 0; i2 < 8; i2++) {
+      packed[i] += bits[i * 8 + i2] * (1 << (8 - 1 - i2));
+    }
+  }
+  return packed;
+}
+template IPFS (size_json, size_path, size_val, nBlocks) {
+    signal input encoded[size_json];
+    signal input path[size_path];
+    signal input val[size_val];
+    signal output exist;
+    signal output out[32];
+    var binary[458];
+    var _json[size_json];
+    var _path[size_json];
+    var _val[size_json];
+    var _temp[size_json];
+    _json = parse(encoded, size_json, _path, _val, _json, _temp);
+    component _json2 = JSON(256, size_path, size_val);
+    _json2.json <-- _json;
+    _json2.path <== path;
+    _json2.val <== val;
+    exist <== _json2.exist;
+
+    var c[9] = [0, size_json, 0, 0, 0, 0, 0, 0, 0];
+    var i = 0;
+    while(c[5] == 0){
+        c = next(encoded, c);
+        for(var j = 0; j < 8; j++){
+           binary[i] = ((c[0] >> (7 - j)) & 1);
+           i++;
+        }
+    }
+    var paddedIn[nBlocks][512];
+    var tBlock = ((i + 64)\512)+1;
+    var k;
+    for (k=0; k<i; k++) {
+        paddedIn[k \ 512][k % 512] = binary[k];
+    }
+    paddedIn[i \ 512][i % 512] = 1;
+    
+    for (k=i+1; k<tBlock*512-64; k++) {
+        paddedIn[k \ 512][k % 512] = 0;
+    }
+    for (k = 0; k< 64; k++) {
+        paddedIn[(tBlock * 512 - k - 1) \ 512][(tBlock * 512 - k - 1) % 512] = (i >> k)&1;
+    }
+    component sha = Sha256_unsafe(nBlocks);
+    sha.tBlock <-- tBlock;
+    sha.in <-- paddedIn;
+    var packed[32] = packBits(sha.out);
+    out <== packed;
+}

package/circom/ipfs/parse.circom

@@ -0,0 +1,289 @@
+pragma circom 2.1.5;
+include "../utils/uint.circom";
+
+function eql  (a, b, blen, size)  {
+  var alen = length(a, size);
+  if (alen != blen) return 0;
+  var c[9] = [0, size, 0, 0, 0, 0, 0, 0, 0];
+  for (var i = 0; i < blen; i++) {
+    c = next(a, c);
+    if (c[0] != b[i]) return 0;
+  }
+  return 1;
+}
+
+function constVal  (_v, type, size, val)  {
+  var _true_[4] = [116, 114, 117, 101];
+  
+  val = push(val, size, 76, type);
+  if (type == 1) {
+    if (eql(_v, _true_, 4, size) == 1) {
+      val = push(val, size, 76, 1);
+    } else {
+      val = push(val, size, 76, 0);
+    }
+  } else if (type == 3) {
+    val = push(val, size, 76, length(_v, size));
+    var c[9] = [0, size, 0, 0, 0, 0, 0, 0, 0];
+    while (c[5] == 0) {
+      c = next(_v, c);
+      val = push(val, size, 76, c[0]);
+    }
+  } else if (type == 2) {
+    if (get(_v, size, 0) == 45) {
+      val = push(val, size, 76, 0);
+    } else {
+      val = push(val, size, 76, 1);
+    }
+    var after = 0;
+    var right = 0;
+    var digits = 0;
+    var c[9] = [0, size, 0, 0, 0, 0, 0, 0, 0];
+    while (c[5] == 0) {
+      c = next(_v, c);
+      if (c[0] == 46) {
+        after = 1;
+      } else if (c[0] != 45) {
+        if (after == 1) right += 1;
+        digits = digits * 10 + (c[0] - 48);
+      }
+    }
+    val = push(val, size, 76, right);
+    val = push(val, size, 76, digits);
+  }
+  return val;
+}
+
+function constPath  (p, size, pth2)  {
+  var len = get(p, size, 0);
+  pth2 = push(pth2, size, 76, len);
+  for (var i = 0; i < len; i++) {
+    var len2 = get(p, size, i + 1);
+    var _sum = sum(p, size, 76, 1, 1 + i);
+    var first = get(p, size, 1 + len + _sum);
+    if (first == 0) {
+      pth2 = push(pth2, size, 76, 0);
+    } else {
+      pth2 = push(pth2, size, 76, len2);
+    }
+    for (var i2 = 0; i2 < len2; i2++) {
+      var v = get(p, size, 1 + len + _sum + i2);
+      pth2 = push(pth2, size, 76, v);
+    }
+  }
+  return pth2;
+}
+
+function isNumber  (val, size, digit) {
+  var len = length(val, size);
+  var c[9] = [0, size, 0, 0, 0, 0, 0, 0, 0];
+  while (c[5] == 0) {
+    c = next(val, c);
+    if (c[0] == 47 || c[0] < 45 || c[0] > 57) return 0;
+  }
+
+  return 1;
+}
+
+
+function empty(_arr, size) {
+  for(var i = 0; i < size; i++){
+    _arr[i] = 0;
+  }
+  return _arr;
+}
+
+function parse  (str, size, path, val, json, temp) {
+  var _null_[4] = [110, 117, 108, 108];
+  var _true_[4] = [116, 114, 117, 101];
+  var _false_[5] = [102, 97, 108, 115, 101];
+  var inVal = 0;
+  var isNum = 0;
+  var esc = 0;
+  var nextKey = 0;
+  var arr = 0;
+  var obj = 0;
+  var ao[5];
+  var ind[5];
+  var err = 0;
+  var c[9] = [0, size, 0, 0, 0, 0, 0, 0, 0];
+  var bare = 1;
+  while (c[5] == 0) {
+    c = next(str, c);
+    var s = c[0];
+    if (inVal == 1) {
+      if (s == 92) {
+        esc = 1;
+      } else if (s == 34) {
+        if (esc == 1) {
+          val = push(val, size, 76, s);
+        } else {
+          inVal = 0;
+          if (nextKey == 1 && last(ao, 5) == 1) {
+            path = pushArray(path, size, 76, val, size, temp);
+          } else {
+            if (last(ao, 5) == 2) {
+              var _ind = last(ind, 5);
+              var __ind[5];
+              __ind = push(__ind, 5, 76, 0);
+              __ind = push(__ind, 5, 76, _ind);
+              path = pushArray(path, size, 76, __ind, 5, temp);
+              ind = pop(ind, 5);
+              ind = push(ind, 5, 76, _ind + 1);
+            }
+            json = concat(
+              json,
+              concat(constPath(path, size, temp), constVal(val, 3, size, temp), size, 76),
+              size,
+              76
+            );
+	    if(bare == 0)  path = popArray(path, size, 76, temp);
+          }
+
+          val = empty(val, size);
+          nextKey = 0;
+        }
+        esc = 0;
+      } else {
+        val = push(val, size, 76, s);
+        esc = 0;
+      }
+    } else if (isNum == 1) {
+      if (s == 44 || s == 32 || s == 125 || s == 93) {
+        if (last(ao, 5) == 2) {
+          var _ind = last(ind, 5);
+          var __ind[5];
+          __ind = push(__ind, 5, 76, 0);
+          __ind = push(__ind, 5, 76, _ind);
+          path = pushArray(path, size, 76, __ind, 5, temp);
+          ind = pop(ind, 5);
+          ind = push(ind, 5, 76, _ind + 1);
+        }
+        if (
+          eql(val, _true_, 4, size) == 0 &&
+          eql(val, _false_, 5, size) == 0 &&
+          eql(val, _null_, 4, size) == 0 &&
+          isNumber(val, size, 76) == 0
+        ) {
+          err = 1;
+        }
+        var type = 2;
+        if (eql(val, _null_, 4, size) == 1) {
+          type = 0;
+        } else if (
+          eql(val, _true_, 4, size) == 1 ||
+          eql(val, _false_, 5, size) == 1
+        ) {
+          type = 1;
+        }
+        json = concat(
+          json,
+          concat(constPath(path, size, temp), constVal(val, type, size, temp), size, 76),
+          size,
+          76
+        );
+        path = popArray(path, size, 76, temp);
+        if (s == 93) {
+          if (last(ao, 5) != 2) err = 1;
+          ao = pop(ao, 5);
+	  if(bare == 0)  path = popArray(path, size, 76, temp);
+          arr--;
+          ind = pop(ind, 5);
+        }
+        if (s == 125) {
+          if (last(ao, 5) != 1) err = 1;
+          ao = pop(ao, 5);
+          obj--;
+        }
+        isNum = 0;
+        val = empty(val, size);
+        if (s == 44) nextKey = 1;
+      } else {
+        val = push(val, size, 76, s);
+      }
+    } else if (s == 34) {
+      inVal = 1;
+    } else if (
+      s != 123 &&
+      s != 58 &&
+      s != 32 &&
+      s != 44 &&
+      s != 91 &&
+      s != 93 &&
+      s != 125
+    ) {
+      isNum = 1;
+      val = push(val, size, 76, s);
+    } else {
+      if (s != 32) {
+        if (s == 123 || s == 44){
+	  bare = 0;
+	  nextKey = 1;
+	}
+        if (s == 123) {
+          if (last(ao, 5) == 2) {
+            var _ind = last(ind, 5);
+            var __ind[5];
+            __ind = push(__ind, 5, 76, 0);
+            __ind = push(__ind, 5, 76, _ind);
+            path = pushArray(path, size, 76, __ind, 5, temp);
+            ind = pop(ind, 5);
+            ind = push(ind, 5, 76, _ind + 1);
+          }
+          ao = push(ao, 5, 76, 1);
+          obj++;
+        }
+        if (s == 125) {
+          if (last(ao, 5) != 1) err = 1;
+          ao = pop(ao, 5);
+          obj--;
+        }
+        if (s == 91) {
+          if (last(ao, 5) == 2) {
+            var _ind = last(ind, 5);
+            var __ind[5];
+            __ind = push(__ind, 5, 76, 0);
+            __ind = push(__ind, 5, 76, _ind);
+            path = pushArray(path, size, 76, __ind, 5, temp);
+            ind = pop(ind, 5);
+            ind = push(ind, 5, 76, _ind + 1);
+          }
+          ind = push(ind, 5, 76, 0);
+          ao = push(ao, 5, 76, 2);
+          arr++;
+        }
+        if (s == 93) {
+          if (last(ao, 5) != 2) err = 1;
+          ao = pop(ao, 5);
+          ind = pop(ind, 5);
+          path = popArray(path, size, 76, temp);
+          arr--;
+        }
+      }
+    }
+  }
+  if (length(val, size) != 0) {
+    var type = 4;
+    if (eql(val, _null_, 4, size) == 1) {
+      type = 0;
+      isNum = 0;
+    } else if (eql(val, _true_, 4, size) == 1 || eql(val, _false_, 5, size)) {
+      type = 1;
+      isNum = 0;
+    } else if (isNumber(val, size, 76) == 1) {
+      type = 2;
+      isNum = 0;
+    }
+    json = concat(
+      json,
+      concat(constPath(path, size, temp), constVal(val, type, size, temp), size, 76),
+      size,
+      76
+    );
+  }
+  if (length(ao, 5) > 0) err = 1;
+  if (length(ind, 5) > 0) err = 1;
+  if (inVal) err = 1;
+  if (isNum) err = 1;
+  return json;
+}