@sabaaa1/common 0.1.6 → 0.1.14

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

@@ -0,0 +1,153 @@
+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 _ {
+  connection;
+  programId;
+  _latestSlot;
+  _initialSlot;
+  onEventsProcessed;
+  eventProcessors = /* @__PURE__ */ new Set();
+  maxPageSize;
+  isReady = !1;
+  isServer;
+  intervalId;
+  inProgress;
+  // to remove race conditions
+  anchorParser;
+  constructor(t, r, i, s, n) {
+    this.connection = t, this.programId = r, this._initialSlot = i, this.maxPageSize = n, this.isServer = s, this.inProgress = !1;
+  }
+  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 i = t;
+    return this.requireReady(), await P.runExclusive(async () => {
+      try {
+        if (this.inProgress && !r)
+          return !1;
+        this.inProgress = !0;
+        let n = 0;
+        const o = await this.getLastSlotForEventRequest();
+        if (o < i)
+          return this.inProgress = !1, !1;
+        const c = f(i, o, this.maxPageSize), h = [];
+        await S(
+          c.map(({ from: e, to: g }) => async () => {
+            const m = await this.getProgramEvents(e, g);
+            h.push(...m);
+          })
+        );
+        const a = await Promise.all(
+          [...this.eventProcessors].map((e) => e(h))
+        );
+        return this._latestSlot = o, n += a.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 i = [];
+    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 a = s[s.length - 1], e = await this.connection.getSignaturesForAddress(this.programId, {
+          limit: d,
+          before: a.signature
+        });
+        if (e.length === 0)
+          break;
+        s.push(...e), n = e.length;
+      }
+      const c = s.filter((a) => a.slot >= t && a.slot <= r).map(async (a) => {
+        try {
+          const e = await this.connection.getTransaction(a.signature, {
+            commitment: "confirmed",
+            maxSupportedTransactionVersion: 0
+          });
+          return e && e.meta && e.meta.logMessages ? this.parseLogsForEvents(
+            e.meta.logMessages,
+            a.signature,
+            a.slot,
+            e.blockTime || null
+          ) : [];
+        } catch (e) {
+          return l.error(`Failed to get transaction ${a.signature}:`, e), [];
+        }
+      }), h = await Promise.all(c);
+      i.push(...h.flat());
+    } catch (s) {
+      l.error("Error getting program events:", s);
+    }
+    return i;
+  }
+  parseLogsForEvents(t, r, i, s) {
+    if (!this.anchorParser)
+      return [];
+    try {
+      return Array.from(this.anchorParser.parseLogs(t)).map(({ name: o, data: c }) => ({
+        signature: r,
+        slot: i,
+        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 {
+  _ 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

@@ -14,4 +14,5 @@ export * from './IndexedDB';
 export * from './TokenDBs';
 export * from './presale';
 export * from './snapshot';
+export * from './http';
 export * from './ApprovalDBs';

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

@@ -1,4 +1,3 @@
-import { TransactionRequest, TransactionResponse } from '@ethersproject/providers';
 import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
 import { Contract, ethers, Signer } from 'ethers';
 export interface ChainEventListener {
@@ -8,7 +7,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 +24,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>;

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

@@ -12,5 +12,5 @@ export declare class SnapshotFetcherService {
     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>;
+    getApprovals(forceRefresh?: boolean): Promise<import("../../API/fetchCommitmentsCache").IApprovalsSnapshot | undefined>;
 }

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,5 +1,5 @@
-import { AbstractAccessTokenSnapshotService, AccessTokenSerializedSnapshot, BlockchainEventEmitter } from '../event-service';
-import { SnapshotFetcherService } from './SnapshotFetcherService';
+import { AbstractAccessTokenSnapshotService, AccessTokenSerializedSnapshot, BlockchainEventEmitter } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
 export declare class ClientAccessTokenSnapshotService extends AbstractAccessTokenSnapshotService {
     private snapshotsService;
     constructor(accessTokenEventFetcher: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);

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

@@ -1,16 +1,20 @@
-import { AbstractAccessTokenSnapshotService as r } from "../event-service/AbstractAccessTokenSnapshotService.mjs";
+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 { SnapshotFetcherService as o } from "./SnapshotFetcherService.mjs";
-class T extends r {
+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;
@@ -33,5 +37,5 @@ class T extends r {
   }
 }
 export {
-  T as ClientAccessTokenSnapshotService
+  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,6 +1,5 @@
-import { AbstractApprovalsSnapshotService, ApprovalsSerializedSnapshot } from '../event-service/AbstractApprovalsSnapshotService';
-import { BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../event-service';
-import { SnapshotFetcherService } from './SnapshotFetcherService';
+import { AbstractApprovalsSnapshotService, ApprovalsSerializedSnapshot, BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
 export declare class ClientApprovalsSnapshotService extends AbstractApprovalsSnapshotService {
     private snapshotsService;
     constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);

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/{ClientCommitmentsSnapshotService.d.ts → evm-snapshots/ClientCommitmentsSnapshotService.d.ts}

@@ -1,5 +1,5 @@
-import { AbstractCommitmentsSnapshotService, BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../event-service';
-import { SnapshotFetcherService } from './SnapshotFetcherService';
+import { AbstractCommitmentsSnapshotService, BlockchainEventEmitter, CommitmentsSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
 export declare class ClientCommitmentsSnapshotService extends AbstractCommitmentsSnapshotService {
     private snapshotsService;
     constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService);

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/{ClientNullifierSnapshotService.d.ts → evm-snapshots/ClientNullifierSnapshotService.d.ts}

@@ -1,5 +1,5 @@
-import { AbstractNullifierSnapshotService, BlockchainEventEmitter, NullifierSerializedSnapshot } from '../event-service';
-import { SnapshotFetcherService } from './SnapshotFetcherService';
+import { AbstractNullifierSnapshotService, BlockchainEventEmitter, NullifierSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
 export declare class ClientNullifierSnapshotService extends AbstractNullifierSnapshotService {
     private snapshotsService;
     constructor(hinkalEventEmitter: BlockchainEventEmitter, snapshotsFetcher: SnapshotFetcherService);

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

@@ -0,0 +1,34 @@
+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 { AbstractNullifierSnapshotService as i } from "../../event-service/evm/AbstractNullifierSnapshotService.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 d extends i {
+  snapshotsService;
+  constructor(t, r) {
+    super(t), this.snapshotsService = r;
+  }
+  async fetchSnapshot() {
+    const t = await this.snapshotsService.getNullifiers();
+    return {
+      latestBlockNumber: t.latestBlockNumber,
+      nullifiers: t.nullifiers
+    };
+  }
+  persistSnapshot(t) {
+    return Promise.resolve();
+  }
+}
+export {
+  d as ClientNullifierSnapshotService
+};

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

@@ -1 +1,8 @@
 export * from './SnapshotFetcherService';
+export * from './solana-snapshots/ClientSolanaCommitmentsSnapshotService';
+export * from './solana-snapshots/ClientSolanaNullifierSnapshotService';
+export * from './solana-snapshots/ClientSolanaAccessTokenSnapshotService';
+export * from './evm-snapshots/ClientAccessTokenSnapshotService';
+export * from './evm-snapshots/ClientCommitmentsSnapshotService';
+export * from './evm-snapshots/ClientNullifierSnapshotService';
+export * from './evm-snapshots/ClientApprovalsSnapshotService';

package/data-structures/snapshot/solana-snapshots/ClientSolanaAccessTokenSnapshotService.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");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 s=require("../../event-service/solana/AbstractSolanaAccessTokenSnapshotService.cjs"),t=require("../SnapshotFetcherService.cjs");class n extends s.AbstractSolanaAccessTokenSnapshotService{snapshotsService;constructor(r,e){super(r),this.snapshotsService=e}async fetchSnapshot(){const{chainId:r}=this.solanaBlockchainEventEmitter;this.snapshotsService||(this.snapshotsService=new t.SnapshotFetcherService(r,this.solanaBlockchainEventEmitter.programId.toString()));const e=await this.snapshotsService.getAccessTokens();return{latestBlockNumber:e.latestBlockNumber,merkleTree:e.merkleTree,senderAddresses:e.senderAddresses,senderAddressIndexMap:e.senderAddressIndexMap}}persistSnapshot(r){return Promise.resolve()}}exports.ClientSolanaAccessTokenSnapshotService=n;

package/data-structures/snapshot/solana-snapshots/ClientSolanaAccessTokenSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractSolanaAccessTokenSnapshotService, SolanaAccessTokenSerializedSnapshot, SolanaBlockchainEventEmitter } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientSolanaAccessTokenSnapshotService extends AbstractSolanaAccessTokenSnapshotService {
+    private snapshotsService;
+    constructor(accessTokenEventEmitter: SolanaBlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<SolanaAccessTokenSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: SolanaAccessTokenSerializedSnapshot): Promise<unknown>;
+}

package/data-structures/snapshot/solana-snapshots/ClientSolanaAccessTokenSnapshotService.mjs

@@ -0,0 +1,42 @@
+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 { AbstractSolanaAccessTokenSnapshotService as t } from "../../event-service/solana/AbstractSolanaAccessTokenSnapshotService.mjs";
+import { SnapshotFetcherService as r } from "../SnapshotFetcherService.mjs";
+class x extends t {
+  snapshotsService;
+  constructor(s, e) {
+    super(s), this.snapshotsService = e;
+  }
+  async fetchSnapshot() {
+    const { chainId: s } = this.solanaBlockchainEventEmitter;
+    this.snapshotsService || (this.snapshotsService = new r(
+      s,
+      this.solanaBlockchainEventEmitter.programId.toString()
+    ));
+    const e = await this.snapshotsService.getAccessTokens();
+    return {
+      latestBlockNumber: e.latestBlockNumber,
+      merkleTree: e.merkleTree,
+      senderAddresses: e.senderAddresses,
+      senderAddressIndexMap: e.senderAddressIndexMap
+    };
+  }
+  persistSnapshot(s) {
+    return Promise.resolve();
+  }
+}
+export {
+  x as ClientSolanaAccessTokenSnapshotService
+};

package/data-structures/snapshot/solana-snapshots/ClientSolanaCommitmentsSnapshotService.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");require("../../../constants/reorg-depths.constants.cjs");require("../../../functions/utils/mutexes.utils.cjs");require("@coral-xyz/anchor");require("../../../constants/chains.constants.cjs");const t=require("../../event-service/solana/AbstractSolanaCommitmentsSnapshotService.cjs");require("@solana/web3.js");class s extends t.AbstractSolanaCommitmentsSnapshotService{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.ClientSolanaCommitmentsSnapshotService=s;

package/data-structures/snapshot/solana-snapshots/ClientSolanaCommitmentsSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractSolanaCommitmentsSnapshotService, SolanaBlockchainEventEmitter, SolanaCommitmentsSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientSolanaCommitmentsSnapshotService extends AbstractSolanaCommitmentsSnapshotService {
+    private snapshotsService;
+    constructor(commitmentsEventEmitter: SolanaBlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<SolanaCommitmentsSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: SolanaCommitmentsSerializedSnapshot): Promise<unknown>;
+}

package/data-structures/snapshot/solana-snapshots/ClientSolanaCommitmentsSnapshotService.mjs

@@ -0,0 +1,34 @@
+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 { AbstractSolanaCommitmentsSnapshotService as r } from "../../event-service/solana/AbstractSolanaCommitmentsSnapshotService.mjs";
+import "@solana/web3.js";
+class C 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 {
+  C as ClientSolanaCommitmentsSnapshotService
+};

package/data-structures/snapshot/solana-snapshots/ClientSolanaNullifierSnapshotService.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");require("../../../constants/reorg-depths.constants.cjs");require("../../../functions/utils/mutexes.utils.cjs");require("@coral-xyz/anchor");require("../../../constants/chains.constants.cjs");const i=require("../../event-service/solana/AbstractSolanaNullifierSnapshotService.cjs");require("@solana/web3.js");require("../../crypto-keys/keys.cjs");class s extends i.AbstractSolanaNullifierSnapshotService{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.ClientSolanaNullifierSnapshotService=s;

package/data-structures/snapshot/solana-snapshots/ClientSolanaNullifierSnapshotService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractSolanaNullifierSnapshotService, SolanaBlockchainEventEmitter, SolanaNullifierSerializedSnapshot } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientSolanaNullifierSnapshotService extends AbstractSolanaNullifierSnapshotService {
+    private snapshotsService;
+    constructor(nullifierEventEmitter: SolanaBlockchainEventEmitter, snapshotFetcher: SnapshotFetcherService);
+    protected fetchSnapshot(): Promise<SolanaNullifierSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: SolanaNullifierSerializedSnapshot): Promise<unknown>;
+}