@hinkal/common 0.2.15 → 0.2.16

package/data-structures/event-service/solana/SolanaBlockchainEventEmitter.mjs

@@ -0,0 +1,154 @@
+import { BorshCoder as v, EventParser as p } from "@coral-xyz/anchor";
+import { getSequence as f, resolveSync as S } from "../../../functions/utils/resolve-sync.utils.mjs";
+import { balanceFetchingMutex as P } from "../../../functions/utils/mutexes.utils.mjs";
+import { Logger as l } from "../../../error-handling/logger.mjs";
+import { networkRegistry as y, chainIds as u } from "../../../constants/chains.constants.mjs";
+import { caseInsensitiveEqual as E } from "../../../functions/utils/caseInsensitive.utils.mjs";
+const d = 1e3;
+class A {
+  connection;
+  programId;
+  _latestSlot;
+  _initialSlot;
+  onEventsProcessed;
+  eventProcessors = /* @__PURE__ */ new Set();
+  maxPageSize;
+  isReady = !1;
+  isServer;
+  intervalId;
+  inProgress;
+  // to remove race conditions
+  anchorParser;
+  eventsFetchingMutex;
+  constructor(t, r, a, s, n, o = P) {
+    this.connection = t, this.programId = r, this._initialSlot = a, this.maxPageSize = n, this.isServer = s, this.inProgress = !1, this.eventsFetchingMutex = o;
+  }
+  get latestBlockNumber() {
+    return this._latestSlot ?? this._initialSlot;
+  }
+  setIdl(t) {
+    try {
+      const r = new v(t);
+      this.anchorParser = new p(this.programId, r);
+    } catch (r) {
+      l.error("Failed to initialize Anchor EventParser:", r), this.anchorParser = void 0;
+    }
+  }
+  syncFromAtMost(t) {
+    (this._latestSlot === void 0 || t < this._latestSlot) && (this._latestSlot = t);
+  }
+  intervalClear() {
+    this.isReady = !1, this.eventProcessors = /* @__PURE__ */ new Set(), 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");
+  }
+  get chainId() {
+    const t = this.connection.rpcEndpoint;
+    return E(t, y[u.solanaMainnet].fetchRpcUrl) ? u.solanaMainnet : u.solanaLocalnet;
+  }
+  addEventProcessorFunction(t) {
+    if (this.isReady)
+      throw new Error("Can't add event processor after event emitter initialized");
+    this.eventProcessors.add(t);
+  }
+  async getLastSlotForEventRequest() {
+    const t = await this.connection.getSlot();
+    return this.isServer ? Math.max(this.latestBlockNumber, t - 32 + 1) : t;
+  }
+  // Implementation for IBlockchainEventEmitter interface (blockNumber terminology)
+  async retrieveEvents(t, r = !1) {
+    const a = t;
+    return this.requireReady(), await this.eventsFetchingMutex.runExclusive(async () => {
+      try {
+        if (this.inProgress && !r)
+          return !1;
+        this.inProgress = !0;
+        let n = 0;
+        const o = await this.getLastSlotForEventRequest();
+        if (o < a)
+          return this.inProgress = !1, !1;
+        const c = f(a, o, this.maxPageSize), h = [];
+        await S(
+          c.map(({ from: e, to: g }) => async () => {
+            const m = await this.getProgramEvents(e, g);
+            h.push(...m);
+          })
+        );
+        const i = await Promise.all(
+          [...this.eventProcessors].map((e) => e(h))
+        );
+        return this._latestSlot = o, n += i.reduce((e, g) => e + g, 0), this.onEventsProcessed?.(n), this.inProgress = !1, !0;
+      } catch (n) {
+        return l.error("retrieveEvents error:", n), this.inProgress = !1, !1;
+      }
+    });
+  }
+  async getProgramEvents(t, r) {
+    const a = [];
+    try {
+      const s = await this.connection.getSignaturesForAddress(this.programId, {
+        limit: d,
+        before: void 0
+        // Start from the latest
+      });
+      let n = s.length;
+      for (; n >= d; ) {
+        const i = s[s.length - 1], e = await this.connection.getSignaturesForAddress(this.programId, {
+          limit: d,
+          before: i.signature
+        });
+        if (e.length === 0)
+          break;
+        s.push(...e), n = e.length;
+      }
+      const c = s.filter((i) => i.slot >= t && i.slot <= r).map(async (i) => {
+        try {
+          const e = await this.connection.getTransaction(i.signature, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0
+          });
+          return e && e.meta && e.meta.logMessages ? this.parseLogsForEvents(
+            e.meta.logMessages,
+            i.signature,
+            i.slot,
+            e.blockTime || null
+          ) : [];
+        } catch (e) {
+          return l.error(`Failed to get transaction ${i.signature}:`, e), [];
+        }
+      }), h = await Promise.all(c);
+      a.push(...h.flat());
+    } catch (s) {
+      l.error("Error getting program events:", s);
+    }
+    return a;
+  }
+  parseLogsForEvents(t, r, a, s) {
+    if (!this.anchorParser)
+      return [];
+    try {
+      return Array.from(this.anchorParser.parseLogs(t)).map(({ name: o, data: c }) => ({
+        signature: r,
+        slot: a,
+        blockTime: s || 0,
+        programId: this.programId,
+        data: c,
+        eventName: o
+      }));
+    } catch (n) {
+      return l.error("Anchor EventParser failed; falling back to generic parsing:", n), [];
+    }
+  }
+}
+export {
+  A as SolanaBlockchainEventEmitter
+};

package/data-structures/http/BasicHttpClient.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("axios");class o{axiosInstance;constructor(){this.axiosInstance=n.create()}async get(s,t){return(await this.axiosInstance.get(s,t)).data}async post(s,t,e){return(await this.axiosInstance.post(s,t,e)).data}async put(s,t,e){return(await this.axiosInstance.put(s,t,e)).data}async patch(s,t,e){return(await this.axiosInstance.patch(s,t,e)).data}async delete(s,t){return(await this.axiosInstance.delete(s,t)).data}}exports.BasicHttpClient=o;

package/data-structures/http/BasicHttpClient.d.ts

@@ -0,0 +1,11 @@
+import { AxiosRequestConfig } from 'axios';
+import { HttpClient } from '../../types/http.types';
+export declare class BasicHttpClient implements HttpClient {
+    private axiosInstance;
+    constructor();
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+}

package/data-structures/http/BasicHttpClient.mjs

@@ -0,0 +1,25 @@
+import n from "axios";
+class c {
+  axiosInstance;
+  constructor() {
+    this.axiosInstance = n.create();
+  }
+  async get(s, t) {
+    return (await this.axiosInstance.get(s, t)).data;
+  }
+  async post(s, t, a) {
+    return (await this.axiosInstance.post(s, t, a)).data;
+  }
+  async put(s, t, a) {
+    return (await this.axiosInstance.put(s, t, a)).data;
+  }
+  async patch(s, t, a) {
+    return (await this.axiosInstance.patch(s, t, a)).data;
+  }
+  async delete(s, t) {
+    return (await this.axiosInstance.delete(s, t)).data;
+  }
+}
+export {
+  c as BasicHttpClient
+};

package/data-structures/http/HttpClient.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./BasicHttpClient.cjs");let n=new i.BasicHttpClient;const l={setHttpClient:t=>{n=t},get:(t,e)=>n.get(t,e),post:(t,e,p)=>n.post(t,e,p),put:(t,e,p)=>n.put(t,e,p),patch:(t,e,p)=>n.patch(t,e,p),delete:(t,e)=>n.delete(t,e)};exports.httpClient=l;

package/data-structures/http/HttpClient.d.ts

@@ -0,0 +1,10 @@
+import { HttpClient } from '../../types/http.types';
+declare const httpClient: {
+    setHttpClient: (client: HttpClient) => void;
+    get: <T = any>(url: string, config?: any) => Promise<T>;
+    post: <T_1 = any>(url: string, data?: any, config?: any) => Promise<T_1>;
+    put: <T_2 = any>(url: string, data?: any, config?: any) => Promise<T_2>;
+    patch: <T_3 = any>(url: string, data?: any, config?: any) => Promise<T_3>;
+    delete: <T_4 = any>(url: string, config?: any) => Promise<T_4>;
+};
+export { httpClient };

package/data-structures/http/HttpClient.mjs

@@ -0,0 +1,15 @@
+import { BasicHttpClient as l } from "./BasicHttpClient.mjs";
+let p = new l();
+const o = {
+  setHttpClient: (t) => {
+    p = t;
+  },
+  get: (t, e) => p.get(t, e),
+  post: (t, e, n) => p.post(t, e, n),
+  put: (t, e, n) => p.put(t, e, n),
+  patch: (t, e, n) => p.patch(t, e, n),
+  delete: (t, e) => p.delete(t, e)
+};
+export {
+  o as httpClient
+};

package/data-structures/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from './HttpClient';
+export * from './BasicHttpClient';

package/data-structures/index.d.ts

@@ -8,8 +8,11 @@ export * from './utxo/Utxo';
 export * from './custom-token-registry/CustomTokenRegistry';
 export * from './token-price-fetcher';
 export * from './transactions-manager';
-export * from './volatile-helper';
 export * from './MultiThreadedUtxoUtils/MultiThreadedUtxoUtils';
 export * from './cacheDevices';
 export * from './IndexedDB';
 export * from './TokenDBs';
+export * from './presale';
+export * from './snapshot';
+export * from './http';
+export * from './ApprovalDBs';

package/data-structures/presale/PresaleContractWrapper.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../../constants/presale.constants.cjs"),s=require("ethers");class o{contract;eventsFrom;constructor(t,e){const{address:r,eventsFrom:a}=n.presaleContractInfoByChain[e];this.contract=new s.ethers.Contract(r,n.presaleABI,t),this.eventsFrom=a}deposit(t,e,r){return this.contract.deposit(t.erc20TokenAddress,e,r)}withdraw(t,e){return this.contract.withdraw(t,e)}moveToNextStage(t){return this.contract.moveToNextStage(t||{})}async estimateMoveToNextStageGas(){return(await this.contract.estimateGas.moveToNextStage()).toBigInt()}async getTotalDeposit(){return(await this.contract.totalDeposit()).toBigInt()}async getDeposits(t,e){return(await this.contract.deposits(t,e.erc20TokenAddress)).toBigInt()}async getTotalHINK(t){return(await this.contract.totalHINK(t)).toBigInt()}async getCurrentPresaleStageIndex(){const t=await this.contract.currentPresaleStageIndex();return Number(t)}async getCurrentMaxDepositAmount(){return(await this.contract.currentMaxDepositAmount()).toBigInt()}async currentPresaleStage(){const[t,e]=await this.contract.currentPresaleStage(),[r,a]=[t,e].map(BigInt);return{amountToRaise:r,priceMultiplier:a}}async calculateHINK(t){return(await this.contract.calculateHINK(t)).toBigInt()}async queryDeposits(){return this.contract.queryFilter(this.contract.filters.Deposit(),this.eventsFrom)}onEvent(t,e){this.contract.on(t,e)}}exports.PresaleContractWrapper=o;

package/data-structures/presale/PresaleContractWrapper.d.ts

@@ -0,0 +1,23 @@
+import { ERC20Token } from '../../types/token.types';
+import { ethers } from 'ethers';
+export declare class PresaleContractWrapper {
+    contract: ethers.Contract;
+    eventsFrom: number;
+    constructor(signerOrProvider: ethers.Signer | ethers.providers.Provider, chainId: number);
+    deposit(token: ERC20Token, amount: bigint, minHINK: bigint): Promise<ethers.ContractTransaction>;
+    withdraw(token: string, amount: bigint): Promise<ethers.ContractTransaction>;
+    moveToNextStage(overrides?: ethers.Overrides): Promise<ethers.ContractTransaction>;
+    estimateMoveToNextStageGas(): Promise<bigint>;
+    getTotalDeposit(): Promise<bigint>;
+    getDeposits(depositor: string, token: ERC20Token): Promise<bigint>;
+    getTotalHINK(depositor: string): Promise<bigint>;
+    getCurrentPresaleStageIndex(): Promise<number>;
+    getCurrentMaxDepositAmount(): Promise<bigint>;
+    currentPresaleStage(): Promise<{
+        amountToRaise: bigint;
+        priceMultiplier: bigint;
+    }>;
+    calculateHINK(amount: bigint): Promise<bigint>;
+    queryDeposits(): Promise<ethers.Event[]>;
+    onEvent(eventName: string, handleEvent: ethers.providers.Listener): void;
+}

package/data-structures/presale/PresaleContractWrapper.mjs

@@ -0,0 +1,54 @@
+import { presaleContractInfoByChain as n, presaleABI as o } from "../../constants/presale.constants.mjs";
+import { ethers as s } from "ethers";
+class l {
+  contract;
+  eventsFrom;
+  constructor(t, e) {
+    const { address: r, eventsFrom: a } = n[e];
+    this.contract = new s.Contract(r, o, t), this.eventsFrom = a;
+  }
+  deposit(t, e, r) {
+    return this.contract.deposit(t.erc20TokenAddress, e, r);
+  }
+  withdraw(t, e) {
+    return this.contract.withdraw(t, e);
+  }
+  moveToNextStage(t) {
+    return this.contract.moveToNextStage(t || {});
+  }
+  async estimateMoveToNextStageGas() {
+    return (await this.contract.estimateGas.moveToNextStage()).toBigInt();
+  }
+  async getTotalDeposit() {
+    return (await this.contract.totalDeposit()).toBigInt();
+  }
+  async getDeposits(t, e) {
+    return (await this.contract.deposits(t, e.erc20TokenAddress)).toBigInt();
+  }
+  async getTotalHINK(t) {
+    return (await this.contract.totalHINK(t)).toBigInt();
+  }
+  async getCurrentPresaleStageIndex() {
+    const t = await this.contract.currentPresaleStageIndex();
+    return Number(t);
+  }
+  async getCurrentMaxDepositAmount() {
+    return (await this.contract.currentMaxDepositAmount()).toBigInt();
+  }
+  async currentPresaleStage() {
+    const [t, e] = await this.contract.currentPresaleStage(), [r, a] = [t, e].map(BigInt);
+    return { amountToRaise: r, priceMultiplier: a };
+  }
+  async calculateHINK(t) {
+    return (await this.contract.calculateHINK(t)).toBigInt();
+  }
+  async queryDeposits() {
+    return this.contract.queryFilter(this.contract.filters.Deposit(), this.eventsFrom);
+  }
+  onEvent(t, e) {
+    this.contract.on(t, e);
+  }
+}
+export {
+  l as PresaleContractWrapper
+};

package/data-structures/presale/index.d.ts

@@ -0,0 +1 @@
+export * from './PresaleContractWrapper';

package/data-structures/provider-adapter/IProviderAdapter.d.ts

@@ -1,6 +1,6 @@
-import { TransactionRequest, TransactionResponse } from '@ethersproject/providers';
 import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
 import { Contract, ethers, Signer } from 'ethers';
+import { Call } from '../../types/eip5792.types';
 export interface ChainEventListener {
     onAccountChanged(): void;
     onChainChanged(chainId?: number): void;
@@ -8,7 +8,6 @@ export interface ChainEventListener {
 export interface IProviderAdapter<ConnectorType = unknown> {
     chainId: number | undefined;
     initConnector(connector: ConnectorType): void;
-    getSigner(): Signer;
     initSigner?(signer: Signer): void;
     init(chainId?: number): Promise<void>;
     initConfig?(config?: any): Promise<void> | void;
@@ -26,7 +25,7 @@ export interface IProviderAdapter<ConnectorType = unknown> {
     getContractWithSigner(contract: ContractType, contractAddress?: string): Contract;
     getContractWithFetcher(contract: ContractType, contractAddress?: string): Contract;
     getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): Contract;
-    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
+    sendTransaction(tx: ethers.providers.TransactionRequest): Promise<ethers.providers.TransactionResponse>;
     switchNetwork(network: EthereumNetwork): Promise<unknown>;
     switchAccount(signer: ethers.Signer): Promise<void>;
     onAccountChanged(): Promise<unknown>;
@@ -34,4 +33,6 @@ export interface IProviderAdapter<ConnectorType = unknown> {
     isPermitterAvailable(): boolean;
     getGasPrice(): Promise<bigint>;
     signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    sendBatchCallsTransaction?(calls: Call[]): Promise<ethers.providers.TransactionResponse>;
+    supportsBatchCall?(): Promise<boolean>;
 }

package/data-structures/snapshot/SnapshotFetcherService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../../functions/utils/caseInsensitive.utils.cjs"),i=require("../../API/fetchCommitmentsCache.cjs"),c=5*60*1e3;class r{chainId;contractAddress;snapshotsPromise;lastFetchedAt;cacheDurationMs;constructor(s,t,e=c){this.chainId=s,this.contractAddress=t,this.cacheDurationMs=e}async fetchSnapshots(){return this.lastFetchedAt=Date.now(),i.fetchSnapshots(this.chainId)}async ensureSnapshots(s=!1){const t=Date.now(),e=!this.lastFetchedAt||t-this.lastFetchedAt>this.cacheDurationMs;(s||!this.snapshotsPromise||e)&&(this.snapshotsPromise=this.fetchSnapshots());const n=await this.snapshotsPromise;if(!a.caseInsensitiveEqual(n.commitments.hinkalAddress,this.contractAddress)||n.commitments.chainId!==this.chainId)throw Error("Snapshots: incorrect contract or chain id");return n}async getAll(s=!1){return this.ensureSnapshots(s)}async getCommitments(s=!1){return(await this.ensureSnapshots(s)).commitments}async getAccessTokens(s=!1){return(await this.ensureSnapshots(s)).accessTokens}async getNullifiers(s=!1){return(await this.ensureSnapshots(s)).nullifiers}async getApprovals(s=!1){return(await this.ensureSnapshots(s)).approvals}}exports.SnapshotFetcherService=r;

package/data-structures/snapshot/SnapshotFetcherService.d.ts

@@ -0,0 +1,16 @@
+import { ISnapshotsResponse } from '../../API/fetchCommitmentsCache';
+export declare class SnapshotFetcherService {
+    private chainId;
+    private contractAddress;
+    private snapshotsPromise;
+    private lastFetchedAt;
+    private readonly cacheDurationMs;
+    constructor(chainId: number, contractAddress: string, cacheDurationMs?: number);
+    private fetchSnapshots;
+    private ensureSnapshots;
+    getAll(forceRefresh?: boolean): Promise<ISnapshotsResponse>;
+    getCommitments(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").ICommitmentsTreeSnapshot>;
+    getAccessTokens(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").IAccessTokenTreeSnapshot>;
+    getNullifiers(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").INullifiersSnapshot>;
+    getApprovals(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").IApprovalsSnapshot | undefined>;
+}

package/data-structures/snapshot/SnapshotFetcherService.mjs

@@ -0,0 +1,42 @@
+import { caseInsensitiveEqual as n } from "../../functions/utils/caseInsensitive.utils.mjs";
+import { fetchSnapshots as i } from "../../API/fetchCommitmentsCache.mjs";
+const r = 5 * 60 * 1e3;
+class p {
+  chainId;
+  contractAddress;
+  snapshotsPromise;
+  lastFetchedAt;
+  cacheDurationMs;
+  constructor(s, t, e = r) {
+    this.chainId = s, this.contractAddress = t, this.cacheDurationMs = e;
+  }
+  async fetchSnapshots() {
+    return this.lastFetchedAt = Date.now(), i(this.chainId);
+  }
+  async ensureSnapshots(s = !1) {
+    const t = Date.now(), e = !this.lastFetchedAt || t - this.lastFetchedAt > this.cacheDurationMs;
+    (s || !this.snapshotsPromise || e) && (this.snapshotsPromise = this.fetchSnapshots());
+    const a = await this.snapshotsPromise;
+    if (!n(a.commitments.hinkalAddress, this.contractAddress) || a.commitments.chainId !== this.chainId)
+      throw Error("Snapshots: incorrect contract or chain id");
+    return a;
+  }
+  async getAll(s = !1) {
+    return this.ensureSnapshots(s);
+  }
+  async getCommitments(s = !1) {
+    return (await this.ensureSnapshots(s)).commitments;
+  }
+  async getAccessTokens(s = !1) {
+    return (await this.ensureSnapshots(s)).accessTokens;
+  }
+  async getNullifiers(s = !1) {
+    return (await this.ensureSnapshots(s)).nullifiers;
+  }
+  async getApprovals(s = !1) {
+    return (await this.ensureSnapshots(s)).approvals;
+  }
+}
+export {
+  p as SnapshotFetcherService
+};

package/data-structures/snapshot/evm-snapshots/ClientAccessTokenSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("../../event-service/evm/AbstractAccessTokenSnapshotService.cjs");require("ethers");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");require("../../../constants/vite.constants.cjs");require("../../../error-handling/error-codes.constants.cjs");require("../../../constants/save-depths.cjs");require("../../../constants/reorg-depths.constants.cjs");require("../../../functions/utils/mutexes.utils.cjs");require("@coral-xyz/anchor");require("../../../constants/chains.constants.cjs");require("@solana/web3.js");require("../../crypto-keys/keys.cjs");const c=require("../SnapshotFetcherService.cjs");class i extends t.AbstractAccessTokenSnapshotService{snapshotsService;constructor(e,s){super(e),this.snapshotsService=s}async fetchSnapshot(){const{contract:e}=this.blockchainEventEmitter,{chainId:s}=await e.provider.getNetwork();this.snapshotsService||(this.snapshotsService=new c.SnapshotFetcherService(s,e.address));const r=await this.snapshotsService.getAccessTokens();if(r.accessTokenContractAddress!==e.address||r.chainId!==s)throw Error("Commitment Snapshot: incorrect contract or chain id");return{latestBlockNumber:r.latestBlockNumber,merkleTree:r.merkleTree,senderAddresses:r.senderAddresses,senderAddressIndexMap:r.senderAddressIndexMap}}persistSnapshot(e){return Promise.resolve()}}exports.ClientAccessTokenSnapshotService=i;

package/data-structures/snapshot/{ClientAccessTokenSnapshotService.d.ts → evm-snapshots/ClientAccessTokenSnapshotService.d.ts}

@@ -1,7 +1,8 @@
-import { AbstractAccessTokenSnapshotService, AccessTokenSerializedSnapshot } from '../event-service';
-import { Contract } from 'ethers';
+import { AbstractAccessTokenSnapshotService, AccessTokenSerializedSnapshot, BlockchainEventEmitter } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
 export declare class ClientAccessTokenSnapshotService extends AbstractAccessTokenSnapshotService {
-    constructor(contract: Contract, maxPageSize?: number);
+    private snapshotsService;
+    constructor(accessTokenEventFetcher: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
     protected fetchSnapshot(): Promise<AccessTokenSerializedSnapshot>;
     protected persistSnapshot(_serializedSnapshot: AccessTokenSerializedSnapshot): Promise<unknown>;
 }

package/data-structures/snapshot/evm-snapshots/ClientAccessTokenSnapshotService.mjs

@@ -0,0 +1,41 @@
+import { AbstractAccessTokenSnapshotService as r } from "../../event-service/evm/AbstractAccessTokenSnapshotService.mjs";
+import "ethers";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import "../../../constants/vite.constants.mjs";
+import "../../../error-handling/error-codes.constants.mjs";
+import "../../../constants/save-depths.mjs";
+import "../../../constants/reorg-depths.constants.mjs";
+import "../../../functions/utils/mutexes.utils.mjs";
+import "@coral-xyz/anchor";
+import "../../../constants/chains.constants.mjs";
+import "@solana/web3.js";
+import "../../crypto-keys/keys.mjs";
+import { SnapshotFetcherService as o } from "../SnapshotFetcherService.mjs";
+class b extends r {
+  snapshotsService;
+  constructor(e, t) {
+    super(e), this.snapshotsService = t;
+  }
+  async fetchSnapshot() {
+    const { contract: e } = this.blockchainEventEmitter, { chainId: t } = await e.provider.getNetwork();
+    this.snapshotsService || (this.snapshotsService = new o(t, e.address));
+    const s = await this.snapshotsService.getAccessTokens();
+    if (s.accessTokenContractAddress !== e.address || s.chainId !== t)
+      throw Error("Commitment Snapshot: incorrect contract or chain id");
+    return {
+      latestBlockNumber: s.latestBlockNumber,
+      merkleTree: s.merkleTree,
+      senderAddresses: s.senderAddresses,
+      senderAddressIndexMap: s.senderAddressIndexMap
+    };
+  }
+  persistSnapshot(e) {
+    return Promise.resolve();
+  }
+}
+export {
+  b as ClientAccessTokenSnapshotService
+};

package/data-structures/snapshot/evm-snapshots/ClientApprovalsSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("ethers");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");require("../../../constants/vite.constants.cjs");require("../../../error-handling/error-codes.constants.cjs");require("../../../constants/save-depths.cjs");const s=require("../../event-service/evm/AbstractApprovalsSnapshotService.cjs");require("../../../constants/reorg-depths.constants.cjs");require("../../../functions/utils/mutexes.utils.cjs");require("@coral-xyz/anchor");require("../../../constants/chains.constants.cjs");require("@solana/web3.js");require("../../crypto-keys/keys.cjs");class a extends s.AbstractApprovalsSnapshotService{snapshotsService;constructor(r,t){super(r),this.snapshotsService=t}async fetchSnapshot(){const{contract:r}=this.blockchainEventEmitter,{chainId:t}=await r.provider.getNetwork(),e=await this.snapshotsService.getApprovals();if(!e)return{latestBlockNumber:0,approvals:{},events:[]};if(e.hinkalAddress!==r.address||e.chainId!==t)throw Error("approvalsSnapshotData Snapshot: incorrect contract or chain id");return{latestBlockNumber:e.latestBlockNumber,approvals:e.approvals,events:e.events}}persistSnapshot(r){return Promise.resolve()}}exports.ClientApprovalsSnapshotService=a;

package/data-structures/snapshot/{ClientApprovalsSnapshotService.d.ts → evm-snapshots/ClientApprovalsSnapshotService.d.ts}

@@ -1,8 +1,8 @@
-import { Contract } from 'ethers';
-import { AbstractApprovalsSnapshotService, ApprovalsSerializedSnapshot } from '../event-service/AbstractApprovalsSnapshotService';
-import { CommitmentsSerializedSnapshot } from '../event-service';
+import { AbstractApprovalsSnapshotService, ApprovalsSerializedSnapshot, BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
 export declare class ClientApprovalsSnapshotService extends AbstractApprovalsSnapshotService {
-    constructor(contract: Contract, maxPageSize?: number);
+    private snapshotsService;
+    constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
     protected fetchSnapshot(): Promise<ApprovalsSerializedSnapshot>;
     protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown>;
 }

package/data-structures/snapshot/evm-snapshots/ClientApprovalsSnapshotService.mjs

@@ -0,0 +1,43 @@
+import "ethers";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import "../../../constants/vite.constants.mjs";
+import "../../../error-handling/error-codes.constants.mjs";
+import "../../../constants/save-depths.mjs";
+import { AbstractApprovalsSnapshotService as s } from "../../event-service/evm/AbstractApprovalsSnapshotService.mjs";
+import "../../../constants/reorg-depths.constants.mjs";
+import "../../../functions/utils/mutexes.utils.mjs";
+import "@coral-xyz/anchor";
+import "../../../constants/chains.constants.mjs";
+import "@solana/web3.js";
+import "../../crypto-keys/keys.mjs";
+class f extends s {
+  snapshotsService;
+  constructor(r, o) {
+    super(r), this.snapshotsService = o;
+  }
+  async fetchSnapshot() {
+    const { contract: r } = this.blockchainEventEmitter, { chainId: o } = await r.provider.getNetwork(), t = await this.snapshotsService.getApprovals();
+    if (!t)
+      return {
+        latestBlockNumber: 0,
+        approvals: {},
+        events: []
+      };
+    if (t.hinkalAddress !== r.address || t.chainId !== o)
+      throw Error("approvalsSnapshotData Snapshot: incorrect contract or chain id");
+    return {
+      latestBlockNumber: t.latestBlockNumber,
+      approvals: t.approvals,
+      events: t.events
+    };
+  }
+  persistSnapshot(r) {
+    return Promise.resolve();
+  }
+}
+export {
+  f as ClientApprovalsSnapshotService
+};

package/data-structures/snapshot/evm-snapshots/ClientCommitmentsSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("ethers");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");require("../../../constants/vite.constants.cjs");require("../../../error-handling/error-codes.constants.cjs");require("../../../constants/save-depths.cjs");const t=require("../../event-service/evm/AbstractCommitmentsSnapshotService.cjs");require("../../../constants/reorg-depths.constants.cjs");require("../../../functions/utils/mutexes.utils.cjs");require("@coral-xyz/anchor");require("../../../constants/chains.constants.cjs");require("@solana/web3.js");require("../../crypto-keys/keys.cjs");class s extends t.AbstractCommitmentsSnapshotService{snapshotsService;constructor(e,r){super(e),this.snapshotsService=r}async fetchSnapshot(){const e=await this.snapshotsService.getCommitments();return{latestBlockNumber:e.latestBlockNumber,merkleTree:e.merkleTree,encryptedOutputs:e.encryptedOutputs}}persistSnapshot(e){return Promise.resolve()}}exports.ClientCommitmentsSnapshotService=s;

package/data-structures/snapshot/evm-snapshots/ClientCommitmentsSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractCommitmentsSnapshotService, BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientCommitmentsSnapshotService extends AbstractCommitmentsSnapshotService {
+    private snapshotsService;
+    constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<CommitmentsSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown>;
+}

package/data-structures/snapshot/evm-snapshots/ClientCommitmentsSnapshotService.mjs

@@ -0,0 +1,35 @@
+import "ethers";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import "../../../constants/vite.constants.mjs";
+import "../../../error-handling/error-codes.constants.mjs";
+import "../../../constants/save-depths.mjs";
+import { AbstractCommitmentsSnapshotService as r } from "../../event-service/evm/AbstractCommitmentsSnapshotService.mjs";
+import "../../../constants/reorg-depths.constants.mjs";
+import "../../../functions/utils/mutexes.utils.mjs";
+import "@coral-xyz/anchor";
+import "../../../constants/chains.constants.mjs";
+import "@solana/web3.js";
+import "../../crypto-keys/keys.mjs";
+class b extends r {
+  snapshotsService;
+  constructor(t, e) {
+    super(t), this.snapshotsService = e;
+  }
+  async fetchSnapshot() {
+    const t = await this.snapshotsService.getCommitments();
+    return {
+      latestBlockNumber: t.latestBlockNumber,
+      merkleTree: t.merkleTree,
+      encryptedOutputs: t.encryptedOutputs
+    };
+  }
+  persistSnapshot(t) {
+    return Promise.resolve();
+  }
+}
+export {
+  b as ClientCommitmentsSnapshotService
+};

package/data-structures/snapshot/evm-snapshots/ClientNullifierSnapshotService.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("ethers");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");require("../../../constants/vite.constants.cjs");require("../../../error-handling/error-codes.constants.cjs");require("../../../constants/save-depths.cjs");const i=require("../../event-service/evm/AbstractNullifierSnapshotService.cjs");require("../../../constants/reorg-depths.constants.cjs");require("../../../functions/utils/mutexes.utils.cjs");require("@coral-xyz/anchor");require("../../../constants/chains.constants.cjs");require("@solana/web3.js");require("../../crypto-keys/keys.cjs");class s extends i.AbstractNullifierSnapshotService{snapshotsService;constructor(e,r){super(e),this.snapshotsService=r}async fetchSnapshot(){const e=await this.snapshotsService.getNullifiers();return{latestBlockNumber:e.latestBlockNumber,nullifiers:e.nullifiers}}persistSnapshot(e){return Promise.resolve()}}exports.ClientNullifierSnapshotService=s;

package/data-structures/snapshot/evm-snapshots/ClientNullifierSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractNullifierSnapshotService, BlockchainEventEmitter, NullifierSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientNullifierSnapshotService extends AbstractNullifierSnapshotService {
+    private snapshotsService;
+    constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<NullifierSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: NullifierSerializedSnapshot): Promise<unknown>;
+}