@gurge/sdk 0.3.5 → 0.3.7

package/common/src/data-structures/Hinkal/hinkalActionReceive.d.ts

@@ -0,0 +1,7 @@
+import { IHinkal } from './IHinkal';
+import { FeeStructure } from '../../types/hinkal.types';
+import { ERC20Token } from '../../types/token.types';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const hinkalActionReceive: (hinkal: IHinkal, erc20Tokens: ERC20Token[], deltaAmountsBase: bigint[], // should be positive
+feeToken?: string, feeStructureOverride?: FeeStructure, subAccount?: SubAccount, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalClaimUtxo.d.ts

@@ -0,0 +1,5 @@
+import { ERC20Token } from '../../types/token.types';
+import { IHinkal } from './IHinkal';
+import { FeeStructure } from '../../types/hinkal.types';
+import { Utxo } from '../utxo/Utxo';
+export declare const hinkalClaimUtxo: (hinkal: IHinkal, erc20Token: ERC20Token, utxo: Utxo, feeStructureOverride?: FeeStructure, claimableSignature?: string) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalDeposit.d.ts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+import { Types as TronWebTypes } from 'tronweb';
+import { IHinkal } from './IHinkal';
+import { AdminTransactionType, ERC20Token } from '../../types';
+export declare const hinkalDeposit: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[], preEstimateGas?: boolean, returnTxData?: boolean) => Promise<ethers.TransactionResponse | ethers.TransactionRequest | string | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+export declare const hinkalDepositForOther: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[], recipientInfo: string, preEstimateGas?: boolean, returnTxData?: boolean, action?: AdminTransactionType) => Promise<ethers.TransactionResponse | ethers.TransactionRequest | string | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;

package/common/src/data-structures/Hinkal/hinkalDepositAndBridge.d.ts

@@ -0,0 +1,4 @@
+import { IHinkal } from './IHinkal';
+import { AdminTransactionType, BridgeRecipient, ERC20Token } from '../../types';
+import { FeeStructure } from '../../types/hinkal.types';
+export declare const hinkalDepositAndBridge: (hinkal: IHinkal, erc20Token: ERC20Token, recipients: BridgeRecipient[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, ref?: string, action?: AdminTransactionType, dashboardAccountId?: string, preEstimateGas?: boolean) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalDepositAndWithdraw.d.ts

@@ -0,0 +1,6 @@
+import { IHinkal } from './IHinkal';
+import { AdminTransactionType, ERC20Token, RecipientUtxo } from '../../types';
+import { FeeStructure } from '../../types/hinkal.types';
+export declare const hinkalWithdrawBatch: (hinkal: IHinkal, chainId: number, erc20Token: ERC20Token, userDepositedUtxos: RecipientUtxo[], recipientAmounts: bigint[], feeStructure: FeeStructure, hashedEthereumAddress: string, statusId: string | undefined, txCompletionTime?: number, ref?: string, action?: AdminTransactionType, hashedDashboardAccountId?: string) => Promise<string>;
+export declare const hinkalDepositAndWithdraw: (hinkal: IHinkal, erc20Token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, // Should be passed fee for only one withdraw transaction, multiplication happening in this function
+ref?: string, action?: AdminTransactionType, dashboardAccountId?: string, preEstimateGas?: boolean) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalDepositOnChainUtxos.d.ts

@@ -0,0 +1,8 @@
+import { IHinkal } from './IHinkal';
+import { ERC20Token, RecipientUtxo } from '../../types';
+import { FeeStructure } from '../../types/hinkal.types';
+export declare const hinkalDepositOnChainUtxos: (hinkal: IHinkal, chainId: number, erc20Token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], feeStructure: FeeStructure, hashedEthereumAddress: string, preEstimateGas?: boolean) => Promise<{
+    userDepositedUtxos: RecipientUtxo[];
+    statusId?: string;
+    depositTxHash: string;
+}>;

package/common/src/data-structures/Hinkal/hinkalGetRecipientInfo.d.ts

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

package/common/src/data-structures/Hinkal/hinkalGetZkMeProvider.d.ts

@@ -0,0 +1,28 @@
+import { IHinkal } from './IHinkal';
+export type ZkMeTransactionRequest = {
+    type: null | number;
+    from: string;
+    to: string;
+    data: string;
+    chainId: string;
+    gasLimit: string;
+    gasPrice: string;
+    maxFeePerGas: string | null;
+    maxPriorityFeePerGas: string | null;
+};
+export declare const getHinkalZkMeProvider: (hinkal: IHinkal) => {
+    getAccessToken(): Promise<any>;
+    getUserAccounts(): Promise<string[]>;
+    delegateTransaction(tx: ZkMeTransactionRequest): Promise<string>;
+};
+export type ZkMeProvider = ReturnType<typeof getHinkalZkMeProvider>;
+export type ZkMeWidgetMessageBody = {
+    id?: string;
+    channelId: string;
+    method?: 'getUserAccounts' | 'delegateTransaction' | 'signMessage' | 'getAccessToken';
+    params?: ZkMeTransactionRequest | string;
+    kycResults?: 'matching' | 'mismatch';
+    verifiedAddress?: string;
+    event?: 'close' | 'finished';
+    email?: string;
+};

package/common/src/data-structures/Hinkal/hinkalMultiSend.d.ts

@@ -0,0 +1,3 @@
+import { IHinkal } from './IHinkal';
+import { ERC20Token } from '../../types/token.types';
+export declare const hinkalMultiSendPrivateRecipients: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amounts: bigint[], extendedRecipientInfos?: string[]) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalNearDepositAndBridge.d.ts

@@ -0,0 +1,6 @@
+import { AdminTransactionType } from '../../types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { NearBridgeParams, NearBridgeResult } from '../../types/near-intents.types';
+import { ERC20Token } from '../../types/token.types';
+import { IHinkal } from './IHinkal';
+export declare const hinkalNearDepositAndBridge: (hinkal: IHinkal, token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], params: NearBridgeParams, txCompletionTime?: number, feeStructureOverride?: FeeStructure, ref?: string, action?: AdminTransactionType, dashboardAccountId?: string) => Promise<NearBridgeResult>;

package/common/src/data-structures/Hinkal/hinkalPalEvmDeposit.d.ts

@@ -0,0 +1,9 @@
+import { ethers } from 'ethers';
+import { IHinkal } from './IHinkal';
+import { ERC20Token } from '../../types';
+import { FeeStructure } from '../../types/hinkal.types';
+export type PalEvmDepositPrepareResult = {
+    unsignedTx: ethers.TransactionRequest;
+    utxoAmounts: bigint[];
+};
+export declare const hinkalPalEvmDepositPrepare: (hinkal: IHinkal, chainId: number, token: ERC20Token, recipientAmounts: bigint[], feeStructure: FeeStructure, orderId: string) => Promise<PalEvmDepositPrepareResult>;

package/common/src/data-structures/Hinkal/hinkalPalSolanaDepositPrepare.d.ts

@@ -0,0 +1,9 @@
+import { VersionedTransaction } from '@solana/web3.js';
+import { FeeStructure } from '../../types/hinkal.types';
+import { ERC20Token } from '../../types/token.types';
+import { IHinkal } from './IHinkal';
+export type PalSolanaDepositPrepareResult = {
+    unsignedTx: VersionedTransaction;
+    utxoAmounts: bigint[];
+};
+export declare const hinkalPalSolanaDepositPrepare: (hinkal: IHinkal, chainId: number, token: ERC20Token, recipientAmounts: bigint[], feeStructure: FeeStructure, orderId: string) => Promise<PalSolanaDepositPrepareResult>;

package/common/src/data-structures/Hinkal/hinkalPalTronDepositPrepare.d.ts

@@ -0,0 +1,9 @@
+import { IHinkal } from './IHinkal';
+import { ERC20Token } from '../../types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { Types as TronWebTypes } from 'tronweb';
+export type PalTronDepositPrepareResult = {
+    unsignedTx: TronWebTypes.Transaction;
+    utxoAmounts: bigint[];
+};
+export declare const hinkalPalTronDepositPrepare: (hinkal: IHinkal, chainId: number, token: ERC20Token, recipientAmounts: bigint[], feeStructure: FeeStructure, orderId: string) => Promise<PalTronDepositPrepareResult>;

package/common/src/data-structures/Hinkal/hinkalPrivateWallet.d.ts

@@ -0,0 +1,6 @@
+import { IHinkal } from './IHinkal';
+import { FeeStructure } from '../../types/hinkal.types';
+import { ERC20Token, PrivateRecipientInfo, TokenChanges } from '../../types/token.types';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const hinkalPrivateWallet: (hinkal: IHinkal, chainId: number, erc20Tokens: ERC20Token[], deltaChanges: bigint[], onChainCreation: boolean[], ops: string[], emporiumTokenChanges: TokenChanges<bigint>[], subAccount?: SubAccount, feeToken?: string, feeStructureOverride?: FeeStructure, relayOverride?: string, autoDepositBack?: boolean, maxGasInDollar?: string, action?: AdminTransactionType, privateRecipientInfo?: PrivateRecipientInfo) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalProoflessDeposit.d.ts

@@ -0,0 +1,8 @@
+import { ethers } from 'ethers';
+import { Types as TronWebTypes } from 'tronweb';
+import { ERC20Token } from '../../types/token.types';
+import { IHinkal } from './IHinkal';
+import { StealthAddressStructure } from '../../types/circom-data.types';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const hinkalProoflessDeposit: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[], stealthAddressStructuresOverride?: StealthAddressStructure[], action?: AdminTransactionType, returnTxData?: boolean) => Promise<string | ethers.TransactionRequest | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+export declare const hinkalProoflessDepositWithPublicFee: (hinkal: IHinkal, chainId: number, erc20Token: ERC20Token, amounts: bigint[], stealthAddressStructures: StealthAddressStructure[], feeAmount: bigint, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalProoflessDeposit.utils.d.ts

@@ -0,0 +1,7 @@
+import { ERC20Token, TokenBalance } from '../../types/token.types';
+import { StealthAddressStructure } from '../../types/circom-data.types';
+import { IHinkal } from './IHinkal';
+export declare const aggregateAmountsForApproval: (erc20Tokens: ERC20Token[], amounts: bigint[]) => TokenBalance[];
+export declare const approveTokens: (hinkal: IHinkal, chainId: number, spenderAddress: string, tokensWithBalances: TokenBalance[]) => Promise<void>;
+export declare const approveTronTokens: (tronWeb: any, ethereumAddress: string, spenderAddress: string, tokensNeedingApproval: Map<string, bigint>) => Promise<void>;
+export declare const assertNoDuplicateStealthAddressStructures: (stealthAddressStructures: StealthAddressStructure[]) => void;

package/common/src/data-structures/Hinkal/hinkalProoflessDepositViaWrapper.d.ts

@@ -0,0 +1,6 @@
+import { ERC20Token } from '../../types/token.types';
+import { IHinkal } from './IHinkal';
+import { StealthAddressStructure } from '../../types/circom-data.types';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const hinkalTronProoflessDepositViaWrapper: (hinkal: IHinkal, chainId: number, feeToken: string, feeAmount: bigint, erc20Tokens: ERC20Token[], amounts: bigint[], stealthAddressStructures: StealthAddressStructure[], action?: AdminTransactionType) => Promise<string>;
+export declare const hinkalEvmProoflessDepositViaWrapper: (hinkal: IHinkal, chainId: number, feeToken: string, feeAmount: bigint, erc20Tokens: ERC20Token[], amounts: bigint[], stealthAddressStructures: StealthAddressStructure[], action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalProxySwap.d.ts

@@ -0,0 +1,7 @@
+import { ERC20Token } from '../../types/token.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { IHinkal } from './IHinkal';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const hinkalProxySwap: (hinkal: IHinkal, erc20Tokens: ERC20Token[], deltaAmounts: bigint[], externalActionId: ExternalActionId, data: string, isTheSameChainSwap: boolean, subAccount: SubAccount, feeToken?: string, feeStructureOverride?: FeeStructure, autoDepositBack?: boolean, maxGasInDollar?: string, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalProxyToPrivate.d.ts

@@ -0,0 +1,6 @@
+import { ERC20Token } from '../../types/token.types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { AdminTransactionType } from '../../types/admin.types';
+import { IHinkal } from './IHinkal';
+import { SubAccount } from '../../types/proxy.types';
+export declare const hinkalProxyToPrivate: (hinkal: IHinkal, erc20Tokens: ERC20Token[], deltaAmountsBase: bigint[], recipientInfo: string, feeToken?: string, feeStructureOverride?: FeeStructure, subAccount?: SubAccount, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSignSubAccount.d.ts

@@ -0,0 +1,4 @@
+import { SubAccount } from '../../types/proxy.types';
+import { TypedData } from '../../types/circom-data.types';
+export declare const hinkalSignSubAccount: (chainId: number, messageToSign: string | undefined, // it should be a hex number in string format
+typedData: TypedData | undefined, subAccount: SubAccount) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaClaimUtxo.d.ts

@@ -0,0 +1,5 @@
+import { ERC20Token } from '../../types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { Utxo } from '../utxo/Utxo';
+import { IHinkal } from './IHinkal';
+export declare const hinkalSolanaClaimUtxo: (hinkal: IHinkal, erc20Token: ERC20Token, utxo: Utxo, feeStructureOverride?: FeeStructure, claimableSignature?: string) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaDeposit.d.ts

@@ -0,0 +1,8 @@
+import { StealthAddressStructure } from '../../types/circom-data.types';
+import { ERC20Token } from '../../types/token.types';
+import { IHinkal } from './IHinkal';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const submitSolanaProoflessDeposit: (hinkal: IHinkal, token: ERC20Token, amounts: bigint[], stealthAddressStructures: StealthAddressStructure[], action?: AdminTransactionType, returnTxData?: boolean) => Promise<string>;
+export declare const hinkalSolanaProoflessDepositWithPublicFee: (hinkal: IHinkal, token: ERC20Token, amounts: bigint[], stealthAddressStructures: StealthAddressStructure[], feeAmount: bigint, action?: AdminTransactionType) => Promise<string>;
+export declare const hinkalSolanaDeposit: (hinkal: IHinkal, amount: bigint, token: ERC20Token, returnTxData?: boolean) => Promise<string>;
+export declare const hinkalSolanaDepositForOther: (hinkal: IHinkal, amount: bigint, token: ERC20Token, recipientInfo: string, returnTxData?: boolean, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaDepositAndWithdraw.d.ts

@@ -0,0 +1,24 @@
+import { FeeStructure } from '../../types/hinkal.types';
+import { IHinkal } from './IHinkal';
+import { PublicKey } from '@solana/web3.js';
+import { AdminTransactionType, RecipientUtxo } from '../../types';
+import { ERC20Token } from '../../types/token.types';
+export declare const buildMultiPaymentDepositSetup: (hinkal: IHinkal, chainId: number, token: ERC20Token, amounts: bigint[]) => {
+    program: import('@coral-xyz/anchor').Program<import('@coral-xyz/anchor').Idl>;
+    publicKey: PublicKey;
+    originalDeployer: PublicKey;
+    mint: PublicKey | null;
+    atasValue: null | undefined;
+    storageAccount: PublicKey;
+    storageVault: PublicKey;
+    merkleAccount: PublicKey;
+    amounts: bigint[];
+    anchorStealthStructures: import('../..').AnchorStealthAddressStructure[];
+};
+export type MultiPaymentDepositSetup = ReturnType<typeof buildMultiPaymentDepositSetup>;
+export declare const buildMultiPaymentDepositBuilder: (setup: MultiPaymentDepositSetup) => import('@coral-xyz/anchor/dist/cjs/program/namespace/methods').MethodsBuilder<import('@coral-xyz/anchor').Idl, import('@coral-xyz/anchor/dist/cjs/idl').IdlInstruction & {
+    name: string;
+}, import('@coral-xyz/anchor/dist/cjs/idl').IdlInstructionAccountItem>;
+export declare const hinkalSolanaWithdrawBatch: (hinkal: IHinkal, chainId: number, token: ERC20Token, userDepositedUtxos: RecipientUtxo[], feeStructure: FeeStructure, hashedEthereumAddress: string, recipientAmounts: bigint[], statusId: string | undefined, txCompletionTime?: number, ref?: string, action?: AdminTransactionType, hashedDashboardAccountId?: string, displayRecipients?: string[]) => Promise<string>;
+export declare const hinkalSolanaDepositAndWithdraw: (hinkal: IHinkal, token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, // Should be passed fee for only one withdraw transaction, multiplication happening in this function
+ref?: string, action?: AdminTransactionType, dashboardAccountId?: string, displayRecipients?: string[]) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaProoflessDeposit.d.ts

@@ -0,0 +1,5 @@
+import { StealthAddressStructure } from '../../types/circom-data.types';
+import { ERC20Token } from '../../types/token.types';
+import { IHinkal } from './IHinkal';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const hinkalSolanaProoflessDeposit: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[], stealthAddressStructuresOverride?: StealthAddressStructure[], action?: AdminTransactionType, returnTxData?: boolean) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaProxySend.d.ts

@@ -0,0 +1,6 @@
+import { ERC20Token } from '../../types/token.types';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+import { IHinkal } from './IHinkal';
+export declare const hinkalSolanaProxySend: (hinkal: IHinkal, token: ERC20Token, tokenAmount: bigint, subAccount: SubAccount, recipientAddress: string, action?: AdminTransactionType) => Promise<string>;
+export declare const getSolanaProxySendSerializedTransaction: (token: ERC20Token, tokenAmount: bigint, subAccount: SubAccount, recipientAddress: string) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaProxyShield.d.ts

@@ -0,0 +1,6 @@
+import { ERC20Token } from '../../types/token.types';
+import { IHinkal } from './IHinkal';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const hinkalSolanaProxyShield: (hinkal: IHinkal, token: ERC20Token, tokenAmount: bigint, subAccount: SubAccount, recipientInfo?: string, action?: AdminTransactionType) => Promise<string>;
+export declare const getSolanaProxyShieldSerializedTransaction: (hinkal: IHinkal, token: ERC20Token, tokenAmount: bigint, subAccount: SubAccount, recipientInfo?: string) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaProxySwap.d.ts

@@ -0,0 +1,6 @@
+import { AdminTransactionType, ERC20Token, SubAccount } from '../../types';
+import { IHinkal } from './IHinkal';
+import { FeeStructure } from '../../types/hinkal.types';
+import { ExternalActionId } from '../../types/external-action.types';
+export declare const hinkalSolanaProxySwap: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[], data: string, subAccount: SubAccount, externalActionId: ExternalActionId, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType) => Promise<string>;
+export declare const getSolanaProxySwapSerializedTransaction: (chainId: number, data: string, subAccount: SubAccount, externalActionId: ExternalActionId) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaSwap.d.ts

@@ -0,0 +1,4 @@
+import { AdminTransactionType, FeeStructure, OKXSwapResponseInstruction } from '../../types';
+import { IHinkal } from './IHinkal';
+import { ERC20Token } from '../../types/token.types';
+export declare const hinkalSolanaSwap: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[], swapperAccountSalt: bigint, instructionLists: OKXSwapResponseInstruction[], addressLookupTableAccount: string[], feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSolanaTransfer.d.ts

@@ -0,0 +1,31 @@
+import { AdminTransactionType, CommitmentValidationDataType, ERC20Token, FeeStructure } from '../../types';
+import { IHinkal } from './IHinkal';
+import { Utxo } from '../utxo/Utxo';
+import { constructAdminData } from '../../functions/pre-transaction';
+type SolanaTransferPlan = {
+    chainId: number;
+    relay: string;
+    commitmentValidationData?: CommitmentValidationDataType;
+    args: {
+        proofAArr: number[];
+        proofBArr: number[];
+        proofCArr: number[];
+        publicInputsArr: number[][];
+        encryptedOutputs: number[][];
+        relayerFee: string;
+        dimensions: {
+            tokenNumber: number;
+            nullifierAmount: number;
+            outputAmount: number;
+        };
+    };
+    accounts: {
+        recipient: string;
+        mint?: string;
+    };
+    adminData: ReturnType<typeof constructAdminData>;
+    recipientUtxo: Utxo;
+};
+export declare const buildSolanaTransferPlan: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChangesInput: bigint[], recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType) => Promise<SolanaTransferPlan>;
+export declare const hinkalSolanaTransfer: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[], recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType, onlyGasEstimate?: boolean) => Promise<string>;
+export {};

package/common/src/data-structures/Hinkal/hinkalSolanaWithdraw.d.ts

@@ -0,0 +1,4 @@
+import { AdminTransactionType, FeeStructure } from '../../types';
+import { IHinkal } from './IHinkal';
+import { ERC20Token } from '../../types/token.types';
+export declare const hinkalSolanaWithdraw: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChanges: bigint[], recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalSwap.d.ts

@@ -0,0 +1,7 @@
+import { ExternalActionId } from '../../types/external-action.types';
+import { IHinkal } from './IHinkal';
+import { FeeStructure } from '../../types/hinkal.types';
+import { ERC20Token } from '../../types/token.types';
+import { AdminTransactionType } from '../../types/admin.types';
+export declare const hinkalSwap: (hinkal: IHinkal, erc20tokens: ERC20Token[], deltaAmounts: bigint[], externalActionId: ExternalActionId, data: string, // call data used to call the router contracts.
+feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalTransfer.d.ts

@@ -0,0 +1,4 @@
+import { FeeStructure } from '../../types/hinkal.types';
+import { AdminTransactionType, ERC20Token } from '../../types';
+import { IHinkal } from './IHinkal';
+export declare const hinkalTransfer: (hinkal: IHinkal, erc20Tokens: ERC20Token[], amountChangesBase: bigint[], recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType) => Promise<string>;

package/common/src/data-structures/Hinkal/hinkalWithdraw.d.ts

@@ -0,0 +1,7 @@
+import { IHinkal } from './IHinkal';
+import { FeeStructure } from '../../types/hinkal.types';
+import { AdminTransactionType, ERC20Token } from '../../types';
+import { ethers } from 'ethers';
+export declare const hinkalWithdraw: (hinkal: IHinkal, erc20Tokens: ERC20Token[], deltaAmountsBase: bigint[], // should differentiate now: amountChanges is about off-chain utxos
+recipientAddress: string, // for Tron this address may be passed as base58
+isRelayerOff: boolean, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType) => Promise<ethers.TransactionResponse | string>;

package/common/src/data-structures/Hinkal/hinkalWithdrawStuckUtxos.d.ts

@@ -0,0 +1,3 @@
+import { IHinkal } from './IHinkal';
+import { ERC20Token } from '../../types';
+export declare const hinkalWithdrawStuckUtxos: (hinkal: IHinkal, erc20Token: ERC20Token, recipientAddress: string) => Promise<string[]>;

package/common/src/data-structures/Hinkal/index.d.ts

@@ -0,0 +1,25 @@
+export * from './Hinkal';
+export * from './HinkalPrivateBalanceController';
+export * from './IHinkal';
+export * from './hinkalDeposit';
+export * from './hinkalSwap';
+export * from './hinkalTransfer';
+export * from './hinkalSolanaTransfer';
+export * from './hinkalWithdraw';
+export * from './hinkalPrivateWallet';
+export * from './resetMerkleTrees';
+export * from './hinkalProxySwap';
+export * from './hinkalSolanaProxySwap';
+export * from './hinkalSolanaProxySend';
+export * from './hinkalSolanaProxyShield';
+export * from './hinkalDepositAndWithdraw';
+export * from './hinkalClaimUtxo';
+export * from './hinkalSolanaProoflessDeposit';
+export * from './hinkalSolanaClaimUtxo';
+export * from './hinkalWithdrawStuckUtxos';
+export * from './hinkalPalSolanaDepositPrepare';
+export * from './hinkalPalEvmDeposit';
+export * from './hinkalPalTronDepositPrepare';
+export * from './prepareDepositOnChainUtxosZkProof';
+export * from './hinkalSolanaDepositAndWithdraw';
+export * from './hinkalNearDepositAndBridge';

package/common/src/data-structures/Hinkal/prepareDepositOnChainUtxosZkProof.d.ts

@@ -0,0 +1,22 @@
+import { ethers } from 'ethers';
+import { ERC20Token } from '../../types';
+import { FeeStructure } from '../../types/hinkal.types';
+import { HookDataType } from '../../types/circom-data.types';
+import { Utxo } from '../utxo/Utxo';
+import { IHinkal } from './IHinkal';
+interface PrepareOptions {
+    hookData?: HookDataType;
+}
+export declare const prepareDepositOnChainUtxosZkProof: (hinkal: IHinkal, chainId: number, erc20Token: ERC20Token, recipientAmounts: bigint[], feeStructure: FeeStructure, options?: PrepareOptions) => Promise<{
+    zkCallData: import('../..').NewZkCallDataType;
+    circomData: import('../..').CircomDataType;
+    dimData: import('../..').DimDataType;
+    utxoAmounts: bigint[];
+    totalAmount: bigint;
+    hinkalWrapperAddress: string;
+    depositOnChainUtxosExternalActionAddress: string;
+    hinkalWrapperABI: ethers.InterfaceAbi;
+    depositOnChainUtxosExternalActionABI: ethers.InterfaceAbi;
+    inputUtxosArray: Utxo[][];
+}>;
+export {};

package/common/src/data-structures/Hinkal/resetMerkleTrees.d.ts

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

package/common/src/data-structures/IndexedDB/activity-db.d.ts

@@ -0,0 +1,14 @@
+import { Activity, ActivityAddRequest, TransactionResponse } from '../../types';
+export declare class ActivityStorage {
+    protected generateTxId(): string;
+    private getTransactionRecord;
+    saveTxRequest(txRequest: ActivityAddRequest): Promise<string>;
+    getTxRequest(id: string): Promise<Activity>;
+    getAllTxRequests(chainId: number): Promise<Activity[]>;
+    updateTxHash(activityId: string, newTxHash: string): Promise<void>;
+    private updateTxStatusAndHash;
+    private updateActivity;
+    removePendingTransactions(pendingActivityId: string): Promise<void>;
+    updatePendingTransactions(transactionResponse: TransactionResponse, pendingActivityId: string, onTxSuccess?: () => void, onTxError?: (errorResponse: Error) => void): Promise<void>;
+}
+export declare const activityStorage: ActivityStorage;

package/common/src/data-structures/IndexedDB/balances-db.d.ts

@@ -0,0 +1,13 @@
+import { ERC20Token, TokenBalance } from '../../types';
+interface WalletBalances {
+    [key: string]: TokenBalance[];
+}
+declare class PublicBalancesStorage {
+    readonly balancesRecordLabel = "walletsBalances";
+    getBalances(): Promise<WalletBalances | undefined>;
+    getBalancesByWallet(address: string, chainId: number): Promise<TokenBalance[] | undefined>;
+    setBalances(chainId: number, ethereumAddress: string, balances: TokenBalance[], concreteTokensList: ERC20Token[] | undefined): Promise<TokenBalance[]>;
+    private createBalanceLookup;
+}
+export declare const publicBalancesStorage: PublicBalancesStorage;
+export {};

package/common/src/data-structures/IndexedDB/contact-db.d.ts

@@ -0,0 +1,12 @@
+import { Contact } from '../../types/contacts.types';
+declare class ContactStorage {
+    private readonly STORAGE_KEY;
+    private checkForDuplicate;
+    createContact(walletAddress: string, newContact: Contact): Promise<void>;
+    getContacts(walletAddress: string): Promise<Contact[]>;
+    editContact(walletAddress: string, oldContactAddress: string, editedContact: Contact): Promise<void>;
+    private removeOldStylePrivateAddressContacts;
+    deleteContact(walletAddress: string, contactAddressToDelete: string): Promise<void>;
+}
+export declare const contactStorage: ContactStorage;
+export {};

package/common/src/data-structures/IndexedDB/index.d.ts

@@ -0,0 +1,8 @@
+export * from './key-val-store';
+export * from './activity-db';
+export * from './balances-db';
+export * from './private-balances-db';
+export * from './prices-db';
+export * from './contact-db';
+export * from './signatures-db';
+export * from './pay-activity-db';

package/common/src/data-structures/IndexedDB/key-val-store.d.ts

@@ -0,0 +1,6 @@
+export interface IKeyValStore {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    update<T>(key: string, updater: (current: T | undefined) => T): Promise<T>;
+}
+export declare const keyValStore: IKeyValStore;

package/common/src/data-structures/IndexedDB/pay-activity-db.d.ts

@@ -0,0 +1,9 @@
+import { PayActivity, PayActivityAddRequest } from '../../types';
+import { ActivityStorage } from './activity-db';
+declare class PayActivityStorage extends ActivityStorage {
+    savePrivateSendTx(txRequest: PayActivityAddRequest): Promise<string>;
+    saveMultiplePrivateSendTxs(txRequests: PayActivityAddRequest[]): Promise<string[]>;
+    getTransactionRecords(): Promise<PayActivity[]>;
+}
+export declare const payActivityStorage: PayActivityStorage;
+export {};

package/common/src/data-structures/IndexedDB/prices-db.d.ts

@@ -0,0 +1,9 @@
+declare class PricesStorage {
+    readonly tokenPricesRecordLabel = "tokenPrices";
+    getPrices(): Promise<Record<string, number> | undefined>;
+    updatePrices(chainId: number, erc20Addresses: string[]): Promise<number[]>;
+    getAndUpdatePrices(currentChainId: number, erc20Addresses: string[]): Promise<number[]>;
+    updateCachedPricesByChain(chainId: number): Promise<void>;
+}
+export declare const pricesStorage: PricesStorage;
+export {};

package/common/src/data-structures/IndexedDB/private-balances-db.d.ts

@@ -0,0 +1,9 @@
+import { TokenBalance } from '../../types/token.types';
+declare class PrivateBalancesStorage {
+    readonly balancesRecordLabel = "privateWalletsBalances";
+    getBalances(): Promise<Record<string, TokenBalance[]> | undefined>;
+    getBalancesByWallet(address: string, chainId: number): Promise<TokenBalance[] | undefined>;
+    setBalances(address: string, chainId: number, newBalances: TokenBalance[]): Promise<void>;
+}
+export declare const privateBalancesStorage: PrivateBalancesStorage;
+export {};

package/common/src/data-structures/IndexedDB/signatures-db.d.ts

@@ -0,0 +1,10 @@
+import { ConfirmationRequestType } from '../../types/confirmation-request.types';
+import { AppMetaData } from '../../types/wc.types';
+import { SignedMessage } from '../../types';
+declare class SignedMessagesStorage {
+    private generateMessageId;
+    saveSignedMessage(chainId: number, messageText: string, messageType: ConfirmationRequestType.PERSONAL_SIGN | ConfirmationRequestType.SIGN_TYPE_V4, subAccountAddress: string, signature: string, appMetaData: AppMetaData): Promise<void>;
+    getAllSignedMessages(): Promise<SignedMessage[]>;
+}
+export declare const signedMessagesStorage: SignedMessagesStorage;
+export {};

package/common/src/data-structures/MultiThreadedUtxoUtils/MultiThreadedUtxoUtils.d.ts

@@ -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, chainId: number): Promise<Utxo[]>;
+    private sliceArrayIntoParts;
+    findLastOutput(lastOutputsArray: string[], lastOutput: string): string;
+    batchProcess(encryptedOutputs: EncryptedOutputWithSign[], lastOutput: string, userKeys: UserKeys, chainId: number): Promise<OutputsWithSignAndLast<boolean>>;
+}

package/common/src/data-structures/TokenDBs/AlchemyPublicTokensDB.d.ts

@@ -0,0 +1,19 @@
+import { ERC20Token } from '../../types/token.types';
+import { IPublicTokensDB } from './IPublicTokensDB';
+export declare class AlchemyPublicTokensDB implements IPublicTokensDB {
+    private fetchedTokens;
+    private readonly ALCHEMY_URLS;
+    private readonly KNOWN_GOOD_NFTS;
+    private isWhitelistedNFT;
+    getPublicTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    getFetchedTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    fetchAndUpdatePublicTokens(walletAddress: string, chainId: number): Promise<void>;
+    private fetchAndUpdateSolanaTokens;
+    getWalletTokenAddresses(chainId: number, walletAddress: string): Promise<string[]>;
+    private fetchAndUpdateEVMTokens;
+    private getSolanaTokenAddresses;
+    private getNFTAddresses;
+    private getEVMTokenAddresses;
+    private getNFTTokens;
+}
+export declare const alchemyPublicTokensDB: AlchemyPublicTokensDB;

package/common/src/data-structures/TokenDBs/ArcPublicTokensDB.d.ts

@@ -0,0 +1,11 @@
+import { ERC20Token } from '../../types/token.types';
+export declare class ArcPublicTokensDB {
+    private readonly API_BASE;
+    private fetchedTokens;
+    getPublicTokens(walletAddress: string): Promise<ERC20Token[]>;
+    getFetchedTokens(walletAddress: string): ERC20Token[];
+    fetchAndUpdatePublicTokens(walletAddress: string): Promise<void>;
+    private getERC20TokenAddresses;
+    private getNFTTokens;
+}
+export declare const arcPublicTokensDB: ArcPublicTokensDB;

package/common/src/data-structures/TokenDBs/EventsPublicTokensDB.d.ts

@@ -0,0 +1,18 @@
+import { ERC20Token } from '../../types/token.types';
+import { IPublicTokensDB } from './IPublicTokensDB';
+export declare class EventsPublicTokensDB implements IPublicTokensDB {
+    private fetchedTokens;
+    private updateMutexes;
+    private readonly transferEventTopic;
+    private readonly chunkSize;
+    private getMutex;
+    getPublicTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    getFetchedTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    fetchAndUpdatePublicTokens(walletAddress: string, chainId: number): Promise<void>;
+    private getLastProcessedBlock;
+    private updateLastProcessedBlock;
+    private getEvents;
+    private updateTokenIds;
+    private fetchPublicTokens;
+}
+export declare const eventsPublicTokensDB: EventsPublicTokensDB;

package/common/src/data-structures/TokenDBs/IPublicTokensDB.d.ts

@@ -0,0 +1,6 @@
+import { ERC20Token } from '../../types/token.types';
+export interface IPublicTokensDB {
+    getPublicTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    getFetchedTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    fetchAndUpdatePublicTokens(walletAddress: string, chainId: number): Promise<void>;
+}

package/common/src/data-structures/TokenDBs/PrivateTokensDB.d.ts

@@ -0,0 +1,11 @@
+import { ERC20Token } from '../../types/token.types';
+export declare class PrivateTokensDB {
+    private fetchedTokens;
+    initalFetched: boolean;
+    updateFetchedTokens(): Promise<void>;
+    getPrivateTokens(chainId: number, walletAddress: string): Promise<ERC20Token[]>;
+    private fetchPrivateTokens;
+    fetchAndUpdatePrivateTokens(erc20Addresses: string[], chainId: number, walletAddress: string, preFetchedTokens?: ERC20Token[]): Promise<void>;
+    getFetchedTokens(chainId: number, walletAddress: string): ERC20Token[];
+}
+export declare const privateTokensDB: PrivateTokensDB;