h_test_1 0.0.1

package/data-structures/merkle-tree/MerkleTree.d.ts

@@ -0,0 +1,81 @@
+export type MerkleTreeJson = {
+    tree: Record<string, string>;
+    reverseTree?: Record<string, string>;
+    count: string;
+    index: string;
+};
+/**
+ * Merkle tree implementation that allows the user to insert in specific places in the tree
+ *
+ */
+export declare class MerkleTree<T> {
+    private hashFunction;
+    private levels;
+    private defaultNodeValue;
+    /**
+     * the map where the items are stored
+     */
+    private readonly tree;
+    /**
+     * amount of elements inserted inside the bottom row of the tree
+     */
+    private count;
+    /**
+     * the maximum index inserted into the tree
+     * used together with count to make sure that the merkle tree is complete.
+     * meaning that there aren't any missing elements between getStartIndex() and index
+     */
+    private index;
+    private reverseTree;
+    static createWithData<T>(tree: Map<bigint, T>, reverseTree: Map<T, bigint> | undefined, index: bigint, count: bigint, hashFunction: (a: T, b: T) => T, levels: bigint, defaultNodeValue: T): MerkleTree<T>;
+    /**
+     * @param hashFunction the hashFunction used to fill the upper layers of the merkle tree
+     * @param levels the amount of layers in the merkle tree
+     * @param defaultNodeValue the default value of an empty node in the merkle tree
+     */
+    static create<T>(hashFunction: (a: T, b: T) => T, defaultNodeValue: T, levels?: bigint): MerkleTree<T>;
+    private createReverseTree;
+    private constructor();
+    /**
+     * get starting nodeIndex from which inserts are allowed
+     */
+    getStartIndex(): bigint;
+    /**
+     * implementation of logarithm2 function from merkle contract
+     */
+    logarithm2(a: bigint): bigint;
+    bigIntMax(a: bigint, b: bigint): bigint;
+    private forceInsert;
+    /**
+     * insert value into the merkle tree
+     * @param value the value to insert
+     * @param nodeIndex the index to insert the value, you can get starting index from getStartIndex()
+     * @return true - if added, false - if already exists
+     * @throws will throw RangeError if nodeIndex is less than getStartIndex()
+     */
+    insert(value: T, nodeIndex: bigint): boolean;
+    remove(nodeIndex: bigint): void;
+    private completenessCheck;
+    /**
+     * get root hash of the merkle tree
+     * @returns the hash, if the merkle tree is empty, will return
+     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+     */
+    getRootHash(): T | undefined;
+    getMerkleData(): Map<bigint, T>;
+    getSiblingIndex(index: bigint): bigint;
+    /**
+     * get sibling hashes needed by main.circom
+     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+     */
+    getSiblingHashesForVerification(item: T): bigint[] | T[];
+    /**
+     * get item's sibling hashes side
+     * @returns sibling's indexes
+     * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+     */
+    getSiblingSides(item: T): bigint[];
+    toJSON(): MerkleTreeJson;
+    clone(): MerkleTree<T>;
+    getIndex(): bigint;
+}

package/data-structures/merkle-tree/MerkleTree.mjs

@@ -0,0 +1,168 @@
+import { MERKLE_LEVELS as a, CIRCOM_MERKLE_LENGTH as o } from "../../constants/protocol.constants.mjs";
+import { logError as u } from "../../error-handling/logError.mjs";
+import { MerkleTreeIncompleteError as c } from "./MerkleTreeIncompleteError.mjs";
+class l {
+  constructor(t, e, r, i, s, n, h) {
+    this.hashFunction = t, this.levels = e, this.defaultNodeValue = r, this.tree = i ?? /* @__PURE__ */ new Map(), this.count = h ?? 0n, this.index = n ?? 2n ** (e - 1n), s ? this.reverseTree = s : this.reverseTree = this.createReverseTree();
+  }
+  /**
+   * the map where the items are stored
+   */
+  tree;
+  /**
+   * amount of elements inserted inside the bottom row of the tree
+   */
+  count;
+  /**
+   * the maximum index inserted into the tree
+   * used together with count to make sure that the merkle tree is complete.
+   * meaning that there aren't any missing elements between getStartIndex() and index
+   */
+  index;
+  reverseTree;
+  static createWithData(t, e, r, i, s, n, h) {
+    return new l(s, n, h, t, e, r, i);
+  }
+  /**
+   * @param hashFunction the hashFunction used to fill the upper layers of the merkle tree
+   * @param levels the amount of layers in the merkle tree
+   * @param defaultNodeValue the default value of an empty node in the merkle tree
+   */
+  static create(t, e, r = a) {
+    return new l(t, r, e);
+  }
+  createReverseTree() {
+    const t = /* @__PURE__ */ new Map();
+    for (let e = this.getStartIndex(); e < this.getStartIndex() + this.count; e += 1n) {
+      const r = this.tree.get(e);
+      r !== void 0 && t.set(r, e);
+    }
+    return t;
+  }
+  /**
+   * get starting nodeIndex from which inserts are allowed
+   */
+  getStartIndex() {
+    return 2n ** (this.levels - 1n);
+  }
+  /**
+   * implementation of logarithm2 function from merkle contract
+   */
+  logarithm2(t) {
+    let e = 0n;
+    for (; 2n ** e < t; )
+      e += 1n;
+    return e;
+  }
+  bigIntMax(t, e) {
+    return t > e ? t : e;
+  }
+  forceInsert(t, e) {
+    if (e < this.getStartIndex())
+      throw new RangeError();
+    this.tree.set(e, t), this.reverseTree.set(t, e);
+    const r = this.index - this.getStartIndex(), i = this.logarithm2(r);
+    let s = e;
+    for (let n = 1n; n <= i; n += 1n) {
+      s /= 2n;
+      const h = this.hashFunction(
+        this.tree.get(s * 2n) || this.defaultNodeValue,
+        this.tree.get(s * 2n + 1n) || this.defaultNodeValue
+      );
+      this.tree.set(s, h);
+    }
+  }
+  /**
+   * insert value into the merkle tree
+   * @param value the value to insert
+   * @param nodeIndex the index to insert the value, you can get starting index from getStartIndex()
+   * @return true - if added, false - if already exists
+   * @throws will throw RangeError if nodeIndex is less than getStartIndex()
+   */
+  insert(t, e) {
+    let r = !1;
+    return this.tree.has(e) && (r = !0, u(`Editing commitment index: ${e} `)), r || (this.count += 1n), this.index = this.bigIntMax(this.index, e + 1n), this.forceInsert(t, e), !0;
+  }
+  remove(t) {
+    this.forceInsert(this.defaultNodeValue, t);
+  }
+  completenessCheck() {
+    if (this.count !== this.index - this.getStartIndex())
+      throw new c();
+  }
+  /**
+   * get root hash of the merkle tree
+   * @returns the hash, if the merkle tree is empty, will return
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getRootHash() {
+    this.completenessCheck();
+    for (let t = 1n; t < 2n ** this.levels; t *= 2n)
+      if (this.tree.get(t))
+        return this.tree.get(t);
+    return this.defaultNodeValue;
+  }
+  getMerkleData() {
+    return this.completenessCheck(), new Map(this.tree);
+  }
+  getSiblingIndex(t) {
+    return t === 1n ? 1n : t % 2n === 1n ? t - 1n : t + 1n;
+  }
+  /**
+   * get sibling hashes needed by main.circom
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingHashesForVerification(t) {
+    this.completenessCheck();
+    let e = this.reverseTree.get(t);
+    if (e === void 0)
+      return new Array(Number(o)).fill(0n);
+    const r = [];
+    for (; e !== 0n; )
+      r.push(this.tree.get(this.getSiblingIndex(e)) || this.defaultNodeValue), e /= 2n;
+    return r.slice(0, o);
+  }
+  /**
+   * get item's sibling hashes side
+   * @returns sibling's indexes
+   * @throws will throw MerkleTreeIncompleteError if there are missing elements in the tree
+   */
+  getSiblingSides(t) {
+    this.completenessCheck();
+    let e = this.reverseTree.get(t);
+    if (e === void 0)
+      return new Array(Number(o)).fill(0n);
+    const r = [];
+    for (; e !== 0n; ) {
+      const i = e % 2n === 0n ? 0n : 1n;
+      r.push(i), e /= 2n;
+    }
+    return r.slice(0, o);
+  }
+  toJSON() {
+    const { tree: t, reverseTree: e, count: r, index: i } = this;
+    return {
+      tree: Object.fromEntries(t),
+      reverseTree: Object.fromEntries(e),
+      count: r.toString(),
+      index: i.toString()
+    };
+  }
+  clone() {
+    return l.createWithData(
+      new Map(this.tree),
+      new Map(this.reverseTree),
+      this.index,
+      this.count,
+      this.hashFunction,
+      this.levels,
+      this.defaultNodeValue
+    );
+  }
+  getIndex() {
+    return this.index;
+  }
+}
+export {
+  l as MerkleTree
+};

package/data-structures/merkle-tree/MerkleTreeIncompleteError.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class e extends Error{constructor(){super("Merkle tree is incomplete"),this.name="MerkleTreeIncompleteError"}}exports.MerkleTreeIncompleteError=e;

package/data-structures/merkle-tree/MerkleTreeIncompleteError.d.ts

@@ -0,0 +1,3 @@
+export declare class MerkleTreeIncompleteError extends Error {
+    constructor();
+}

package/data-structures/merkle-tree/MerkleTreeIncompleteError.mjs

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

package/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../../functions/web3/etherFunctions.cjs"),c=require("../../crypto/poseidon.cjs"),i=require("./MerkleTree.cjs"),g=(r,n,o,t)=>{if(!t||o){const e=i.MerkleTree.create(c.poseidonFunction,0n);return e.insert(BigInt(n.getAccessKey()),e.getStartIndex()),t||e.insert(s.randomBigInt(31),e.getStartIndex()+1n),e}return r};exports.getPatchedAccessTokenMerkleTree=g;

package/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.d.ts

@@ -0,0 +1,3 @@
+import { UserKeys } from '../crypto-keys/keys';
+import { MerkleTree } from './MerkleTree';
+export declare const getPatchedAccessTokenMerkleTree: (merkleTreeAccessToken: MerkleTree<bigint>, userKeys: UserKeys, patchAccessTokenMerkleTree: boolean, kycRequired: boolean) => MerkleTree<bigint>;

package/data-structures/merkle-tree/getPatchedAccessTokenMerkleTree.mjs

@@ -0,0 +1,13 @@
+import { randomBigInt as i } from "../../functions/web3/etherFunctions.mjs";
+import { poseidonFunction as s } from "../../crypto/poseidon.mjs";
+import { MerkleTree as c } from "./MerkleTree.mjs";
+const f = (r, n, o, t) => {
+  if (!t || o) {
+    const e = c.create(s, 0n);
+    return e.insert(BigInt(n.getAccessKey()), e.getStartIndex()), t || e.insert(i(31), e.getStartIndex() + 1n), e;
+  }
+  return r;
+};
+export {
+  f as getPatchedAccessTokenMerkleTree
+};

package/data-structures/merkle-tree/index.d.ts

@@ -0,0 +1,3 @@
+export * from './MerkleTree';
+export * from './getPatchedAccessTokenMerkleTree';
+export * from './MerkleTreeIncompleteError';

package/data-structures/presale/PresaleContractWrapper.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../../constants/presale.constants.cjs"),n=require("ethers");class o{contract;eventsFrom;constructor(t,e){const{address:r,eventsFrom:a}=s.presaleContractInfoByChain[e];this.contract=new n.ethers.Contract(r,s.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 this.contract.moveToNextStage.estimateGas()}async getTotalDeposit(){return await this.contract.totalDeposit()}async getDeposits(t,e){return await this.contract.deposits(t,e.erc20TokenAddress)}async getTotalHINK(t){return await this.contract.totalHINK(t)}async getCurrentPresaleStageIndex(){const t=await this.contract.currentPresaleStageIndex();return Number(t)}async getCurrentMaxDepositAmount(){return await this.contract.currentMaxDepositAmount()}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)}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.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.Log | ethers.EventLog)[]>;
+    onEvent(eventName: string, handleEvent: ethers.Listener): void;
+}

package/data-structures/presale/PresaleContractWrapper.mjs

@@ -0,0 +1,54 @@
+import { presaleContractInfoByChain as s, presaleABI as n } from "../../constants/presale.constants.mjs";
+import { ethers as o } from "ethers";
+class l {
+  contract;
+  eventsFrom;
+  constructor(t, e) {
+    const { address: r, eventsFrom: a } = s[e];
+    this.contract = new o.Contract(r, n, 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 this.contract.moveToNextStage.estimateGas();
+  }
+  async getTotalDeposit() {
+    return await this.contract.totalDeposit();
+  }
+  async getDeposits(t, e) {
+    return await this.contract.deposits(t, e.erc20TokenAddress);
+  }
+  async getTotalHINK(t) {
+    return await this.contract.totalHINK(t);
+  }
+  async getCurrentPresaleStageIndex() {
+    const t = await this.contract.currentPresaleStageIndex();
+    return Number(t);
+  }
+  async getCurrentMaxDepositAmount() {
+    return await this.contract.currentMaxDepositAmount();
+  }
+  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);
+  }
+  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

@@ -0,0 +1,38 @@
+import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { ethers } from 'ethers';
+import { Call } from '../../types/eip5792.types';
+export interface ChainEventListener {
+    onAccountChanged(): void;
+    onChainChanged(chainId?: number): void;
+}
+export interface IProviderAdapter<ConnectorType = unknown> {
+    chainId: number | undefined;
+    initConnector(connector: ConnectorType): void;
+    initSigner?(signer: ethers.Signer): void;
+    init(chainId?: number): Promise<void>;
+    initConfig?(config?: any): Promise<void> | void;
+    connectToConnector(connector: ConnectorType): Promise<number>;
+    disconnectFromConnector(): Promise<void>;
+    connectAndPatchProvider(connector: ConnectorType): Promise<number>;
+    waitForTransaction(transactionHash: string, confirmations: number): Promise<boolean>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    getAddress(): Promise<string>;
+    getSelectedNetwork(): EthereumNetwork | undefined;
+    setChainEventListener(chainEventListener: ChainEventListener): void;
+    release(): void;
+    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+    getContract(contractType: ContractType, contractAddress?: string, chainId?: number): ethers.Contract;
+    getContractWithSigner(contract: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): ethers.Contract;
+    sendTransaction(tx: ethers.TransactionRequest): Promise<ethers.TransactionResponse>;
+    switchNetwork(network: EthereumNetwork): Promise<unknown>;
+    switchAccount(signer: ethers.Signer): Promise<void>;
+    onAccountChanged(): Promise<unknown>;
+    onChainChanged(chainId?: number): Promise<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.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 c=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");const i=require("../../../functions/utils/getSignerFromContract.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 o=require("../SnapshotFetcherService.cjs"),n=require("../../../functions/utils/getContractAddress.cjs");class a extends c.AbstractAccessTokenSnapshotService{snapshotsService;constructor(e,s){super(e),this.snapshotsService=s}async fetchSnapshot(){const{contract:e}=this.blockchainEventEmitter,{chainId:s}=await i.getProviderFromContract(e).getNetwork(),t=Number(s);this.snapshotsService||(this.snapshotsService=new o.SnapshotFetcherService(t,n.getContractAddress(e)));const r=await this.snapshotsService.getAccessTokens();if(r.accessTokenContractAddress!==n.getContractAddress(e)||r.chainId!==t)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=a;

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

@@ -0,0 +1,8 @@
+import { AbstractAccessTokenSnapshotService, AccessTokenSerializedSnapshot, BlockchainEventEmitter } from '../../event-service';
+import { SnapshotFetcherService } from '../SnapshotFetcherService';
+export declare class ClientAccessTokenSnapshotService extends AbstractAccessTokenSnapshotService {
+    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,43 @@
+import { AbstractAccessTokenSnapshotService as i } 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 { getProviderFromContract as n } from "../../../functions/utils/getSignerFromContract.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 c } from "../SnapshotFetcherService.mjs";
+import { getContractAddress as o } from "../../../functions/utils/getContractAddress.mjs";
+class N extends i {
+  snapshotsService;
+  constructor(e, r) {
+    super(e), this.snapshotsService = r;
+  }
+  async fetchSnapshot() {
+    const { contract: e } = this.blockchainEventEmitter, { chainId: r } = await n(e).getNetwork(), s = Number(r);
+    this.snapshotsService || (this.snapshotsService = new c(s, o(e)));
+    const t = await this.snapshotsService.getAccessTokens();
+    if (t.accessTokenContractAddress !== o(e) || t.chainId !== s)
+      throw Error("Commitment Snapshot: incorrect contract or chain id");
+    return {
+      latestBlockNumber: t.latestBlockNumber,
+      merkleTree: t.merkleTree,
+      senderAddresses: t.senderAddresses,
+      senderAddressIndexMap: t.senderAddressIndexMap
+    };
+  }
+  persistSnapshot(e) {
+    return Promise.resolve();
+  }
+}
+export {
+  N as ClientAccessTokenSnapshotService
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../../../functions/utils/getContractAddress.cjs"),o=require("../../../functions/utils/getSignerFromContract.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");const i=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 n extends i.AbstractApprovalsSnapshotService{snapshotsService;constructor(r,t){super(r),this.snapshotsService=t}async fetchSnapshot(){const{contract:r}=this.blockchainEventEmitter,{chainId:t}=await o.getProviderFromContract(r).getNetwork(),s=Number(t),e=await this.snapshotsService.getApprovals();if(!e)return{latestBlockNumber:0,approvals:{},events:[]};if(e.hinkalAddress!==a.getContractAddress(r)||e.chainId!==s)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=n;

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

@@ -0,0 +1,8 @@
+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);
+    protected fetchSnapshot(): Promise<ApprovalsSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown>;
+}

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

@@ -0,0 +1,45 @@
+import { getContractAddress as a } from "../../../functions/utils/getContractAddress.mjs";
+import { getProviderFromContract as e } from "../../../functions/utils/getSignerFromContract.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 { AbstractApprovalsSnapshotService as p } 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 B extends p {
+  snapshotsService;
+  constructor(r, o) {
+    super(r), this.snapshotsService = o;
+  }
+  async fetchSnapshot() {
+    const { contract: r } = this.blockchainEventEmitter, { chainId: o } = await e(r).getNetwork(), s = Number(o), t = await this.snapshotsService.getApprovals();
+    if (!t)
+      return {
+        latestBlockNumber: 0,
+        approvals: {},
+        events: []
+      };
+    if (t.hinkalAddress !== a(r) || t.chainId !== s)
+      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 {
+  B 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>;
+}