@reown/appkit-core 0.0.3

package/dist/types/src/controllers/RouterController.d.ts

@@ -0,0 +1,55 @@
+import type { Connector, WcWallet } from '../utils/TypeUtil.js';
+import type { SwapInputTarget } from './SwapController.js';
+import type { CaipNetwork, ChainNamespace } from '@reown/appkit-common';
+type TransactionAction = {
+    /**
+     * If true, the router will go back to the previous view after the transaction is complete..
+     */
+    goBack: boolean;
+    /**
+     * If set, the router will navigate to the specified view after the transaction is complete.
+     */
+    view: RouterControllerState['view'] | null;
+    /**
+     * If true, the router will remove the previous view from the history and navigate to the current view.
+     */
+    replace?: boolean;
+    /**
+     * Function to be called when the transaction is complete.
+     */
+    onSuccess?: () => void;
+    /**
+     * Function to be called when the transaction is cancelled.
+     */
+    onCancel?: () => void;
+};
+export interface RouterControllerState {
+    view: 'Account' | 'AccountSettings' | 'SelectAddresses' | 'AllWallets' | 'ApproveTransaction' | 'BuyInProgress' | 'WalletCompatibleNetworks' | 'ChooseAccountName' | 'Connect' | 'ConnectingExternal' | 'ConnectingFarcaster' | 'ConnectingWalletConnect' | 'ConnectingSiwe' | 'ConnectingSocial' | 'ConnectSocials' | 'ConnectWallets' | 'Downloads' | 'EmailVerifyOtp' | 'EmailVerifyDevice' | 'GetWallet' | 'Networks' | 'OnRampActivity' | 'OnRampFiatSelect' | 'OnRampProviders' | 'OnRampTokenSelect' | 'Profile' | 'RegisterAccountName' | 'RegisterAccountNameSuccess' | 'SwitchNetwork' | 'SwitchAddress' | 'Transactions' | 'UnsupportedChain' | 'UpdateEmailWallet' | 'UpdateEmailPrimaryOtp' | 'UpdateEmailSecondaryOtp' | 'UpgradeEmailWallet' | 'UpgradeToSmartAccount' | 'WalletReceive' | 'WalletSend' | 'WalletSendPreview' | 'WalletSendSelectToken' | 'WhatIsANetwork' | 'WhatIsAWallet' | 'WhatIsABuy' | 'Swap' | 'SwapSelectToken' | 'SwapPreview' | 'ConnectingMultiChain' | 'SwitchActiveChain';
+    history: RouterControllerState['view'][];
+    data?: {
+        connector?: Connector;
+        wallet?: WcWallet;
+        network?: CaipNetwork;
+        email?: string;
+        newEmail?: string;
+        target?: SwapInputTarget;
+        swapUnsupportedChain?: boolean;
+        connectors?: Connector[];
+        switchToChain?: ChainNamespace;
+        navigateTo?: RouterControllerState['view'];
+        navigateWithReplace?: boolean;
+    };
+    transactionStack: TransactionAction[];
+}
+export declare const RouterController: {
+    state: RouterControllerState;
+    subscribeKey<K extends keyof RouterControllerState>(key: K, callback: (value: RouterControllerState[K]) => void): () => void;
+    pushTransactionStack(action: TransactionAction): void;
+    popTransactionStack(cancel?: boolean): void;
+    push(view: RouterControllerState['view'], data?: RouterControllerState['data']): void;
+    reset(view: RouterControllerState['view']): void;
+    replace(view: RouterControllerState['view'], data?: RouterControllerState['data']): void;
+    goBack(): void;
+    goBackToIndex(historyIndex: number): void;
+};
+export {};

package/dist/types/src/controllers/SendController.d.ts

@@ -0,0 +1,42 @@
+import { type Balance } from '@reown/appkit-common';
+export interface TxParams {
+    receiverAddress: string;
+    sendTokenAmount: number;
+    gasPrice: bigint;
+    decimals: string;
+}
+export interface ContractWriteParams {
+    receiverAddress: string;
+    tokenAddress: string;
+    sendTokenAmount: number;
+    decimals: string;
+}
+export interface SendControllerState {
+    token?: Balance;
+    sendTokenAmount?: number;
+    receiverAddress?: string;
+    receiverProfileName?: string;
+    receiverProfileImageUrl?: string;
+    gasPrice?: bigint;
+    gasPriceInUSD?: number;
+    loading: boolean;
+}
+export declare const SendController: {
+    state: SendControllerState;
+    subscribe(callback: (newState: SendControllerState) => void): () => void;
+    subscribeKey<K extends keyof SendControllerState>(key: K, callback: (value: SendControllerState[K]) => void): () => void;
+    setToken(token: SendControllerState['token']): void;
+    setTokenAmount(sendTokenAmount: SendControllerState['sendTokenAmount']): void;
+    setReceiverAddress(receiverAddress: SendControllerState['receiverAddress']): void;
+    setReceiverProfileImageUrl(receiverProfileImageUrl: SendControllerState['receiverProfileImageUrl']): void;
+    setReceiverProfileName(receiverProfileName: SendControllerState['receiverProfileName']): void;
+    setGasPrice(gasPrice: SendControllerState['gasPrice']): void;
+    setGasPriceInUsd(gasPriceInUSD: SendControllerState['gasPriceInUSD']): void;
+    setLoading(loading: SendControllerState['loading']): void;
+    sendToken(): void;
+    sendEvmToken(): void;
+    sendNativeToken(params: TxParams): Promise<void>;
+    sendERC20Token(params: ContractWriteParams): Promise<void>;
+    sendSolanaToken(): void;
+    resetSend(): void;
+};

package/dist/types/src/controllers/SnackController.d.ts

@@ -0,0 +1,13 @@
+export interface SnackControllerState {
+    message: string;
+    variant: 'error' | 'success' | 'loading';
+    open: boolean;
+}
+export declare const SnackController: {
+    state: SnackControllerState;
+    subscribeKey<K extends keyof SnackControllerState>(key: K, callback: (value: SnackControllerState[K]) => void): () => void;
+    showLoading(message: SnackControllerState['message']): void;
+    showSuccess(message: SnackControllerState['message']): void;
+    showError(message: unknown): void;
+    hide(): void;
+};

package/dist/types/src/controllers/SwapController.d.ts

@@ -0,0 +1,126 @@
+import type { SwapTokenWithBalance } from '../utils/TypeUtil.js';
+export declare const INITIAL_GAS_LIMIT = 150000;
+export declare const TO_AMOUNT_DECIMALS = 6;
+export type SwapInputTarget = 'sourceToken' | 'toToken';
+type TransactionParams = {
+    data: string;
+    to: string;
+    gas: bigint;
+    gasPrice: bigint;
+    value: bigint;
+    toAmount: string;
+};
+export interface SwapControllerState {
+    initializing: boolean;
+    initialized: boolean;
+    loadingPrices: boolean;
+    loadingQuote?: boolean;
+    loadingApprovalTransaction?: boolean;
+    loadingBuildTransaction?: boolean;
+    loadingTransaction?: boolean;
+    fetchError: boolean;
+    approvalTransaction: TransactionParams | undefined;
+    swapTransaction: TransactionParams | undefined;
+    transactionError?: string;
+    sourceToken?: SwapTokenWithBalance;
+    sourceTokenAmount: string;
+    sourceTokenPriceInUSD: number;
+    toToken?: SwapTokenWithBalance;
+    toTokenAmount: string;
+    toTokenPriceInUSD: number;
+    networkPrice: string;
+    networkBalanceInUSD: string;
+    networkTokenSymbol: string;
+    inputError: string | undefined;
+    slippage: number;
+    tokens?: SwapTokenWithBalance[];
+    suggestedTokens?: SwapTokenWithBalance[];
+    popularTokens?: SwapTokenWithBalance[];
+    foundTokens?: SwapTokenWithBalance[];
+    myTokensWithBalance?: SwapTokenWithBalance[];
+    tokensPriceMap: Record<string, number>;
+    gasFee: string;
+    gasPriceInUSD?: number;
+    priceImpact: number | undefined;
+    maxSlippage: number | undefined;
+    providerFee: string | undefined;
+}
+export interface TokenInfo {
+    address: `0x${string}`;
+    symbol: string;
+    name: string;
+    decimals: number;
+    logoURI: string;
+    domainVersion?: string;
+    eip2612?: boolean;
+    isFoT?: boolean;
+    tags?: string[];
+}
+export declare const SwapController: {
+    state: SwapControllerState;
+    subscribe(callback: (newState: SwapControllerState) => void): () => void;
+    subscribeKey<K extends keyof SwapControllerState>(key: K, callback: (value: SwapControllerState[K]) => void): () => void;
+    getParams(): {
+        networkAddress: string;
+        fromAddress: string;
+        fromCaipAddress: `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | undefined;
+        sourceTokenAddress: `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | undefined;
+        toTokenAddress: `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | undefined;
+        toTokenAmount: string;
+        toTokenDecimals: number | undefined;
+        sourceTokenAmount: string;
+        sourceTokenDecimals: number | undefined;
+        invalidToToken: boolean;
+        invalidSourceToken: boolean;
+        invalidSourceTokenAmount: boolean;
+        availableToSwap: boolean | undefined;
+        isAuthConnector: boolean;
+    };
+    setSourceToken(sourceToken: SwapTokenWithBalance | undefined): void;
+    setSourceTokenAmount(amount: string): void;
+    setToToken(toToken: SwapTokenWithBalance | undefined): void;
+    setToTokenAmount(amount: string): void;
+    setTokenPrice(address: string, target: SwapInputTarget): Promise<void>;
+    switchTokens(): void;
+    resetState(): void;
+    resetValues(): void;
+    getApprovalLoadingState(): boolean | undefined;
+    clearError(): void;
+    initializeState(): Promise<void>;
+    fetchTokens(): Promise<void>;
+    getTokenList(): Promise<void>;
+    getAddressPrice(address: string): Promise<number>;
+    getNetworkTokenPrice(): Promise<void>;
+    getMyTokensWithBalance(forceUpdate?: string): Promise<void>;
+    setBalances(balances: SwapTokenWithBalance[]): void;
+    getInitialGasPrice(): Promise<{
+        gasPrice: null;
+        gasPriceInUSD: null;
+    } | {
+        gasPrice: bigint;
+        gasPriceInUSD: number;
+    }>;
+    swapTokens(): Promise<void>;
+    getTransaction(): Promise<TransactionParams | undefined>;
+    createAllowanceTransaction(): Promise<{
+        data: `0x${string}`;
+        to: `0x${string}`;
+        gas: bigint;
+        gasPrice: bigint;
+        value: bigint;
+        toAmount: string;
+    } | undefined>;
+    createSwapTransaction(): Promise<{
+        data: `0x${string}`;
+        to: `0x${string}`;
+        gas: bigint;
+        gasPrice: bigint;
+        value: bigint;
+        toAmount: string;
+    } | undefined>;
+    sendTransactionForApproval(data: TransactionParams): Promise<void>;
+    sendTransactionForSwap(data: TransactionParams | undefined): Promise<string | null | undefined>;
+    hasInsufficientToken(sourceTokenAmount: string, sourceTokenAddress: string): boolean;
+    setTransactionDetails(): void;
+};
+export {};

package/dist/types/src/controllers/ThemeController.d.ts

@@ -0,0 +1,29 @@
+import type { ThemeMode, ThemeVariables } from '../utils/TypeUtil.js';
+import type { W3mThemeVariables } from '@reown/appkit-common';
+export interface ThemeControllerState {
+    themeMode: ThemeMode;
+    themeVariables: ThemeVariables;
+    w3mThemeVariables: W3mThemeVariables | undefined;
+}
+export declare const ThemeController: {
+    state: ThemeControllerState;
+    subscribe(callback: (newState: ThemeControllerState) => void): () => void;
+    setThemeMode(themeMode: ThemeControllerState['themeMode']): void;
+    setThemeVariables(themeVariables: ThemeControllerState['themeVariables']): void;
+    getSnapshot(): {
+        readonly themeMode: ThemeMode;
+        readonly themeVariables: {
+            readonly '--w3m-font-family'?: string | undefined;
+            readonly '--w3m-accent'?: string | undefined;
+            readonly '--w3m-color-mix'?: string | undefined;
+            readonly '--w3m-color-mix-strength'?: number | undefined;
+            readonly '--w3m-font-size-master'?: string | undefined;
+            readonly '--w3m-border-radius-master'?: string | undefined;
+            readonly '--w3m-z-index'?: number | undefined;
+        };
+        readonly w3mThemeVariables: {
+            readonly '--w3m-accent': string;
+            readonly '--w3m-background': string;
+        } | undefined;
+    };
+};

package/dist/types/src/controllers/TooltipController.d.ts

@@ -0,0 +1,24 @@
+type TriggerRect = {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+export interface TooltipControllerState {
+    message: string;
+    triggerRect: TriggerRect;
+    open: boolean;
+    variant: 'shade' | 'fill';
+}
+export declare const TooltipController: {
+    state: TooltipControllerState;
+    subscribe(callback: (newState: TooltipControllerState) => void): () => void;
+    subscribeKey<K extends keyof TooltipControllerState>(key: K, callback: (value: TooltipControllerState[K]) => void): () => void;
+    showTooltip({ message, triggerRect, variant }: {
+        message: string;
+        triggerRect: TriggerRect;
+        variant: 'shade' | 'fill';
+    }): void;
+    hide(): void;
+};
+export {};

package/dist/types/src/controllers/TransactionsController.d.ts

@@ -0,0 +1,25 @@
+import type { Transaction } from '@reown/appkit-common';
+import type { CaipNetworkId } from '@reown/appkit-common';
+type TransactionByMonthMap = Record<number, Transaction[]>;
+type TransactionByYearMap = Record<number, TransactionByMonthMap>;
+export interface TransactionsControllerState {
+    transactions: Transaction[];
+    coinbaseTransactions: TransactionByYearMap;
+    transactionsByYear: TransactionByYearMap;
+    lastNetworkInView: CaipNetworkId | undefined;
+    loading: boolean;
+    empty: boolean;
+    next: string | undefined;
+}
+export declare const TransactionsController: {
+    state: TransactionsControllerState;
+    subscribe(callback: (newState: TransactionsControllerState) => void): () => void;
+    setLastNetworkInView(lastNetworkInView: TransactionsControllerState['lastNetworkInView']): void;
+    fetchTransactions(accountAddress?: string, onramp?: 'coinbase'): Promise<void>;
+    groupTransactionsByYearAndMonth(transactionsMap?: TransactionByYearMap, transactions?: Transaction[]): TransactionByYearMap;
+    filterSpamTransactions(transactions: Transaction[]): Transaction[];
+    filterByConnectedChain(transactions: Transaction[]): Transaction[];
+    clearCursor(): void;
+    resetTransactions(): void;
+};
+export {};

package/dist/types/src/utils/AssetUtil.d.ts

@@ -0,0 +1,11 @@
+import type { ChainNamespace, CaipNetwork } from '@reown/appkit-common';
+import type { Connector, WcWallet } from './TypeUtil.js';
+export declare const AssetUtil: {
+    fetchWalletImage(imageId?: string): Promise<string | undefined>;
+    getWalletImageById(imageId?: string): string | undefined;
+    getWalletImage(wallet?: WcWallet): string | undefined;
+    getNetworkImage(network?: CaipNetwork): string | undefined;
+    getNetworkImageById(imageId?: string): string | undefined;
+    getConnectorImage(connector?: Connector): string | undefined;
+    getChainImage(chain: ChainNamespace): string | undefined;
+};

package/dist/types/src/utils/ConstantsUtil.d.ts

@@ -0,0 +1,45 @@
+import type { Features } from './TypeUtil.js';
+export declare const ONRAMP_PROVIDERS: {
+    label: string;
+    name: string;
+    feeRange: string;
+    url: string;
+    supportedChains: string[];
+}[];
+export declare const MELD_DEV_PUBLIC_KEY = "WXETMsajb7XcQBm7mcxAab:q3MtzJpiEMtXVNXsqYkAnAaBkgStybGVtZ";
+export declare const MELD_PROD_PUBLIC_KEY = "WXETMuFUQmqqybHuRkSgxv:25B8LJHSfpG6LVjR2ytU5Cwh7Z4Sch2ocoU";
+export declare const ConstantsUtil: {
+    FOUR_MINUTES_MS: number;
+    TEN_SEC_MS: number;
+    ONE_SEC_MS: number;
+    SECURE_SITE: string;
+    SECURE_SITE_DASHBOARD: string;
+    SECURE_SITE_FAVICON: string;
+    RESTRICTED_TIMEZONES: string[];
+    /**
+     * Network name to Coinbase Pay SDK chain name map object
+     * @see supported chain names on Coinbase for Pay SDK: https://github.com/coinbase/cbpay-js/blob/d4bda2c05c4d5917c8db6a05476b603546046394/src/types/onramp.ts
+     */
+    WC_COINBASE_PAY_SDK_CHAINS: string[];
+    WC_COINBASE_PAY_SDK_FALLBACK_CHAIN: string;
+    WC_COINBASE_PAY_SDK_CHAIN_NAME_MAP: {
+        Ethereum: string;
+        'Arbitrum One': string;
+        Polygon: string;
+        Avalanche: string;
+        'OP Mainnet': string;
+        Celo: string;
+        Base: string;
+    };
+    WC_COINBASE_ONRAMP_APP_ID: string;
+    SWAP_SUGGESTED_TOKENS: string[];
+    SWAP_POPULAR_TOKENS: string[];
+    SWAP_SUPPORTED_NETWORKS: string[];
+    NATIVE_TOKEN_ADDRESS: {
+        readonly eip155: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+        readonly solana: "So11111111111111111111111111111111111111111";
+        readonly polkadot: "0x";
+    };
+    CONVERT_SLIPPAGE_TOLERANCE: number;
+    DEFAULT_FEATURES: Features;
+};

package/dist/types/src/utils/CoreHelperUtil.d.ts

@@ -0,0 +1,43 @@
+import type { Balance, ChainNamespace } from '@reown/appkit-common';
+import type { CaipAddress, CaipNetwork } from '@reown/appkit-common';
+import type { LinkingRecord } from './TypeUtil.js';
+export declare const CoreHelperUtil: {
+    isMobile(): boolean;
+    checkCaipNetwork(network: CaipNetwork | undefined, networkName?: string): boolean | undefined;
+    isAndroid(): boolean;
+    isIos(): boolean;
+    isClient(): boolean;
+    isPairingExpired(expiry?: number): boolean;
+    isAllowedRetry(lastRetry: number): boolean;
+    copyToClopboard(text: string): void;
+    getPairingExpiry(): number;
+    getNetworkId(caipAddress: CaipAddress | undefined): string | undefined;
+    getPlainAddress(caipAddress: CaipAddress | undefined): string | undefined;
+    wait(milliseconds: number): Promise<unknown>;
+    debounce(func: (...args: any[]) => unknown, timeout?: number): (...args: unknown[]) => void;
+    isHttpUrl(url: string): boolean;
+    formatNativeUrl(appUrl: string, wcUri: string): LinkingRecord;
+    formatUniversalUrl(appUrl: string, wcUri: string): LinkingRecord;
+    openHref(href: string, target: '_blank' | '_self' | 'popupWindow', features?: string): void;
+    returnOpenHref(href: string, target: '_blank' | '_self' | 'popupWindow', features?: string): Window | null;
+    preloadImage(src: string): Promise<unknown>;
+    formatBalance(balance: string | undefined, symbol: string | undefined): string;
+    formatBalance2(balance: string | undefined, symbol: string | undefined): {
+        value: string;
+        rest: string;
+        symbol: string | undefined;
+    };
+    getApiUrl(): "https://api.web3modal.org";
+    getBlockchainApiUrl(): "https://rpc.walletconnect.org";
+    getAnalyticsUrl(): "https://pulse.walletconnect.org";
+    getUUID(): string;
+    parseError(error: any): string;
+    sortRequestedNetworks(approvedIds: `${string}:${string}`[] | undefined, requestedNetworks?: CaipNetwork[]): CaipNetwork[];
+    calculateBalance(array: Balance[]): number;
+    formatTokenBalance(number: number): {
+        dollars: string | undefined;
+        pennies: string | undefined;
+    };
+    isAddress(address: string, chain?: ChainNamespace): boolean;
+    uniqueBy<T>(arr: T[], key: keyof T): T[];
+};

package/dist/types/src/utils/EnsUtil.d.ts

@@ -0,0 +1,3 @@
+export declare const EnsUtil: {
+    convertEVMChainIdToCoinType(chainId: number): number;
+};

package/dist/types/src/utils/FetchUtil.d.ts

@@ -0,0 +1,26 @@
+interface Options {
+    baseUrl: string;
+    clientId: string | null;
+}
+interface RequestArguments {
+    path: string;
+    headers?: HeadersInit;
+    params?: Record<string, string | undefined>;
+    cache?: RequestCache;
+    signal?: AbortSignal;
+}
+interface PostArguments extends RequestArguments {
+    body?: Record<string, unknown>;
+}
+export declare class FetchUtil {
+    baseUrl: Options['baseUrl'];
+    clientId: Options['clientId'];
+    constructor({ baseUrl, clientId }: Options);
+    get<T>({ headers, signal, cache, ...args }: RequestArguments): Promise<T>;
+    getBlob({ headers, signal, ...args }: RequestArguments): Promise<Blob>;
+    post<T>({ body, headers, signal, ...args }: PostArguments): Promise<T>;
+    put<T>({ body, headers, signal, ...args }: PostArguments): Promise<T>;
+    delete<T>({ body, headers, signal, ...args }: PostArguments): Promise<T>;
+    private createUrl;
+}
+export {};

package/dist/types/src/utils/OptionsUtil.d.ts

@@ -0,0 +1,4 @@
+import type { Features, FeaturesKeys } from './TypeUtil.js';
+export declare const OptionsUtil: {
+    getFeatureValue(key: FeaturesKeys, features?: Features): boolean | import("./TypeUtil.js").FeaturesSocials[] | undefined;
+};

package/dist/types/src/utils/RouterUtil.d.ts

@@ -0,0 +1,4 @@
+export declare const RouterUtil: {
+    goBackOrCloseModal(): void;
+    navigateAfterNetworkSwitch(): void;
+};

package/dist/types/src/utils/StorageUtil.d.ts

@@ -0,0 +1,16 @@
+import type { WcWallet, ConnectorType, SocialProvider } from './TypeUtil.js';
+export declare const StorageUtil: {
+    setWalletConnectDeepLink({ href, name }: {
+        href: string;
+        name: string;
+    }): void;
+    getWalletConnectDeepLink(): any;
+    deleteWalletConnectDeepLink(): void;
+    setWeb3ModalRecent(wallet: WcWallet): void;
+    getRecentWallets(): WcWallet[];
+    setConnectedConnector(connectorType: ConnectorType): void;
+    getConnectedConnector(): ConnectorType | undefined;
+    setConnectedSocialProvider(socialProvider: SocialProvider): void;
+    getConnectedSocialProvider(): string | null | undefined;
+    getConnectedSocialUsername(): string | null | undefined;
+};

package/dist/types/src/utils/SwapApiUtil.d.ts

@@ -0,0 +1,23 @@
+import type { SwapTokenWithBalance } from './TypeUtil.js';
+import type { BlockchainApiSwapAllowanceRequest, BlockchainApiBalanceResponse } from './TypeUtil.js';
+export type TokenInfo = {
+    address: `0x${string}`;
+    symbol: string;
+    name: string;
+    decimals: number;
+    logoURI: string;
+    domainVersion?: string;
+    eip2612?: boolean;
+    isFoT?: boolean;
+    tags?: string[];
+};
+export declare const SwapApiUtil: {
+    getTokenList(): Promise<SwapTokenWithBalance[]>;
+    fetchGasPrice(): Promise<import("./TypeUtil.js").BlockchainApiGasPriceResponse | null>;
+    fetchSwapAllowance({ tokenAddress, userAddress, sourceTokenAmount, sourceTokenDecimals }: Pick<BlockchainApiSwapAllowanceRequest, "userAddress" | "tokenAddress"> & {
+        sourceTokenAmount: string;
+        sourceTokenDecimals: number;
+    }): Promise<boolean>;
+    getMyTokensWithBalance(forceUpdate?: string): Promise<SwapTokenWithBalance[]>;
+    mapBalancesToSwapTokens(balances: BlockchainApiBalanceResponse['balances']): SwapTokenWithBalance[];
+};

package/dist/types/src/utils/SwapCalculationUtil.d.ts

@@ -0,0 +1,22 @@
+import type { SwapTokenWithBalance } from './TypeUtil.js';
+export declare const SwapCalculationUtil: {
+    getGasPriceInEther(gas: bigint, gasPrice: bigint): number;
+    getGasPriceInUSD(networkPrice: string, gas: bigint, gasPrice: bigint): number;
+    getPriceImpact({ sourceTokenAmount, sourceTokenPriceInUSD, toTokenPriceInUSD, toTokenAmount }: {
+        sourceTokenAmount: string;
+        sourceTokenPriceInUSD: number;
+        toTokenPriceInUSD: number;
+        toTokenAmount: string;
+    }): number;
+    getMaxSlippage(slippage: number, toTokenAmount: string): number;
+    getProviderFee(sourceTokenAmount: string, feePercentage?: number): string;
+    isInsufficientNetworkTokenForGas(networkBalanceInUSD: string, gasPriceInUSD: number | undefined): boolean;
+    isInsufficientSourceTokenForSwap(sourceTokenAmount: string, sourceTokenAddress: string, balance: SwapTokenWithBalance[] | undefined): boolean;
+    getToTokenAmount({ sourceToken, toToken, sourceTokenPrice, toTokenPrice, sourceTokenAmount }: {
+        sourceToken: SwapTokenWithBalance | undefined;
+        toToken: SwapTokenWithBalance | undefined;
+        sourceTokenPrice: number;
+        toTokenPrice: number;
+        sourceTokenAmount: string;
+    }): string;
+};