@hinkal/common 0.2.9 → 0.2.11

package/data-structures/event-service/AbstractCommitmentsSnapshotService.d.mts

@@ -0,0 +1,30 @@
+import { ethers } from 'ethers';
+import { MerkleTree, MerkleTreeJson } from '../merkle-tree';
+import { CommitmentEvent, EncryptedOutputWithSign } from '../../types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+export type CommitmentsSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly encryptedOutputs: EncryptedOutputWithSign[];
+};
+export type CommitmentsSerializedSnapshot = {
+    latestBlockNumber?: number;
+    reserveBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    encryptedOutputs?: EncryptedOutputWithSign<string>[];
+};
+export declare abstract class AbstractCommitmentsSnapshotService extends AbstractSnapshotService<CommitmentEvent<bigint>, CommitmentEvent, CommitmentsSnapshotPayload, CommitmentsSerializedSnapshot> {
+    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    private _merkleTree;
+    private _encryptedOutputs;
+    get merkleTree(): MerkleTree<bigint>;
+    get encryptedOutputs(): EncryptedOutputWithSign<boolean>[];
+    protected serializeSnapshot(snapshot: Snapshot<CommitmentsSnapshotPayload>): CommitmentsSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: CommitmentsSerializedSnapshot): Snapshot<CommitmentsSnapshotPayload>;
+    protected getSnapshotPayload(): {
+        merkleTree: MerkleTree<bigint>;
+        encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+    };
+    protected populateSnapshot({ payload: { merkleTree, encryptedOutputs }, }: Snapshot<CommitmentsSnapshotPayload>): void;
+    protected mapEvent(event: CommitmentEvent): CommitmentEvent<bigint>;
+    protected acceptEvent(event: CommitmentEvent<bigint>, _blockNumber: number): boolean;
+}

package/data-structures/event-service/AbstractEventService.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const v=require("../../constants/reorg-depths.constants.cjs"),o=require("../../functions/utils/resolve-sync.utils.cjs");class u{contract;eventConfig;_latestBlockNumber;maxPageSize;isReady=!1;_onNewEvent;isServer;intervalId;inProgress;constructor(e,t,s,r,n){this.contract=e,this.eventConfig=t,this._latestBlockNumber=s,this.maxPageSize=n,this.isServer=r,this.inProgress=!1}get latestBlockNumber(){return this._latestBlockNumber}set onNewEvent(e){this._onNewEvent=e}intervalClear(){this.isReady=!1,this._onNewEvent=void 0,clearInterval(this.intervalId)}async init(){if(this.isReady)throw new Error("Already initialized");this.isReady=!0,await this.retrieveEvents(this._latestBlockNumber+1),this.intervalId=setInterval(async()=>{await this.retrieveEvents(this.latestBlockNumber)},3500)}requireReady(){if(!this.isReady)throw new Error("Not ready")}emitNewEvent(e){this._onNewEvent?.(e)}getLastBlockNumberForEventRequest=async()=>{const e=await this.contract.provider.getBlockNumber();if(!this.isServer)return e;const{chainId:t}=await this.contract.provider.getNetwork();return Math.max(this.latestBlockNumber,e-v.blockReorgDepth[t]+1)};async retrieveEvents(e,t=!1){try{if(this.requireReady(),this.inProgress&&!t)return!1;this.inProgress=!0;const s=await this.getLastBlockNumberForEventRequest();if(s<e)return this.inProgress=!1,!1;const r=o.getSequence(e,s,this.maxPageSize);return await o.resolveSync(r.map(({from:n,to:i})=>async()=>{const c=await this.contract.queryFilter(this.contract.filters[this.eventConfig.name](),n,i);let a=[];c.length>0&&(a=await this.processEventsPage(c)),this._latestBlockNumber=i,await this.afterEventsAccepted(),a.length>0&&this.emitNewEvent()})),this.inProgress=!1,!0}catch{return this.inProgress=!1,!1}}async processEventsPage(e){const t=[];return await o.resolveSync(e.map(s=>async()=>{const{args:r,blockNumber:n}=s;if(!r)throw new Error("Wrong event structure");const i=this.mapEvent(r);await this.acceptEvent(i,n)&&t.push(i)})),t}handleEvent=async(...e)=>{const{args:t}=this.eventConfig,{blockNumber:s}=e[e.length-1],r=e.slice(0,t.length),n=t.reduce((a,l,h)=>(a[l]=r[h],a),{});if(!s)throw new Error("Wrong event structure");const i=this.mapEvent(n);if(!await this.acceptEvent(i,s))throw new Error("Failed to retrieve events");this._latestBlockNumber=s,await this.afterEventsAccepted(),this.emitNewEvent(i)}}exports.AbstractEventService=u;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("../../constants/reorg-depths.constants.cjs"),o=require("../../functions/utils/resolve-sync.utils.cjs");require("ethers");require("axios");require("../../constants/chains.constants.cjs");require("../../constants/vite.constants.cjs");require("../../types/circom-data.types.cjs");require("../../types/transactions.types.cjs");require("../../types/curve.types.cjs");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");const v=require("../../error-handling/logError.cjs");class g{contract;eventConfig;_latestBlockNumber;maxPageSize;isReady=!1;_onNewEvent;isServer;intervalId;inProgress;constructor(e,r,t,s,n){this.contract=e,this.eventConfig=r,this._latestBlockNumber=t,this.maxPageSize=n,this.isServer=s,this.inProgress=!1}get latestBlockNumber(){return this._latestBlockNumber}set onNewEvent(e){this._onNewEvent=e}intervalClear(){this.isReady=!1,this._onNewEvent=void 0,clearInterval(this.intervalId)}async init(){if(this.isReady)throw new Error("Already initialized");this.isReady=!0,await this.retrieveEvents(this._latestBlockNumber+1),this.intervalId=setInterval(async()=>{await this.retrieveEvents(this.latestBlockNumber)},3500)}requireReady(){if(!this.isReady)throw new Error("Not ready")}emitNewEvent(e){this._onNewEvent?.(e)}getLastBlockNumberForEventRequest=async()=>{const e=await this.contract.provider.getBlockNumber();if(!this.isServer)return e;const{chainId:r}=await this.contract.provider.getNetwork();return Math.max(this.latestBlockNumber,e-u.blockReorgDepth[r]+1)};async retrieveEvents(e,r=!1){try{if(this.requireReady(),this.inProgress&&!r)return!1;this.inProgress=!0;const t=await this.getLastBlockNumberForEventRequest();if(t<e)return this.inProgress=!1,!1;const s=o.getSequence(e,t,this.maxPageSize);return await o.resolveSync(s.map(({from:n,to:i})=>async()=>{const c=await this.contract.queryFilter(this.contract.filters[this.eventConfig.name](),n,i);let a=[];c.length>0&&(a=await this.processEventsPage(c)),this._latestBlockNumber=i,await this.afterEventsAccepted(),a.length>0&&this.emitNewEvent()})),this.inProgress=!1,!0}catch(t){return v.logError("retrieveEvents error:",{err:t}),this.inProgress=!1,!1}}async processEventsPage(e){const r=[];return await o.resolveSync(e.map(t=>async()=>{const{args:s,blockNumber:n}=t;if(!s)throw new Error("Wrong event structure");const i=this.mapEvent(s);await this.acceptEvent(i,n)&&r.push(i)})),r}handleEvent=async(...e)=>{const{args:r}=this.eventConfig,{blockNumber:t}=e[e.length-1],s=e.slice(0,r.length),n=r.reduce((a,l,h)=>(a[l]=s[h],a),{});if(!t)throw new Error("Wrong event structure");const i=this.mapEvent(n);if(!await this.acceptEvent(i,t))throw new Error("Failed to retrieve events");this._latestBlockNumber=t,await this.afterEventsAccepted(),this.emitNewEvent(i)}}exports.AbstractEventService=g;

package/data-structures/event-service/AbstractEventService.d.mts

@@ -0,0 +1,31 @@
+import { ethers } from 'ethers';
+export type NewEventListener<E> = (event?: E) => unknown;
+export interface EventConfig {
+    name: string;
+    args: string[];
+}
+export declare abstract class AbstractEventService<EventType, SerializedEventType = unknown> {
+    protected readonly contract: ethers.Contract;
+    protected readonly eventConfig: EventConfig;
+    protected _latestBlockNumber: number;
+    private readonly maxPageSize?;
+    private isReady;
+    private _onNewEvent?;
+    protected isServer: boolean;
+    protected intervalId?: any;
+    protected inProgress: boolean;
+    protected constructor(contract: ethers.Contract, eventConfig: EventConfig, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    get latestBlockNumber(): number;
+    set onNewEvent(value: NewEventListener<EventType>);
+    intervalClear(): void;
+    init(): Promise<void>;
+    protected requireReady(): void;
+    protected emitNewEvent(event?: EventType): void;
+    private getLastBlockNumberForEventRequest;
+    protected retrieveEvents(fromBlockNumber: number, useForce?: boolean): Promise<boolean>;
+    private processEventsPage;
+    protected handleEvent: (...args: unknown[]) => Promise<void>;
+    protected abstract acceptEvent(event: EventType, blockNumber: number): boolean | Promise<boolean>;
+    protected abstract mapEvent(event: SerializedEventType): EventType;
+    protected abstract afterEventsAccepted(): Promise<unknown>;
+}

package/data-structures/event-service/AbstractEventService.mjs

@@ -1,6 +1,18 @@
 import { blockReorgDepth as v } from "../../constants/reorg-depths.constants.mjs";
-import { getSequence as u, resolveSync as o } from "../../functions/utils/resolve-sync.utils.mjs";
-class g {
+import { getSequence as m, resolveSync as c } from "../../functions/utils/resolve-sync.utils.mjs";
+import "ethers";
+import "axios";
+import "../../constants/chains.constants.mjs";
+import "../../constants/vite.constants.mjs";
+import "../../types/circom-data.types.mjs";
+import "../../types/transactions.types.mjs";
+import "../../types/curve.types.mjs";
+import "circomlibjs-hinkal-fork";
+import "libsodium-wrappers";
+import "process";
+import "buffer";
+import { logError as u } from "../../error-handling/logError.mjs";
+class q {
   contract;
   eventConfig;
   _latestBlockNumber;
@@ -11,8 +23,8 @@ class g {
   intervalId;
   inProgress;
   // to remove race conditions
-  constructor(e, t, s, r, n) {
-    this.contract = e, this.eventConfig = t, this._latestBlockNumber = s, this.maxPageSize = n, this.isServer = r, this.inProgress = !1;
+  constructor(e, r, t, s, n) {
+    this.contract = e, this.eventConfig = r, this._latestBlockNumber = t, this.maxPageSize = n, this.isServer = s, this.inProgress = !1;
   }
   get latestBlockNumber() {
     return this._latestBlockNumber;
@@ -41,55 +53,55 @@ class g {
     const e = await this.contract.provider.getBlockNumber();
     if (!this.isServer)
       return e;
-    const { chainId: t } = await this.contract.provider.getNetwork();
-    return Math.max(this.latestBlockNumber, e - v[t] + 1);
+    const { chainId: r } = await this.contract.provider.getNetwork();
+    return Math.max(this.latestBlockNumber, e - v[r] + 1);
   };
-  async retrieveEvents(e, t = !1) {
+  async retrieveEvents(e, r = !1) {
     try {
-      if (this.requireReady(), this.inProgress && !t)
+      if (this.requireReady(), this.inProgress && !r)
         return !1;
       this.inProgress = !0;
-      const s = await this.getLastBlockNumberForEventRequest();
-      if (s < e)
+      const t = await this.getLastBlockNumberForEventRequest();
+      if (t < e)
         return this.inProgress = !1, !1;
-      const r = u(e, s, this.maxPageSize);
-      return await o(
-        r.map(({ from: n, to: i }) => async () => {
-          const c = await this.contract.queryFilter(
+      const s = m(e, t, this.maxPageSize);
+      return await c(
+        s.map(({ from: n, to: i }) => async () => {
+          const o = await this.contract.queryFilter(
             this.contract.filters[this.eventConfig.name](),
             n,
             i
           );
           let a = [];
-          c.length > 0 && (a = await this.processEventsPage(c)), this._latestBlockNumber = i, await this.afterEventsAccepted(), a.length > 0 && this.emitNewEvent();
+          o.length > 0 && (a = await this.processEventsPage(o)), this._latestBlockNumber = i, await this.afterEventsAccepted(), a.length > 0 && this.emitNewEvent();
         })
       ), this.inProgress = !1, !0;
-    } catch {
-      return this.inProgress = !1, !1;
+    } catch (t) {
+      return u("retrieveEvents error:", { err: t }), this.inProgress = !1, !1;
     }
   }
   async processEventsPage(e) {
-    const t = [];
-    return await o(
-      e.map((s) => async () => {
-        const { args: r, blockNumber: n } = s;
-        if (!r)
+    const r = [];
+    return await c(
+      e.map((t) => async () => {
+        const { args: s, blockNumber: n } = t;
+        if (!s)
           throw new Error("Wrong event structure");
-        const i = this.mapEvent(r);
-        await this.acceptEvent(i, n) && t.push(i);
+        const i = this.mapEvent(s);
+        await this.acceptEvent(i, n) && r.push(i);
       })
-    ), t;
+    ), r;
   }
   handleEvent = async (...e) => {
-    const { args: t } = this.eventConfig, { blockNumber: s } = e[e.length - 1], r = e.slice(0, t.length), n = t.reduce((a, h, l) => (a[h] = r[l], a), {});
-    if (!s)
+    const { args: r } = this.eventConfig, { blockNumber: t } = e[e.length - 1], s = e.slice(0, r.length), n = r.reduce((a, h, l) => (a[h] = s[l], a), {});
+    if (!t)
       throw new Error("Wrong event structure");
     const i = this.mapEvent(n);
-    if (!await this.acceptEvent(i, s))
+    if (!await this.acceptEvent(i, t))
       throw new Error("Failed to retrieve events");
-    this._latestBlockNumber = s, await this.afterEventsAccepted(), this.emitNewEvent(i);
+    this._latestBlockNumber = t, await this.afterEventsAccepted(), this.emitNewEvent(i);
   };
 }
 export {
-  g as AbstractEventService
+  q as AbstractEventService
 };

package/data-structures/event-service/AbstractNullifierSnapshotService.d.mts

@@ -0,0 +1,22 @@
+import { BigNumber, ethers } from 'ethers';
+import { NullifierEvent } from '../../types/commitments.types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+export type NullifierSnapshotPayload = {
+    readonly nullifiers: Set<string>;
+};
+export type NullifierSerializedSnapshot = {
+    latestBlockNumber?: number;
+    reserveBlockNumber?: number;
+    nullifiers?: string[];
+};
+export declare abstract class AbstractNullifierSnapshotService extends AbstractSnapshotService<NullifierEvent<string>, NullifierEvent<BigNumber>, NullifierSnapshotPayload, NullifierSerializedSnapshot> {
+    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    private _nullifiers;
+    get nullifiers(): Set<string>;
+    protected serializeSnapshot(snapshot: Snapshot<NullifierSnapshotPayload>): NullifierSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: NullifierSerializedSnapshot): Snapshot<NullifierSnapshotPayload>;
+    protected acceptEvent(event: NullifierEvent<string>, _blockNumber: number): boolean;
+    protected mapEvent(event: NullifierEvent<BigNumber>): NullifierEvent<string>;
+    protected getSnapshotPayload(): NullifierSnapshotPayload;
+    protected populateSnapshot({ payload: { nullifiers } }: Snapshot<NullifierSnapshotPayload>): void;
+}

package/data-structures/event-service/AbstractSnapshotService.d.mts

@@ -0,0 +1,23 @@
+import { ethers } from 'ethers';
+import { AbstractEventService, EventConfig } from './AbstractEventService';
+export interface Snapshot<SnapshotPayloadType> {
+    readonly latestBlockNumber: number;
+    readonly reserveBlockNumber: number;
+    readonly payload: SnapshotPayloadType;
+}
+export declare abstract class AbstractSnapshotService<EventType, SerializedEventType, SnapshotPayloadType, SerializedSnapshotType> extends AbstractEventService<EventType, SerializedEventType> {
+    protected reserveBlockNumber: number;
+    protected constructor(contract: ethers.Contract, eventConfig: EventConfig, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    init(): Promise<void>;
+    retrieveEventsFromLatestBlock(): Promise<void>;
+    restoreSnapshotState(): Promise<void>;
+    private loadSnapshot;
+    protected saveSnapshot(): Promise<unknown>;
+    protected afterEventsAccepted(): Promise<unknown>;
+    protected abstract getSnapshotPayload(): SnapshotPayloadType;
+    protected abstract populateSnapshot(snapshot: Snapshot<SnapshotPayloadType>): void;
+    protected abstract serializeSnapshot(snapshot: Snapshot<SnapshotPayloadType>): SerializedSnapshotType;
+    protected abstract deserializeSnapshot(serializedSnapshot: SerializedSnapshotType): Snapshot<SnapshotPayloadType>;
+    protected abstract fetchSnapshot(): Promise<SerializedSnapshotType>;
+    protected abstract persistSnapshot(serializedSnapshot: SerializedSnapshotType): Promise<unknown>;
+}

package/data-structures/event-service/index.d.mts

@@ -0,0 +1,5 @@
+export * from './AbstractAccessTokenSnapshotService';
+export * from './AbstractCommitmentsSnapshotService';
+export * from './AbstractNullifierSnapshotService';
+export * from './AbstractSnapshotService';
+export * from './AbstractEventService';

package/data-structures/index.d.mts

@@ -0,0 +1,13 @@
+export * from './ValueCache';
+export * from './crypto-keys';
+export * from './Hinkal';
+export * from './merkle-tree';
+export * from './provider-adapter/IProviderAdapter';
+export * from './event-service';
+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';

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

@@ -0,0 +1,78 @@
+export type MerkleTreeJson = {
+    tree: 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;
+    static createWithData<T>(tree: Map<bigint, T>, 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, levels: bigint, defaultNodeValue: T): MerkleTree<T>;
+    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/MerkleTreeIncompleteError.d.mts

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { TransactionRequest, TransactionResponse } from '@ethersproject/providers';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { Contract, ethers, Signer } from 'ethers';
+export interface ChainEventListener {
+    onAccountChanged(): void;
+    onChainChanged(chainId?: number): void;
+}
+export interface IProviderAdapter<ConnectorType = unknown> {
+    chainId: number | undefined;
+    initConnector(connector: ConnectorType): void;
+    initSigner?(signer: 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): Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: string): Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): Contract;
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
+    switchNetwork(network: EthereumNetwork): Promise<unknown>;
+    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>;
+}

package/data-structures/snapshot/ClientAccessTokenSnapshotService.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../event-service/AbstractAccessTokenSnapshotService.cjs");require("ethers");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");require("../../constants/vite.constants.cjs");require("../../constants/reorg-depths.constants.cjs");const t=require("../../API/fetchCommitmentsCache.cjs");class c extends s.AbstractAccessTokenSnapshotService{constructor(r,e){super(r,0,!1,e)}async fetchSnapshot(){const{chainId:r}=await this.contract.provider.getNetwork(),e=await t.fetchAccessTokenSnapshot(r);if(e.accessTokenContractAddress!==this.contract.address||e.chainId!==r)throw Error("Commitment Snapshot: incorrect contract or chain id");return{latestBlockNumber:e.latestBlockNumber,merkleTree:e.merkleTree,senderAddresses:e.senderAddresses,senderAddressIndexMap:e.senderAddressIndexMap}}persistSnapshot(r){return Promise.resolve()}}exports.ClientAccessTokenSnapshotService=c;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("../event-service/AbstractAccessTokenSnapshotService.cjs");require("ethers");require("circomlibjs-hinkal-fork");require("libsodium-wrappers");require("process");require("buffer");require("../../constants/vite.constants.cjs");require("../../constants/reorg-depths.constants.cjs");require("axios");require("../../constants/chains.constants.cjs");require("../../types/circom-data.types.cjs");require("../../types/transactions.types.cjs");require("../../types/curve.types.cjs");const t=require("../../API/fetchCommitmentsCache.cjs");class c extends s.AbstractAccessTokenSnapshotService{constructor(r,e){super(r,0,!1,e)}async fetchSnapshot(){const{chainId:r}=await this.contract.provider.getNetwork(),e=await t.fetchAccessTokenSnapshot(r);if(e.accessTokenContractAddress!==this.contract.address||e.chainId!==r)throw Error("Commitment Snapshot: incorrect contract or chain id");return{latestBlockNumber:e.latestBlockNumber,merkleTree:e.merkleTree,senderAddresses:e.senderAddresses,senderAddressIndexMap:e.senderAddressIndexMap}}persistSnapshot(r){return Promise.resolve()}}exports.ClientAccessTokenSnapshotService=c;

package/data-structures/snapshot/ClientAccessTokenSnapshotService.d.mts

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

package/data-structures/snapshot/ClientAccessTokenSnapshotService.mjs

@@ -1,4 +1,4 @@
-import { AbstractAccessTokenSnapshotService as s } from "../event-service/AbstractAccessTokenSnapshotService.mjs";
+import { AbstractAccessTokenSnapshotService as t } from "../event-service/AbstractAccessTokenSnapshotService.mjs";
 import "ethers";
 import "circomlibjs-hinkal-fork";
 import "libsodium-wrappers";
@@ -6,13 +6,18 @@ import "process";
 import "buffer";
 import "../../constants/vite.constants.mjs";
 import "../../constants/reorg-depths.constants.mjs";
-import { fetchAccessTokenSnapshot as t } from "../../API/fetchCommitmentsCache.mjs";
-class k extends s {
+import "axios";
+import "../../constants/chains.constants.mjs";
+import "../../types/circom-data.types.mjs";
+import "../../types/transactions.types.mjs";
+import "../../types/curve.types.mjs";
+import { fetchAccessTokenSnapshot as s } from "../../API/fetchCommitmentsCache.mjs";
+class u extends t {
   constructor(r, e) {
     super(r, 0, !1, e);
   }
   async fetchSnapshot() {
-    const { chainId: r } = await this.contract.provider.getNetwork(), e = await t(r);
+    const { chainId: r } = await this.contract.provider.getNetwork(), e = await s(r);
     if (e.accessTokenContractAddress !== this.contract.address || e.chainId !== r)
       throw Error("Commitment Snapshot: incorrect contract or chain id");
     return {
@@ -27,5 +32,5 @@ class k extends s {
   }
 }
 export {
-  k as ClientAccessTokenSnapshotService
+  u as ClientAccessTokenSnapshotService
 };

package/data-structures/snapshot/ClientCommitmentsSnapshotService.cjs

@@ -1 +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("../../constants/reorg-depths.constants.cjs");const r=require("../event-service/AbstractCommitmentsSnapshotService.cjs"),s=require("../../API/fetchCommitmentsCache.cjs");class i extends r.AbstractCommitmentsSnapshotService{constructor(t,e){super(t,0,!1,e)}async fetchSnapshot(){const{chainId:t}=await this.contract.provider.getNetwork(),e=await s.fetchCommitmentsSnapshot(t);if(e.hinkalAddress!==this.contract.address||e.chainId!==t)throw Error("Commitment Snapshot: incorrect contract or chain id");return{latestBlockNumber:e.latestBlockNumber,merkleTree:e.merkleTree,encryptedOutputs:e.encryptedOutputs}}persistSnapshot(t){return Promise.resolve()}}exports.ClientCommitmentsSnapshotService=i;
+"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("../../constants/reorg-depths.constants.cjs");require("axios");require("../../constants/chains.constants.cjs");require("../../types/circom-data.types.cjs");require("../../types/transactions.types.cjs");require("../../types/curve.types.cjs");const r=require("../../API/fetchCommitmentsCache.cjs"),i=require("../event-service/AbstractCommitmentsSnapshotService.cjs");class s extends i.AbstractCommitmentsSnapshotService{constructor(t,e){super(t,0,!1,e)}async fetchSnapshot(){const{chainId:t}=await this.contract.provider.getNetwork(),e=await r.fetchCommitmentsSnapshot(t);if(e.hinkalAddress!==this.contract.address||e.chainId!==t)throw Error("Commitment Snapshot: incorrect contract or chain id");return{latestBlockNumber:e.latestBlockNumber,merkleTree:e.merkleTree,encryptedOutputs:e.encryptedOutputs}}persistSnapshot(t){return Promise.resolve()}}exports.ClientCommitmentsSnapshotService=s;

package/data-structures/snapshot/ClientCommitmentsSnapshotService.d.mts

@@ -0,0 +1,7 @@
+import { AbstractCommitmentsSnapshotService, CommitmentsSerializedSnapshot } from '../event-service';
+import { Contract } from 'ethers';
+export declare class ClientCommitmentsSnapshotService extends AbstractCommitmentsSnapshotService {
+    constructor(contract: Contract, maxPageSize?: number);
+    protected fetchSnapshot(): Promise<CommitmentsSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: CommitmentsSerializedSnapshot): Promise<unknown>;
+}

package/data-structures/snapshot/ClientCommitmentsSnapshotService.mjs

@@ -5,14 +5,19 @@ import "process";
 import "buffer";
 import "../../constants/vite.constants.mjs";
 import "../../constants/reorg-depths.constants.mjs";
-import { AbstractCommitmentsSnapshotService as e } from "../event-service/AbstractCommitmentsSnapshotService.mjs";
-import { fetchCommitmentsSnapshot as o } from "../../API/fetchCommitmentsCache.mjs";
-class u extends e {
+import "axios";
+import "../../constants/chains.constants.mjs";
+import "../../types/circom-data.types.mjs";
+import "../../types/transactions.types.mjs";
+import "../../types/curve.types.mjs";
+import { fetchCommitmentsSnapshot as e } from "../../API/fetchCommitmentsCache.mjs";
+import { AbstractCommitmentsSnapshotService as o } from "../event-service/AbstractCommitmentsSnapshotService.mjs";
+class v extends o {
   constructor(r, t) {
     super(r, 0, !1, t);
   }
   async fetchSnapshot() {
-    const { chainId: r } = await this.contract.provider.getNetwork(), t = await o(r);
+    const { chainId: r } = await this.contract.provider.getNetwork(), t = await e(r);
     if (t.hinkalAddress !== this.contract.address || t.chainId !== r)
       throw Error("Commitment Snapshot: incorrect contract or chain id");
     return {
@@ -26,5 +31,5 @@ class u extends e {
   }
 }
 export {
-  u as ClientCommitmentsSnapshotService
+  v as ClientCommitmentsSnapshotService
 };

package/data-structures/snapshot/ClientNullifierSnapshotService.cjs

@@ -1 +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("../../constants/reorg-depths.constants.cjs");const i=require("../event-service/AbstractNullifierSnapshotService.cjs"),t=require("../../API/fetchNullifiers.cjs");class s extends i.AbstractNullifierSnapshotService{constructor(e,r){super(e,0,!1,r)}async fetchSnapshot(){const{chainId:e}=await this.contract.provider.getNetwork(),r=await t.fetchNullifiers(e);return{latestBlockNumber:r.latestBlockNumber,nullifiers:r.nullifiers}}persistSnapshot(e){return Promise.resolve()}}exports.ClientNullifierSnapshotService=s;
+"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("../../constants/reorg-depths.constants.cjs");require("axios");require("../../constants/chains.constants.cjs");require("../../types/circom-data.types.cjs");require("../../types/transactions.types.cjs");require("../../types/curve.types.cjs");const i=require("../../API/fetchNullifiers.cjs"),t=require("../event-service/AbstractNullifierSnapshotService.cjs");class s extends t.AbstractNullifierSnapshotService{constructor(e,r){super(e,0,!1,r)}async fetchSnapshot(){const{chainId:e}=await this.contract.provider.getNetwork(),r=await i.fetchNullifiers(e);return{latestBlockNumber:r.latestBlockNumber,nullifiers:r.nullifiers}}persistSnapshot(e){return Promise.resolve()}}exports.ClientNullifierSnapshotService=s;

package/data-structures/snapshot/ClientNullifierSnapshotService.d.mts

@@ -0,0 +1,7 @@
+import { AbstractNullifierSnapshotService, NullifierSerializedSnapshot } from '../event-service';
+import { Contract } from 'ethers';
+export declare class ClientNullifierSnapshotService extends AbstractNullifierSnapshotService {
+    constructor(contract: Contract, maxPageSize?: number);
+    protected fetchSnapshot(): Promise<NullifierSerializedSnapshot>;
+    protected persistSnapshot(_serializedSnapshot: NullifierSerializedSnapshot): Promise<unknown>;
+}

package/data-structures/snapshot/ClientNullifierSnapshotService.mjs

@@ -5,9 +5,14 @@ import "process";
 import "buffer";
 import "../../constants/vite.constants.mjs";
 import "../../constants/reorg-depths.constants.mjs";
-import { AbstractNullifierSnapshotService as e } from "../event-service/AbstractNullifierSnapshotService.mjs";
+import "axios";
+import "../../constants/chains.constants.mjs";
+import "../../types/circom-data.types.mjs";
+import "../../types/transactions.types.mjs";
+import "../../types/curve.types.mjs";
 import { fetchNullifiers as i } from "../../API/fetchNullifiers.mjs";
-class h extends e {
+import { AbstractNullifierSnapshotService as o } from "../event-service/AbstractNullifierSnapshotService.mjs";
+class b extends o {
   constructor(t, r) {
     super(t, 0, !1, r);
   }
@@ -23,5 +28,5 @@ class h extends e {
   }
 }
 export {
-  h as ClientNullifierSnapshotService
+  b as ClientNullifierSnapshotService
 };

package/data-structures/token-price-fetcher/TokenChecker.d.mts

@@ -0,0 +1,20 @@
+import { ERC20Token } from '../../types/token.types';
+export declare class TokenChecker {
+    static isCurveLPToken: (token: ERC20Token, curveTokens: string[]) => boolean;
+    static isCurveStakeToken: (token: ERC20Token) => boolean;
+    static isConvexToken: (token: ERC20Token) => boolean;
+    static isBeefyLpToken: (token: ERC20Token) => boolean;
+    static isBeefyStakeToken: (token: ERC20Token) => boolean;
+    static isLidoToken: (token: ERC20Token) => boolean;
+    static isCurveOrConvex: (token: ERC20Token, curveTokens: string[]) => boolean;
+    static isBeefyToken: (token: ERC20Token) => boolean;
+    static isStakeToken: (token: ERC20Token) => boolean;
+    static isPendleYtToken: (token: ERC20Token) => boolean;
+    static isPendleLPToken: (token: ERC20Token) => boolean;
+    static isPendleSyToken: (token: ERC20Token) => boolean;
+    static isPendleNativeToken: (token: ERC20Token) => boolean;
+    static isPendleToken: (token: ERC20Token) => boolean;
+    static isAaveToken: (token: ERC20Token) => boolean | undefined;
+    static isKinzaToken: (token: ERC20Token) => boolean;
+    static isProtocolToken: (token: ERC20Token, curveTokens: string[]) => boolean | undefined;
+}

package/data-structures/token-price-fetcher/index.d.mts

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

package/data-structures/transactions-manager/TransactionsManager.d.mts

@@ -0,0 +1,27 @@
+import { Contract } from 'ethers';
+import { DecodedTx, HashInfoByChain, RawTx } from '../../types';
+import { TransactionField } from './history/history.types';
+import { UserKeys } from '../crypto-keys';
+export declare class TransactionsManager {
+    readonly circuitSize: number;
+    hinkalContract: Contract;
+    init(hinkalContract: Contract): void;
+    requireInit(): void;
+    private filterOwnTransactions;
+    private saveTxsInStorage;
+    private loadTxsFromStorage;
+    getAllTransactions: (chainId: number, userKeys: UserKeys, week?: number, startWeek?: number) => Promise<RawTx[]>;
+    getHinkalHistoryBase: (chainId: number, userKeys: UserKeys, week?: number, includeOthersDeposits?: boolean, startWeek?: number) => Promise<DecodedTx[]>;
+    getHinkalHistory: (chainId: number, userKeys: UserKeys) => Promise<TransactionField[]>;
+    private sortInBatches;
+    private generateTransactionsProof;
+    private userVerifyTransactions;
+    private verifyTransactionsInBatches;
+    processAndSendTransactionsForVerification: (chainId: number, userKeys: UserKeys, ethereumAddress: string, latestCertifiedHash?: string, startWeek?: number) => Promise<{
+        trade: number;
+        transactions: number;
+        lockedDeposit: number;
+        verification: boolean;
+    }>;
+    multiProcessAndSendTransactionsForVerification: (userKeys: UserKeys, ethereumAddress: string, lastCertifiedHashes?: HashInfoByChain) => Promise<boolean>;
+}

package/data-structures/transactions-manager/history/getBeefyData.d.mts

@@ -0,0 +1,3 @@
+import { BeefyResult, PastTransaction } from './history.types';
+import { OnChainUtxo } from '../../../types';
+export declare const getBeefyData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => BeefyResult;

package/data-structures/transactions-manager/history/getConvexData.d.mts

@@ -0,0 +1,6 @@
+import { ConvexAction, OnChainUtxo } from '../../../types';
+import { ConvexStakeUnstake, PastTransaction, TransactionType } from './history.types';
+export declare const getConvexData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => ConvexStakeUnstake | {
+    type: TransactionType;
+    convexAction: ConvexAction;
+};

package/data-structures/transactions-manager/history/getCurveData.d.mts

@@ -0,0 +1,6 @@
+import { CurveAction, OnChainUtxo } from '../../../types';
+import { CurveDepositWithdrawResult, CurveStakeUnstake, PastTransaction, TransactionType } from './history.types';
+export declare const getCurveData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => CurveDepositWithdrawResult | CurveStakeUnstake | {
+    type: TransactionType;
+    curveAction: CurveAction;
+};

package/data-structures/transactions-manager/history/getDepositData.d.mts

@@ -0,0 +1,2 @@
+import { DepositResult, PastTransaction, WithdrawResult } from './history.types';
+export declare const getDepositData: (input: PastTransaction, chainId: number) => DepositResult | WithdrawResult;

package/data-structures/transactions-manager/history/getLidoData.d.mts

@@ -0,0 +1,10 @@
+import { ERC20Token, OnChainUtxo } from '../../../types';
+import { PastTransaction, TransactionType } from './history.types';
+export declare const getLidoData: (input: PastTransaction, utxosArray: OnChainUtxo[], chainId: number) => {
+    lidoToken: {
+        token: ERC20Token | undefined;
+        balance: bigint;
+    };
+    type: TransactionType;
+    lidoAction: any;
+};