zkjson 0.6.1 → 1.0.2

package/solidity/test/ZKArweave.js

@@ -0,0 +1,97 @@
+const snarkjs = require("snarkjs")
+const { utils } = require("ethers")
+const { newMemEmptyTrie, buildPoseidon } = require("../../sdk/circomlibjs")
+const { resolve } = require("path")
+const { range, splitEvery } = require("ramda")
+const {
+  pad,
+  encode,
+  decode,
+  encodePath,
+  decodePath,
+  encodeVal,
+  decodeVal,
+  str2id,
+  toSignal,
+} = require("../../sdk")
+
+module.exports = class ZKArweave {
+  constructor(zkdb, size_path, size_val, size_json) {
+    this.zkdb = zkdb
+    this.size_path = size_path
+    this.size_val = size_val
+    this.size_json = size_json
+  }
+  async genProof(_path, _json) {
+    const json = pad(toSignal(encode(_json)), this.size_json)
+    const path = pad(toSignal(encodePath(_path)), this.size_path)
+    const val = pad(toSignal(encodeVal(_json[_path])), this.size_val)
+    const _inputs = { json, path, val }
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+      _inputs,
+      resolve(
+        __dirname,
+        "../../circom/build/circuits/json/index_js/index.wasm",
+      ),
+      resolve(__dirname, "../../circom/build/circuits/json/index_0001.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 genHash(_json) {
+    const _value = pad(toSignal(encode(_json)), this.size_json)
+    const tree = await newMemEmptyTrie()
+    const poseidon = await buildPoseidon()
+    let _hash_value = _value
+    if (_value.length === 256) {
+      _hash_value = []
+      for (let v of splitEvery(16, _value)) {
+        const poseidon = await buildPoseidon()
+        const value = poseidon(v)
+        _hash_value.push(value)
+      }
+    }
+    const value = poseidon(_hash_value)
+    return tree.F.toObject(value).toString()
+  }
+
+  async query(txid, _path, _json, pkp) {
+    const val = _json[_path]
+    const inputs = await this.genProof(_path, _json)
+    const hash = await this.zkdb.getMessageHash(txid, inputs[9])
+    const sig = await pkp.signMessage(utils.arrayify(hash))
+    const sigs = inputs.slice(8)
+    const params = [txid, sigs.slice(2, 7), inputs, sig]
+    let type =
+      val === null
+        ? 0
+        : typeof val === "string"
+          ? 3
+          : typeof val === "boolean"
+            ? 1
+            : typeof val === "number"
+              ? Number.isInteger(val)
+                ? 2
+                : 2.5
+              : 4
+    switch (type) {
+      case 0:
+        return await this.zkdb.qNull(...params)
+      case 1:
+        return await this.zkdb.qBool(...params)
+      case 2:
+        return (await this.zkdb.qInt(...params)).toString() * 1
+      case 2.5:
+        return (await this.zkdb.qFloat(...params)).map(n => n.toString() * 1)
+      case 3:
+        return await this.zkdb.qString(...params)
+      case 4:
+        return (await this.zkdb.qRaw(...params)).map(n => n.toString() * 1)
+    }
+  }
+}

package/solidity/test/arweave.js

@@ -0,0 +1,55 @@
+const snarkjs = require("snarkjs")
+const { splitEvery } = require("ramda")
+const { newMemEmptyTrie, buildPoseidon } = require("../../sdk/circomlibjs")
+const {
+  pad,
+  encode,
+  decode,
+  encodePath,
+  decodePath,
+  encodeVal,
+  decodeVal,
+  toSignal,
+} = require("../../sdk")
+const { Wallet, utils } = require("ethers")
+const { resolve } = require("path")
+const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers")
+const { expect } = require("chai")
+const ZKAR = require("./ZKArweave")
+async function deploy() {
+  const [owner, otherAccount] = await ethers.getSigners()
+  const pkp = Wallet.createRandom()
+  const VerifierJSON = await ethers.getContractFactory("Groth16VerifierJSON")
+  const verifierJSON = await VerifierJSON.deploy()
+  const ZKAR = await ethers.getContractFactory("ZKArweave")
+  const zkdb = await ZKAR.deploy(verifierJSON.address, pkp.address)
+  return { owner, otherAccount, zkdb, pkp }
+}
+
+describe("zkArweave", function () {
+  let zkdb, verifier, pkp
+  this.timeout(1000000000)
+
+  beforeEach(async () => {
+    const dep = await loadFixture(deploy)
+    zkdb = dep.zkdb
+    const verifier = dep.verifier
+    pkp = dep.pkp
+  })
+
+  it("Should verify rollup transactions", async function () {
+    const zkar = new ZKAR(zkdb, 4, 8, 256)
+
+    const _json = { a: "Hello", b: true, c: null, d: 1.1, e: 5, f: [1, 2, 3] }
+    const _path = "a"
+    const inputs = await zkar.genProof(_path, _json)
+    const txid = "ArweaveTxID"
+    expect(await zkar.query(txid, "a", _json, pkp)).to.eql("Hello")
+    expect(await zkar.query(txid, "b", _json, pkp)).to.eql(true)
+    expect(await zkar.query(txid, "c", _json, pkp)).to.eql(true)
+    expect(await zkar.query(txid, "d", _json, pkp)).to.eql([1, 1, 11])
+    expect(await zkar.query(txid, "e", _json, pkp)).to.eql(5)
+    expect(await zkar.genHash(_json)).to.eql(inputs[9])
+    return
+  })
+})

package/solidity/test/bridge.js

@@ -0,0 +1,71 @@
+const { DB } = require("../../sdk")
+const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers")
+const { expect } = require("chai")
+const { resolve } = require("path")
+async function deploy() {
+  const [owner, user] = await ethers.getSigners()
+  const VerifierDB = await ethers.getContractFactory("Groth16VerifierDB")
+  const verifierDB = await VerifierDB.deploy()
+  const Verifier = await ethers.getContractFactory("Groth16VerifierRU")
+  const verifier = await Verifier.deploy()
+  const ZKDB = await ethers.getContractFactory("SimpleOPRU")
+  const zkdb = await ZKDB.deploy(
+    verifier.address,
+    verifierDB.address,
+    owner.address,
+  )
+  const Token = await ethers.getContractFactory("Token")
+  const token = await Token.deploy()
+  const ZKBridge = await ethers.getContractFactory("ZKBridge")
+  const bridge = await ZKBridge.deploy(zkdb.address, token.address)
+  return { bridge, verifierDB, verifier, owner, user, zkdb, token }
+}
+
+describe("zkDB", function () {
+  this.timeout(0)
+  it("Should transfer point token", async function () {
+    const { token, user, owner, bridge, zkdb } = await loadFixture(deploy)
+
+    const addr = owner.address.toLowerCase().slice(2, 10)
+    const addr2 = user.address.toLowerCase().slice(2, 10)
+    const json = { amount: 100, to: user.address.toLowerCase() }
+
+    const db = new DB({
+      wasm: resolve(
+        __dirname,
+        "../../circom/build/circuits/db/index_js/index.wasm",
+      ),
+      zkey: resolve(
+        __dirname,
+        "../../circom/build/circuits/db/index_0001.zkey",
+      ),
+    })
+    await db.init()
+    const col = await db.addCollection()
+    let txs = [[col, "abc", json]]
+    for (const v of txs) await db.insert(...v)
+    const root = db.tree.F.toObject(db.tree.root).toString()
+    await zkdb.commitRoot(root)
+
+    const proof = await db.genProof({
+      col_id: col,
+      id: "abc",
+      json: json,
+      path: "to",
+    })
+
+    const proof2 = await db.genProof({
+      col_id: col,
+      id: "abc",
+      json: json,
+      path: "amount",
+    })
+    const sigs = proof.slice(8)
+    const _col = sigs[14]
+    const _doc = sigs[15]
+
+    expect((await token.balanceOf(user.address)).toNumber()).to.eql(0)
+    await bridge.bridge(_col, _doc, proof, proof2)
+    expect((await token.balanceOf(user.address)).toNumber()).to.eql(100)
+  })
+})

package/solidity/test/simple.js

@@ -0,0 +1,76 @@
+const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers")
+const { path, Doc } = require("../../sdk")
+const { resolve } = require("path")
+const { expect } = require("chai")
+
+async function deploy() {
+  const Verifier = await ethers.getContractFactory("Groth16VerifierJSON")
+  const verifier = await Verifier.deploy()
+  const MyApp = await ethers.getContractFactory("SimpleJSON")
+  const myapp = await MyApp.deploy(verifier.address)
+  return { myapp }
+}
+
+describe("MyApp", function () {
+  let myapp
+  this.timeout(0)
+
+  beforeEach(async () => {
+    const dep = await loadFixture(deploy)
+    myapp = dep.myapp
+  })
+
+  it("should verify JSON", async function () {
+    const doc = new Doc({
+      wasm: resolve(
+        __dirname,
+        "../../circom/build/circuits/json/index_js/index.wasm",
+      ),
+      zkey: resolve(
+        __dirname,
+        "../../circom/build/circuits/json/index_0001.zkey",
+      ),
+    })
+    const json = {
+      num: 1,
+      float: 1.23,
+      str: "string",
+      bool: true,
+      null: null,
+      array: [1, 2, 3],
+    }
+
+    // query number
+    const zkp = await doc.genProof({ json, path: "num" })
+    expect((await myapp.qInt(path("num"), zkp)).toNumber()).to.eql(1)
+
+    // query string
+    const zkp2 = await doc.genProof({ json, path: "str" })
+    expect(await myapp.qString(path("str"), zkp2)).to.eql("string")
+
+    // query bool
+    const zkp3 = await doc.genProof({ json, path: "bool" })
+    expect(await myapp.qBool(path("bool"), zkp3)).to.eql(true)
+
+    // query null
+    const zkp4 = await doc.genProof({ json, path: "null" })
+    expect(await myapp.qNull(path("null"), zkp4)).to.eql(true)
+
+    // query float
+    const zkp5 = await doc.genProof({ json, path: "float" })
+    expect(
+      (await myapp.qFloat(path("float"), zkp5)).map(f => f.toNumber()),
+    ).to.eql([1, 2, 123])
+
+    // query array and get number
+    const zkp6 = await doc.genProof({ json, path: "array" })
+    expect(
+      (await myapp.qCustom(path("array"), path("[1]"), zkp6)).toNumber(),
+    ).to.eql(2)
+
+    // conditional operator
+    const zkp7 = await doc.genProof({ json, path: "num", query: ["$gt", 0] })
+    expect(await myapp.qCond(path("num"), zkp7.slice(14), zkp7)).to.eql(true)
+    return
+  })
+})

package/solidity/test/simpleOPRU.js

@@ -0,0 +1,98 @@
+const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers")
+const { toIndex, path, DB } = require("../../sdk")
+const { resolve } = require("path")
+const { expect } = require("chai")
+
+async function deploy() {
+  const [committer] = await ethers.getSigners()
+  const VerifierRU = await ethers.getContractFactory("Groth16VerifierRU")
+  const verifierRU = await VerifierRU.deploy()
+  const VerifierDB = await ethers.getContractFactory("Groth16VerifierDB")
+  const verifierDB = await VerifierDB.deploy()
+
+  const MyRU = await ethers.getContractFactory("SimpleOPRU")
+  const myru = await MyRU.deploy(
+    verifierRU.address,
+    verifierDB.address,
+    committer.address,
+  )
+  return { myru, committer }
+}
+
+describe("MyRollup", function () {
+  let myru, committer, db, col_id, ru
+  this.timeout(0)
+
+  beforeEach(async () => {
+    const dep = await loadFixture(deploy)
+    myru = dep.myru
+    committer = dep.committer
+  })
+
+  it("should verify rollup transactions", async function () {
+    db = new DB({
+      level: 168,
+      size_path: 4,
+      size_val: 8,
+      size_json: 256,
+      size_txs: 10,
+      level_col: 8,
+      wasmRU: resolve(
+        __dirname,
+        "../../circom/build/circuits/rollup/index_js/index.wasm",
+      ),
+      zkeyRU: resolve(
+        __dirname,
+        "../../circom/build/circuits/rollup/index_0001.zkey",
+      ),
+      wasm: resolve(
+        __dirname,
+        "../../circom/build/circuits/db/index_js/index.wasm",
+      ),
+      zkey: resolve(
+        __dirname,
+        "../../circom/build/circuits/db/index_0001.zkey",
+      ),
+    })
+    await db.init()
+    col_id = await db.addCollection()
+    const people = [{ name: "Bob", age: 5 }]
+    let txs = people.map(v => {
+      return [col_id, v.name, v]
+    })
+
+    for (const v of txs) {
+      await db.insert(...v)
+    }
+    const root = db.tree.F.toObject(db.tree.root).toString()
+
+    await myru.commitRoot(root)
+
+    const zkp2 = await db.genProof({
+      json: people[0],
+      col_id,
+      path: "name",
+      id: "Bob",
+    })
+
+    expect(
+      await myru.qString([col_id, toIndex("Bob"), ...path("name")], zkp2),
+    ).to.eql("Bob")
+
+    const zkp3 = await db.genProof({
+      json: people[0],
+      col_id,
+      path: "age",
+      id: "Bob",
+      query: ["$gt", 3],
+    })
+
+    expect(
+      await myru.qCond(
+        [col_id, toIndex("Bob"), ...path("age")],
+        zkp3.slice(13, 14),
+        zkp3,
+      ),
+    ).to.eql(true)
+  })
+})

package/solidity/test/simpleRU.js

@@ -0,0 +1,94 @@
+const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers")
+const { toIndex, path, DB } = require("../../sdk")
+const { resolve } = require("path")
+const { expect } = require("chai")
+
+async function deploy() {
+  const [committer] = await ethers.getSigners()
+  const VerifierRU = await ethers.getContractFactory("Groth16VerifierRU")
+  const verifierRU = await VerifierRU.deploy()
+  const VerifierDB = await ethers.getContractFactory("Groth16VerifierDB")
+  const verifierDB = await VerifierDB.deploy()
+
+  const MyRU = await ethers.getContractFactory("SimpleRU")
+  const myru = await MyRU.deploy(
+    verifierRU.address,
+    verifierDB.address,
+    committer.address,
+  )
+  return { myru, committer }
+}
+
+describe("MyRollup", function () {
+  let myru, committer, db, col_id, ru
+  this.timeout(0)
+
+  beforeEach(async () => {
+    const dep = await loadFixture(deploy)
+    myru = dep.myru
+    committer = dep.committer
+  })
+
+  it("should verify rollup transactions", async function () {
+    db = new DB({
+      level: 168,
+      size_path: 4,
+      size_val: 8,
+      size_json: 256,
+      size_txs: 10,
+      level_col: 8,
+      wasmRU: resolve(
+        __dirname,
+        "../../circom/build/circuits/rollup/index_js/index.wasm",
+      ),
+      zkeyRU: resolve(
+        __dirname,
+        "../../circom/build/circuits/rollup/index_0001.zkey",
+      ),
+      wasm: resolve(
+        __dirname,
+        "../../circom/build/circuits/db/index_js/index.wasm",
+      ),
+      zkey: resolve(
+        __dirname,
+        "../../circom/build/circuits/db/index_0001.zkey",
+      ),
+    })
+    await db.init()
+    col_id = await db.addCollection()
+    const people = [
+      { name: "Bob", age: 10 },
+      { name: "Alice", age: 20 },
+      { name: "Mike", age: 30 },
+      { name: "Beth", age: 40 },
+    ]
+    let txs = people.map(v => {
+      return [col_id, v.name, v]
+    })
+    const zkp = await db.genRollupProof(txs)
+    await myru.commit(zkp)
+
+    const zkp2 = await db.genProof({
+      json: people[0],
+      col_id,
+      path: "age",
+      id: "Bob",
+    })
+
+    expect(
+      (
+        await myru.qInt([col_id, toIndex("Bob"), ...path("age")], zkp2)
+      ).toNumber(),
+    ).to.eql(10)
+
+    const zkp3 = await db.genProof({
+      json: people[3],
+      col_id,
+      path: "name",
+      id: "Beth",
+    })
+    expect(
+      await myru.qString([col_id, toIndex("Beth"), ...path("name")], zkp3),
+    ).to.eql("Beth")
+  })
+})

package/solidity/test/zknft.js

@@ -0,0 +1,98 @@
+const NFT = require("../../sdk/nft")
+const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers")
+const { expect } = require("chai")
+const { resolve } = require("path")
+
+const wasm = resolve(
+  __dirname,
+  "../../circom/build/circuits/ipfs/index_js/index.wasm",
+)
+const zkey = resolve(
+  __dirname,
+  "../../circom/build/circuits/ipfs/index_0001.zkey",
+)
+
+async function deploy() {
+  const [owner, user] = await ethers.getSigners()
+  const VerifierIPFS = await ethers.getContractFactory("Groth16VerifierIPFS")
+  const verifierIPFS = await VerifierIPFS.deploy()
+  const ZKNFT = await ethers.getContractFactory("ZKNFT")
+  const zknft = await ZKNFT.deploy(verifierIPFS.address)
+  return { zknft, owner, user }
+}
+
+describe("zkNFT", function () {
+  this.timeout(0)
+  it("Should query metadata", async function () {
+    const { user, owner, zknft } = await loadFixture(deploy)
+    const json = {
+      str: "Hello, World!",
+      int: 123,
+      bool: true,
+      null: null,
+      float: 1.23,
+      arr: [1, 2, 3, true, null, "hello", 3.14],
+    }
+    const nft = new NFT({ wasm, zkey, json })
+    const cid = nft.cid()
+    await zknft.mint(user.address, `ipfs://${cid}`)
+
+    // query string
+    expect(
+      await zknft.qString(0, nft.path("str"), await nft.zkp("str")),
+    ).to.eql(json["str"])
+
+    // query int
+    expect(
+      (await zknft.qInt(0, nft.path("int"), await nft.zkp("int"))).toNumber(),
+    ).to.eql(json["int"])
+
+    // query bool
+    expect(
+      await zknft.qBool(0, nft.path("bool"), await nft.zkp("bool")),
+    ).to.eql(json["bool"])
+
+    // query null
+    expect(
+      await zknft.qNull(0, nft.path("null"), await nft.zkp("null")),
+    ).to.eql(true)
+
+    // query float
+    expect(
+      (await zknft.qFloat(0, nft.path("float"), await nft.zkp("float"))).map(
+        n => n.toNumber(),
+      ),
+    ).to.eql([1, 2, 123])
+
+    // custom
+    expect(
+      (
+        await zknft.qCustom(
+          0,
+          nft.path("arr"),
+          nft.path("[1]"),
+          await nft.zkp("arr"),
+        )
+      ).toNumber(),
+    ).to.eql(2)
+
+    // query cond
+    expect(
+      await zknft.qCond(
+        0,
+        nft.path("int"),
+        nft.query("int", ["$gt", 100]),
+        await nft.zkp("int", ["$gt", 100]),
+      ),
+    ).to.eql(true)
+
+    expect(
+      await zknft.qCond(
+        0,
+        nft.path("arr"),
+        nft.query("arr", ["$contains", 2]),
+        await nft.zkp("arr", ["$contains", 2]),
+      ),
+    ).to.eql(true)
+  })
+})