zkjson 0.7.1 → 0.8.0

package/esm/circomlibjs/SMT.js

@@ -0,0 +1,349 @@
+import * as ffjavascript from "ffjavascript"
+import buildPoseidon from "./buildPoseidon.js"
+import { splitEvery } from "ramda"
+export default class SMT {
+  constructor(db, root, hash0, hash1, F) {
+    this.db = db
+    this.root = root
+    this.hash0 = hash0
+    this.hash1 = hash1
+    this.F = F
+  }
+
+  _splitBits(_key) {
+    const F = this.F
+    const res = ffjavascript.Scalar.bits(F.toObject(_key))
+
+    while (res.length < 256) res.push(false)
+
+    return res
+  }
+
+  async update(_key, _newValue) {
+    this.poseidon ??= await buildPoseidon()
+    this.zero ??= this.poseidon([
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+    ])
+    let _hash_value = _newValue
+    if (_newValue.length === 256) {
+      _hash_value = []
+      for (let v of splitEvery(16, _newValue)) {
+        const value =
+          v.join("") === "0000000000000000" ? this.zero : this.poseidon(v)
+        _hash_value.push(value)
+      }
+    }
+    const newValue = this.poseidon(_hash_value)
+    const F = this.F
+    const key = F.e(_key)
+    const resFind = await this.find(key)
+    const res = {}
+    res.oldRoot = this.root
+    res.oldKey = key
+    res.oldValue = resFind.foundValue
+    res.newKey = key
+    res.newValue = newValue
+    res.siblings = resFind.siblings
+
+    const ins = []
+    const dels = []
+
+    let rtOld = this.hash1(key, resFind.foundValue)
+    let rtNew = this.hash1(key, newValue)
+    ins.push([rtNew, [1, key, newValue]])
+    dels.push(rtOld)
+
+    const keyBits = this._splitBits(key)
+    for (let level = resFind.siblings.length - 1; level >= 0; level--) {
+      let oldNode, newNode
+      const sibling = resFind.siblings[level]
+      if (keyBits[level]) {
+        oldNode = [sibling, rtOld]
+        newNode = [sibling, rtNew]
+      } else {
+        oldNode = [rtOld, sibling]
+        newNode = [rtNew, sibling]
+      }
+      rtOld = this.hash0(oldNode[0], oldNode[1])
+      rtNew = this.hash0(newNode[0], newNode[1])
+      dels.push(rtOld)
+      ins.push([rtNew, newNode])
+    }
+
+    res.newRoot = rtNew
+
+    await this.db.multiDel(dels)
+    await this.db.multiIns(ins)
+    await this.db.setRoot(rtNew)
+    this.root = rtNew
+
+    return res
+  }
+
+  async delete(_key) {
+    const F = this.F
+    const key = F.e(_key)
+
+    const resFind = await this.find(key)
+    if (!resFind.found) throw new Error("Key does not exists")
+
+    const res = {
+      siblings: [],
+      delKey: key,
+      delValue: resFind.foundValue,
+    }
+
+    const dels = []
+    const ins = []
+    let rtOld = this.hash1(key, resFind.foundValue)
+    let rtNew
+    dels.push(rtOld)
+
+    let mixed
+    if (resFind.siblings.length > 0) {
+      const record = await this.db.get(
+        resFind.siblings[resFind.siblings.length - 1],
+      )
+      if (record.length == 3 && F.eq(record[0], F.one)) {
+        mixed = false
+        res.oldKey = record[1]
+        res.oldValue = record[2]
+        res.isOld0 = false
+        rtNew = resFind.siblings[resFind.siblings.length - 1]
+      } else if (record.length == 2) {
+        mixed = true
+        res.oldKey = key
+        res.oldValue = F.zero
+        res.isOld0 = true
+        rtNew = F.zero
+      } else {
+        throw new Error("Invalid node. Database corrupted")
+      }
+    } else {
+      rtNew = F.zero
+      res.oldKey = key
+      res.oldValue = F.zero
+      res.isOld0 = true
+    }
+
+    const keyBits = this._splitBits(key)
+
+    for (let level = resFind.siblings.length - 1; level >= 0; level--) {
+      let newSibling = resFind.siblings[level]
+      if (level == resFind.siblings.length - 1 && !res.isOld0) {
+        newSibling = F.zero
+      }
+      const oldSibling = resFind.siblings[level]
+      if (keyBits[level]) {
+        rtOld = this.hash0(oldSibling, rtOld)
+      } else {
+        rtOld = this.hash0(rtOld, oldSibling)
+      }
+      dels.push(rtOld)
+      if (!F.isZero(newSibling)) {
+        mixed = true
+      }
+
+      if (mixed) {
+        res.siblings.unshift(resFind.siblings[level])
+        let newNode
+        if (keyBits[level]) {
+          newNode = [newSibling, rtNew]
+        } else {
+          newNode = [rtNew, newSibling]
+        }
+        rtNew = this.hash0(newNode[0], newNode[1])
+        ins.push([rtNew, newNode])
+      }
+    }
+
+    await this.db.multiIns(ins)
+    await this.db.setRoot(rtNew)
+    this.root = rtNew
+    await this.db.multiDel(dels)
+
+    res.newRoot = rtNew
+    res.oldRoot = rtOld
+
+    return res
+  }
+
+  async insert(_key, _value) {
+    this.poseidon ??= await buildPoseidon()
+    this.zero ??= this.poseidon([
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+      "0",
+    ])
+    let _hash_value = _value
+    if (_value.length === 256) {
+      _hash_value = []
+      for (let v of splitEvery(16, _value)) {
+        const value =
+          v.join("") === "0000000000000000" ? this.zero : this.poseidon(v)
+        _hash_value.push(value)
+      }
+    }
+
+    const value = this.poseidon(_hash_value)
+    const F = this.F
+    const key = F.e(_key)
+    let addedOne = false
+    const res = {}
+    res.oldRoot = this.root
+    const newKeyBits = this._splitBits(key)
+
+    let rtOld
+
+    const resFind = await this.find(key)
+    if (resFind.found) throw new Error("Key already exists")
+
+    res.siblings = resFind.siblings
+    let mixed
+
+    if (!resFind.isOld0) {
+      const oldKeyits = this._splitBits(resFind.notFoundKey)
+      for (let i = res.siblings.length; oldKeyits[i] == newKeyBits[i]; i++) {
+        res.siblings.push(F.zero)
+      }
+      rtOld = this.hash1(resFind.notFoundKey, resFind.notFoundValue)
+      res.siblings.push(rtOld)
+      addedOne = true
+      mixed = false
+    } else if (res.siblings.length > 0) {
+      mixed = true
+      rtOld = F.zero
+    }
+
+    const inserts = []
+    const dels = []
+
+    let rt = this.hash1(key, value)
+    inserts.push([rt, [1, key, value]])
+
+    for (let i = res.siblings.length - 1; i >= 0; i--) {
+      if (i < res.siblings.length - 1 && !F.isZero(res.siblings[i])) {
+        mixed = true
+      }
+      if (mixed) {
+        const oldSibling = resFind.siblings[i]
+        if (newKeyBits[i]) {
+          rtOld = this.hash0(oldSibling, rtOld)
+        } else {
+          rtOld = this.hash0(rtOld, oldSibling)
+        }
+        dels.push(rtOld)
+      }
+
+      let newRt
+      if (newKeyBits[i]) {
+        newRt = this.hash0(res.siblings[i], rt)
+        inserts.push([newRt, [res.siblings[i], rt]])
+      } else {
+        newRt = this.hash0(rt, res.siblings[i])
+        inserts.push([newRt, [rt, res.siblings[i]]])
+      }
+      rt = newRt
+    }
+
+    if (addedOne) res.siblings.pop()
+    while (
+      res.siblings.length > 0 &&
+      F.isZero(res.siblings[res.siblings.length - 1])
+    ) {
+      res.siblings.pop()
+    }
+    res.oldKey = resFind.notFoundKey
+    res.oldValue = resFind.notFoundValue
+    res.newRoot = rt
+    res.isOld0 = resFind.isOld0
+
+    await this.db.multiIns(inserts)
+    await this.db.setRoot(rt)
+    this.root = rt
+    await this.db.multiDel(dels)
+
+    return res
+  }
+
+  async find(_key) {
+    const key = this.F.e(_key)
+    const keyBits = this._splitBits(key)
+    return await this._find(key, keyBits, this.root, 0)
+  }
+
+  async _find(key, keyBits, root, level) {
+    const F = this.F
+    if (typeof root === "undefined") root = this.root
+
+    let res
+    if (F.isZero(root)) {
+      res = {
+        found: false,
+        siblings: [],
+        notFoundKey: key,
+        notFoundValue: F.zero,
+        isOld0: true,
+      }
+      return res
+    }
+
+    const record = await this.db.get(root)
+
+    if (record.length == 3 && F.eq(record[0], F.one)) {
+      if (F.eq(record[1], key)) {
+        res = {
+          found: true,
+          siblings: [],
+          foundValue: record[2],
+          isOld0: false,
+        }
+      } else {
+        res = {
+          found: false,
+          siblings: [],
+          notFoundKey: record[1],
+          notFoundValue: record[2],
+          isOld0: false,
+        }
+      }
+    } else {
+      if (keyBits[level] == 0) {
+        res = await this._find(key, keyBits, record[0], level + 1)
+        res.siblings.unshift(record[1])
+      } else {
+        res = await this._find(key, keyBits, record[1], level + 1)
+        res.siblings.unshift(record[0])
+      }
+    }
+    return res
+  }
+}

package/esm/circomlibjs/SMTMemDb.js

@@ -0,0 +1,69 @@
+export default class SMTMemDb {
+  constructor(F, kv) {
+    this.kv = kv
+    this.nodes = {}
+    this.root = F.zero
+    if (this.kv) {
+      const root = this.kv.get("root")
+      if (root) this.root = root
+      else this.kv.put("root", this.root)
+    }
+    this.F = F
+  }
+
+  async getRoot() {
+    return this.root
+  }
+
+  _key2str(k) {
+    this.F
+    const keyS = this.F.toString(k)
+    return keyS
+  }
+
+  _normalize(n) {
+    this.F
+    for (let i = 0; i < n.length; i++) {
+      n[i] = this.F.e(n[i])
+    }
+  }
+
+  async get(key) {
+    const keyS = this._key2str(key)
+    if (!this.nodes[keyS]) {
+      let node = this.kv.get(`node_${keyS}`)
+      if (node) this.nodes[keyS] = node
+    }
+    return this.nodes[keyS]
+  }
+
+  async multiGet(keys) {
+    const promises = []
+    for (let i = 0; i < keys.length; i++) {
+      promises.push(this.get(keys[i]))
+    }
+    return await Promise.all(promises)
+  }
+
+  async setRoot(rt) {
+    this.root = rt
+    if (this.kv) this.kv.put("root", this.root)
+  }
+
+  async multiIns(inserts) {
+    for (let i = 0; i < inserts.length; i++) {
+      const keyS = this._key2str(inserts[i][0])
+      this._normalize(inserts[i][1])
+      this.nodes[keyS] = inserts[i][1]
+      if (this.kv) this.kv.put(`node_${keyS}`, this.nodes[keyS])
+    }
+  }
+
+  async multiDel(dels) {
+    for (let i = 0; i < dels.length; i++) {
+      const keyS = this._key2str(dels[i])
+      delete this.nodes[keyS]
+      if (this.kv) this.kv.del(`node_${keyS}`)
+    }
+  }
+}

package/esm/circomlibjs/buildPoseidon.js

@@ -0,0 +1,113 @@
+import * as ffjavascript from "ffjavascript"
+import poseidonConstants$1 from "./poseidonConstants$1.js"
+import * as assert from "assert"
+const assert__default = assert
+
+function unsringifyConstants(Fr, o) {
+  if (typeof o == "string" && /^[0-9]+$/.test(o)) {
+    return Fr.e(o)
+  } else if (typeof o == "string" && /^0x[0-9a-fA-F]+$/.test(o)) {
+    return Fr.e(o)
+  } else if (Array.isArray(o)) {
+    return o.map(unsringifyConstants.bind(null, Fr))
+  } else if (typeof o == "object") {
+    if (o === null) return null
+    const res = {}
+    const keys = Object.keys(o)
+    keys.forEach(k => {
+      res[k] = unsringifyConstants(Fr, o[k])
+    })
+    return res
+  } else {
+    return o
+  }
+}
+
+export default async function buildPoseidon() {
+  const bn128 = await ffjavascript.getCurveFromName("bn128", true)
+
+  const F = bn128.Fr
+
+  const opt = unsringifyConstants(F, poseidonConstants$1)
+
+  const N_ROUNDS_F = 8
+  const N_ROUNDS_P = [
+    56, 57, 56, 60, 60, 63, 64, 63, 60, 66, 60, 65, 70, 60, 64, 68,
+  ]
+
+  const pow5 = a => F.mul(a, F.square(F.square(a, a)))
+
+  function poseidon(inputs, initState, nOut) {
+    assert__default["default"](inputs.length > 0)
+    assert__default["default"](inputs.length <= N_ROUNDS_P.length)
+
+    if (initState) {
+      initState = F.e(initState)
+    } else {
+      initState = F.zero
+    }
+    nOut = nOut || 1
+
+    const t = inputs.length + 1
+    const nRoundsF = N_ROUNDS_F
+    const nRoundsP = N_ROUNDS_P[t - 2]
+    const C = opt.C[t - 2]
+    const S = opt.S[t - 2]
+    const M = opt.M[t - 2]
+    const P = opt.P[t - 2]
+
+    let state = [initState, ...inputs.map(a => F.e(a))]
+
+    state = state.map((a, i) => F.add(a, C[i]))
+
+    for (let r = 0; r < nRoundsF / 2 - 1; r++) {
+      state = state.map(a => pow5(a))
+      state = state.map((a, i) => F.add(a, C[(r + 1) * t + i]))
+      state = state.map((_, i) =>
+        state.reduce((acc, a, j) => F.add(acc, F.mul(M[j][i], a)), F.zero),
+      )
+    }
+    state = state.map(a => pow5(a))
+    state = state.map((a, i) => F.add(a, C[(nRoundsF / 2 - 1 + 1) * t + i]))
+    state = state.map((_, i) =>
+      state.reduce((acc, a, j) => F.add(acc, F.mul(P[j][i], a)), F.zero),
+    )
+    for (let r = 0; r < nRoundsP; r++) {
+      state[0] = pow5(state[0])
+      state[0] = F.add(state[0], C[(nRoundsF / 2 + 1) * t + r])
+
+      const s0 = state.reduce((acc, a, j) => {
+        return F.add(acc, F.mul(S[(t * 2 - 1) * r + j], a))
+      }, F.zero)
+      for (let k = 1; k < t; k++) {
+        state[k] = F.add(
+          state[k],
+          F.mul(state[0], S[(t * 2 - 1) * r + t + k - 1]),
+        )
+      }
+      state[0] = s0
+    }
+    for (let r = 0; r < nRoundsF / 2 - 1; r++) {
+      state = state.map(a => pow5(a))
+      state = state.map((a, i) =>
+        F.add(a, C[(nRoundsF / 2 + 1) * t + nRoundsP + r * t + i]),
+      )
+      state = state.map((_, i) =>
+        state.reduce((acc, a, j) => F.add(acc, F.mul(M[j][i], a)), F.zero),
+      )
+    }
+    state = state.map(a => pow5(a))
+    state = state.map((_, i) =>
+      state.reduce((acc, a, j) => F.add(acc, F.mul(M[j][i], a)), F.zero),
+    )
+
+    if (nOut == 1) {
+      return state[0]
+    } else {
+      return state.slice(0, nOut)
+    }
+  }
+
+  poseidon.F = F
+  return poseidon
+}