@hinkal/common 0.0.112 → 0.0.114

package/data-structures/crypto-keys/decodeUTXO.js

@@ -0,0 +1,40 @@
+import { ethers as m } from "ethers";
+import { Utxo as g } from "../utxo/Utxo.js";
+import { UserKeys as x } from "./keys.js";
+const c = (o) => {
+  const t = m.utils.defaultAbiCoder.decode(
+    ["uint256", "address", "tuple(uint256, uint256, uint256, uint256)", "uint256", "uint256"],
+    o
+  ), e = t[0].toBigInt(), r = t[1], s = t[2][0].toBigInt(), n = t[2][1].toHexString(), i = t[2][2].toBigInt(), d = t[2][3].toBigInt(), u = t[3].toString(), a = t[4].toNumber();
+  return {
+    amount: e,
+    erc20TokenAddress: r,
+    randomization: s,
+    stealthAddress: n,
+    H0: i,
+    H1: d,
+    timeStamp: u,
+    tokenId: a
+  };
+}, U = (o, t) => {
+  const { amount: e, erc20TokenAddress: r, timeStamp: s, tokenId: n, randomization: i } = c(o);
+  return {
+    amount: e,
+    erc20TokenAddress: r,
+    timeStamp: s,
+    tokenId: n,
+    randomization: i,
+    shieldedPrivateKey: t
+  };
+}, k = (o, t) => new g(U(o, t)), I = (o, t) => {
+  const { randomization: e, H0: r, H1: s } = c(o), n = x.checkSignature(e, r, s, t);
+  if (!n)
+    throw new Error("UTXO doesn't belong to user");
+  return n;
+};
+export {
+  c as abiDecodeUtxo,
+  I as checkUtxoSignature,
+  k as decodeUtxo,
+  U as decodeUtxoConstructorArgs
+};

package/data-structures/crypto-keys/encryptDecryptUtxo.js

@@ -0,0 +1,41 @@
+import { ethers as t } from "ethers";
+import a from "libsodium-wrappers";
+import { Utxo as d } from "../utxo/Utxo.js";
+import { UserKeys as l } from "./keys.js";
+(async () => await a.ready)();
+const B = (e, i) => {
+  const o = [
+    Buffer.from(t.utils.hexlify(i ? 0n : e.amount)),
+    Buffer.from(t.utils.hexlify(e.erc20TokenAddress)),
+    Buffer.from(t.utils.hexlify(e.randomization)),
+    Buffer.from(e.getStealthAddress()),
+    Buffer.from(t.utils.hexlify(BigInt(e.timeStamp)))
+  ];
+  e.tokenId > 0 && o.push(Buffer.from(t.utils.hexlify(e.tokenId)));
+  const n = Buffer.concat(o);
+  return a.crypto_box_seal(n, t.utils.arrayify(e.getEncryptionKey()));
+}, m = (e, i) => {
+  const { publicKey: o, privateKey: n } = l.getEncryptionKeyPair(i.getShieldedPrivateKey()), y = a.crypto_box_seal_open(
+    e,
+    t.utils.arrayify(o),
+    t.utils.arrayify(n)
+  ), r = Buffer.from(y).toString("utf-8").split("0x").filter((f) => f.length !== 0).map((f, c) => {
+    let s;
+    return [0, 2, 4, 5].includes(c) ? s = BigInt(`0x${f}`) : [1, 3].includes(c) && (s = `0x${f}`), s;
+  });
+  return {
+    amount: r[0],
+    erc20TokenAddress: r[1],
+    randomization: r[2],
+    stealthAddress: r[3],
+    shieldedPrivateKey: i.getShieldedPrivateKey(),
+    timeStamp: r[4].toString(),
+    tokenId: r[5] ? Number(r[5]) : 0
+    // tokenId
+  };
+}, x = (e, i) => new d(m(e, i));
+export {
+  x as decryptUtxo,
+  m as decryptUtxoConstructorArgs,
+  B as encryptUtxo
+};

package/data-structures/crypto-keys/keyUtils.js

@@ -0,0 +1,10 @@
+import { CIRCOM_P as o, CIRCOM_P_HALF as t } from "../../constants/protocol.constants.js";
+const e = (r) => {
+  if (r < 0n || r >= o)
+    throw new RangeError();
+  return r > t;
+}, n = (r) => e(r) ? 1n : 0n;
+export {
+  n as getCircomSign,
+  e as isCircomNegative
+};

package/data-structures/crypto-keys/keys.js

@@ -0,0 +1,90 @@
+import { utils as S, ethers as o } from "ethers";
+import d from "libsodium-wrappers";
+import { CIRCOM_P as h } from "../../constants/protocol.constants.js";
+import { babyJubInstance as m } from "../../crypto/babyJub.js";
+import { poseidonHash as u } from "../../crypto/poseidon.js";
+import { memoizeFunc as c } from "../../functions/utils/memoize.utils.js";
+import { getCircomSign as g } from "./keyUtils.js";
+(async () => await d.ready)();
+const q = {
+  privateKey: "",
+  publicKey: ""
+};
+class H {
+  signature;
+  constructor(t) {
+    this.signature = t;
+  }
+  getSignature() {
+    return this.requireSignature(), this.signature;
+  }
+  setSignature(t) {
+    this.signature = t;
+  }
+  requireSignature() {
+    if (!this.signature)
+      throw Error("No signature provided");
+  }
+  verifyMessage(t) {
+    return this.requireSignature(), S.verifyMessage(t, this.signature);
+  }
+  /**
+   * get shielded private key from message signature used to login to the application,
+   * this private key is used to generate encryption keypairs as well as public key
+   * @retuns 0x-prefixed shielded private key
+   */
+  getShieldedPrivateKey = () => (this.requireSignature(), o.utils.keccak256(this.signature));
+  /**
+   * generate shielded public key from private key
+   * @param privateKey the key used to generate the shielded public key, this should be the signature
+   * that the user provided
+   * @retuns shielded public key in hexstring with 0x prefixed
+   */
+  getShieldedPublicKey = () => (this.requireSignature(), u(this.getShieldedPrivateKey()));
+  /**
+   * generate access token, this accessKey is what should be sent to the server for signing
+   * @returns accessKey in hexstring with 0x prefixed
+   */
+  getAccessKey = () => (this.requireSignature(), u(this.getShieldedPrivateKey(), this.getShieldedPublicKey()));
+  getWalletSalt = (t) => (this.requireSignature(), u(this.getShieldedPublicKey(), this.getShieldedPrivateKey(), t));
+  /**
+   * generate backend token, which is used for access control on backend
+   * @returns accessKey in hexstring with 0x prefixed
+   */
+  getBackendToken = () => (this.requireSignature(), u(this.getAccessKey(), this.getShieldedPublicKey()));
+  static getRandomizedStealthPair = c(
+    (t, i) => {
+      const e = m(), r = BigInt(i) % h, n = t * r % h, s = e.mulPointEscalar(e.Base8, t), a = e.mulPointEscalar(e.Base8, n), l = [BigInt(e.F.toString(s[0])), BigInt(e.F.toString(s[1]))], y = [BigInt(e.F.toString(a[0])), BigInt(e.F.toString(a[1]))];
+      return { H0: l, H1: y };
+    }
+  );
+  static getStealthAddressCompressedPoints = (t, i) => {
+    const { H0: e, H1: r } = this.getRandomizedStealthPair(t, i), [n, s] = [e, r].map((a) => BigInt(a[1]) + 2n ** 255n * g(a[0]));
+    return { h0: n, h1: s };
+  };
+  static getStealthAddress = c((t, i) => {
+    const { H0: e, H1: r } = this.getRandomizedStealthPair(t, i), s = [2n * g(e[0]) + g(r[0]), e[1], r[1]];
+    return u(...s);
+  });
+  static getStealthAddressWithEKey = (t, i) => ({ stealthAddress: this.getStealthAddress(t, i), encryptionKey: this.getEncryptionKeyPair(i).publicKey });
+  static checkSignature = (t, i, e, r) => {
+    const { h0: n, h1: s } = this.getStealthAddressCompressedPoints(t, r);
+    return i === n && e === s;
+  };
+  /**
+   * generate private and public keypair
+   * @param seed seed to use to deterministically generate key, must be in DataHexString format
+   * and must correspond to 32 bytes
+   */
+  static getEncryptionKeyPair = (t) => {
+    const i = d.crypto_box_seed_keypair(o.utils.arrayify(t));
+    return {
+      privateKey: o.utils.hexlify(i.privateKey),
+      publicKey: o.utils.hexlify(i.publicKey)
+    };
+  };
+}
+export {
+  q as EncryptionKeyPairDefaultValue,
+  H as UserKeys
+};

package/data-structures/custom-token-registry/CustomTokenRegistry.js

@@ -0,0 +1,33 @@
+class o {
+  localStorageKey = "tokenRegistry";
+  tokenRegistry;
+  constructor() {
+    if (this.tokenRegistry = [], typeof localStorage < "u") {
+      const t = localStorage.getItem(this.localStorageKey);
+      t && (this.tokenRegistry = JSON.parse(t));
+    }
+  }
+  persistRegistry() {
+    typeof localStorage < "u" && localStorage.setItem(this.localStorageKey, JSON.stringify(this.tokenRegistry));
+  }
+  getCustomTokens(t) {
+    return this.tokenRegistry.filter((s) => s.chainId === t);
+  }
+  tokenExists(t, s) {
+    return t.find(
+      (e) => e.erc20TokenAddress === s.erc20TokenAddress || e.symbol === s.symbol || e.name === s.name
+    );
+  }
+  addCustomToken(t) {
+    const { chainId: s } = t, e = this.getCustomTokens(s);
+    this.tokenExists(e, t) || this.tokenRegistry.push(t), this.persistRegistry();
+  }
+  removeCustomToken(t) {
+    const { chainId: s } = t, r = this.getCustomTokens(s).filter((i) => i.erc20TokenAddress !== t.erc20TokenAddress);
+    this.tokenRegistry = r, this.persistRegistry();
+  }
+}
+const g = new o();
+export {
+  g as customTokenRegistry
+};

package/data-structures/event-service/AbstractAccessTokenSnapshotService.js

@@ -0,0 +1,131 @@
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "ethers";
+import { zeroAddress as i } from "../../constants/protocol.constants.js";
+import { poseidonFunction as m } from "../../crypto/poseidon.js";
+import "../crypto-keys/keys.js";
+import { toBigInt as t } from "../../functions/utils/amounts.utils.js";
+import "axios";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../../functions/utils/external-action.utils.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "../../functions/utils/userAgent.js";
+import "circomlibjs";
+import { MerkleTree as o } from "../merkle-tree/MerkleTree.js";
+import { AbstractSnapshotService as c } from "./AbstractSnapshotService.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import "../volatile-helper/VolatileHelper.js";
+import "libsodium-wrappers";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+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/data-structures/event-service/AbstractCommitmentsSnapshotService.js

@@ -0,0 +1,132 @@
+import { poseidonFunction as o } from "../../crypto/poseidon.js";
+import "circomlibjs";
+import { MerkleTree as p } from "../merkle-tree/MerkleTree.js";
+import { toBigInt as i } from "../../functions/utils/amounts.utils.js";
+import "ethers";
+import "axios";
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "../crypto-keys/keys.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/utils/external-action.utils.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "libsodium-wrappers";
+import { AbstractSnapshotService as c } from "./AbstractSnapshotService.js";
+import "../../constants/reorg-depths.constants.js";
+import "../../constants/kyc.constants.js";
+import "../volatile-helper/VolatileHelper.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../functions/utils/userAgent.js";
+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/data-structures/event-service/AbstractEventService.js

@@ -0,0 +1,118 @@
+import { blockReorgDepth as v } from "../../constants/reorg-depths.constants.js";
+import "ethers";
+import "axios";
+import "../../constants/chains.constants.js";
+import "../../types/circom-data.types.js";
+import "../../types/transactions.types.js";
+import "../../types/curve.types.js";
+import "circomlibjs";
+import "../crypto-keys/keys.js";
+import "../../functions/web3/events/getShieldedBalance.js";
+import "../../webworker/workerFactory.js";
+import "../crypto-keys/encryptDecryptUtxo.js";
+import "../../functions/utils/external-action.utils.js";
+import "../../constants/coingecko.constants.js";
+import "../../constants/vite.constants.js";
+import "libsodium-wrappers";
+import { getSequence as m, resolveSync as c } from "../../functions/utils/resolve-sync.utils.js";
+import "../../constants/kyc.constants.js";
+import "../volatile-helper/VolatileHelper.js";
+import "../custom-token-registry/CustomTokenRegistry.js";
+import "../../constants/contracts.constants.js";
+import "../../constants/axelar.constants.js";
+import "../../constants/rewards.constants.js";
+import "../../functions/utils/convertIntegrationProviderToExternalActionId.js";
+import "../../functions/utils/userAgent.js";
+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
+};

package/data-structures/event-service/AbstractNullifierSnapshotService.js

@@ -0,0 +1,59 @@
+import { AbstractSnapshotService as i } from "./AbstractSnapshotService.js";
+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/data-structures/event-service/AbstractSnapshotService.js

@@ -0,0 +1,35 @@
+import { AbstractEventService as o } from "./AbstractEventService.js";
+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
+};