@gurge/sdk 0.3.5 → 0.3.7

package/common/src/constants/save-depths.d.ts

@@ -0,0 +1,19 @@
+import { chainIds } from './chains.constants';
+export declare const saveDepths: {
+    [chainIds.ethMainnet]: number;
+    [chainIds.bnbMainnet]: number;
+    [chainIds.polygon]: number;
+    [chainIds.arbMainnet]: number;
+    [chainIds.optimism]: number;
+    [chainIds.optimismTest]: number;
+    [chainIds.base]: number;
+    [chainIds.arcTestnet]: number;
+    [chainIds.sepoliaTestnet]: number;
+    [chainIds.tempo]: number;
+    [chainIds.localhost]: number;
+    [chainIds.solanaMainnet]: number;
+    [chainIds.solanaLocalnet]: number;
+    [chainIds.tronNile]: number;
+    [chainIds.tronMainnet]: number;
+    [chainIds.tronLocalnet]: number;
+};

package/common/src/constants/schedule.constants.d.ts

@@ -0,0 +1,2 @@
+import { ScheduleDelayOption } from '../types/schedule.types';
+export declare const SCHEDULE_DELAY_OPTIONS: Partial<Record<ScheduleDelayOption, number | undefined>>;

package/common/src/constants/server.constants.d.ts

@@ -0,0 +1,142 @@
+import { TaskTypes } from '../types';
+export declare const API_CONFIG: {
+    ROUTES: {
+        checkKycStatus: string;
+        startReclaimVerification: string;
+        startUserVerification: string;
+        zkMeAccessToken: string;
+        getSnapshots: (chainId: number) => string;
+        getMerkleTreeSiblings: string;
+        getSnapshotServerEvents: string;
+        callOdosAPI: string;
+        callOneInchAPI: string;
+        callLifiAPI: string;
+        callOkxAPI: string;
+        callNearIntentsQuote: string;
+        callNearIntentsTokens: string;
+        getOdosPriceForToken: (chainId: number, tokenAddress: string) => string;
+        monitor: string;
+        monitorBatch: string;
+        checkRisk: (address: string) => string;
+        simulateTransaction: string;
+        simulateBatchTx: string;
+        simulateVolatileTokenTransfer: string;
+        getTokensInfo: string;
+        getTokensForChain: string;
+        getTokenBySymbol: string;
+        getTokenData: (tokenSymbol: string) => string;
+        getProxyAccounts: (secureKey: string) => string;
+        updateProxyAccounts: string;
+        getTemporaryWalletNonces: (hashedEthereumAddress: string, chainId: number) => string;
+        addTemporaryWalletNonce: string;
+        removeTemporaryWalletNonce: string;
+        encodeMoonPayBuyUrl: string;
+        getMoonPayQuote: string;
+        privateSendTopUpRecipientInfos: string;
+        privateSendAllocateRecipientInfos: string;
+        privateSendNonceSync: string;
+        privateSendNonceReserve: string;
+        getDashboardAccount: string;
+        updateDashboardAccount: string;
+        deleteDashboardAccount: string;
+        updateUserProfile: string;
+        addDashboardContact: string;
+        deleteDashboardContact: string;
+        updateDashboardContact: string;
+        getDashboardContacts: string;
+        sendDashboardInvitationEmail: string;
+        removeMember: string;
+        editMember: string;
+        createDashboardPayout: string;
+        getDashboardPayouts: string;
+        syncDashboardBalances: string;
+        getDashboardBalances: string;
+        changePayoutStatus: string;
+        getDashboardTransactions: string;
+        createDashboardTransactions: string;
+        tronSubsidyEligibility: string;
+        tronSubsidyRecord: string;
+        privateSendRecipientInfoGetAny: string;
+    };
+};
+export declare const RELAYER_CONFIG: {
+    getGasEstimate: (tokenAddress: string, externalActionId: string, erc20TokenAddressLength: number, gasAmount?: number) => string;
+    getTokenPrices: string;
+    TRANSACT: string;
+    TRANSACT_BATCH: string;
+    SOLANA_TRANSACT: string;
+    SOLANA_TRANSACT_BATCH: string;
+    getIdleRelay: string;
+    emitTxPublicData: string;
+    emitReferralTx: string;
+    getScheduledTransactions: string;
+    getScheduledTransactionById: (scheduleId: string) => string;
+    getScheduledTransactionsNullifierIndexes: string;
+    updateDepositAndWithdrawStatus: string;
+    getTokenPriceChartData: string;
+    getTokenPreviousDayPrices: string;
+    getPrivateTransactionsRatio: (hashedOwner: string) => string;
+    savePrivacyScoreAndGetPrivacyRank: string;
+};
+export declare const WALLET_TASK_VERIFICATION_TYPES: TaskTypes[];
+export declare const VERIFICATION_ROUTES: Partial<Record<TaskTypes, (ethereumAddress: string) => string>>;
+export declare const DATA_SERVER_CONFIG: {
+    createPresaleReferral: string;
+    updatePresaleReferralList: string;
+    generateTradingPoints: string;
+    getBrotherhoodUsers: (brotherhoodId: number) => string;
+    getCurrentUserBrotherhoodUsers: (ethereumAddress: string) => string;
+    editBrotherhood: string;
+    createBrotherhood: string;
+    getCurrentUserBrotherhood: string;
+    getPublicBrotherhoods: string;
+    getBrotherhood: (brotherhoodId: number) => string;
+    leaveBrotherhood: (brotherhoodId: number) => string;
+    joinBrotherhood: (brotherhoodId: number) => string;
+    getUserAnalytics: string;
+    getBrotherhoodAnalytics: string;
+    connectRewardsUser: string;
+    updateRewardsUser: string;
+    getRewardsUser: (ethereumAddress: string) => string;
+    checkUsernameAvailability: (username: string) => string;
+    getSwapStreak: string;
+    getUserCurrentLeaderboard: string;
+    getBrotherhoodsLeaderboard: string;
+    getCurrentUserReferral: string;
+    submitReferralCode: string;
+    getCurrentUserAppliedReferralCode: string;
+    submitAccessCode: string;
+    getAccessCodeBenefits: string;
+    getTelegramCallback: string;
+    generateAumPoints: string;
+    getTasksProgress: (ethereumAddress: string) => string;
+    disconnectSocialNetwork: string;
+    getNftMultiplier: (ethereumAddress: string) => string;
+    seedlessInit: string;
+    seedlessBackup: string;
+    seedlessCheckPassword: string;
+    seedlessStatus: string;
+    seedlessSalt: string;
+    sendPrivateSendEmailNotifications: string;
+    webflowBlogPosts: string;
+    brevoSubscribe: string;
+    versionChecker: (version: string) => string;
+};
+export declare const backendVersion = "v12";
+export declare const deploymentModeWithVersion: string | undefined;
+export declare const PLAYGROUND_URL = "https://wallet-playground.hinkal.io";
+export declare const STAGING_URL = "https://wallet-staging.hinkal.io";
+export declare const PRODUCTION_URL = "https://wallet-prodv12.hinkal.io";
+export declare const SERVER_URL_LOCAL = "http://localhost:7072";
+export declare const SERVER_URL_ENDPOINT = "/server";
+export declare const RELAYER_URL_LOCAL = "http://localhost:7073";
+export declare const RELAYER_URL_ENDPOINT = "/relayer";
+export declare const SNAPSHOT_SERVER_URL_LOCAL = "http://localhost:7074";
+export declare const SNAPSHOT_SERVER_URL_ENDPOINT = "/snapshot-server";
+export declare const DATA_SERVER_URL_LOCAL = "http://localhost:7090";
+export declare const DATA_SERVER_URL_ENDPOINT = "/data-server";
+export declare const FUND_COMPLIANCE_URL_LOCAL = "http://localhost:7075";
+export declare const FUND_COMPLIANCE_URL_ENDPOINT = "/compliance-server";
+export declare const ENCLAVE_API_URL_LOCAL = "http://localhost:7077";
+export declare const ENCLAVE_API_STAGING_URL = "https://api-staging.hinkal.io";
+export declare const ENCLAVE_API_PRODUCTION_URL = "https://api.hinkal.io";

package/common/src/constants/tasks.constants.d.ts

@@ -0,0 +1,9 @@
+import { Task } from '../types';
+import { Achievement } from '../types/new-rewards.type';
+export declare const WELCOME_TASKS: Task[];
+export declare const BROTHERHOOD_TASKS: Task[];
+export declare const DAILY_TASKS: Task[];
+export declare const POINTS_BOOST_TASKS: Task[];
+export declare const REFERRAL_BONUS_TASK: Task;
+export declare const REWARDS_TASKS: Task[];
+export declare const ACHIEVEMENTS: Achievement[];

package/common/src/constants/token.limits.constants.d.ts

@@ -0,0 +1,5 @@
+export declare const TOKEN_LIMITS: Record<number, Record<string, string>>;
+export declare const getTokensLimits: (chainId: number) => {
+    erc20Addresses: string[];
+    limits: bigint[];
+};

package/common/src/constants/tokens.constants.d.ts

@@ -0,0 +1,4 @@
+export declare const PopularTokenSymbols: string[];
+export declare const NativeTokenSymbols: string[];
+export declare const SOLANA_PAY_DASHBOARD_SUPPORTED_TOKEN_SYMBOLS: string[];
+export declare const chainNativeTokenSymbol: Partial<Record<number, string>>;

package/common/src/constants/tx-confirmation.constants.d.ts

@@ -0,0 +1,4 @@
+export declare const TX_CONFIRMATION_TIMEOUT: number;
+export declare const RELAYER_TX_CONFIRMATION_TIMEOUT: number;
+export declare const TX_CONFIRMATION_TIMEOUT_EXTENDED: number;
+export declare const TX_CONFIRMATION_CONFIRMATIONS_COUNT = 1;

package/common/src/constants/vite.constants.d.ts

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

package/common/src/constants/wallet.constants.d.ts

@@ -0,0 +1 @@
+export declare const SOLANA_LEDGER_WALLET_ID = "solana-ledger";

package/common/src/crypto/babyJub.d.ts

@@ -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<T = bigint> = [T, T];
+export interface BabyJubType {
+    mulPointEscalar: (point: [Uint8Array, Uint8Array], s: bigint) => [Uint8Array, Uint8Array];
+    F: {
+        toString: (arr: Uint8Array) => string;
+    };
+    Base8: [Uint8Array, Uint8Array];
+}
+export {};

package/common/src/crypto/ecdh-dual-path.d.ts

@@ -0,0 +1,13 @@
+interface KeyPair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+export declare const encryptDualPath: (msgBytes: Uint8Array, senderViewingKey: KeyPair, receiver1PublicKey: Uint8Array, receiver2PublicKey: Uint8Array) => Promise<{
+    blindedSenderKey: Uint8Array<ArrayBufferLike>;
+    wrapKeyReceiver1: Uint8Array<ArrayBufferLike>;
+    wrapKeyReceiver2: Uint8Array<ArrayBufferLike>;
+    ciphertext: Uint8Array<ArrayBufferLike>;
+    nonce: Uint8Array<ArrayBufferLike>;
+}>;
+export declare const decryptDualPath: (ciphertext: Uint8Array, privateKey: Uint8Array, blindedSenderKey: Uint8Array, wrapKey: Uint8Array, nonce: Uint8Array) => Promise<string>;
+export {};

package/common/src/crypto/ecdh-sealed-keys.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Multi-recipient encryption: encrypt the body ONCE with a random content key
+ * (XSalsa20-Poly1305 via crypto_secretbox), then crypto_box_seal that 32-byte
+ * content key once per recipient. Each recipient opens its sealed key and decrypts
+ * the shared body, so message size does not scale with the number of recipients.
+ *
+ * Everything is packed into a single Uint8Array:
+ *   [ count (1 byte) ][ nonce (NONCEBYTES) ][ sealedKey_0 ]...[ sealedKey_n ][ ciphertext ]
+ * Each sealed key has a fixed length (crypto_box_SEALBYTES + content-key size).
+ *
+ * Public/private keys are X25519 (libsodium crypto_box) keys in hex, matching ecdh.ts.
+ */
+interface SealedParts {
+    nonce: Uint8Array;
+    sealedKeys: Uint8Array[];
+    ciphertext: Uint8Array;
+}
+export declare const pack: ({ nonce, sealedKeys, ciphertext }: SealedParts) => Uint8Array;
+export declare const unpack: (packed: Uint8Array) => SealedParts;
+export declare const encryptSealedKeys: (msgBytes: Uint8Array, recipientPublicKeys: string[]) => Uint8Array;
+export declare const decryptSealedKeys: (packed: Uint8Array, privateKey: string, publicKey: string, recipientIndex: number) => Buffer;
+export {};

package/common/src/crypto/ecdh.d.ts

@@ -0,0 +1,2 @@
+export declare const encryptBoxSeal: (msgBytes: Uint8Array, encryptionKey: string) => Uint8Array<ArrayBufferLike>;
+export declare const decryptBoxSeal: (ciphertext: Uint8Array, privateKey: string, publicKey: string) => Buffer;

package/common/src/crypto/eddsa.d.ts

@@ -0,0 +1,8 @@
+declare class EddsaHolder {
+    private eddsa;
+    init(): Promise<void>;
+    getEddsa(): any;
+}
+export declare const eddsaHolder: EddsaHolder;
+export declare const eddsaInstance: () => any;
+export {};

package/common/src/crypto/index.d.ts

@@ -0,0 +1,7 @@
+export * from './poseidon';
+export * from './babyJub';
+export * from './preProcessing';
+export * from './eddsa';
+export * from './ecdh';
+export * from './ecdh-sealed-keys';
+export * from './ecdh-dual-path';

package/common/src/crypto/poseidon.d.ts

@@ -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/common/src/crypto/preProcessing.d.ts

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

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

@@ -0,0 +1,17 @@
+import { Connection, Keypair, VersionedTransaction } from '@solana/web3.js';
+import { ethers } from 'ethers';
+import { SubAccount } from '../../types/proxy.types';
+export declare class AccountActions {
+    static getEvmPrivateKeyFromSolanaPrivateKey: (solanaPrivateKey: string) => string;
+    static getSolanaPrivateKeyFromEvmPrivateKey: (evmPrivateKey: string) => string;
+    static getSolanaSignerFromPrivateKey: (secretKeyBase58: string) => Keypair;
+    static getSignerAddressFromPrivateKey(chainId: number, privateKey: string): string;
+    static signMessageFromPrivateKey: (chainId: number, privateKey: string, message: string) => Promise<string>;
+    static signSolanaTransactionFromPrivateKey: (chainId: number, privateKey: string, transaction: VersionedTransaction) => void;
+    static sendAndSignSolanaTransactionFromPrivateKey: (connection: Connection, privateKey: string, transaction: VersionedTransaction, skipPreflight?: boolean) => Promise<string>;
+    static signTypedDataFromPrivateKey: (chainId: number, privateKey: string, domain: ethers.TypedDataDomain, types: Record<string, Array<ethers.TypedDataField>>, value: Record<string, any>) => Promise<string>;
+    static authorizeDelegation: (chainId: number, privateKey: string, implementation: string, nonce?: number) => Promise<ethers.Authorization>;
+    static getAddressFromSubAccount: (chainId: number, subAccount: SubAccount) => string | undefined;
+    static getPrivateKeyFromSubAccount: (chainId: number, subAccount: SubAccount) => string | undefined;
+    static getAvailableAddressFromSubAccount: (subAccount: SubAccount) => string;
+}

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

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

package/common/src/data-structures/ApprovalDBs/EventsPublicApprovalsDB.d.ts

@@ -0,0 +1,18 @@
+import { TokenApproval } from '../../types/approvals.types';
+export declare class EventsPublicApprovalsDB {
+    private updateMutexes;
+    private readonly approvalTopic;
+    private readonly approvalForAllTopic;
+    private readonly getApprovedSelector;
+    private readonly isApprovedForAllSelector;
+    private readonly ALCHEMY_URLS;
+    private getMutex;
+    private getAlchemyUrl;
+    getApprovals(chainId: number, walletAddress: string): Promise<TokenApproval[]>;
+    private getLastProcessedBlock;
+    private updateLastProcessedBlock;
+    private getApprovalEvents;
+    private checkCurrentAllowances;
+    fetchAndUpdatePublicApprovals(walletAddress: string, chainId: number): Promise<void>;
+}
+export declare const eventsPublicApprovalsDB: EventsPublicApprovalsDB;

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

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

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

@@ -0,0 +1,14 @@
+import { SolanaEvent } from '../../types/solana.types';
+import { ethers } from 'ethers';
+export declare class BlockchainEvent {
+    eventName: string;
+    transactionHash: string;
+    blockNumber: number;
+    private args;
+    constructor(eventName: string, transactionHash: string, blockNumber: number, args: string);
+    static fromSerialized(serialized: string): BlockchainEvent;
+    static fromEthers(event: ethers.EventLog): BlockchainEvent;
+    static fromSolanaEvent(event: SolanaEvent): BlockchainEvent;
+    getArg<T>(key: string): T;
+    serialize(): string;
+}

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

@@ -0,0 +1,116 @@
+import { ethers } from 'ethers';
+import { Types as TronWebTypes } from 'tronweb';
+import { FeeStructure, HinkalConfig, LoginMessageMode } from '../../types/hinkal.types';
+import { ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { IMultiThreadedUtxoUtils } from '../../types/IMultiThreadedUtxoUtils';
+import { ERC20Token, PrivateRecipientInfo, TokenBalance, TokenChanges } from '../../types/token.types';
+import { UserKeys } from '../crypto-keys/keys';
+import { IProviderAdapter } from '../provider-adapter/IProviderAdapter';
+import { IHinkal } from './IHinkal';
+import { MerkleTree } from '../merkle-tree';
+import { IAPI } from '../../API';
+import { ICacheDevice } from '../../types/ICacheDevice';
+import { StealthAddressStructure, TypedData } from '../../types/circom-data.types';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+import { ClientCommitmentsSnapshotService, ClientNullifierSnapshotService, ClientSolanaCommitmentsSnapshotService, ClientSolanaNullifierSnapshotService } from '../snapshot';
+import { Idl, Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { BridgeRecipient } from '../../types/bridging-tx.types';
+import { NearBridgeParams, NearBridgeResult } from '../../types/near-intents.types';
+import { Utxo } from '../utxo/Utxo';
+import { PrivateBalancesState } from '../../types/balances.types';
+export declare class Hinkal<ConnectorType> implements IHinkal {
+    private ethereumProviderAdapter?;
+    private solanaProviderAdapter?;
+    private tronProviderAdapter?;
+    userKeys: UserKeys;
+    readonly signingMessage: string;
+    readonly privateTransferSigningMessage: string;
+    merkleTreeHinkalByChain: Record<number, MerkleTree<bigint>>;
+    nullifiersByChain: Record<number, Set<string>>;
+    encryptedOutputsByChain: Record<number, EncryptedOutputWithSign[]>;
+    commitmentsSnapshotServiceByChain: Record<number, ClientCommitmentsSnapshotService | ClientSolanaCommitmentsSnapshotService | undefined>;
+    nullifierSnapshotServiceByChain: Record<number, ClientNullifierSnapshotService | ClientSolanaNullifierSnapshotService | undefined>;
+    utxoUtils: IMultiThreadedUtxoUtils;
+    private lastCallState;
+    cacheDevice: ICacheDevice;
+    generateProofRemotely: boolean;
+    private disableMerkleTreeUpdates;
+    private readonly privateBalances;
+    constructor(hinkalConfig?: HinkalConfig);
+    private enforceRateLimit;
+    getProviderAdapter(chainId?: number): IProviderAdapter<ConnectorType>;
+    initProviderAdapter(connector: ConnectorType, providerAdapter: IProviderAdapter<ConnectorType>): Promise<void>;
+    getSigningMessage(mode?: LoginMessageMode): string;
+    signHinkalMessage(mode?: LoginMessageMode): Promise<string>;
+    initUserKeys(mode?: LoginMessageMode): Promise<void>;
+    initUserKeysWithSignature(signature: string): void;
+    initUserKeysFromSeedPhrases(seedPhrases: string[]): Promise<void>;
+    storeAndGetInitialSignature(authSignature: string, isSolanaLedger: boolean, txMessageForSolanaLedger?: string): Promise<string>;
+    resetMerkle(chains?: number[]): Promise<void>;
+    getTronWeb(): import('tronweb').TronWeb;
+    getSupportedChains(): number[];
+    waitForTransaction(chainId: number, transactionHash: string, confirmations?: number): Promise<boolean>;
+    getContract(chainId: number, contractType: ContractType, contractAddress?: undefined): 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>;
+    signWithSubAccount(chainId: number, messageToSign: string | undefined, typedData: TypedData | undefined, subAccount: SubAccount): Promise<string>;
+    getContractWithSigner(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcher(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    isSelectedNetworkSupported(chainId: number): boolean;
+    switchNetwork(network: EthereumNetwork): Promise<void>;
+    isPermitterAvailable(chainId: number): boolean;
+    disconnectFromConnector(): Promise<void>;
+    resetProviderAdapters(): Promise<void>;
+    private updateProviderAdapter;
+    setListeners(): Promise<void>;
+    private onAccountChanged;
+    private onChainChanged;
+    monitorConnectedAddress(chainId: number): Promise<void>;
+    getBalances(chainId: number, passedShieldedPrivateKey: string, passedShieldedPublicKey: string, ethAddress: string, resetCacheBefore?: boolean, updateTokensListBefore?: boolean, useBlockedUtxos?: boolean): Promise<Map<string, TokenBalance>>;
+    getTotalBalance(chainId: number, _userKeys?: UserKeys, _ethAddress?: string, resetCacheBefore?: boolean, updateTokensListBefore?: boolean, useBlockedUtxos?: boolean): Promise<TokenBalance[]>;
+    getStuckShieldedBalances(chainId: number, _userKeys?: UserKeys, _ethAddress?: string, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<TokenBalance[]>;
+    get privateBalancesWithUSD(): PrivateBalancesState;
+    onPrivateBalancesWithUSDChange(callback: (state: PrivateBalancesState) => void): () => void;
+    getSupportedPassportLinks(): string[];
+    checkAccessToken(_chainId: number, _accessKeyOverride?: string): Promise<boolean>;
+    checkExternalTokenLimitsUSD(chainId: number, tokenAddresses: string[], amounts: bigint[]): Promise<boolean>;
+    getHinkalTreeRootHash(chainId: number): Promise<any>;
+    resetMerkleTreesIfNecessary(chainIdsToCheck?: number[]): Promise<void>;
+    getEthereumAddress(): Promise<string>;
+    getEthereumAddressByChain(chainId: number): Promise<string>;
+    getRandomRelay(chainId: number, markAsPending?: boolean): Promise<string | undefined>;
+    getGasPrice(chainId: number): Promise<bigint>;
+    getAPI(): IAPI;
+    snapshotsClearInterval(): void;
+    getRecipientInfo(): string;
+    deposit(erc20Tokens: ERC20Token[], amountChanges: bigint[], preEstimateGas?: boolean, returnTxData?: boolean): Promise<ethers.TransactionResponse | ethers.TransactionRequest | string | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    depositSolana(amount: bigint, token: ERC20Token, returnTxData?: boolean): Promise<string>;
+    depositForOther(erc20Tokens: ERC20Token[], amountChanges: bigint[], recipientInfo: string, preEstimateGas?: boolean, returnTxData?: boolean, action?: AdminTransactionType): Promise<ethers.TransactionResponse | ethers.TransactionRequest | string | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    depositSolanaForOther(amount: bigint, token: ERC20Token, recipientInfo: string, returnTxData?: boolean, action?: AdminTransactionType): Promise<string>;
+    depositAndWithdraw(erc20Token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, ref?: string, action?: AdminTransactionType, dashboardAccountId?: string, preEstimateGas?: boolean): Promise<string>;
+    claimUtxo(erc20Token: ERC20Token, utxo: Utxo, feeStructureOverride?: FeeStructure, claimableSignature?: string): Promise<string>;
+    depositAndBridge(erc20Token: ERC20Token, recipientBridges: BridgeRecipient[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, ref?: string, action?: AdminTransactionType, dashboardAccountId?: string, preEstimateGas?: boolean): Promise<string>;
+    nearDepositAndBridge(erc20Token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], params: NearBridgeParams, txCompletionTime?: number, feeStructureOverride?: FeeStructure, ref?: string, action?: AdminTransactionType, dashboardAccountId?: string): Promise<NearBridgeResult>;
+    prooflessDeposit(erc20Tokens: ERC20Token[], amountChanges: bigint[], stealthAddressStructures?: StealthAddressStructure[], action?: AdminTransactionType, returnTxData?: boolean): Promise<string | ethers.TransactionRequest | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    prooflessDepositWithPublicFee(erc20Token: ERC20Token, amounts: bigint[], stealthAddressStructures: StealthAddressStructure[], feeAmount: bigint, action?: AdminTransactionType): Promise<string>;
+    getSolanaProgram(idl: Idl): Program;
+    getSolanaPublicKey(): PublicKey;
+    transfer(erc20Tokens: ERC20Token[], amountChanges: bigint[], recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    withdraw(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], recipientAddress: string, isRelayerOff: boolean, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<ethers.TransactionResponse | string>;
+    withdrawStuckUtxos(erc20Token: ERC20Token, recipientAddress: string): Promise<string[]>;
+    swap(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    swapSolana(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], swapData: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    actionReceive(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], feeToken?: string, feeStructureOverride?: FeeStructure, subAccount?: SubAccount, action?: AdminTransactionType): Promise<string>;
+    actionPrivateWallet(chainId: number, erc20Tokens: ERC20Token[], deltaAmounts: 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>;
+    proxySwap(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, isTheSameChainSwap: boolean, subAccount: SubAccount, feeToken?: string, feeStructureOverride?: FeeStructure, autoDepositBack?: boolean, maxGasInDollar?: string, action?: AdminTransactionType): Promise<string>;
+    proxyToPrivate(erc20Tokens: ERC20Token[], deltaAmountsBase: bigint[], subAccount: SubAccount, recipientInfo: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    proxySend(erc20Tokens: ERC20Token[], amounts: bigint[], subAccount: SubAccount, recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    multiSendPrivateRecipients(erc20Tokens: ERC20Token[], amounts: bigint[], extendedRecipientInfos?: string[]): Promise<string>;
+    areMerkleTreeUpdatesDisabled(): boolean;
+    updateMerkleTreeUpdates(value: boolean): void;
+}

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

@@ -0,0 +1,19 @@
+import { PrivateBalancesState } from '../../types/balances.types';
+import { IHinkal } from './IHinkal';
+export declare class HinkalPrivateBalanceController {
+    private readonly hinkal;
+    private privateBalancesState;
+    private readonly privateBalancesListeners;
+    constructor(hinkal: IHinkal);
+    getSnapshot(): PrivateBalancesState;
+    onPrivateBalancesWithUSDChange(callback: (state: PrivateBalancesState) => void): () => void;
+    private applyRefreshFromBalanceChangeEvent;
+    private dispatch;
+    private getAddressAndChain;
+    private hasCache;
+    private getBalancesWithUsdValues;
+    private handleCached;
+    private handleFresh;
+    private getSupportedChainsToUpdate;
+    private refreshInternal;
+}

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

@@ -0,0 +1,103 @@
+import { FeeStructure, LoginMessageMode } from '../../types/hinkal.types';
+import { ContractType, EthereumNetwork } from '../../types/ethereum-network.types';
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { ExternalActionId } from '../../types/external-action.types';
+import { IMultiThreadedUtxoUtils } from '../../types/IMultiThreadedUtxoUtils';
+import { ERC20Token, PrivateRecipientInfo, TokenBalance, TokenChanges } from '../../types/token.types';
+import { ethers } from 'ethers';
+import { Types as TronWebTypes, TronWeb } from 'tronweb';
+import { UserKeys } from '../crypto-keys/keys';
+import { IProviderAdapter } from '../provider-adapter/IProviderAdapter';
+import { ClientCommitmentsSnapshotService, ClientNullifierSnapshotService, ClientSolanaCommitmentsSnapshotService, ClientSolanaNullifierSnapshotService } from '../snapshot';
+import { MerkleTree } from '../merkle-tree';
+import { IAPI } from '../../API/API';
+import { ICacheDevice } from '../../types/ICacheDevice';
+import { StealthAddressStructure, TypedData } from '../../types/circom-data.types';
+import { SubAccount } from '../../types/proxy.types';
+import { AdminTransactionType } from '../../types/admin.types';
+import { Idl, Program } from '@coral-xyz/anchor';
+import { PublicKey } from '@solana/web3.js';
+import { BridgeRecipient } from '../../types/bridging-tx.types';
+import { NearBridgeParams, NearBridgeResult } from '../../types/near-intents.types';
+import { PrivateBalancesState } from '../../types/balances.types';
+import { Utxo } from '../utxo/Utxo';
+export interface IHinkal<ConnectorType = unknown> {
+    userKeys: UserKeys;
+    readonly signingMessage: string;
+    readonly privateTransferSigningMessage: string;
+    merkleTreeHinkalByChain: Record<number, MerkleTree<bigint>>;
+    nullifiersByChain: Record<number, Set<string>>;
+    encryptedOutputsByChain: Record<number, EncryptedOutputWithSign[]>;
+    commitmentsSnapshotServiceByChain: Record<number, ClientCommitmentsSnapshotService | ClientSolanaCommitmentsSnapshotService | undefined>;
+    nullifierSnapshotServiceByChain: Record<number, ClientNullifierSnapshotService | ClientSolanaNullifierSnapshotService | undefined>;
+    generateProofRemotely: boolean;
+    utxoUtils: IMultiThreadedUtxoUtils;
+    cacheDevice: ICacheDevice;
+    getBalances(chainId: number, passedShieldedPrivateKey: string, passedShieldedPublicKey: string, ethAddress: string, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<Map<string, TokenBalance>>;
+    getTotalBalance(chainId: number, userKeys?: UserKeys, ethAddress?: string, resetCacheBefore?: boolean, updateTokensListBefore?: boolean, useBlockedUtxos?: boolean): Promise<TokenBalance[]>;
+    getStuckShieldedBalances(chainId: number, userKeys?: UserKeys, ethAddress?: string, resetCacheBefore?: boolean, updateTokensListBefore?: boolean): Promise<TokenBalance[]>;
+    privateBalancesWithUSD: PrivateBalancesState;
+    onPrivateBalancesWithUSDChange(callback: (state: PrivateBalancesState) => void): () => void;
+    getSupportedPassportLinks(): string[];
+    checkAccessToken(chainId: number, accessKeyOverride?: string): Promise<boolean>;
+    checkExternalTokenLimitsUSD(chainId: number, tokenAddresses: string[], amounts: bigint[]): Promise<boolean>;
+    getSupportedChains(): number[];
+    getEthereumAddress(): Promise<string>;
+    getEthereumAddressByChain(chainId: number): Promise<string>;
+    getHinkalTreeRootHash(chainId: number): Promise<bigint>;
+    resetMerkleTreesIfNecessary(chainIdsToCheck?: number[]): Promise<void>;
+    resetMerkle(chainIds?: number[]): Promise<void>;
+    getRandomRelay(chainId: number, markAsPending?: boolean): Promise<string | undefined>;
+    getGasPrice(chainId: number): Promise<bigint>;
+    getAPI(): IAPI;
+    snapshotsClearInterval(): void;
+    getRecipientInfo(): string;
+    deposit(erc20Tokens: ERC20Token[], amountChanges: bigint[], preEstimateGas?: boolean, returnTxData?: boolean): Promise<ethers.TransactionResponse | ethers.TransactionRequest | string | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    depositForOther(erc20Tokens: ERC20Token[], amountChanges: bigint[], recepinetInfo: string, preEstimateGas?: boolean, returnTxData?: boolean, action?: AdminTransactionType): Promise<ethers.TransactionResponse | ethers.TransactionRequest | string | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    claimUtxo(erc20Token: ERC20Token, utxo: Utxo, feeStructureOverride?: FeeStructure, claimableSignature?: string): Promise<string>;
+    depositAndWithdraw(erc20Token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, ref?: string, action?: AdminTransactionType, dashboardAccountId?: string, preEstimateGas?: boolean): Promise<string>;
+    depositAndBridge(erc20Token: ERC20Token, recipientBridges: BridgeRecipient[], txCompletionTime?: number, feeStructureOverride?: FeeStructure, ref?: string, action?: AdminTransactionType, dashboardAccountId?: string, preEstimateGas?: boolean): Promise<string>;
+    nearDepositAndBridge(erc20Token: ERC20Token, recipientAmounts: bigint[], recipientAddresses: string[], params: NearBridgeParams, txCompletionTime?: number, feeStructureOverride?: FeeStructure, ref?: string, action?: AdminTransactionType, dashboardAccountId?: string): Promise<NearBridgeResult>;
+    prooflessDeposit(erc20Tokens: ERC20Token[], amountChanges: bigint[], stealthAddressStructures?: StealthAddressStructure[], action?: AdminTransactionType, returnTxData?: boolean): Promise<string | ethers.TransactionRequest | TronWebTypes.Transaction<TronWebTypes.TriggerSmartContract>>;
+    prooflessDepositWithPublicFee(erc20Token: ERC20Token, amounts: bigint[], stealthAddressStructures: StealthAddressStructure[], feeAmount: bigint, action?: AdminTransactionType): Promise<string>;
+    getSolanaProgram(idl: Idl): Program;
+    getSolanaPublicKey(): PublicKey;
+    depositSolana(amount: bigint, token: ERC20Token): Promise<string>;
+    depositSolanaForOther(amount: bigint, token: ERC20Token, recipientInfo: string, returnTxData?: boolean, action?: AdminTransactionType): Promise<string>;
+    transfer(erc20Tokens: ERC20Token[], amountChanges: bigint[], recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    withdraw(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], recipientAddress: string, isRelayerOff: boolean, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<ethers.TransactionResponse | string>;
+    withdrawStuckUtxos(erc20Token: ERC20Token, recipientAddress: string): Promise<string[]>;
+    swap(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    getProviderAdapter(chainId?: number): IProviderAdapter;
+    getTronWeb(): TronWeb;
+    getSigningMessage(mode?: LoginMessageMode): string;
+    signHinkalMessage(mode?: LoginMessageMode): Promise<string>;
+    initUserKeys(mode?: LoginMessageMode): Promise<void>;
+    initUserKeysWithSignature(signature: string): void;
+    initUserKeysFromSeedPhrases(seedPhrases: string[]): Promise<void>;
+    storeAndGetInitialSignature(authSignature: string, isSolanaLedger: boolean, txMessageForSolanaLedger?: string): Promise<string>;
+    initProviderAdapter(connector: ConnectorType, providerAdapter: IProviderAdapter<ConnectorType>): Promise<void>;
+    disconnectFromConnector(): Promise<void>;
+    resetProviderAdapters(): Promise<void>;
+    setListeners(providerAdapter: IProviderAdapter): Promise<void>;
+    waitForTransaction(chainId: number, transactionHash: string, confirmations?: number): Promise<boolean>;
+    getContract(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithSigner(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcher(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    getContractWithFetcherByChainId(chainId: number, contractType: ContractType, contractAddress?: string): ethers.Contract;
+    isSelectedNetworkSupported(chainId: number): boolean;
+    switchNetwork(network: EthereumNetwork): Promise<unknown>;
+    monitorConnectedAddress(chainId: number): Promise<void>;
+    isPermitterAvailable(chainId: number): boolean;
+    signMessage(message: string): Promise<string>;
+    signTypedData(domain: ethers.TypedDataDomain, types: Record<string, ethers.TypedDataField[]>, value: Record<string, unknown>): Promise<string>;
+    signWithSubAccount(chainId: number, messageToSign: string | undefined, typedData: TypedData | undefined, subAccount: SubAccount): Promise<string>;
+    actionPrivateWallet(chainId: number, erc20Tokens: ERC20Token[], deltaAmounts: 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>;
+    actionReceive(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], feeTokens?: string, feeStructureOverride?: FeeStructure, subAccount?: SubAccount, action?: AdminTransactionType): Promise<string>;
+    proxySwap(erc20Tokens: ERC20Token[], deltaAmounts: bigint[], externalActionId: ExternalActionId, swapData: string, isTheSameChainSwap: boolean, subAccount: SubAccount, feeToken?: string, feeStructureOverride?: FeeStructure, autoDepositBack?: boolean, maxGasInDollar?: string, action?: AdminTransactionType): Promise<string>;
+    proxyToPrivate(erc20Tokens: ERC20Token[], deltaAmountsBase: bigint[], subAccount: SubAccount, recipientInfo: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    proxySend(erc20Tokens: ERC20Token[], amounts: bigint[], subAccount: SubAccount, recipientAddress: string, feeToken?: string, feeStructureOverride?: FeeStructure, action?: AdminTransactionType): Promise<string>;
+    multiSendPrivateRecipients(erc20Tokens: ERC20Token[], amounts: bigint[], extendedRecipientInfos?: string[]): Promise<string>;
+    areMerkleTreeUpdatesDisabled(): boolean;
+    updateMerkleTreeUpdates(value: boolean): void;
+}

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

@@ -0,0 +1,3 @@
+import { IHinkal } from './IHinkal';
+import { CircomDataType, SubAccount, TokenChanges } from '../../types';
+export declare const handleAutoDepositBack: (hinkal: IHinkal, chainId: number, walletAddress: string | undefined, subAccount: SubAccount, feeToken: string | undefined, maxGasInDollar: string | undefined, emporiumTokenChanges: TokenChanges<bigint>[], circomData: CircomDataType) => Promise<void>;