zkjson 0.1.10 → 0.1.11

package/contracts/ZKRollup.sol

@@ -2,7 +2,6 @@
 
 pragma solidity >=0.7.0 <0.9.0;
 import "hardhat/console.sol";
-import "./ZKJson.sol";
 import "./ZKQuery.sol";
 
 interface VerifierRU {
@@ -12,7 +11,7 @@ interface VerifierRU {
 
 contract ZKRollup is ZKQuery {
   address public verifierRU;
-  address public comitter;
+  address public committer;
   uint public root;
   
   function _verifyRU(uint[] calldata zkp) internal view returns (bool) {
@@ -29,29 +28,27 @@ contract ZKRollup is ZKQuery {
     return true;
   }
   
-  function _validateQueryRU(uint[] memory path, uint[] calldata zkp, uint size) internal view returns(uint[] memory){
+  function _validateQueryRU(uint[] memory path, uint[] calldata zkp, uint size_path, uint size_val) internal view returns(uint[] memory){
     require(zkp[19] == root, "root mismatch");
-    require(zkp[size * 2 + 10] == path[0], "wrong collection");
-    require(zkp[size * 2 + 11] == path[1], "wrong doc");
+    require(zkp[size_path + size_val + 10] == path[0], "wrong collection");
+    require(zkp[size_path + size_val + 11] == path[1], "wrong doc");
     require(zkp[8] == 1, "value doesn't exist");
-    require(path.length <= size + 2, "path too long");
+    require(path.length <= size_path + size_val, "path too long");
     for(uint i = 9; i < 9 + path.length - 2; i++) require(path[i - 7] == zkp[i], "wrong path");
-    uint[] memory value = new uint[](size);
-    for(uint i = 9 + size; i < 9 + size * 2; i++) value[i - (9 + size)] = zkp[i];
+    uint[] memory value = new uint[](size_val);
+    for(uint i = 9 + size_path; i < 9 + size_path + size_val; i++) value[i - (9 + size_path)] = zkp[i];
     return toArr(value);
   }
 
   function commit (uint[] calldata zkp) public returns (uint) {
     require (zkp[9] == root, "wrong merkle root");
-    require(msg.sender == comitter, "sender is not comitter");
+    require(msg.sender == committer, "sender is not committer");
     root = zkp[8];
     verifyRU(zkp);
     return root;
-    
   }
 
   function verifyRU(uint[] calldata zkp) public view returns (bool) {
     return _verifyRU(zkp);
   }
-
 }

package/db.js

@@ -1,4 +1,5 @@
 const newMemEmptyTrie = require("./circomlibjs").newMemEmptyTrie
+const snarkjs = require("snarkjs")
 const { range } = require("ramda")
 const {
   pad,
@@ -7,7 +8,7 @@ const {
   val2str,
   id2str,
   encode,
-  str2id,
+  toIndex,
 } = require("./encoder")
 const Collection = require("./collection")
 
@@ -19,7 +20,15 @@ class DB {
     size_json = 256,
     size_txs = 10,
     level_col = 8,
+    wasm,
+    zkey,
+    wasmRU,
+    zkeyRU,
   }) {
+    this.wasm = wasm
+    this.zkey = zkey
+    this.wasmRU = wasmRU
+    this.zkeyRU = zkeyRU
     this.level_col = level_col
     this.size = size_val
     this.size_path = size_path
@@ -47,7 +56,63 @@ class DB {
     siblings = siblings.map(s => s.toString())
     return { isOld0, oldRoot, oldKey, oldValue, siblings, newRoot }
   }
+  _getVal(j, p) {
+    if (p.length === 0) {
+      return j
+    } else {
+      const sp = p[0].split("[")
+      for (let v of sp) {
+        if (/]$/.test(v)) {
+          j = j[v.replace(/]$/, "") * 1]
+        } else {
+          j = j[v]
+        }
+      }
+      return this._getVal(j, p.slice(1))
+    }
+  }
+  getVal(j, p) {
+    if (p === "") return j
+    return this._getVal(j, p.split("."))
+  }
 
+  async genProof({ json, col_id, path, id }) {
+    const inputs = await this.getInputs({
+      id,
+      col_id,
+      json,
+      path,
+      val: this.getVal(json, path),
+    })
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+      inputs,
+      this.wasm,
+      this.zkey
+    )
+    return [
+      ...proof.pi_a.slice(0, 2),
+      ...proof.pi_b[0].slice(0, 2).reverse(),
+      ...proof.pi_b[1].slice(0, 2).reverse(),
+      ...proof.pi_c.slice(0, 2),
+      ...publicSignals,
+    ]
+  }
+
+  async genRollupProof(txs) {
+    const inputs = await this.getRollupInputs({ queries: txs })
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+      inputs,
+      this.wasmRU,
+      this.zkeyRU
+    )
+    return [
+      ...proof.pi_a.slice(0, 2),
+      ...proof.pi_b[0].slice(0, 2).reverse(),
+      ...proof.pi_b[1].slice(0, 2).reverse(),
+      ...proof.pi_c.slice(0, 2),
+      ...publicSignals,
+    ]
+  }
   async getRollupInputs({ queries }) {
     let write, _json
     let oldRoot = []
@@ -79,6 +144,7 @@ class DB {
         siblings.push(range(0, this.level).map(() => "0"))
         isOld0.push("0")
         oldRoot_db.push(newRoot_db[i - 1])
+        newRoot_db.push(newRoot_db[i - 1])
         oldKey_db.push("0")
         oldValue_db.push("0")
         siblings_db.push(range(0, this.level_col).map(() => "0"))
@@ -92,9 +158,9 @@ class DB {
       const icol = this.parse(res, tree, this.level)
       const idb = this.parse(res2, this.tree, this.level_col)
       _res = idb
-      const _newKey = str2id(v[1])
+      const _newKey = toIndex(v[1])
       json.push(pad(val2str(encode(_json)), this.size_json))
-      const _newKey_db = v[0]
+      const _newKey_db = v[0].toString()
       fnc.push(update ? [0, 1] : [1, 0])
       newRoot.push(idb.newRoot)
       oldRoot.push(icol.oldRoot)
@@ -140,8 +206,8 @@ class DB {
     } = await this.insert(col_id, id, json)
     const icol = this.parse(res, tree, this.level)
     const idb = this.parse(res2, this.tree, this.level_col)
-    const newKey = str2id(id)
-    const newKey_db = col_id
+    const newKey = toIndex(id)
+    const newKey_db = col_id.toString()
     return {
       fnc: update ? [0, 1] : [1, 0],
       oldRoot: icol.oldRoot,
@@ -179,7 +245,7 @@ class DB {
       json: col_inputs.json,
       root: col_inputs.root,
       siblings: col_inputs.siblings,
-      key: str2id(id),
+      key: toIndex(id),
       col_key,
       col_siblings,
       col_root,
@@ -244,7 +310,7 @@ class DB {
     return await _col.get(_key)
   }
   async getCol(_key) {
-    const id = str2id(_key)
+    const id = toIndex(_key)
     return await this.tree.find(id)
   }
 }

package/encoder.js

@@ -453,6 +453,9 @@ const fromSignal = str2val
 const toIndex = str2id
 const fromIndex = id2str
 
+const path = p => toSignal(encodePath(p))
+const val = v => toSignal(encodeVal(v))
+
 module.exports = {
   encode,
   decode,
@@ -471,4 +474,6 @@ module.exports = {
   fromSignal,
   toIndex,
   fromIndex,
+  path,
+  val,
 }

package/index.js

@@ -1,6 +1,7 @@
 const encoder = require("./encoder")
 const DB = require("./db")
 const Doc = require("./doc")
+const Rollup = require("./rollup")
 const Collection = require("./collection")
 
-module.exports = { ...encoder, DB, Collection, Doc }
+module.exports = { ...encoder, DB, Collection, Doc, Rollup }

package/package.json

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

package/rollup.js

@@ -0,0 +1,224 @@
+const snarkjs = require("snarkjs")
+const { resolve } = require("path")
+const { pad, toSignal, encode, encodePath, encodeVal } = require("./encoder")
+const DB = require("./db")
+const { range } = require("ramda")
+
+module.exports = class Rollup {
+  constructor({
+    size_val = 5,
+    size_path = 5,
+    size_json = 256,
+    level = 100,
+    size_txs = 10,
+    level_col = 8,
+    wasm,
+    zkey,
+  }) {
+    this.size_val = size_val
+    this.size_path = size_path
+    this.size_json = size_json
+    this.size_txs = size_txs
+    this.level = level
+    this.level_col = level_col
+    this.wasm = wasm
+    this.zkey = zkey
+  }
+  async init() {
+    this.db = new DB({
+      level: this.level,
+      size_path: this.size_path,
+      size_val: this.size_val,
+      size_json: this.size_json,
+      size_txs: this.size_txs,
+      level_col: this.level_col,
+    })
+    await this.db.init()
+  }
+  async getInputs(queries) {
+    let write, _json
+    let oldRoot = []
+    let newRoot = []
+    let oldKey = []
+    let oldValue = []
+    let siblings = []
+    let isOld0 = []
+    let oldRoot_db = []
+    let newRoot_db = []
+    let oldKey_db = []
+    let oldValue_db = []
+    let siblings_db = []
+    let isOld0_db = []
+    let newKey_db = []
+    let newKey = []
+    let _res
+    let json = []
+    let fnc = []
+    for (let i = 0; i < this.size_txs; i++) {
+      const v = queries[i]
+      if (!v) {
+        json.push(range(0, this.size_json).map(() => "0"))
+        fnc.push([0, 0])
+        newRoot.push(newRoot[i - 1])
+        oldRoot.push("0")
+        oldKey.push("0")
+        oldValue.push("0")
+        siblings.push(range(0, this.level).map(() => "0"))
+        isOld0.push("0")
+        oldRoot_db.push(newRoot_db[i - 1])
+        oldKey_db.push("0")
+        oldValue_db.push("0")
+        siblings_db.push(range(0, this.level_col).map(() => "0"))
+        isOld0_db.push("0")
+        newKey_db.push("0")
+        newKey.push("0")
+        continue
+      }
+      _json = v[2]
+      const { update, tree, col: res2, doc: res } = await this.insert(...v)
+      const icol = this.parse(res, tree, this.level)
+      const idb = this.parse(res2, this.tree, this.level_col)
+      _res = idb
+      const _newKey = str2id(v[1])
+      json.push(pad(val2str(encode(_json)), this.size_json))
+      const _newKey_db = v[0]
+      fnc.push(update ? [0, 1] : [1, 0])
+      newRoot.push(idb.newRoot)
+      oldRoot.push(icol.oldRoot)
+      oldKey.push(icol.oldKey)
+      oldValue.push(icol.oldValue)
+      siblings.push(icol.siblings)
+      isOld0.push(icol.isOld0)
+      oldRoot_db.push(idb.oldRoot)
+      newRoot_db.push(idb.newRoot)
+      oldKey_db.push(idb.oldKey)
+      oldValue_db.push(idb.oldValue)
+      siblings_db.push(idb.siblings)
+      isOld0_db.push(idb.isOld0)
+      newKey_db.push(_newKey_db)
+      newKey.push(_newKey)
+    }
+
+    return {
+      fnc,
+      oldRoot,
+      newRoot,
+      oldKey,
+      oldValue,
+      siblings,
+      isOld0,
+      oldRoot_db,
+      oldKey_db,
+      oldValue_db,
+      siblings_db,
+      isOld0_db,
+      newKey_db,
+      newKey,
+      json,
+    }
+  }
+  async genProof(queries) {
+    const inputs = await this.getInputs(queries)
+    console.log(inputs)
+    return 3
+  }
+  async genProof2(col, doc, tar, path) {
+    const val = this.getVal(tar, path)
+
+    const col_root = this.db.tree.F.toObject(this.db.tree.root).toString()
+    const col_res = await this.db.getCol(doc)
+
+    let col_siblings = col_res.siblings
+    for (let i = 0; i < col_siblings.length; i++)
+      col_siblings[i] = this.db.tree.F.toObject(col_siblings[i])
+    while (col_siblings.length < this.level_col) col_siblings.push(0)
+    col_siblings = col_siblings.map(s => s.toString())
+    const col_key = col
+
+    const _col = this.db.getColTree(col)
+    const root = _col.tree.F.toObject(_col.tree.root).toString()
+    const res = await _col.get(doc)
+    let _siblings = res.siblings
+    for (let i = 0; i < _siblings.length; i++)
+      _siblings[i] = _col.tree.F.toObject(_siblings[i])
+    while (_siblings.length < this.level) _siblings.push(0)
+    _siblings = _siblings.map(s => s.toString())
+    const key = toIndex(doc)
+
+    const _json = pad(toSignal(encode(tar)), this.size_json)
+    const _path = pad(toSignal(encodePath(path)), this.size_path)
+    const _val = pad(toSignal(encodeVal(val)), this.size)
+    const _write = {
+      json: _json,
+      path: _path,
+      val: _val,
+      root,
+      siblings: _siblings,
+      key,
+      col_key,
+      col_siblings,
+      col_root,
+    }
+    const { proof: proof2, publicSignals: sigs } =
+      await snarkjs.groth16.fullProve(
+        _write,
+        resolve(
+          __dirname,
+          "../../circom/build/circuits/db/index_js/index.wasm"
+        ),
+        resolve(__dirname, "../../circom/build/circuits/db/index_0001.zkey")
+      )
+    return [
+      ...proof2.pi_a.slice(0, 2),
+      ...proof2.pi_b[0].slice(0, 2).reverse(),
+      ...proof2.pi_b[1].slice(0, 2).reverse(),
+      ...proof2.pi_c.slice(0, 2),
+      ...sigs,
+    ]
+  }
+
+  async getInputs2({ json, path }) {
+    return {
+      json: pad(toSignal(encode(json)), this.size_json),
+      path: pad(toSignal(encodePath(path)), this.size_path),
+      val: pad(toSignal(encodeVal(this.getVal(json, path))), this.size_val),
+    }
+  }
+
+  _getVal(j, p) {
+    if (p.length === 0) {
+      return j
+    } else {
+      const sp = p[0].split("[")
+      for (let v of sp) {
+        if (/]$/.test(v)) {
+          j = j[v.replace(/]$/, "") * 1]
+        } else {
+          j = j[v]
+        }
+      }
+      return this._getVal(j, p.slice(1))
+    }
+  }
+
+  getVal(j, p) {
+    if (p === "") return j
+    return this._getVal(j, p.split("."))
+  }
+
+  async genProof2(json, path) {
+    const inputs = await this.getInputs(json, path)
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+      inputs,
+      this.wasm,
+      this.zkey
+    )
+    return [
+      ...proof.pi_a.slice(0, 2),
+      ...proof.pi_b[0].slice(0, 2).reverse(),
+      ...proof.pi_b[1].slice(0, 2).reverse(),
+      ...proof.pi_c.slice(0, 2),
+      ...publicSignals,
+    ]
+  }
+}