@hinkal/common 0.0.113 → 0.0.115

package/common64.mjs

@@ -0,0 +1,177 @@
+import "ethers";
+import "axios";
+import "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "circomlibjs";
+import "./common51.mjs";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import { logError as l } from "./common84.mjs";
+import "./common129.mjs";
+import { MerkleTreeIncompleteError as a } from "./common65.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common33.mjs";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+class o {
+  constructor(e, t, i, r, n, s) {
+    this.hashFunction = e, this.levels = t, this.defaultNodeValue = i, this.tree = r ?? /* @__PURE__ */ new Map(), this.count = s ?? 0n, this.index = n ?? 2n ** (t - 1n);
+  }
+  /**
+   * the map where the items are stored
+   */
+  tree;
+  /**
+   * amount of elements inserted inside the bottom row of the tree
+   */
+  count;
+  /**
+   * the maximum index inserted into the tree
+   * used together with count to make sure that the merkle tree is complete.
+   * meaning that there aren't any missing elements between getStartIndex() and index
+   */
+  index;
+  static createWithData(e, t, i, r, n, s) {
+    return new o(r, n, s, e, t, i);
+  }
+  /**
+   * @param hashFunction the hashFunction used to fill the upper layers of the merkle tree
+   * @param levels the amount of layers in the merkle tree
+   * @param defaultNodeValue the default value of an empty node in the merkle tree
+   */
+  static create(e, t, i) {
+    return new o(e, t, i);
+  }
+  /**
+   * get starting nodeIndex from which inserts are allowed
+   */
+  getStartIndex() {
+    return 2n ** (this.levels - 1n);
+  }
+  /**
+   * implementation of logarithm2 function from merkle contract
+   */
+  logarithm2(e) {
+    let t = 0n;
+    for (; 2n ** t < e; )
+      t += 1n;
+    return t;
+  }
+  bigIntMax(e, t) {
+    return e > t ? e : t;
+  }
+  forceInsert(e, t) {
+    if (t < this.getStartIndex())
+      throw new RangeError();
+    this.tree.set(t, e);
+    const i = this.index - this.getStartIndex(), r = this.logarithm2(i);
+    let n = t;
+    for (let s = 1n; s <= r; s += 1n) {
+      n /= 2n;
+      const h = this.hashFunction(
+        this.tree.get(n * 2n) || this.defaultNodeValue,
+        this.tree.get(n * 2n + 1n) || this.defaultNodeValue
+      );
+      this.tree.set(n, h);
+    }
+  }
+  /**
+   * insert value into the merkle tree
+   * @param value the value to insert
+   * @param nodeIndex the index to insert the value, you can get starting index from getStartIndex()
+   * @return true - if added, false - if already exists
+   * @throws will throw RangeError if nodeIndex is less than getStartIndex()
+   */
+  insert(e, t) {
+    let i = !1;
+    return this.tree.has(t) && (i = !0, l(`Editing commitment index: ${t} `)), i || (this.count += 1n), this.index = this.bigIntMax(this.index, t + 1n), this.forceInsert(e, t), !0;
+  }
+  remove(e) {
+    this.forceInsert(this.defaultNodeValue, e);
+  }
+  completenessCheck() {
+    if (this.count !== this.index - this.getStartIndex())
+      throw new a();
+  }
+  /**
+   * get root hash of the merkle tree
+   * @returns the hash, if the merkle tree is empty, will return
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getRootHash() {
+    this.completenessCheck();
+    for (let e = 1n; e < 2n ** this.levels; e *= 2n)
+      if (this.tree.get(e))
+        return this.tree.get(e);
+    return this.defaultNodeValue;
+  }
+  getMerkleData() {
+    return this.completenessCheck(), new Map(this.tree);
+  }
+  getSiblingIndex(e) {
+    return e === 1n ? 1n : e % 2n === 1n ? e - 1n : e + 1n;
+  }
+  /**
+   * get sibling hashes needed by main.circom
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingHashesForVerification(e) {
+    this.completenessCheck();
+    let t;
+    for (let r = this.getStartIndex(); r < this.getStartIndex() + this.index; r += 1n)
+      if (this.tree.get(r) === e) {
+        t = r;
+        break;
+      }
+    if (t === void 0)
+      return new Array(Number(this.levels)).fill(0n);
+    const i = [];
+    for (; t !== 0n; )
+      i.push(this.tree.get(this.getSiblingIndex(t)) || this.defaultNodeValue), t /= 2n;
+    return i;
+  }
+  /**
+   * get item's sibling hashes side
+   * @returns sibling's indexes
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingSides(e) {
+    this.completenessCheck();
+    let t;
+    for (let r = this.getStartIndex(); r < this.getStartIndex() + this.index; r += 1n)
+      if (this.tree.get(r) === e) {
+        t = r;
+        break;
+      }
+    if (t === void 0)
+      return new Array(Number(this.levels)).fill(0n);
+    const i = [];
+    for (; t !== 0n; ) {
+      const r = t % 2n === 0n ? 0n : 1n;
+      i.push(r), t /= 2n;
+    }
+    return i;
+  }
+  toJSON() {
+    const { tree: e, count: t, index: i } = this;
+    return {
+      tree: Object.fromEntries(e),
+      count: t.toString(),
+      index: i.toString()
+    };
+  }
+}
+export {
+  o as MerkleTree
+};

package/common65.mjs

@@ -0,0 +1,8 @@
+class r extends Error {
+  constructor() {
+    super("Merkle tree is incomplete"), this.name = "MerkleTreeIncompleteError";
+  }
+}
+export {
+  r as MerkleTreeIncompleteError
+};

package/common66.mjs

@@ -0,0 +1,131 @@
+import "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "ethers";
+import { zeroAddress as i } from "./common34.mjs";
+import { poseidonFunction as m } from "./common45.mjs";
+import "./common51.mjs";
+import { toBigInt as t } from "./common114.mjs";
+import "axios";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "./common129.mjs";
+import "circomlibjs";
+import { MerkleTree as o } from "./common64.mjs";
+import { AbstractSnapshotService as c } from "./common69.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+class G extends c {
+  constructor(e, s, r, d) {
+    super(
+      e,
+      {
+        name: "NewAccessKeyAdded",
+        args: ["accessKey", "index", "senderAddress"]
+      },
+      s,
+      r,
+      d
+    );
+  }
+  _merkleTree;
+  _senderAddresses;
+  _senderAddressIndexMap;
+  get merkleTree() {
+    return this._merkleTree;
+  }
+  get senderAddresses() {
+    return this._senderAddresses;
+  }
+  get senderAddressIndexMap() {
+    return this._senderAddressIndexMap;
+  }
+  serializeSnapshot(e) {
+    return {
+      merkleTree: e.payload.merkleTree.toJSON(),
+      senderAddresses: Array.from(e.payload.senderAddresses),
+      latestBlockNumber: e.latestBlockNumber,
+      reserveBlockNumber: e.reserveBlockNumber,
+      senderAddressIndexMap: Array.from(e.payload.senderAddressIndexMap).map(([s, r]) => ({
+        address: s,
+        index: r
+      }))
+    };
+  }
+  deserializeSnapshot(e) {
+    let s, r;
+    if (e.latestBlockNumber && e.merkleTree) {
+      const d = new Map(
+        Object.entries(e.merkleTree.tree).map(([n, p]) => [
+          BigInt(n),
+          BigInt(p)
+        ])
+      );
+      s = o.createWithData(
+        d,
+        t(e.merkleTree.index),
+        t(e.merkleTree.count),
+        m,
+        25n,
+        0n
+      );
+    } else
+      s = o.create(m, 25n, 0n);
+    return e.latestBlockNumber && e.senderAddressIndexMap ? r = new Map(
+      e.senderAddressIndexMap.map(({ address: d, index: n }) => [d, n])
+    ) : r = /* @__PURE__ */ new Map(), {
+      latestBlockNumber: e.latestBlockNumber ?? 0,
+      reserveBlockNumber: e.reserveBlockNumber ?? 0,
+      payload: {
+        merkleTree: s,
+        senderAddresses: e.senderAddresses ?? [],
+        senderAddressIndexMap: r
+      }
+    };
+  }
+  acceptEvent(e, s) {
+    try {
+      return this._merkleTree.insert(e.accessKey, e.index), this._senderAddressIndexMap.set(
+        e.senderAddress,
+        Math.max(Number(e.index), this._senderAddressIndexMap.get(e.senderAddress) ?? 0)
+      ), this._senderAddresses.includes(e.senderAddress) || this._senderAddresses.push(e.senderAddress), e.accessKey === 0n && e.senderAddress === i && this._merkleTree.remove(e.index), !0;
+    } catch (r) {
+      return console.error(r), !1;
+    }
+  }
+  mapEvent(e) {
+    const { accessKey: s, index: r, senderAddress: d } = e;
+    return {
+      accessKey: t(s),
+      index: t(r),
+      senderAddress: d
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      merkleTree: this._merkleTree,
+      senderAddresses: this._senderAddresses,
+      senderAddressIndexMap: this._senderAddressIndexMap
+    };
+  }
+  populateSnapshot({
+    payload: { merkleTree: e, senderAddresses: s, senderAddressIndexMap: r }
+  }) {
+    this._merkleTree = e, this._senderAddresses = s, this._senderAddressIndexMap = r;
+  }
+}
+export {
+  G as AbstractAccessTokenSnapshotService
+};

package/common67.mjs

@@ -0,0 +1,132 @@
+import { poseidonFunction as o } from "./common45.mjs";
+import "circomlibjs";
+import { MerkleTree as p } from "./common64.mjs";
+import { toBigInt as i } from "./common114.mjs";
+import "ethers";
+import "axios";
+import "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "./common51.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common50.mjs";
+import "./common117.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "libsodium-wrappers";
+import { AbstractSnapshotService as c } from "./common69.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "./common72.mjs";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+import "./common121.mjs";
+import "./common129.mjs";
+class D extends c {
+  constructor(e, t, m, r) {
+    super(
+      e,
+      {
+        name: "NewCommitment",
+        args: ["commitment", "index", "encryptedOutput"]
+      },
+      t,
+      m,
+      r
+    );
+  }
+  _merkleTree;
+  _encryptedOutputs;
+  get merkleTree() {
+    return this._merkleTree;
+  }
+  get encryptedOutputs() {
+    return this._encryptedOutputs;
+  }
+  serializeSnapshot(e) {
+    return {
+      merkleTree: e.payload.merkleTree.toJSON(),
+      latestBlockNumber: e.latestBlockNumber,
+      reserveBlockNumber: e.reserveBlockNumber,
+      encryptedOutputs: e.payload.encryptedOutputs.map((t) => ({
+        value: t.value,
+        isPositive: String(t.isPositive)
+      }))
+    };
+  }
+  deserializeSnapshot(e) {
+    let t;
+    if (e.latestBlockNumber && e.merkleTree) {
+      const r = new Map(
+        Object.entries(e.merkleTree.tree).map(([u, n]) => [
+          BigInt(u),
+          BigInt(n)
+        ])
+      );
+      t = p.createWithData(
+        r,
+        i(e.merkleTree.index),
+        i(e.merkleTree.count),
+        o,
+        25n,
+        0n
+      );
+    } else
+      t = p.create(o, 25n, 0n);
+    const m = e.encryptedOutputs?.map((r) => ({
+      value: r.value,
+      isPositive: JSON.parse(r.isPositive)
+    }));
+    return {
+      latestBlockNumber: e.latestBlockNumber ?? 0,
+      reserveBlockNumber: e.reserveBlockNumber ?? 0,
+      payload: {
+        merkleTree: t,
+        encryptedOutputs: m || []
+      }
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      merkleTree: this._merkleTree,
+      encryptedOutputs: this._encryptedOutputs
+    };
+  }
+  populateSnapshot({
+    payload: { merkleTree: e, encryptedOutputs: t }
+  }) {
+    this._merkleTree = e, this._encryptedOutputs = t;
+  }
+  mapEvent(e) {
+    const { commitment: t, index: m, encryptedOutput: r } = e;
+    return {
+      commitment: i(t),
+      index: i(m),
+      encryptedOutput: r
+    };
+  }
+  acceptEvent(e, t) {
+    if (!this.encryptedOutputs.map((m) => m.value).includes(e.encryptedOutput)) {
+      if (this.isServer && console.log(
+        `Adding commitment to file ${e.commitment} at index ${e.index} for encrypted output ${e.encryptedOutput}. Block Number: ${t}
+
+
+`
+      ), !this._merkleTree.insert(e.commitment, e.index >= 0 ? e.index : -1n * e.index))
+        return console.log(`Could not add  ${e.commitment} at index ${e.index}  `), !1;
+      const r = {
+        value: e.encryptedOutput,
+        isPositive: e.index >= 0n
+      };
+      return this._encryptedOutputs.push(r), !0;
+    }
+    return !1;
+  }
+}
+export {
+  D as AbstractCommitmentsSnapshotService
+};

package/common68.mjs

@@ -0,0 +1,59 @@
+import { AbstractSnapshotService as i } from "./common69.mjs";
+class s extends i {
+  constructor(e, r, l, t) {
+    super(
+      e,
+      {
+        name: "Nullified",
+        args: ["nullifier"]
+      },
+      r,
+      l,
+      t
+    );
+  }
+  _nullifiers;
+  get nullifiers() {
+    return this._nullifiers;
+  }
+  serializeSnapshot(e) {
+    return {
+      nullifiers: Array.from(e.payload.nullifiers).map((r) => r.toString()),
+      latestBlockNumber: e.latestBlockNumber,
+      reserveBlockNumber: e.reserveBlockNumber
+    };
+  }
+  deserializeSnapshot(e) {
+    return {
+      latestBlockNumber: e.latestBlockNumber ?? 0,
+      reserveBlockNumber: e.reserveBlockNumber ?? 0,
+      payload: {
+        nullifiers: new Set(e.nullifiers ?? [])
+      }
+    };
+  }
+  acceptEvent(e, r) {
+    try {
+      return this._nullifiers.add(e.nullifier), !0;
+    } catch (l) {
+      return console.error(l), !1;
+    }
+  }
+  mapEvent(e) {
+    const { nullifier: r } = e;
+    return {
+      nullifier: r.toHexString()
+    };
+  }
+  getSnapshotPayload() {
+    return {
+      nullifiers: this._nullifiers
+    };
+  }
+  populateSnapshot({ payload: { nullifiers: e } }) {
+    this._nullifiers = e;
+  }
+}
+export {
+  s as AbstractNullifierSnapshotService
+};

package/common69.mjs

@@ -0,0 +1,35 @@
+import { AbstractEventService as o } from "./common70.mjs";
+class h extends o {
+  reserveBlockNumber;
+  constructor(t, e, s, r, a) {
+    super(t, e, s, r, a), this.reserveBlockNumber = s;
+  }
+  async init() {
+    await this.loadSnapshot(), await super.init();
+  }
+  async retrieveEventsFromLatestBlock() {
+    await super.retrieveEvents(this._latestBlockNumber);
+  }
+  async restoreSnapshotState() {
+    await this.retrieveEvents(this.reserveBlockNumber, !0) && (this.reserveBlockNumber = this.latestBlockNumber, await this.afterEventsAccepted());
+  }
+  async loadSnapshot() {
+    const t = await this.fetchSnapshot(), e = this.deserializeSnapshot(t);
+    this.populateSnapshot(e), this._latestBlockNumber = e.latestBlockNumber, this.reserveBlockNumber = e.reserveBlockNumber;
+  }
+  saveSnapshot() {
+    return this.persistSnapshot(
+      this.serializeSnapshot({
+        latestBlockNumber: this._latestBlockNumber,
+        reserveBlockNumber: this.reserveBlockNumber,
+        payload: this.getSnapshotPayload()
+      })
+    );
+  }
+  afterEventsAccepted() {
+    return this.saveSnapshot();
+  }
+}
+export {
+  h as AbstractSnapshotService
+};

package/common7.mjs

@@ -0,0 +1,37 @@
+import p from "axios";
+import "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "ethers";
+import "circomlibjs";
+import "./common51.mjs";
+import { getServerURL as a } from "./common2.mjs";
+import "./common50.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common117.mjs";
+import "./common72.mjs";
+import "./common121.mjs";
+import "./common35.mjs";
+import { API_CONFIG as e } from "./common32.mjs";
+import "./common33.mjs";
+import "./common129.mjs";
+import "./common42.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "libsodium-wrappers";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+const _ = async (t, r, o, m, i) => (await p.get(
+  `${a(t)}${e.ROUTES.axelarGasEstimate(
+    r,
+    o,
+    m,
+    i
+  )}`
+)).data;
+export {
+  _ as getAxelarGasEstimate
+};

package/common70.mjs

@@ -0,0 +1,118 @@
+import { blockReorgDepth as v } from "./common42.mjs";
+import "ethers";
+import "axios";
+import "./common28.mjs";
+import "./common157.mjs";
+import "./common164.mjs";
+import "./common168.mjs";
+import "circomlibjs";
+import "./common51.mjs";
+import "./common139.mjs";
+import "./common191.mjs";
+import "./common50.mjs";
+import "./common117.mjs";
+import "./common35.mjs";
+import "./common33.mjs";
+import "libsodium-wrappers";
+import { getSequence as m, resolveSync as c } from "./common120.mjs";
+import "./common31.mjs";
+import "./common77.mjs";
+import "./common72.mjs";
+import "./common30.mjs";
+import "./common36.mjs";
+import "./common41.mjs";
+import "./common121.mjs";
+import "./common129.mjs";
+class M {
+  contract;
+  eventConfig;
+  _latestBlockNumber;
+  maxPageSize;
+  isReady = !1;
+  _onNewEvent;
+  isServer;
+  intervalId;
+  inProgress;
+  // to remove race conditions
+  constructor(t, r, e, s, n) {
+    this.contract = t, this.eventConfig = r, this._latestBlockNumber = e, this.maxPageSize = n, this.isServer = s, this.inProgress = !1;
+  }
+  get latestBlockNumber() {
+    return this._latestBlockNumber;
+  }
+  set onNewEvent(t) {
+    this._onNewEvent = t;
+  }
+  intervalClear() {
+    this.isReady = !1, this._onNewEvent = void 0, clearInterval(this.intervalId);
+  }
+  async init() {
+    if (this.isReady)
+      throw new Error("Already initialized");
+    this.isReady = !0, await this.retrieveEvents(this._latestBlockNumber + 1), this.intervalId = setInterval(async () => {
+      await this.retrieveEvents(this.latestBlockNumber);
+    }, 3500);
+  }
+  requireReady() {
+    if (!this.isReady)
+      throw new Error("Not ready");
+  }
+  emitNewEvent(t) {
+    this._onNewEvent?.(t);
+  }
+  getLastBlockNumberForEventRequest = async () => {
+    const t = await this.contract.provider.getBlockNumber();
+    if (!this.isServer)
+      return t;
+    const { chainId: r } = await this.contract.provider.getNetwork();
+    return Math.max(this.latestBlockNumber, t - v[r] + 1);
+  };
+  async retrieveEvents(t, r = !1) {
+    try {
+      if (this.requireReady(), this.inProgress && !r)
+        return !1;
+      this.inProgress = !0;
+      const e = await this.getLastBlockNumberForEventRequest();
+      if (e < t)
+        return this.inProgress = !1, !1;
+      const s = m(t, e, this.maxPageSize);
+      return await c(
+        s.map(({ from: n, to: i }) => async () => {
+          const o = await this.contract.queryFilter(
+            this.contract.filters[this.eventConfig.name](),
+            n,
+            i
+          );
+          let a = [];
+          o.length > 0 && (a = await this.processEventsPage(o)), this._latestBlockNumber = i, await this.afterEventsAccepted(), a.length > 0 && this.emitNewEvent();
+        })
+      ), this.inProgress = !1, !0;
+    } catch (e) {
+      return console.log("retrieveEvents error:", { err: e }), this.inProgress = !1, !1;
+    }
+  }
+  async processEventsPage(t) {
+    const r = [];
+    return await c(
+      t.map((e) => async () => {
+        const { args: s, blockNumber: n } = e;
+        if (!s)
+          throw new Error("Wrong event structure");
+        const i = this.mapEvent(s);
+        await this.acceptEvent(i, n) && r.push(i);
+      })
+    ), r;
+  }
+  handleEvent = async (...t) => {
+    const { args: r } = this.eventConfig, { blockNumber: e } = t[t.length - 1], s = t.slice(0, r.length), n = r.reduce((a, h, l) => (a[h] = s[l], a), {});
+    if (!e)
+      throw new Error("Wrong event structure");
+    const i = this.mapEvent(n);
+    if (!await this.acceptEvent(i, e))
+      throw new Error("Failed to retrieve events");
+    this._latestBlockNumber = e, await this.afterEventsAccepted(), this.emitNewEvent(i);
+  };
+}
+export {
+  M as AbstractEventService
+};