@hinkal/common 0.2.11 → 0.2.12

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

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

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

@@ -1,5 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

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

package/crypto/poseidon.d.mts

@@ -1,15 +0,0 @@
-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

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

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

@@ -1,100 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

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

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

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

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

@@ -1,2 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

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

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

@@ -1,2 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

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

@@ -1,20 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

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

@@ -1,8 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

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

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

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

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

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

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

@@ -1,58 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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;
-}