@hinkal/common 0.2.10 → 0.2.11

package/constants/token-data/popularTokens.constants.d.mts

@@ -0,0 +1,3 @@
+export declare const PopularTokenSymbols: {
+    symbol: string;
+}[];

package/constants/token-data/tokenPricing.consts.d.mts

@@ -0,0 +1,5 @@
+export declare const urlForBeefyVaultTotalInUSD = "https://api.beefy.finance/tvl";
+export declare const urlForBeefyVaultTokens = "https://api.beefy.finance/vaults";
+export declare const urlForBeefyVaultLpTokens = "https://api.beefy.finance/lps";
+export declare const urlForRegularTokenPricesInBeefy = "https://api.beefy.finance/prices";
+export declare const urlForPendleAPI = "https://api-v2.pendle.finance/core/v1/";

package/constants/vite.constants.d.mts

@@ -0,0 +1,14 @@
+export declare const isNode: boolean;
+export declare const isWebpack: boolean;
+export declare enum DEPLOYMENT_MODE {
+    DEVELOPMENT = "development",
+    STAGING = "staging",
+    PLAYGROUND = "playground",
+    PRODUCTION = "production"
+}
+export declare const deploymentMode: DEPLOYMENT_MODE | undefined;
+export declare const isStaging: boolean;
+export declare const isPlayground: boolean;
+export declare const isDevelopment: boolean;
+export declare const isNotProduction: boolean;
+export declare const isNotClientProduction: boolean;

package/crypto/babyJub.d.mts

@@ -0,0 +1,16 @@
+declare class JubHolder {
+    private babyjub;
+    init(): Promise<void>;
+    getJub(): any;
+}
+export declare const jubHolder: JubHolder;
+export declare const babyJubInstance: () => any;
+export type JubPoint = [bigint, bigint];
+export interface BabyJubType {
+    mulPointEscalar: (point: [Uint8Array, Uint8Array], s: bigint) => [Uint8Array, Uint8Array];
+    F: {
+        toString: (arr: Uint8Array) => string;
+    };
+    Base8: [Uint8Array, Uint8Array];
+}
+export {};

package/crypto/index.d.mts

@@ -0,0 +1,3 @@
+export * from './poseidon';
+export * from './babyJub';
+export * from './preProcessing';

package/crypto/poseidon.d.mts

@@ -0,0 +1,15 @@
+declare class PoseidonHolder {
+    private poseidon;
+    init(): Promise<void>;
+    getPoseidon(): any;
+}
+export declare const poseidonHolder: PoseidonHolder;
+export declare function poseidonFunction<T = any>(...args: T[]): bigint;
+/**
+ * hashing algorithm implementation
+ * @param args rest parameter to take unlimited number of arguments
+ * @returns poseidon hash in base 16
+ */
+export declare const poseidonHash: (...args: unknown[]) => string;
+export type PoseidonHasher = (...args: unknown[]) => string;
+export {};

package/crypto/preProcessing.d.mts

@@ -0,0 +1 @@
+export declare const preProcessing: () => Promise<void>;

package/data-structures/Hinkal/Hinkal.d.mts

@@ -0,0 +1,100 @@
+import { ContractTransaction, ethers } from 'ethers';
+import { AxelarMigrationInfo } from '../../types/axelar.types';
+import { BeefyAction, ConvexAction, CurveAction, HinkalConfig, LidoAction, LidoVariant, VolatileHelperData } from '../../types/hinkal.types';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { HinkalStakeMode } from '../../types/hinkal.stake.types';
+import { type IMultiThreadedUtxoUtils } from '../../types/IMultiThreadedUtxoUtils';
+import { PendleLPMetadata, PendleMetadata } from '../../types/pendle.types';
+import { RelayerTransaction } from '../../types/relayer.types';
+import { SignatureData } from '../../types/crypto.types';
+import { TokenBalance } from '../../types/token.types';
+import { UserKeys } from '../crypto-keys/keys';
+import { ClientAccessTokenSnapshotService } from '../snapshot/ClientAccessTokenSnapshotService';
+import { ClientCommitmentsSnapshotService } from '../snapshot/ClientCommitmentsSnapshotService';
+import { ClientNullifierSnapshotService } from '../snapshot/ClientNullifierSnapshotService';
+import { IProviderAdapter } from '../provider-adapter/IProviderAdapter';
+import { type IHinkal } from './IHinkal';
+import { MerkleTree } from '../merkle-tree';
+import { IAPI } from '../../API';
+import { TransactionsManager } from '../transactions-manager';
+import { type ICacheDevice } from '../../types/ICacheDevice';
+export declare class Hinkal<ConnectorType> implements IHinkal {
+    private providerAdapter?;
+    userKeys: UserKeys;
+    readonly signingMessage: string;
+    merkleTreeHinkal: MerkleTree<bigint>;
+    merkleTreeAccessToken: MerkleTree<bigint>;
+    nullifiers: Set<string>;
+    encryptedOutputs: EncryptedOutputWithSign[];
+    commitmentsSnapshotService?: ClientCommitmentsSnapshotService;
+    nullifierSnapshotService?: ClientNullifierSnapshotService;
+    accessTokenSnapshotService?: ClientAccessTokenSnapshotService;
+    transactionsManager: TransactionsManager;
+    utxoUtils: IMultiThreadedUtxoUtils;
+    cacheDevice: ICacheDevice;
+    generateProofRemotely: boolean;
+    constructor(hinkalConfig?: HinkalConfig);
+    initProviderAdapter(connector: ConnectorType, providerAdapter: IProviderAdapter<ConnectorType>): Promise<void>;
+    initUserKeys(): Promise<void>;
+    initUserKeysWithPassword(password: string): Promise<void>;
+    resetMerkle(): Promise<void>;
+    getProviderAdapter(): IProviderAdapter<ConnectorType>;
+    waitForTransaction(transactionHash: string, confirmations?: number): Promise<boolean>;
+    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+    getContract(contractType: ContractType, contractAddress?: undefined, chainId?: number): ethers.Contract;
+    getContractWithFetcherByChainId(chainId: number, contractType: ContractType, contractAddress?: undefined): ethers.Contract;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    getContractWithSigner(contract: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, address: string): ethers.Contract;
+    isSelectedNetworkSupported(): boolean;
+    switchNetwork(network: EthereumNetwork): Promise<void>;
+    getCurrentChainId(): number;
+    getSelectedNetwork(): EthereumNetwork | undefined;
+    isPermitterAvailable(): boolean;
+    connectAndPatchProvider(connector: ConnectorType): Promise<number>;
+    disconnectFromConnector(): Promise<void>;
+    updateProviderAdapter(providerAdapter: IProviderAdapter): Promise<void>;
+    setListeners(): Promise<void>;
+    private onAccountChanged;
+    private onChainChanged;
+    monitorConnectedAddress(): Promise<void>;
+    getBalances(): Promise<TokenBalance[]>;
+    getSupportedPassportLinks(): string[];
+    checkAccessToken(): Promise<boolean>;
+    getAxelarEstimate(chainId: number, sourceChainName: string, destChainName: string, sourceChainToken: string): Promise<import('../../API/getAxelarGasEstimate').AxelarGasResponse>;
+    getConnextReceiveFee(sourceChainName: string, destChainName: string): Promise<import('../../types/connext.types').ConnextFeeResponse>;
+    mintHinkalAccessToken(signatureData: SignatureData): Promise<ethers.ContractTransaction>;
+    mintHinkalAccessTokenCrossChain(signatureData: SignatureData, axelarMigrationInfos: AxelarMigrationInfo[]): Promise<ethers.ContractTransaction>;
+    getHinkalTreeRootHash(): Promise<any>;
+    getAccessTokenTreeRootHash(): Promise<any>;
+    resetMerkleTreesIfNecessary(): Promise<void>;
+    getEventsFromHinkal(): Promise<void>;
+    getEthereumAddress(): Promise<string>;
+    getRandomRelay(): Promise<string | undefined>;
+    getGasPrice(): Promise<bigint>;
+    getAPI(): IAPI;
+    resetCache(): void;
+    snapshotsClearInterval(): void;
+    getRecipientInfo(): string;
+    deposit(erc20Addresses: string[], amountChanges: bigint[]): Promise<ethers.ContractTransaction>;
+    depositForOther(erc20Addresses: string[], amountChanges: bigint[], recipientInfo: string): Promise<ethers.ContractTransaction>;
+    withdraw(erc20Addresses: string[], amountChanges: bigint[], recipientAddress: string, isRelayerOff: boolean, onlyGasEstimate?: boolean): Promise<ethers.ContractTransaction | RelayerTransaction | bigint>;
+    swap(erc20Addresses: string[], amountChanges: bigint[], externalActionId: ExternalActionId, swapData: string, onlyGasEstimate?: boolean, withPrivateMempool?: boolean): Promise<RelayerTransaction | bigint>;
+    actionCurve(tokens: string[], tokenAmounts: bigint[], poolAddress: string, curveAction: CurveAction, newVersion: boolean, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionConvex(tokens: string[], tokenAmounts: bigint[], poolId: number, convexAction: ConvexAction, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionBeefy(tokens: string[], tokenAmounts: bigint[], beefyAction: BeefyAction, oneInchData: string[], zapAddress: string, boostAddress: string | undefined, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionLido(lidoVariant: LidoVariant, lidoAction: LidoAction, tokens: string[], tokenAmounts: bigint[], tokenIds: number[], onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionPendle(erc20Addresses: string[], amountChanges: bigint[], pendleMetadata: PendleMetadata, gasTokenAddress?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | ContractTransaction | bigint>;
+    actionPendleLP(erc20Addresses: string[], amountChanges: bigint[], pendleLPMetadata: PendleLPMetadata, gasTokenAddress?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionVolatile(erc20Addresses: string[], amountChanges: bigint[], volatileHelperData: VolatileHelperData, onlyGasEstimate?: boolean): Promise<RelayerTransaction | ContractTransaction | bigint>;
+    actionStake(erc20Addresses: string[], amountChanges: bigint[], stakeMode: HinkalStakeMode, stakedTokenRecipient: string): Promise<ContractTransaction>;
+    actionPrivateWallet(erc20Addresses: string[], amountChanges: bigint[], onChainCreation: boolean[], ops?: string[], walletNonce?: bigint, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    getPendleLPClaimableParams(wlpTokenAddress: string, wlpTokenBalance: bigint): Promise<{
+        amount: bigint;
+        timestamp: string;
+    }>;
+}

package/data-structures/Hinkal/IHinkal.d.mts

@@ -0,0 +1,93 @@
+import { AxelarMigrationInfo } from '../../types/axelar.types';
+import { BeefyAction, ConvexAction, CurveAction, LidoAction, LidoVariant, VolatileHelperData } from '../../types/hinkal.types';
+import { ContractMetadata, ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { HinkalStakeMode } from '../../types/hinkal.stake.types';
+import { type IMultiThreadedUtxoUtils } from '../../types/IMultiThreadedUtxoUtils';
+import { PendleLPMetadata, PendleMetadata } from '../../types/pendle.types';
+import { RelayerTransaction } from '../../types/relayer.types';
+import { SignatureData } from '../../types/crypto.types';
+import { TokenBalance } from '../../types/token.types';
+import { Bytes, ContractTransaction, ethers } from 'ethers';
+import { type UserKeys } from '../crypto-keys/keys';
+import { IProviderAdapter } from '../provider-adapter/IProviderAdapter';
+import { ClientAccessTokenSnapshotService } from '../snapshot/ClientAccessTokenSnapshotService';
+import { ClientCommitmentsSnapshotService } from '../snapshot/ClientCommitmentsSnapshotService';
+import { ClientNullifierSnapshotService } from '../snapshot/ClientNullifierSnapshotService';
+import { MerkleTree } from '../merkle-tree';
+import { TransactionsManager } from '../transactions-manager/TransactionsManager';
+import { IAPI } from '../../API/API';
+import { AxelarGasResponse } from '../../API/getAxelarGasEstimate';
+import { type ICacheDevice } from '../../types/ICacheDevice';
+export interface IHinkal<ConnectorType = unknown> {
+    userKeys: UserKeys;
+    readonly signingMessage: string;
+    merkleTreeHinkal: MerkleTree<bigint>;
+    merkleTreeAccessToken: MerkleTree<bigint>;
+    nullifiers: Set<string>;
+    encryptedOutputs: EncryptedOutputWithSign[];
+    commitmentsSnapshotService?: ClientCommitmentsSnapshotService;
+    nullifierSnapshotService?: ClientNullifierSnapshotService;
+    accessTokenSnapshotService?: ClientAccessTokenSnapshotService;
+    transactionsManager: TransactionsManager;
+    generateProofRemotely: boolean;
+    utxoUtils: IMultiThreadedUtxoUtils;
+    cacheDevice: ICacheDevice;
+    getBalances(): Promise<TokenBalance[]>;
+    getSupportedPassportLinks(): string[];
+    checkAccessToken(): Promise<boolean>;
+    getAxelarEstimate(chainId: number, sourceChainName: string, destChainName: string, sourceChainToken: string): Promise<AxelarGasResponse>;
+    getEthereumAddress(): Promise<string>;
+    resetMerkleTreesIfNecessary(): Promise<void>;
+    resetMerkle(): Promise<void>;
+    getEventsFromHinkal(): Promise<void>;
+    mintHinkalAccessToken(signatureData: SignatureData): Promise<ethers.ContractTransaction>;
+    mintHinkalAccessTokenCrossChain(signatureData: SignatureData, axelarMigrationInfos: AxelarMigrationInfo[]): Promise<ethers.ContractTransaction>;
+    getRandomRelay(): Promise<string | undefined>;
+    getGasPrice(): Promise<bigint>;
+    getAPI(): IAPI;
+    resetCache(): void;
+    snapshotsClearInterval(): void;
+    getRecipientInfo(): string;
+    deposit(erc20Addresses: string[], amountChanges: bigint[]): Promise<ethers.ContractTransaction>;
+    depositForOther(erc20Addresses: string[], amountChanges: bigint[], recepinetInfo: string): Promise<ethers.ContractTransaction>;
+    withdraw(erc20Addresses: string[], amountChanges: bigint[], recipientAddress: string, isRelayerOff: boolean, onlyGasEstimate?: boolean): Promise<ethers.ContractTransaction | RelayerTransaction | bigint>;
+    swap(erc20Addresses: string[], amountChanges: bigint[], externalActionId: ExternalActionId, swapData: string, onlyGasEstimate?: boolean, withPrivateMempool?: boolean): Promise<RelayerTransaction | bigint>;
+    actionCurve(tokens: string[], tokenAmounts: bigint[], poolAddress: string, curveAction: CurveAction, newVersion: boolean, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionConvex(tokens: string[], tokenAmounts: bigint[], poolId: number, convexAction: ConvexAction, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionBeefy(tokens: string[], tokenAmounts: bigint[], beefyAction: BeefyAction, oneInchData: string[], zapAddress: string, boostAddress: string | undefined, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionStake(erc20Addresses: string[], amountChanges: bigint[], stakeMode: HinkalStakeMode, stakedTokenRecipient: string): Promise<ethers.ContractTransaction>;
+    getProviderAdapter(): IProviderAdapter;
+    initUserKeys(): Promise<void>;
+    initUserKeysWithPassword(password: string): Promise<void>;
+    initProviderAdapter(connector: ConnectorType, providerAdapter: IProviderAdapter<ConnectorType>): Promise<void>;
+    connectAndPatchProvider(connector: ConnectorType): Promise<number>;
+    disconnectFromConnector(): Promise<void>;
+    updateProviderAdapter(providerAdapter: IProviderAdapter): Promise<void>;
+    setListeners(providerAdapter: IProviderAdapter): Promise<void>;
+    waitForTransaction(transactionHash: string, confirmations?: number): Promise<boolean>;
+    getContractMetadata(contractType: ContractType, chainId?: number): ContractMetadata;
+    getContract(contract: ContractType, contractAddress?: string, chainId?: number): ethers.Contract;
+    getContractWithSigner(contract: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcher(contract: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcherByChainId(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcherForEthereum(contract: ContractType, contractAddress?: string): ethers.Contract;
+    isSelectedNetworkSupported(): boolean;
+    switchNetwork(network: EthereumNetwork): Promise<unknown>;
+    getCurrentChainId(): number;
+    monitorConnectedAddress(): Promise<void>;
+    getSelectedNetwork(): EthereumNetwork | undefined;
+    isPermitterAvailable(): boolean;
+    signMessage(message: Bytes | string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    actionLido(lidoVariant: LidoVariant, lidoAction: LidoAction, tokens: string[], tokenAmounts: bigint[], tokenIds: number[], onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionPendle(erc20Addresses: string[], amountChanges: bigint[], pendleMetadata: PendleMetadata, gasTokenAddress?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | ContractTransaction | bigint>;
+    actionPendleLP(erc20Addresses: string[], amountChanges: bigint[], pendleLPMetadata: PendleLPMetadata, gasTokenAddress?: string, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    actionVolatile(erc20Addresses: string[], amountChanges: bigint[], volatileHelperData: VolatileHelperData, onlyGasEstimate?: boolean): Promise<RelayerTransaction | ContractTransaction | bigint>;
+    actionPrivateWallet(erc20Addresses: string[], amountChanges: bigint[], onChainCreation: boolean[], ops: string[], walletNonce?: bigint, onlyGasEstimate?: boolean): Promise<RelayerTransaction | bigint>;
+    getPendleLPClaimableParams(wlpTokenAddress: string, wlpTokenBalance: bigint): Promise<{
+        amount: bigint;
+        timestamp: string;
+    }>;
+}

package/data-structures/Hinkal/hinkalActionBeefy.d.mts

@@ -0,0 +1,3 @@
+import { BeefyAction } from '../../types/hinkal.types';
+import { IHinkal } from './IHinkal';
+export declare const hinkalActionBeefy: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], beefyAction: BeefyAction, oneInchData: string[], zapAddress: string, boostAddress: string | undefined, onlyGasEstimate?: boolean) => Promise<bigint | import('../../index.ts').RelayerTransaction>;

package/data-structures/Hinkal/hinkalActionConvex.d.mts

@@ -0,0 +1,12 @@
+import { ConvexAction } from '../../types/hinkal.types';
+import { IHinkal } from './IHinkal';
+/**
+ *
+ * @param hinkal hinkal class instance
+ * @param tokenAddresses addresses of the tokenAddresses
+ * @param tokenAmounts token amounts
+ * @param minMintAmount LP Token amount
+ * @param poolAddress curve pool address
+ * @returns await transaction object
+ */
+export declare const hinkalActionConvex: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], poolId: number, convexAction: ConvexAction, onlyGasEstimate?: boolean) => Promise<bigint | import('../../index.ts').RelayerTransaction>;

package/data-structures/Hinkal/hinkalActionCurve.d.mts

@@ -0,0 +1,12 @@
+import { CurveAction } from '../../types/hinkal.types';
+import { IHinkal } from './IHinkal';
+/**
+ *
+ * @param hinkal hinkal class instance
+ * @param tokenAddresses addresses of the tokenAddresses
+ * @param tokenAmounts token amounts
+ * @param minMintAmount LP Token amount
+ * @param poolAddress curve pool address
+ * @returns await transaction object
+ */
+export declare const hinkalActionCurve: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], poolAddress: string, curveAction: CurveAction, newVersion: boolean, onlyGasEstimate?: boolean) => Promise<bigint | import('../../index.ts').RelayerTransaction>;

package/data-structures/Hinkal/hinkalActionLidoEth.d.mts

@@ -0,0 +1,4 @@
+import { LidoAction, LidoVariant } from '../../types/hinkal.types';
+import { RelayerTransaction } from '../../types/relayer.types';
+import { IHinkal } from './IHinkal';
+export declare const hinkalActionLido: (hinkal: IHinkal, lidoVariant: LidoVariant, lidoAction: LidoAction, erc20Addresses: string[], amountChanges: bigint[], tokenIds: number[], onlyGasEstimate?: boolean) => Promise<RelayerTransaction | bigint>;

package/data-structures/Hinkal/hinkalActionPendle.d.mts

@@ -0,0 +1,3 @@
+import { PendleMetadata } from '../../types/pendle.types';
+import { IHinkal } from './IHinkal';
+export declare const hinkalActionPendle: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], pendleMetadata: PendleMetadata, gasTokenAddress?: string, onlyGasEstimate?: boolean) => Promise<any>;

package/data-structures/Hinkal/hinkalActionPendleLP.d.mts

@@ -0,0 +1,7 @@
+import { PendleLPMetadata } from '../../types';
+import { IHinkal } from './IHinkal';
+export declare const hinkalActionPendleLP: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], pendleLPMetadata: PendleLPMetadata, gasTokenAddress?: string, onlyGasEstimate?: boolean) => Promise<bigint | import('../../types/relayer.types').RelayerTransaction>;
+export declare const hinkalGetPendleLPClaimableParams: (hinkal: IHinkal, wlpTokenAddress: string, wlpTokenBalance: bigint) => Promise<{
+    amount: bigint;
+    timestamp: string;
+}>;

package/data-structures/Hinkal/hinkalActionStake.d.mts

@@ -0,0 +1,3 @@
+import { IHinkal } from './IHinkal';
+import { HinkalStakeMode } from '../../types';
+export declare const hinkalActionStake: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], stakeMode: HinkalStakeMode, stakedTokenRecipient: string) => Promise<any>;

package/data-structures/Hinkal/hinkalActionVolatile.d.mts

@@ -0,0 +1,3 @@
+import { IHinkal } from './IHinkal';
+import { VolatileHelperData } from '../../types/hinkal.types';
+export declare const hinkalActionVolatile: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], volatileHelperData: VolatileHelperData, onlyGasEstimate: boolean) => Promise<any>;

package/data-structures/Hinkal/hinkalDeposit.d.mts

@@ -0,0 +1,3 @@
+import { IHinkal } from './IHinkal';
+export declare const hinkalDeposit: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[]) => Promise<any>;
+export declare const hinkalDepositForOther: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], recipinetInfo: string) => Promise<any>;

package/data-structures/Hinkal/hinkalGetRecipientInfo.d.mts

@@ -0,0 +1,2 @@
+import { IHinkal } from './IHinkal';
+export declare const getRecipientInfo: (hinkal: IHinkal) => string;

package/data-structures/Hinkal/hinkalGetZkMeProvider.d.mts

@@ -0,0 +1,3 @@
+import { type Provider } from '@zkmelabs/widget';
+import { IHinkal } from './IHinkal';
+export declare const getHinkalZkMeProvider: (hinkal: IHinkal) => Provider;

package/data-structures/Hinkal/hinkalPrivateWallet.d.mts

@@ -0,0 +1,2 @@
+import { IHinkal } from './IHinkal';
+export declare const hinkalPrivateWallet: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], onChainCreation: boolean[], ops?: string[], walletNonce?: bigint, onlyGasEstimate?: boolean) => Promise<bigint | import('../../index.ts').RelayerTransaction>;

package/data-structures/Hinkal/hinkalSwap.d.mts

@@ -0,0 +1,3 @@
+import { ExternalActionId } from '../../types/external-action.types';
+import { IHinkal } from './IHinkal';
+export declare const hinkalSwap: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], externalActionId: ExternalActionId, data: string, onlyGasEstimate?: boolean, withPrivateMempool?: boolean) => Promise<bigint | import('../../index.ts').RelayerTransaction>;

package/data-structures/Hinkal/hinkalTransfer.d.mts

@@ -0,0 +1 @@
+export declare const hinkalTransfer: () => Promise<void>;

package/data-structures/Hinkal/hinkalWithdraw.d.mts

@@ -0,0 +1,2 @@
+import { IHinkal } from './IHinkal';
+export declare const hinkalWithdraw: (hinkal: IHinkal, erc20Addresses: string[], amountChanges: bigint[], recipientAddress: string, isRelayerOff: boolean, onlyGasEstimate?: boolean) => Promise<any>;

package/data-structures/Hinkal/index.d.mts

@@ -0,0 +1,12 @@
+export * from './Hinkal';
+export * from './IHinkal';
+export * from './hinkalActionBeefy';
+export * from './hinkalActionConvex';
+export * from './hinkalActionCurve';
+export * from './hinkalActionPendle';
+export * from './hinkalDeposit';
+export * from './hinkalSwap';
+export * from './hinkalTransfer';
+export * from './hinkalWithdraw';
+export * from './hinkalPrivateWallet';
+export * from './resetMerkleTrees';

package/data-structures/Hinkal/resetMerkleTrees.d.mts

@@ -0,0 +1,2 @@
+import { IHinkal } from './IHinkal';
+export declare const resetMerkleTrees: (hinkal: IHinkal) => Promise<void>;

package/data-structures/MultiThreadedUtxoUtils/MultiThreadedUtxoUtils.d.mts

@@ -0,0 +1,20 @@
+import { EncryptedOutputWithSign, OutputsWithSignAndLast } from '../../types/commitments.types';
+import { IMultiThreadedUtxoUtils } from '../../types/IMultiThreadedUtxoUtils';
+import { UserKeys } from '../crypto-keys/keys';
+import { Utxo } from '../utxo/Utxo';
+declare global {
+    interface Navigator {
+        deviceMemory: number | undefined;
+    }
+}
+export declare class MultiThreadedUtxoUtils implements IMultiThreadedUtxoUtils {
+    readonly NUM_WORKERS: number;
+    readonly NUM_WORKERS_BATCH_PROCESS: number;
+    constructor();
+    private createUtxoPromise;
+    batchFilterUtxosWithNullifier(allUtxos: Utxo[], nullifiers: Set<string>): Promise<Utxo[]>;
+    buildBatchProcess(encryptedOutputs: EncryptedOutputWithSign[], userKeys: UserKeys): Promise<Utxo[]>;
+    sliceArrayIntoParts<T>(arr: T[], numberOfParts: number): T[][];
+    findLastOutput(lastOutputsArray: string[], lastOutput: string): string;
+    batchProcess(encryptedOutputs: EncryptedOutputWithSign[], lastOutput: string, userKeys: UserKeys): Promise<OutputsWithSignAndLast<boolean>>;
+}

package/data-structures/ValueCache/ValueCache.d.mts

@@ -0,0 +1,10 @@
+export declare class ValueCache<T> {
+    constructor(timeoutInMs: number);
+    protected timeoutInMs: number;
+    values: {
+        [key: string]: T;
+    };
+    private setTimer;
+    private onTimeout;
+    clear(): void;
+}

package/data-structures/ValueCache/index.d.mts

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

package/data-structures/cacheDevices/BaseCacheDevice.d.mts

@@ -0,0 +1,8 @@
+import { ICacheDevice } from '../../types/ICacheDevice';
+export declare abstract class BaseCacheDevice implements ICacheDevice {
+    protected inMemoryCache: Map<string, string>;
+    protected getInMemory(key: string): string | undefined;
+    protected setInMemory(key: string, value: string): void;
+    abstract get(key: string): string | undefined;
+    abstract set(key: string, value: string): void;
+}

package/data-structures/cacheDevices/FileCacheDevice.d.mts

@@ -0,0 +1,9 @@
+import { BaseCacheDevice } from './BaseCacheDevice';
+export declare class FileCacheDevice extends BaseCacheDevice {
+    private filePath;
+    private useFileCache;
+    constructor(useFileCache: boolean | undefined, filePath: string);
+    private readFileFromDevice;
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+}

package/data-structures/cacheDevices/LocalStorageCacheDevice.d.mts

@@ -0,0 +1,7 @@
+import { BaseCacheDevice } from './BaseCacheDevice';
+export declare class LocalStorageCacheDevice extends BaseCacheDevice {
+    private localDataStorage;
+    constructor();
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+}

package/data-structures/cacheDevices/index.d.mts

@@ -0,0 +1,2 @@
+export * from './FileCacheDevice';
+export * from './LocalStorageCacheDevice';

package/data-structures/crypto-keys/decodeUTXO.d.mts

@@ -0,0 +1,14 @@
+import { IUtxoConstructor, Utxo } from '../utxo/Utxo';
+export declare const abiDecodeUtxo: (encryptedOutput: string) => {
+    amount: bigint;
+    erc20TokenAddress: string;
+    randomization: bigint;
+    stealthAddress: string;
+    H0: bigint;
+    H1: bigint;
+    timeStamp: string;
+    tokenId: number;
+};
+export declare const decodeUtxoConstructorArgs: (encryptedOutput: string, privateKey: string) => IUtxoConstructor;
+export declare const decodeUtxo: (encryptedOutput: string, privateKey: string) => Utxo;
+export declare const checkUtxoSignature: (encryptedOutput: string, privateKey: string) => boolean;

package/data-structures/crypto-keys/encryptDecryptUtxo.d.mts

@@ -0,0 +1,18 @@
+import { IUtxoConstructor, Utxo } from '../utxo/Utxo';
+import { UserKeys } from './keys';
+/**
+ * encrypt data for the UTXO
+ * @param amount UTXO amount
+ * @param blinding UTXO blinding
+ * @param publicKey sender's encryption public key
+ * @returns returns encrypted data {Uint8Array}
+ */
+export declare const encryptUtxo: (utxo: Utxo, forceZeroAmount: boolean) => Uint8Array;
+export declare const decryptUtxoConstructorArgs: (encryptedData: Uint8Array, userKeys: UserKeys) => IUtxoConstructor;
+/**
+ * decrypt UTXO data from events
+ * @param encryptedData encrypted UTXO data {Uint8Array}
+ * @param publicKey/privateKey sender's encryption keys
+ * @returns decrypted UTXO data Object {amount, blinding}
+ */
+export declare const decryptUtxo: (encryptedData: Uint8Array, userKeys: UserKeys) => Utxo;

package/data-structures/crypto-keys/index.d.mts

@@ -0,0 +1,4 @@
+export * from './decodeUTXO';
+export * from './encryptDecryptUtxo';
+export * from './keys';
+export * from './keyUtils';

package/data-structures/crypto-keys/keyUtils.d.mts

@@ -0,0 +1,2 @@
+export declare const isCircomNegative: (n: bigint) => boolean;
+export declare const getCircomSign: (n: bigint) => 0n | 1n;

package/data-structures/crypto-keys/keys.d.mts

@@ -0,0 +1,58 @@
+import { JubPoint } from '../../crypto/babyJub';
+export interface EncryptionKeyPair {
+    privateKey: string;
+    publicKey: string;
+}
+export declare const EncryptionKeyPairDefaultValue: EncryptionKeyPair;
+export declare class UserKeys {
+    private signature;
+    constructor(_signature?: string);
+    getSignature(): string;
+    setSignature(_signature: string): void;
+    private requireSignature;
+    verifyMessage(signingMessage: string): string;
+    /**
+     * get shielded private key from message signature used to login to the application,
+     * this private key is used to generate encryption keypairs as well as public key
+     * @retuns 0x-prefixed shielded private key
+     */
+    getShieldedPrivateKey: () => string;
+    /**
+     * generate shielded public key from private key
+     * @param privateKey the key used to generate the shielded public key, this should be the signature
+     * that the user provided
+     * @retuns shielded public key in hexstring with 0x prefixed
+     */
+    getShieldedPublicKey: () => string;
+    /**
+     * generate access token, this accessKey is what should be sent to the server for signing
+     * @returns accessKey in hexstring with 0x prefixed
+     */
+    getAccessKey: () => string;
+    getWalletSalt: (walletNonce: bigint) => string;
+    /**
+     * generate backend token, which is used for access control on backend
+     * @returns accessKey in hexstring with 0x prefixed
+     */
+    getBackendToken: () => string;
+    static getRandomizedStealthPair: (s: bigint, privateKey: string) => {
+        H0: JubPoint;
+        H1: JubPoint;
+    };
+    static getStealthAddressCompressedPoints: (s: bigint, privateKey: string) => {
+        h0: bigint;
+        h1: bigint;
+    };
+    static getStealthAddress: (s: bigint, privateKey: string) => string;
+    static getStealthAddressWithEKey: (s: bigint, privateKey: string) => {
+        stealthAddress: string;
+        encryptionKey: string;
+    };
+    static checkSignature: (s: bigint, stealthAddressH0: bigint, stealthAddressH1: bigint, privateKey: string) => boolean;
+    /**
+     * generate private and public keypair
+     * @param seed seed to use to deterministically generate key, must be in DataHexString format
+     * and must correspond to 32 bytes
+     */
+    static getEncryptionKeyPair: (privateKey: string) => EncryptionKeyPair;
+}

package/data-structures/custom-token-registry/CustomTokenRegistry.d.mts

@@ -0,0 +1,13 @@
+import { ERC20Token } from '../../types/token.types';
+declare class CustomTokenRegistry {
+    private localStorageKey;
+    tokenRegistry: ERC20Token[];
+    constructor();
+    private persistRegistry;
+    getCustomTokens(chainId: number): ERC20Token[];
+    tokenExists(registry: ERC20Token[], tokenToCheck: ERC20Token): ERC20Token | undefined;
+    addCustomToken(token: ERC20Token): void;
+    removeCustomToken(tokenToRemove: ERC20Token): void;
+}
+export declare const customTokenRegistry: CustomTokenRegistry;
+export {};

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

@@ -0,0 +1,35 @@
+import { ethers } from 'ethers';
+import { MerkleTree, MerkleTreeJson } from '../merkle-tree';
+import { AccessTokenEvent } from '../../types';
+import { AbstractSnapshotService, Snapshot } from './AbstractSnapshotService';
+export type SenderAddressIndexMapJson = {
+    address: string;
+    index: number;
+}[];
+export type AccessTokenSnapshotPayload = {
+    readonly merkleTree: MerkleTree<bigint>;
+    readonly senderAddresses: string[];
+    readonly senderAddressIndexMap: Map<string, number>;
+};
+export type AccessTokenSerializedSnapshot = {
+    latestBlockNumber?: number;
+    reserveBlockNumber?: number;
+    merkleTree?: MerkleTreeJson;
+    senderAddresses?: string[];
+    senderAddressIndexMap?: SenderAddressIndexMapJson;
+};
+export declare abstract class AbstractAccessTokenSnapshotService extends AbstractSnapshotService<AccessTokenEvent<bigint>, AccessTokenEvent, AccessTokenSnapshotPayload, AccessTokenSerializedSnapshot> {
+    constructor(contract: ethers.Contract, initialBlockNumber: number, isServer: boolean, maxPageSize?: number);
+    private _merkleTree;
+    private _senderAddresses;
+    private _senderAddressIndexMap;
+    get merkleTree(): MerkleTree<bigint>;
+    get senderAddresses(): string[];
+    get senderAddressIndexMap(): Map<string, number>;
+    protected serializeSnapshot(snapshot: Snapshot<AccessTokenSnapshotPayload>): AccessTokenSerializedSnapshot;
+    protected deserializeSnapshot(serializedSnapshot: AccessTokenSerializedSnapshot): Snapshot<AccessTokenSnapshotPayload>;
+    protected acceptEvent(event: AccessTokenEvent<bigint>, _blockNumber: number): boolean;
+    protected mapEvent(event: AccessTokenEvent): AccessTokenEvent<bigint>;
+    protected getSnapshotPayload(): AccessTokenSnapshotPayload;
+    protected populateSnapshot({ payload: { merkleTree, senderAddresses, senderAddressIndexMap }, }: Snapshot<AccessTokenSnapshotPayload>): void;
+}