@reown/appkit-controllers 1.7.0-rc.0

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

@@ -0,0 +1,30 @@
+import type { W3mThemeVariables } from '@reown/appkit-common';
+import type { ThemeMode, ThemeVariables } from '../utils/TypeUtil.js';
+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 '--w3m-qr-color'?: string | undefined;
+        };
+        readonly w3mThemeVariables: {
+            readonly '--w3m-accent': string;
+            readonly '--w3m-background': string;
+        } | undefined;
+    };
+};

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

@@ -0,0 +1,25 @@
+type TriggerRect = {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+export interface TooltipControllerState {
+    message: string;
+    triggerRect: TriggerRect;
+    open: boolean;
+    variant: 'shade' | 'fill';
+}
+type StateKey = keyof TooltipControllerState;
+export declare const TooltipController: {
+    state: TooltipControllerState;
+    subscribe(callback: (newState: TooltipControllerState) => void): () => void;
+    subscribeKey<K extends StateKey>(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,15 @@
+import type { CaipNetwork, ChainNamespace } from '@reown/appkit-common';
+import type { Connector, WcWallet } from './TypeUtil.js';
+export interface AssetUtilState {
+    networkImagePromises: Record<string, Promise<void>>;
+}
+export declare const AssetUtil: {
+    fetchWalletImage(imageId?: string): Promise<string | undefined>;
+    fetchNetworkImage(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,86 @@
+import { type ChainNamespace } from '@reown/appkit-common';
+import type { SocialProvider } from './TypeUtil.js';
+export declare const ONRAMP_PROVIDERS: {
+    label: string;
+    name: string;
+    feeRange: string;
+    url: string;
+    supportedChains: string[];
+}[];
+export declare const MELD_PUBLIC_KEY = "WXETMuFUQmqqybHuRkSgxv:25B8LJHSfpG6LVjR2ytU5Cwh7Z4Sch2ocoU";
+export declare const ConstantsUtil: {
+    FOUR_MINUTES_MS: number;
+    TEN_SEC_MS: number;
+    FIVE_SEC_MS: number;
+    THREE_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;
+        Berachain: string;
+        Avalanche: string;
+        'OP Mainnet': string;
+        Celo: string;
+        Base: string;
+    };
+    WC_COINBASE_ONRAMP_APP_ID: string;
+    SWAP_SUGGESTED_TOKENS: string[];
+    SWAP_POPULAR_TOKENS: string[];
+    BALANCE_SUPPORTED_CHAINS: ChainNamespace[];
+    SWAP_SUPPORTED_NETWORKS: string[];
+    NAMES_SUPPORTED_CHAIN_NAMESPACES: ChainNamespace[];
+    ONRAMP_SUPPORTED_CHAIN_NAMESPACES: ChainNamespace[];
+    ACTIVITY_ENABLED_CHAIN_NAMESPACES: ChainNamespace[];
+    NATIVE_TOKEN_ADDRESS: {
+        readonly eip155: "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+        readonly solana: "So11111111111111111111111111111111111111111";
+        readonly polkadot: "0x";
+        readonly bip122: "0x";
+    };
+    CONVERT_SLIPPAGE_TOLERANCE: number;
+    CONNECT_LABELS: {
+        MOBILE: string;
+    };
+    DEFAULT_FEATURES: {
+        swaps: true;
+        onramp: true;
+        receive: true;
+        send: true;
+        email: true;
+        emailShowWallets: true;
+        socials: SocialProvider[];
+        history: true;
+        analytics: true;
+        allWallets: true;
+        legalCheckbox: false;
+        smartSessions: false;
+        collapseWallets: false;
+        walletFeaturesOrder: ("swaps" | "onramp" | "receive" | "send")[];
+        connectMethodsOrder: undefined;
+    };
+    DEFAULT_ACCOUNT_TYPES: {
+        readonly bip122: "payment";
+        readonly eip155: "smartAccount";
+        readonly polkadot: "eoa";
+        readonly solana: "eoa";
+    };
+    ADAPTER_TYPES: {
+        UNIVERSAL: string;
+        SOLANA: string;
+        WAGMI: string;
+        ETHERS: string;
+        ETHERS5: string;
+        BITCOIN: string;
+    };
+};

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

@@ -0,0 +1,56 @@
+import type { Balance, ChainNamespace, SdkVersion } from '@reown/appkit-common';
+import type { CaipAddress, CaipNetwork } from '@reown/appkit-common';
+import type { AccountTypeMap, ChainAdapter, LinkingRecord, NamespaceTypeMap } from './TypeUtil.js';
+type SDKFramework = 'html' | 'react' | 'vue';
+type OpenTarget = '_blank' | '_self' | 'popupWindow' | '_top';
+export declare const CoreHelperUtil: {
+    isMobile(): boolean;
+    checkCaipNetwork(network: CaipNetwork | undefined, networkName?: string): boolean | undefined;
+    isAndroid(): boolean;
+    isIos(): boolean;
+    isSafari(): boolean;
+    isClient(): boolean;
+    isPairingExpired(expiry?: number): boolean;
+    isAllowedRetry(lastRetry: number, differenceMs?: number): boolean;
+    copyToClopboard(text: string): void;
+    isIframe(): boolean;
+    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;
+    getOpenTargetForPlatform(target: OpenTarget): "_blank" | "_self" | "popupWindow" | "_top";
+    openHref(href: string, target: OpenTarget, features?: string): void;
+    returnOpenHref(href: string, target: OpenTarget, features?: string): Window | null;
+    isTelegram(): boolean;
+    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[];
+    generateSdkVersion(adapters: ChainAdapter[], platform: SDKFramework, version: string): SdkVersion;
+    createAccount<N extends ChainNamespace>(namespace: N, address: string, type: NamespaceTypeMap[N], publicKey?: string, path?: string): AccountTypeMap[N];
+    isCaipAddress(address?: unknown): address is CaipAddress;
+    isMac(): boolean;
+    formatTelegramSocialLoginUrl(url: string): string;
+    injectIntoUrl(url: string, key: string, appendString: string): string;
+};
+export {};

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

@@ -0,0 +1,67 @@
+import type { Balance, CaipNetworkId, ChainNamespace } from '@reown/appkit-common';
+type Hex = `0x${string}`;
+interface Asset {
+    address: `0x${string}` | 'native';
+    balance: `0x${string}`;
+    type: 'NATIVE' | 'ERC20';
+    metadata: Record<string, unknown>;
+}
+export interface WalletGetAssetsRequest {
+    account: Hex;
+    assetFilter?: Record<Hex, (Hex | 'native')[]>;
+    assetTypeFilter?: ('NATIVE' | 'ERC20')[];
+    chainFilter?: Hex[];
+}
+export type WalletGetAssetsResponse = Record<Hex, Asset[]>;
+export declare const ERC7811Utils: {
+    /**
+     * Creates a Balance object from an ERC7811 Asset object
+     * @param asset - Asset object to convert
+     * @param chainId - Chain ID in CAIP-2 format
+     * @returns Balance object
+     */
+    createBalance(asset: Asset, chainId: string): Balance;
+    /**
+     * Converts a hex string to a Balance object
+     * @param hex - Hex string to convert
+     * @param decimals - Number of decimals to use
+     * @returns Balance object
+     */
+    convertHexToBalance({ hex, decimals }: {
+        hex: `0x${string}`;
+        decimals: number;
+    }): string;
+    /**
+     * Converts an address to a CAIP-10 address
+     * @param address - Address to convert
+     * @param chainId - Chain ID in CAIP-2 format
+     * @returns CAIP-10 address
+     */
+    convertAddressToCAIP10Address(address: `0x${string}`, chainId: string): string;
+    /**
+     *  Creates a CAIP-2 Chain ID from a chain ID and namespace
+     * @param chainId  - Chain ID in hex format
+     * @param namespace  - Chain namespace
+     * @returns
+     */
+    createCAIP2ChainId(chainId: `0x${string}`, namespace: ChainNamespace): string;
+    /**
+     * Gets the chain ID in hex format from a CAIP-2 Chain ID
+     * @param caip2ChainId - CAIP-2 Chain ID
+     * @returns Chain ID in hex format
+     */
+    getChainIdHexFromCAIP2ChainId(caip2ChainId: CaipNetworkId): `0x${string}`;
+    /**
+     * Checks if a response is a valid WalletGetAssetsResponse
+     * @param response - The response to check
+     * @returns True if the response is a valid WalletGetAssetsResponse, false otherwise
+     */
+    isWalletGetAssetsResponse(response: WalletGetAssetsResponse): response is WalletGetAssetsResponse;
+    /**
+     * Checks if an asset object is valid.
+     * @param asset - The asset object to check.
+     * @returns True if the asset is valid, false otherwise.
+     */
+    isValidAsset(asset: Asset): asset is Asset;
+};
+export {};

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;
+}
+export 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/MobileWallet.d.ts

@@ -0,0 +1,9 @@
+export declare const MobileWalletUtil: {
+    /**
+     * Handles mobile wallet redirection for wallets that have Universal Links.
+     *
+     * @param {Object} properties - The properties object.
+     * @param {string} properties.name - The name of the wallet.
+     */
+    handleSolanaDeeplinkRedirect(name: string): void;
+};

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

@@ -0,0 +1,5 @@
+import type { Features, FeaturesKeys } from './TypeUtil.js';
+export declare const OptionsUtil: {
+    getFeatureValue(key: FeaturesKeys, features?: Features): boolean | import("./TypeUtil.js").SocialProvider[] | import("./TypeUtil.js").WalletFeature[] | import("./TypeUtil.js").ConnectMethod[] | undefined;
+    filterSocialsByPlatform<T>(socials: Features["socials"]): T | import("./TypeUtil.js").SocialProvider[];
+};

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/SIWXUtil.d.ts

@@ -0,0 +1,183 @@
+import UniversalProvider from '@walletconnect/universal-provider';
+import type { CaipNetworkId } from '@reown/appkit-common';
+/**
+ * SIWXUtil holds the methods to interact with the SIWX plugin and must be called internally on AppKit.
+ */
+export declare const SIWXUtil: {
+    getSIWX(): SIWXConfig | undefined;
+    initializeIfEnabled(): Promise<void>;
+    requestSignMessage(): Promise<void>;
+    cancelSignMessage(): Promise<void>;
+    getSessions(): Promise<SIWXSession[]>;
+    isSIWXCloseDisabled(): Promise<boolean | undefined>;
+    universalProviderAuthenticate({ universalProvider, chains, methods }: {
+        universalProvider: UniversalProvider;
+        chains: CaipNetworkId[];
+        methods: string[];
+    }): Promise<boolean>;
+    getSIWXEventProperties(): {
+        network: string;
+        isSmartAccount: boolean;
+    };
+    clearSessions(): Promise<void>;
+};
+/**
+ * This interface represents the SIWX configuration plugin, which is used to create and manage SIWX messages and sessions.
+ * AppKit provides predefined implementations for this interface through `@reown/appkit-siwx`.
+ * You may use it to create a custom implementation following your needs, but watch close for the methods requirements.
+ */
+export interface SIWXConfig {
+    /**
+     * This method will be called to create a new message to be signed by the user.
+     *
+     * Constraints:
+     * - The message MUST be unique and contain all the necessary information to verify the user's identity.
+     * - SIWXMessage.toString() method MUST be implemented to return the message string.
+     *
+     * @param input SIWXMessage.Input
+     * @returns SIWXMessage
+     */
+    createMessage: (input: SIWXMessage.Input) => Promise<SIWXMessage>;
+    /**
+     * This method will be called to store a new single session.
+     *
+     * Constraints:
+     * - This method MUST verify if the session is valid and store it in the storage successfully.
+     *
+     * @param session SIWXSession
+     */
+    addSession: (session: SIWXSession) => Promise<void>;
+    /**
+     * This method will be called to revoke all the sessions stored for a specific chain and address.
+     *
+     * Constraints:
+     * - This method MUST delete all the sessions stored for the specific chain and address successfully.
+     *
+     * @param chainId CaipNetworkId
+     * @param address string
+     */
+    revokeSession: (chainId: CaipNetworkId, address: string) => Promise<void>;
+    /**
+     * This method will be called to replace all the sessions in the storage with the new ones.
+     *
+     * Constraints:
+     * - This method MUST verify all the sessions before storing them in the storage;
+     * - This method MUST replace all the sessions in the storage with the new ones succesfully otherwise it MUST throw an error.
+     *
+     * @param sessions SIWXSession[]
+     */
+    setSessions: (sessions: SIWXSession[]) => Promise<void>;
+    /**
+     * This method will be called to get all the sessions stored for a specific chain and address.
+     *
+     * Constraints:
+     * - This method MUST return only sessions that are verified and valid;
+     * - This method MUST NOT return expired sessions.
+     *
+     * @param chainId CaipNetworkId
+     * @param address string
+     * @returns
+     */
+    getSessions: (chainId: CaipNetworkId, address: string) => Promise<SIWXSession[]>;
+    /**
+     * This method determines whether the wallet stays connected when the user denies the signature request.
+     *
+     * @returns {boolean}
+     */
+    getRequired?: () => boolean;
+}
+/**
+ * This interface represents a SIWX session, which is used to store the user's identity information.
+ */
+export interface SIWXSession {
+    data: SIWXMessage.Data;
+    message: string;
+    signature: string;
+    cacao?: Cacao;
+}
+/**
+ * This interface represents a SIWX message, which is used to create a message to be signed by the user.
+ * This must contain the necessary information to verify the user's identity and how to generate the string message.
+ */
+export interface SIWXMessage extends SIWXMessage.Data, SIWXMessage.Methods {
+}
+export declare namespace SIWXMessage {
+    /**
+     * This interface represents the SIWX message data, which is used to create a message to be signed by the user.
+     */
+    interface Data extends Input, Metadata, Identifier {
+    }
+    /**
+     * This interface represents the SIWX message input.
+     * Here must contain what is different for each user of the application.
+     */
+    interface Input {
+        accountAddress: string;
+        chainId: CaipNetworkId;
+        notBefore?: Timestamp;
+    }
+    /**
+     * This interface represents the SIWX message metadata.
+     * Here must contain the main data related to the app.
+     */
+    interface Metadata {
+        domain: string;
+        uri: string;
+        version: string;
+        nonce: string;
+        statement?: string;
+        resources?: string[];
+    }
+    /**
+     * This interface represents the SIWX message identifier.
+     * Here must contain the request id and the timestamps.
+     */
+    interface Identifier {
+        requestId?: string;
+        issuedAt?: Timestamp;
+        expirationTime?: Timestamp;
+    }
+    /**
+     * This interface represents the SIWX message methods.
+     * Here must contain the method to generate the message string and any other method performed by the SIWX message.
+     */
+    interface Methods {
+        toString: () => string;
+    }
+    /**
+     * The timestamp is a UTC string representing the time in ISO 8601 format.
+     */
+    type Timestamp = string;
+}
+/**
+ * The Cacao interface is a reference of CAIP-74 and represents a chain-agnostic Object Capability (OCAP).
+ * https://chainagnostic.org/CAIPs/caip-74
+ */
+export interface Cacao {
+    h: Cacao.Header;
+    p: Cacao.Payload;
+    s: {
+        t: 'eip191' | 'eip1271';
+        s: string;
+        m?: string;
+    };
+}
+export declare namespace Cacao {
+    interface Header {
+        t: 'caip122';
+    }
+    interface Payload {
+        domain: string;
+        aud: string;
+        nonce: string;
+        iss: string;
+        version?: string;
+        iat?: string;
+        nbf?: string;
+        exp?: string;
+        statement?: string;
+        requestId?: string;
+        resources?: string[];
+        type?: string;
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { CaipNetwork } from '@reown/appkit-common';
+import type { SwapTokenWithBalance } from './TypeUtil.js';
+import type { BlockchainApiBalanceResponse } from './TypeUtil.js';
+export declare const SendApiUtil: {
+    getMyTokensWithBalance(forceUpdate?: string): Promise<BlockchainApiBalanceResponse["balances"]>;
+    getEIP155Balances(address: string, caipNetwork: CaipNetwork): Promise<import("@reown/appkit-common").Balance[] | null>;
+    /**
+     * The 1Inch API includes many low-quality tokens in the balance response,
+     * which appear inconsistently. This filter prevents them from being displayed.
+     */
+    filterLowQualityTokens(balances: BlockchainApiBalanceResponse["balances"]): import("@reown/appkit-common").Balance[];
+    mapBalancesToSwapTokens(balances: BlockchainApiBalanceResponse["balances"]): SwapTokenWithBalance[];
+};

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

@@ -0,0 +1,99 @@
+import { type CaipNetworkId, type ChainNamespace } from '@reown/appkit-common';
+import type { BlockchainApiBalanceResponse, BlockchainApiIdentityResponse, BlockchainApiLookupEnsName, ConnectionStatus, SocialProvider, WcWallet } from './TypeUtil.js';
+export declare const StorageUtil: {
+    cacheExpiry: {
+        portfolio: number;
+        nativeBalance: number;
+        ens: number;
+        identity: number;
+    };
+    isCacheExpired(timestamp: number, cacheExpiry: number): boolean;
+    getActiveNetworkProps(): {
+        namespace: ChainNamespace | undefined;
+        caipNetworkId: `eip155:${string}` | `eip155:${number}` | `solana:${string}` | `solana:${number}` | `polkadot:${string}` | `polkadot:${number}` | `bip122:${string}` | `bip122:${number}` | undefined;
+        chainId: string | number | undefined;
+    };
+    setWalletConnectDeepLink({ name, href }: {
+        href: string;
+        name: string;
+    }): void;
+    getWalletConnectDeepLink(): any;
+    deleteWalletConnectDeepLink(): void;
+    setActiveNamespace(namespace: ChainNamespace): void;
+    setActiveCaipNetworkId(caipNetworkId: CaipNetworkId): void;
+    getActiveCaipNetworkId(): `eip155:${string}` | `solana:${string}` | `polkadot:${string}` | `bip122:${string}` | undefined;
+    deleteActiveCaipNetworkId(): void;
+    deleteConnectedConnectorId(namespace: ChainNamespace): void;
+    setAppKitRecent(wallet: WcWallet): void;
+    getRecentWallets(): WcWallet[];
+    setConnectedConnectorId(namespace: ChainNamespace, connectorId: string): void;
+    getActiveNamespace(): ChainNamespace | undefined;
+    getConnectedConnectorId(namespace: ChainNamespace | undefined): string | undefined;
+    setConnectedSocialProvider(socialProvider: SocialProvider): void;
+    getConnectedSocialProvider(): string | undefined;
+    deleteConnectedSocialProvider(): void;
+    getConnectedSocialUsername(): string | undefined;
+    getStoredActiveCaipNetworkId(): string | undefined;
+    setConnectionStatus(status: ConnectionStatus): void;
+    getConnectionStatus(): ConnectionStatus | undefined;
+    getConnectedNamespaces(): ChainNamespace[];
+    setConnectedNamespaces(namespaces: ChainNamespace[]): void;
+    addConnectedNamespace(namespace: ChainNamespace): void;
+    removeConnectedNamespace(namespace: ChainNamespace): void;
+    getTelegramSocialProvider(): SocialProvider | null | undefined;
+    setTelegramSocialProvider(socialProvider: SocialProvider): void;
+    removeTelegramSocialProvider(): void;
+    getBalanceCache(): Record<string, {
+        timestamp: number;
+        balance: BlockchainApiBalanceResponse;
+    }>;
+    removeAddressFromBalanceCache(caipAddress: string): void;
+    getBalanceCacheForCaipAddress(caipAddress: string): BlockchainApiBalanceResponse | undefined;
+    updateBalanceCache(params: {
+        caipAddress: string;
+        balance: BlockchainApiBalanceResponse;
+        timestamp: number;
+    }): void;
+    getNativeBalanceCache(): Record<string, {
+        caipAddress: string;
+        balance: string;
+        symbol: string;
+        timestamp: number;
+    }>;
+    removeAddressFromNativeBalanceCache(caipAddress: string): void;
+    getNativeBalanceCacheForCaipAddress(caipAddress: string): {
+        caipAddress: string;
+        balance: string;
+        symbol: string;
+        timestamp: number;
+    } | undefined;
+    updateNativeBalanceCache(params: {
+        caipAddress: string;
+        balance: string;
+        symbol: string;
+        timestamp: number;
+    }): void;
+    getEnsCache(): Record<string, {
+        ens: BlockchainApiLookupEnsName[];
+        timestamp: number;
+    }>;
+    getEnsFromCacheForAddress(address: string): BlockchainApiLookupEnsName[] | undefined;
+    updateEnsCache(params: {
+        address: string;
+        timestamp: number;
+        ens: BlockchainApiLookupEnsName[];
+    }): void;
+    removeEnsFromCache(address: string): void;
+    getIdentityCache(): Record<string, {
+        identity: BlockchainApiIdentityResponse;
+        timestamp: number;
+    }>;
+    getIdentityFromCacheForAddress(address: string): BlockchainApiIdentityResponse | undefined;
+    updateIdentityCache(params: {
+        address: string;
+        timestamp: number;
+        identity: BlockchainApiIdentityResponse;
+    }): void;
+    removeIdentityFromCache(address: string): void;
+    clearAddressCache(): void;
+};