zkjson 0.7.0 → 0.7.2

package/cjs/nft.js

@@ -4,12 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports["default"] = void 0;
-var _crypto = _interopRequireDefault(require("crypto"));
+var _fastSha = require("fast-sha256");
 var _snarkjs = require("snarkjs");
 var _encoder = require("./encoder.js");
 var _uint = require("./uint.js");
 var _parse = require("./parse.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _regenerator() { /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */ var e, t, r = "function" == typeof Symbol ? Symbol : {}, n = r.iterator || "@@iterator", o = r.toStringTag || "@@toStringTag"; function i(r, n, o, i) { var c = n && n.prototype instanceof Generator ? n : Generator, u = Object.create(c.prototype); return _regeneratorDefine2(u, "_invoke", function (r, n, o) { var i, c, u, f = 0, p = o || [], y = !1, G = { p: 0, n: 0, v: e, a: d, f: d.bind(e, 4), d: function d(t, r) { return i = t, c = 0, u = e, G.n = r, a; } }; function d(r, n) { for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) { var o, i = p[t], d = G.p, l = i[2]; r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0)); } if (o || r > 1) return a; throw y = !0, n; } return function (o, p, l) { if (f > 1) throw TypeError("Generator is already running"); for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) { i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u); try { if (f = 2, i) { if (c || (o = "next"), t = i[o]) { if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object"); if (!t.done) return t; u = t.value, c < 2 && (c = 0); } else 1 === c && (t = i["return"]) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1); i = e; } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break; } catch (t) { i = e, c = 1, u = t; } finally { f = 1; } } return { value: t, done: y }; }; }(r, o, i), !0), u; } var a = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} t = Object.getPrototypeOf; var c = [][n] ? t(t([][n]())) : (_regeneratorDefine2(t = {}, n, function () { return this; }), t), u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c); function f(e) { return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine2(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine2(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine2(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine2(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine2(u), _regeneratorDefine2(u, o, "Generator"), _regeneratorDefine2(u, n, function () { return this; }), _regeneratorDefine2(u, "toString", function () { return "[object Generator]"; }), (_regenerator = function _regenerator() { return { w: i, m: f }; })(); }
 function _regeneratorDefine2(e, r, n, t) { var i = Object.defineProperty; try { i({}, "", {}); } catch (e) { i = 0; } _regeneratorDefine2 = function _regeneratorDefine(e, r, n, t) { if (r) i ? i(e, r, { value: n, enumerable: !t, configurable: !t, writable: !t }) : e[r] = n;else { var o = function o(r, n) { _regeneratorDefine2(e, r, function (e) { return this._invoke(r, n, e); }); }; o("next", 0), o("throw", 1), o("return", 2); } }, _regeneratorDefine2(e, r, n, t); }
@@ -158,8 +157,8 @@ var NFT = exports["default"] = /*#__PURE__*/function () {
     key: "cid",
     value: function cid() {
       var str = new TextEncoder().encode(JSON.stringify(this.json));
-      var hash = coerce(_crypto["default"].createHash("sha256").update(str).digest());
-      return toCID(new Uint8Array([18, hash.length].concat(_toConsumableArray(Array.from(hash)))));
+      var hashBytes = (0, _fastSha.hash)(str);
+      return toCID(new Uint8Array([18, hashBytes.length].concat(_toConsumableArray(Array.from(hashBytes)))));
     }
   }]);
 }();

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(`__nodes__/${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(`__nodes__/${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(`__nodes__/${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
+}