zkjson 0.6.0 → 1.0.2

package/circom/rollup/gen.js

@@ -0,0 +1,36 @@
+const { DB } = require("../../sdk")
+
+const gen = async ({
+  size_val = 256,
+  size_path = 256,
+  size_json = 256,
+  level = 168,
+  level_col = 8,
+  size_txs = 10,
+}) => {
+  const db = new DB({
+    size_val,
+    size_path,
+    size_json,
+    level,
+    size_txs,
+    level_col,
+  })
+  await db.init()
+  const col1 = await db.addCollection()
+  const col2 = await db.addCollection()
+  let queries = [
+    [col2, "docA", { d: 4 }],
+    [col2, "docC", { d: 4 }],
+    [col2, "docD", { d: 4 }],
+    [col1, "docD", { b: 4 }],
+    [col1, "docA", { b: 5 }],
+    [col2, "docA2", { d: 4 }],
+    [col2, "docC2", { d: 4 }],
+    [col2, "docD2", { d: 4 }],
+    [col1, "docA2", { b: 4 }],
+  ]
+  return { db, inputs: await db.getRollupInputs({ queries }) }
+}
+
+module.exports = gen

package/circom/rollup/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/rollup/index.circom

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

package/circom/rollup/rollup.circom

@@ -0,0 +1,43 @@
+pragma circom 2.1.5;
+include "../query/query.circom";
+
+template Rollup (tx_size, level_col, level, size_json) {
+    signal input fnc[tx_size][2];
+    signal input siblings[tx_size][level];
+    signal input json[tx_size][size_json];
+    signal input newKey[tx_size];
+    signal input oldRoot[tx_size];
+    signal input newRoot[tx_size];
+    signal input isOld0[tx_size];
+    signal input oldValue[tx_size];
+    signal input oldKey[tx_size];
+    signal input oldRoot_db[tx_size];
+    signal input oldKey_db[tx_size];
+    signal input oldValue_db[tx_size];
+    signal input isOld0_db[tx_size];
+    signal input siblings_db[tx_size][level_col];
+    signal input newKey_db[tx_size];
+    
+    signal output new_root;
+    component query[tx_size];
+    for(var i = 0;i < tx_size;i++){
+        query[i] = Query(level_col, level, size_json);
+        query[i].fnc <== fnc[i];
+        query[i].siblings <== siblings[i];
+        query[i].json <== json[i];
+        query[i].newKey <== newKey[i];
+        query[i].oldRoot <== oldRoot[i];
+        query[i].newRoot <== newRoot[i];
+        query[i].isOld0 <== isOld0[i];
+        query[i].oldValue <== oldValue[i];
+        query[i].oldKey <== oldKey[i];
+        query[i].oldRoot_db <== oldRoot_db[i];
+        query[i].oldKey_db <== oldKey_db[i];
+        query[i].oldValue_db <== oldValue_db[i];
+        query[i].isOld0_db <== isOld0_db[i];
+        query[i].siblings_db <== siblings_db[i];
+        query[i].newKey_db <== newKey_db[i];
+        if(i > 0) query[i - 1].new_root === query[i].oldRoot_db;
+    } 
+    new_root <== query[tx_size - 1].new_root; 
+}

package/circom/rollup/test.js

@@ -0,0 +1,35 @@
+const chai = require("chai")
+const { range } = require("ramda")
+const path = require("path")
+const Scalar = require("ffjavascript").Scalar
+const wasm_tester = require("circom_tester").wasm
+const assert = chai.assert
+const gen = require("./gen")
+const {
+  pad,
+  encode,
+  decode,
+  encodePath,
+  decodePath,
+  encodeVal,
+  decodeVal,
+  str2id,
+  val2str,
+} = require("../../sdk")
+
+describe("SMT Verifier test", 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/rollup/verifier.sol

@@ -0,0 +1,240 @@
+// 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 = 6382598770963503221868241989178034505983713830030338706732180562135705228302;
+    uint256 constant deltax2 = 21197856141823471623406461430327045328337063888153217384477040020290521661075;
+    uint256 constant deltay1 = 3917474521378140980893240833218234849640957594604572843736203586085997385225;
+    uint256 constant deltay2 = 14835789719593847307069905718757171873703176299365135556708948375893296781197;
+
+    
+    uint256 constant IC0x = 20662541603631784033783411850623466276814384175295295876709145346505559490785;
+    uint256 constant IC0y = 8006046329700423418312155249696418399477725117760743047451409025951309235053;
+    
+    uint256 constant IC1x = 19285561784052895999071352462087059624897129991505522910816835510277875569935;
+    uint256 constant IC1y = 5088412779626932902831572326787948377088065901739480602177649205695253931298;
+    
+    uint256 constant IC2x = 16906112931417150993762587715805291967453600986078866926780547005566937018229;
+    uint256 constant IC2y = 16406004371419885542963808166406455372466253891120090979075187559729759077887;
+    
+    uint256 constant IC3x = 4341275995721556388393245268096468823912850229820335159079360530403892879981;
+    uint256 constant IC3y = 2462604992092891980616604542639214739312453086561777882013221218049200078781;
+    
+    uint256 constant IC4x = 7277064584951076939263949249291030051988867251154537475629938673240559596853;
+    uint256 constant IC4y = 14713923541850473885477334331717851629619309015192464754711549104288430191729;
+    
+    uint256 constant IC5x = 1380047561246268234648566758926047861819696113275790626094191145759794852616;
+    uint256 constant IC5y = 11975715682841217814475735189098358844548340304054540097172304523664666456818;
+    
+    uint256 constant IC6x = 19889221053189663675835304903782776506012797094259239673796347297879541341425;
+    uint256 constant IC6y = 21623090991343843017885541457952366267759902394147084578214441440612592545561;
+    
+    uint256 constant IC7x = 21101368779201512942514878828882076303149732417558876049841515757698295467276;
+    uint256 constant IC7y = 4028913196030058373760596313712820451799967403478544075073671694593735901590;
+    
+    uint256 constant IC8x = 2455721476973704253152625771715175790589879242009886193103380068033322414438;
+    uint256 constant IC8y = 18625273757755157943711133805503013403206708905781199275078628565629116421776;
+    
+    uint256 constant IC9x = 7029656770711039689598013638570045303993056662040279019499615994988338079507;
+    uint256 constant IC9y = 9726526515011675836347161915229713103383294389291653853844138945657504329227;
+    
+    uint256 constant IC10x = 18497952841684321869489981207061325388935878843879925971858789217870939562666;
+    uint256 constant IC10y = 4639147689759224858781849014552611717322583925303475076193438536411426115416;
+    
+    uint256 constant IC11x = 2644370262898202054035455297715425980763090245662003176644117618964138767359;
+    uint256 constant IC11y = 82929160403731179325725375411091817788513240869939263133699612899376085683;
+    
+ 
+    // 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[11] 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)))
+                
+
+                // -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)))
+            
+
+            // Validate all evaluations
+            let isValid := checkPairing(_pA, _pB, _pC, _pubSignals, pMem)
+
+            mstore(0, isValid)
+             return(0, 0x20)
+         }
+     }
+ }

package/circom/scripts/ceremony.js

@@ -0,0 +1,39 @@
+const { spawn } = require("node:child_process")
+const { existsSync, mkdirSync } = require("fs")
+const { resolve } = require("path")
+const { v4: uuidv4 } = require("uuid")
+
+let {
+  power,
+  entropy = uuidv4(),
+  name,
+} = require("yargs")(process.argv.slice(2)).options({
+  entropy: { type: "string" },
+  power: { type: "number", demandOption: true },
+  name: { type: "string" },
+}).argv
+
+if (typeof name === "undefined") name = "first contribution"
+
+const main = async () => {
+  const build = resolve(__dirname, "../build")
+  const ptau = resolve(__dirname, "../build/ptau")
+  const ptau_n = resolve(__dirname, "../build/ptau", power.toString())
+  for (const v of [build, ptau, ptau_n]) if (!existsSync(v)) mkdirSync(v)
+
+  const ceremony = resolve(__dirname, "./ceremony.sh")
+  const ls = spawn("sh", [ceremony, power, name, entropy])
+
+  ls.stdout.on("data", data => console.log(`${data}`))
+
+  ls.stderr.on("data", data => {
+    console.error(`stderr: ${data}`)
+    process.exit()
+  })
+
+  ls.on("close", code => {
+    console.log(`child process exited with code ${code}`)
+    process.exit()
+  })
+}
+main()

package/circom/scripts/ceremony.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+DIR="$( cd "$( dirname "$0" )" && pwd )/../build/ptau/$1"
+
+snarkjs powersoftau new bn128 $1 $DIR/pot$1_0000.ptau -v \
+&& echo "$3" | snarkjs powersoftau contribute $DIR/pot$1_0000.ptau $DIR/pot$1_0001.ptau --name="$2" -v \
+&& snarkjs powersoftau prepare phase2 $DIR/pot$1_0001.ptau $DIR/pot$1_final.ptau -v

package/circom/scripts/compile.js

@@ -0,0 +1,113 @@
+const { spawn } = require("node:child_process")
+const { writeFileSync, existsSync, mkdirSync } = require("fs")
+const { resolve } = require("path")
+const { v4: uuidv4 } = require("uuid")
+let {
+  power,
+  entropy = uuidv4(),
+  circuit,
+  size_val = 8,
+  size_path = 4,
+  size_json = 256,
+  level = 168,
+  level_col = 8,
+  size_txs = 10,
+  nBlocks = 10,
+  name,
+} = require("yargs")(process.argv.slice(2)).options({
+  size: { type: "number" },
+  size_json: { type: "number" },
+  size_path: { type: "number" },
+  level: { type: "number" },
+  level_col: { type: "number" },
+  size_txs: { type: "number" },
+  name: { type: "string" },
+  entropy: { type: "string" },
+  power: { type: "number", demandOption: true },
+  circuit: {
+    type: "string",
+    demandOption: true,
+    choices: ["json", "collection", "db", "query", "rollup", "ipfs"],
+  },
+}).argv
+
+if (typeof name === "undefined") name = "zkJSON"
+const main = async () => {
+  const build = resolve(__dirname, "../build")
+  const ptau = resolve(__dirname, "../build/ptau")
+  const ptau_n = resolve(__dirname, "../build/ptau", power.toString())
+  const circuits = resolve(__dirname, "../build/circuits")
+  const circuits_x = resolve(__dirname, "../build/circuits", circuit)
+  const index = resolve(__dirname, "../build/circuits", circuit, "index.circom")
+  const input = resolve(__dirname, "../build/circuits", circuit, "input.json")
+
+  for (const v of [build, ptau, ptau_n])
+    if (!existsSync(v)) {
+      console.log("power of tau missing")
+      process.exit()
+    }
+  for (const v of [circuits, circuits_x]) if (!existsSync(v)) mkdirSync(v)
+
+  let script = ""
+  if (circuit === "ipfs") {
+    script = `pragma circom 2.1.5;
+include "../../../ipfs/ipfs.circom";
+
+component main {public [path, val]} = IPFS(${size_json}, ${size_path}, ${size_val}, ${nBlocks});`
+  } else if (circuit === "json") {
+    script = `pragma circom 2.1.5;
+include "../../../json/json.circom";
+
+component main {public [path, val]} = JSON(${size_json}, ${size_path}, ${size_val});`
+  } else if (circuit === "collection") {
+    script = `pragma circom 2.1.5;
+include "../../../collection/collection.circom";
+
+component main {public [key, path, val]} = Collection(${level}, ${size_json}, ${size_path}, ${size_val});`
+    console.log(script)
+  } else if (circuit === "db") {
+    script = `pragma circom 2.1.5;
+include "../../../db/db.circom";
+
+component main {public [col_key, key, path, val, col_root]} = DB(${level_col}, ${level}, ${size_json}, ${size_path}, ${size_val});`
+  } else if (circuit === "query") {
+    script = `pragma circom 2.1.5;
+include "../../../query/query.circom";
+
+component main {public [oldRoot]} = Query(${level_col}, ${level}, ${size_json});`
+  } else if (circuit === "rollup") {
+    script = `pragma circom 2.1.5;
+include "../../../rollup/rollup.circom";
+
+component main {public [oldRoot]} = Rollup(${size_txs}, ${level_col}, ${level}, ${size_json});`
+  }
+  writeFileSync(index, script)
+
+  const gen = require(`../${circuit}/gen`)
+  const { inputs } = await gen({
+    size_json,
+    size_val,
+    size_path,
+    level,
+    size_txs,
+    level_col,
+  })
+
+  writeFileSync(input, JSON.stringify(inputs))
+
+  const compile = resolve(__dirname, "./compile.sh")
+  const ls = spawn("sh", [compile, circuit, power, entropy, name])
+
+  ls.stdout.on("data", data => console.log(`${data}`))
+
+  ls.stderr.on("data", data => {
+    console.error(`stderr: ${data}`)
+    process.exit()
+  })
+
+  ls.on("close", code => {
+    console.log(`child process exited with code ${code}`)
+    process.exit()
+  })
+}
+main()

package/circom/scripts/compile.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+DIR="$( cd "$( dirname "$0" )" && pwd )/../build/circuits/$1"
+
+cd $DIR \
+&& 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 ../../ptau/$2/pot$2_final.ptau index_0000.zkey \
+&& echo $3 | snarkjs zkey contribute index_0000.zkey index_0001.zkey --name="$4" -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 \
+&& snarkjs zkey export solidityverifier index_0001.zkey verifier.sol;
+
+