@reown/appkit-controllers 1.7.0-rc.0

package/dist/types/exports/index.d.ts

@@ -0,0 +1,51 @@
+export { ModalController } from '../src/controllers/ModalController.js';
+export type { ModalControllerArguments, ModalControllerState } from '../src/controllers/ModalController.js';
+export { RouterController } from '../src/controllers/RouterController.js';
+export type { RouterControllerState } from '../src/controllers/RouterController.js';
+export { AccountController } from '../src/controllers/AccountController.js';
+export type { AccountControllerState } from '../src/controllers/AccountController.js';
+export { ChainController } from '../src/controllers/ChainController.js';
+export type { ChainControllerState } from '../src/controllers/ChainController.js';
+export { OnRampController } from '../src/controllers/OnRampController.js';
+export type { OnRampControllerState, OnRampProvider } from '../src/controllers/OnRampController.js';
+export { ConnectionController } from '../src/controllers/ConnectionController.js';
+export type { ConnectionControllerClient, ConnectionControllerState } from '../src/controllers/ConnectionController.js';
+export { ConnectorController } from '../src/controllers/ConnectorController.js';
+export type { ConnectorControllerState, ConnectorWithProviders } from '../src/controllers/ConnectorController.js';
+export { SnackController } from '../src/controllers/SnackController.js';
+export type { SnackControllerState } from '../src/controllers/SnackController.js';
+export { ApiController } from '../src/controllers/ApiController.js';
+export type { ApiControllerState } from '../src/controllers/ApiController.js';
+export { AssetController } from '../src/controllers/AssetController.js';
+export type { AssetControllerState } from '../src/controllers/AssetController.js';
+export { ThemeController } from '../src/controllers/ThemeController.js';
+export type { ThemeControllerState } from '../src/controllers/ThemeController.js';
+export { OptionsController } from '../src/controllers/OptionsController.js';
+export type { OptionsControllerStatePublic as OptionsControllerState, OptionsControllerStateInternal } from '../src/controllers/OptionsController.js';
+export { BlockchainApiController } from '../src/controllers/BlockchainApiController.js';
+export { PublicStateController } from '../src/controllers/PublicStateController.js';
+export type { PublicStateControllerState } from '../src/controllers/PublicStateController.js';
+export { EventsController } from '../src/controllers/EventsController.js';
+export type { EventsControllerState } from '../src/controllers/EventsController.js';
+export { TransactionsController } from '../src/controllers/TransactionsController.js';
+export type { TransactionsControllerState } from '../src/controllers/TransactionsController.js';
+export { SwapController } from '../src/controllers/SwapController.js';
+export type { SwapControllerState, SwapInputTarget } from '../src/controllers/SwapController.js';
+export { SendController } from '../src/controllers/SendController.js';
+export type { SendControllerState } from '../src/controllers/SendController.js';
+export { TooltipController } from '../src/controllers/TooltipController.js';
+export type { TooltipControllerState } from '../src/controllers/TooltipController.js';
+export { EnsController } from '../src/controllers/EnsController.js';
+export type { EnsControllerState } from '../src/controllers/EnsController.js';
+export { AlertController } from '../src/controllers/AlertController.js';
+export type { AlertControllerState } from '../src/controllers/AlertController.js';
+export { AssetUtil } from '../src/utils/AssetUtil.js';
+export { ConstantsUtil } from '../src/utils/ConstantsUtil.js';
+export { CoreHelperUtil } from '../src/utils/CoreHelperUtil.js';
+export { StorageUtil } from '../src/utils/StorageUtil.js';
+export { RouterUtil } from '../src/utils/RouterUtil.js';
+export { OptionsUtil } from '../src/utils/OptionsUtil.js';
+export { SIWXUtil } from '../src/utils/SIWXUtil.js';
+export { FetchUtil } from '../src/utils/FetchUtil.js';
+export type * from '../src/utils/TypeUtil.js';
+export type * from '../src/utils/SIWXUtil.js';

package/dist/types/exports/modal.d.ts

@@ -0,0 +1,2 @@
+export { modalState, subscribeModal, subscribeModalKey, setModalLoading, shakeModal, openModal, closeModal } from '../src/controllers/ModalController.js';
+export type { ModalControllerArguments, ModalControllerState } from '../src/controllers/ModalController.js';

package/dist/types/exports/react.d.ts

@@ -0,0 +1,9 @@
+import type { ChainNamespace } from '@reown/appkit-common';
+import type { UseAppKitAccountReturn, UseAppKitNetworkReturn } from '../src/utils/TypeUtil.js';
+export declare function useAppKitNetworkCore(): Pick<UseAppKitNetworkReturn, 'caipNetwork' | 'chainId' | 'caipNetworkId'>;
+export declare function useAppKitAccount(options?: {
+    namespace?: ChainNamespace;
+}): UseAppKitAccountReturn;
+export declare function useDisconnect(): {
+    disconnect: () => Promise<void>;
+};

package/dist/types/exports/vue.d.ts

@@ -0,0 +1,9 @@
+import { type Ref } from 'vue';
+import type { ChainNamespace } from '@reown/appkit-common';
+import type { UseAppKitAccountReturn } from '../src/utils/TypeUtil.js';
+export declare function useAppKitAccount(options?: {
+    namespace?: ChainNamespace;
+}): Ref<UseAppKitAccountReturn>;
+export declare function useDisconnect(): {
+    disconnect: () => Promise<void>;
+};

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

@@ -0,0 +1,56 @@
+import type { CaipAddress, ChainNamespace } from '@reown/appkit-common';
+import type { Balance } from '@reown/appkit-common';
+import type { W3mFrameTypes } from '@reown/appkit-wallet';
+import type { AccountType, AccountTypeMap, ConnectedWalletInfo, SocialProvider, User } from '../utils/TypeUtil.js';
+export interface AccountControllerState {
+    currentTab: number;
+    caipAddress?: CaipAddress;
+    user?: User;
+    address?: string;
+    addressLabels: Map<string, string>;
+    allAccounts: AccountType[];
+    balance?: string;
+    balanceSymbol?: string;
+    balanceLoading?: boolean;
+    profileName?: string | null;
+    profileImage?: string | null;
+    addressExplorerUrl?: string;
+    smartAccountDeployed?: boolean;
+    socialProvider?: SocialProvider;
+    tokenBalance?: Balance[];
+    shouldUpdateToAddress?: string;
+    connectedWalletInfo?: ConnectedWalletInfo;
+    preferredAccountType?: W3mFrameTypes.AccountType;
+    socialWindow?: Window;
+    farcasterUrl?: string;
+    status?: 'reconnecting' | 'connected' | 'disconnected' | 'connecting';
+    lastRetry?: number;
+}
+export declare const AccountController: {
+    state: AccountControllerState;
+    replaceState(newState: AccountControllerState | undefined): void;
+    subscribe(callback: (val: AccountControllerState) => void): () => void;
+    subscribeKey<K extends keyof AccountControllerState>(property: K, callback: (val: AccountControllerState[K]) => void, chain?: ChainNamespace): () => void;
+    setStatus(status: AccountControllerState["status"], chain: ChainNamespace | undefined): void;
+    getCaipAddress(chain: ChainNamespace | undefined): `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | `bip122:${string}:${string}` | `bip122:${number}:${string}` | undefined;
+    setCaipAddress(caipAddress: AccountControllerState["caipAddress"], chain: ChainNamespace | undefined): void;
+    setBalance(balance: AccountControllerState["balance"], balanceSymbol: AccountControllerState["balanceSymbol"], chain: ChainNamespace): void;
+    setProfileName(profileName: AccountControllerState["profileName"], chain: ChainNamespace): void;
+    setProfileImage(profileImage: AccountControllerState["profileImage"], chain?: ChainNamespace): void;
+    setUser(user: AccountControllerState["user"], chain: ChainNamespace | undefined): void;
+    setAddressExplorerUrl(explorerUrl: AccountControllerState["addressExplorerUrl"], chain: ChainNamespace | undefined): void;
+    setSmartAccountDeployed(isDeployed: boolean, chain: ChainNamespace | undefined): void;
+    setCurrentTab(currentTab: AccountControllerState["currentTab"]): void;
+    setTokenBalance(tokenBalance: AccountControllerState["tokenBalance"], chain: ChainNamespace | undefined): void;
+    setShouldUpdateToAddress(address: string, chain: ChainNamespace | undefined): void;
+    setAllAccounts<N extends ChainNamespace>(accounts: AccountTypeMap[N][], namespace: N): void;
+    addAddressLabel(address: string, label: string, chain: ChainNamespace | undefined): void;
+    removeAddressLabel(address: string, chain: ChainNamespace | undefined): void;
+    setConnectedWalletInfo(connectedWalletInfo: AccountControllerState["connectedWalletInfo"], chain: ChainNamespace): void;
+    setPreferredAccountType(preferredAccountType: AccountControllerState["preferredAccountType"], chain: ChainNamespace): void;
+    setSocialProvider(socialProvider: AccountControllerState["socialProvider"], chain: ChainNamespace | undefined): void;
+    setSocialWindow(socialWindow: AccountControllerState["socialWindow"], chain: ChainNamespace | undefined): void;
+    setFarcasterUrl(farcasterUrl: AccountControllerState["farcasterUrl"], chain: ChainNamespace | undefined): void;
+    fetchTokenBalance(onError?: (error: unknown) => void): Promise<Balance[]>;
+    resetAccount(chain: ChainNamespace): void;
+};

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

@@ -0,0 +1,17 @@
+export interface AlertControllerState {
+    message: string;
+    variant: 'info' | 'success' | 'warning' | 'error';
+    open: boolean;
+}
+type StateKey = keyof AlertControllerState;
+interface OpenMessageParameters {
+    shortMessage: string;
+    longMessage?: string | (() => void);
+}
+export declare const AlertController: {
+    state: AlertControllerState;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: AlertControllerState[K]) => void): () => void;
+    open(message: OpenMessageParameters, variant: AlertControllerState["variant"]): void;
+    close(): void;
+};
+export {};

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

@@ -0,0 +1,52 @@
+import { FetchUtil } from '../utils/FetchUtil.js';
+import type { ApiGetWalletsRequest, WcWallet } from '../utils/TypeUtil.js';
+export declare const api: FetchUtil;
+export interface ApiControllerState {
+    prefetchPromise?: Promise<unknown>;
+    page: number;
+    count: number;
+    featured: WcWallet[];
+    recommended: WcWallet[];
+    wallets: WcWallet[];
+    search: WcWallet[];
+    isAnalyticsEnabled: boolean;
+    excludedRDNS: string[];
+    isFetchingRecommendedWallets: boolean;
+}
+interface PrefetchParameters {
+    fetchConnectorImages?: boolean;
+    fetchFeaturedWallets?: boolean;
+    fetchRecommendedWallets?: boolean;
+    fetchNetworkImages?: boolean;
+}
+type StateKey = keyof ApiControllerState;
+export declare const ApiController: {
+    state: ApiControllerState;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: ApiControllerState[K]) => void): () => void;
+    _getSdkProperties(): {
+        projectId: string;
+        st: "appkit";
+        sv: import("../utils/TypeUtil.js").SdkVersion;
+    };
+    _filterOutExtensions(wallets: WcWallet[]): WcWallet[];
+    _fetchWalletImage(imageId: string): Promise<void>;
+    _fetchNetworkImage(imageId: string): Promise<void>;
+    _fetchConnectorImage(imageId: string): Promise<void>;
+    _fetchCurrencyImage(countryCode: string): Promise<void>;
+    _fetchTokenImage(symbol: string): Promise<void>;
+    fetchNetworkImages(): Promise<void>;
+    fetchConnectorImages(): Promise<void>;
+    fetchCurrencyImages(currencies?: string[]): Promise<void>;
+    fetchTokenImages(tokens?: string[]): Promise<void>;
+    fetchFeaturedWallets(): Promise<void>;
+    fetchRecommendedWallets(): Promise<void>;
+    fetchWallets({ page }: Pick<ApiGetWalletsRequest, "page">): Promise<void>;
+    initializeExcludedWalletRdns({ ids }: {
+        ids: string[];
+    }): Promise<void>;
+    searchWallet({ search, badge }: Pick<ApiGetWalletsRequest, "search" | "badge">): Promise<void>;
+    prefetch({ fetchConnectorImages, fetchFeaturedWallets, fetchRecommendedWallets, fetchNetworkImages }?: PrefetchParameters): Promise<unknown>;
+    prefetchAnalyticsConfig(): void;
+    fetchAnalyticsConfig(): Promise<void>;
+};
+export {};

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

@@ -0,0 +1,22 @@
+export interface AssetControllerState {
+    walletImages: Record<string, string>;
+    networkImages: Record<string, string>;
+    chainImages: Record<string, string>;
+    connectorImages: Record<string, string>;
+    tokenImages: Record<string, string>;
+    currencyImages: Record<string, string>;
+}
+type StateKey = keyof AssetControllerState;
+export declare const AssetController: {
+    state: AssetControllerState;
+    subscribeNetworkImages(callback: (value: AssetControllerState["networkImages"]) => void): () => void;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: AssetControllerState[K]) => void): () => void;
+    subscribe(callback: (newState: AssetControllerState) => void): () => void;
+    setWalletImage(key: string, value: string): void;
+    setNetworkImage(key: string, value: string): void;
+    setChainImage(key: string, value: string): void;
+    setConnectorImage(key: string, value: string): void;
+    setTokenImage(key: string, value: string): void;
+    setCurrencyImage(key: string, value: string): void;
+};
+export {};

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

@@ -0,0 +1,59 @@
+import type { CaipAddress, CaipNetworkId } from '@reown/appkit-common';
+import { FetchUtil, type RequestArguments } from '../utils/FetchUtil.js';
+import type { BlockchainApiBalanceResponse, BlockchainApiGasPriceRequest, BlockchainApiGasPriceResponse, BlockchainApiGenerateApproveCalldataRequest, BlockchainApiGenerateApproveCalldataResponse, BlockchainApiGenerateSwapCalldataRequest, BlockchainApiGenerateSwapCalldataResponse, BlockchainApiIdentityRequest, BlockchainApiIdentityResponse, BlockchainApiLookupEnsName, BlockchainApiRegisterNameParams, BlockchainApiSuggestionResponse, BlockchainApiSwapAllowanceRequest, BlockchainApiSwapQuoteRequest, BlockchainApiSwapQuoteResponse, BlockchainApiSwapTokensRequest, BlockchainApiSwapTokensResponse, BlockchainApiTokenPriceRequest, BlockchainApiTokenPriceResponse, BlockchainApiTransactionsRequest, BlockchainApiTransactionsResponse, GenerateOnRampUrlArgs, GetQuoteArgs, OnrampQuote, PaymentCurrency, PurchaseCurrency } from '../utils/TypeUtil.js';
+export interface BlockchainApiControllerState {
+    clientId: string | null;
+    api: FetchUtil;
+    supportedChains: {
+        http: CaipNetworkId[];
+        ws: CaipNetworkId[];
+    };
+}
+export declare const BlockchainApiController: {
+    state: BlockchainApiControllerState;
+    get<T>(request: RequestArguments): Promise<T>;
+    getSdkProperties(): {
+        st: "appkit";
+        sv: import("../utils/TypeUtil.js").SdkVersion;
+    };
+    isNetworkSupported(networkId?: CaipNetworkId): Promise<boolean>;
+    getSupportedNetworks(): Promise<{
+        http: CaipNetworkId[];
+        ws: CaipNetworkId[];
+    }>;
+    fetchIdentity({ address, caipNetworkId }: BlockchainApiIdentityRequest & {
+        caipNetworkId: CaipNetworkId;
+    }): Promise<BlockchainApiIdentityResponse>;
+    fetchTransactions({ account, cursor, onramp, signal, cache, chainId }: BlockchainApiTransactionsRequest): Promise<BlockchainApiTransactionsResponse | {
+        data: never[];
+        next: undefined;
+    }>;
+    fetchSwapQuote({ amount, userAddress, from, to, gasPrice }: BlockchainApiSwapQuoteRequest): Promise<BlockchainApiSwapQuoteResponse>;
+    fetchSwapTokens({ chainId }: BlockchainApiSwapTokensRequest): Promise<BlockchainApiSwapTokensResponse>;
+    fetchTokenPrice({ addresses }: BlockchainApiTokenPriceRequest): Promise<BlockchainApiTokenPriceResponse>;
+    fetchSwapAllowance({ tokenAddress, userAddress }: BlockchainApiSwapAllowanceRequest): Promise<{
+        allowance: string;
+    }>;
+    fetchGasPrice({ chainId }: BlockchainApiGasPriceRequest): Promise<BlockchainApiGasPriceResponse>;
+    generateSwapCalldata({ amount, from, to, userAddress }: BlockchainApiGenerateSwapCalldataRequest): Promise<BlockchainApiGenerateSwapCalldataResponse>;
+    generateApproveCalldata({ from, to, userAddress }: BlockchainApiGenerateApproveCalldataRequest): Promise<BlockchainApiGenerateApproveCalldataResponse>;
+    getBalance(address: string, chainId?: string, forceUpdate?: string): Promise<BlockchainApiBalanceResponse>;
+    lookupEnsName(name: string): Promise<BlockchainApiLookupEnsName | {
+        addresses: {};
+        attributes: never[];
+    }>;
+    reverseLookupEnsName({ address }: {
+        address: string;
+    }): Promise<BlockchainApiLookupEnsName[]>;
+    getEnsNameSuggestions(name: string): Promise<BlockchainApiSuggestionResponse>;
+    registerEnsName({ coinType, address, message, signature }: BlockchainApiRegisterNameParams): Promise<unknown>;
+    generateOnRampURL({ destinationWallets, partnerUserId, defaultNetwork, purchaseAmount, paymentAmount }: GenerateOnRampUrlArgs): Promise<string>;
+    getOnrampOptions(): Promise<{
+        paymentCurrencies: PaymentCurrency[];
+        purchaseCurrencies: PurchaseCurrency[];
+    }>;
+    getOnrampQuote({ purchaseCurrency, paymentCurrency, amount, network }: GetQuoteArgs): Promise<OnrampQuote | null>;
+    getSmartSessions(caipAddress: CaipAddress): Promise<unknown>;
+    revokeSmartSession(address: `0x${string}`, pci: string, signature: string): Promise<unknown>;
+    setClientId(clientId: string | null): void;
+};

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

@@ -0,0 +1,75 @@
+import { type CaipAddress, type CaipNetwork, type CaipNetworkId, type ChainNamespace } from '@reown/appkit-common';
+import type { AdapterNetworkState, ChainAdapter, NetworkControllerClient } from '../utils/TypeUtil.js';
+import { type AccountControllerState } from './AccountController.js';
+import { type ConnectionControllerClient } from './ConnectionController.js';
+export type ChainControllerClients = {
+    networkControllerClient: NetworkControllerClient;
+    connectionControllerClient: ConnectionControllerClient;
+};
+export interface ChainControllerState {
+    activeChain: ChainNamespace | undefined;
+    activeCaipAddress: CaipAddress | undefined;
+    activeCaipNetwork?: CaipNetwork;
+    chains: Map<ChainNamespace, ChainAdapter>;
+    universalAdapter: Pick<ChainAdapter, 'networkControllerClient' | 'connectionControllerClient'>;
+    noAdapters: boolean;
+    isSwitchingNamespace: boolean;
+}
+type ChainControllerStateKey = keyof ChainControllerState;
+export declare const ChainController: {
+    state: ChainControllerState;
+    subscribe(callback: (value: ChainControllerState) => void): () => void;
+    subscribeKey<K extends ChainControllerStateKey>(key: K, callback: (value: ChainControllerState[K]) => void): () => void;
+    subscribeChainProp<K extends keyof ChainAdapter>(property: K, callback: (value: ChainAdapter[K] | undefined) => void, chain?: ChainNamespace): () => void;
+    initialize(adapters: ChainAdapter[], caipNetworks: CaipNetwork[] | undefined, clients: {
+        connectionControllerClient: ConnectionControllerClient;
+        networkControllerClient: NetworkControllerClient;
+    }): void;
+    removeAdapter(namespace: ChainNamespace): void;
+    addAdapter(adapter: ChainAdapter, { networkControllerClient, connectionControllerClient }: ChainControllerClients, caipNetworks: [CaipNetwork, ...CaipNetwork[]]): void;
+    addNetwork(network: CaipNetwork): void;
+    removeNetwork(namespace: ChainNamespace, networkId: string | number): void;
+    setAdapterNetworkState(chain: ChainNamespace, props: Partial<AdapterNetworkState>): void;
+    setChainAccountData(chain: ChainNamespace | undefined, accountProps: Partial<AccountControllerState>, _unknown?: boolean): void;
+    setChainNetworkData(chain: ChainNamespace | undefined, networkProps: Partial<AdapterNetworkState>): void;
+    setAccountProp(prop: keyof AccountControllerState, value: AccountControllerState[keyof AccountControllerState], chain: ChainNamespace | undefined, replaceState?: boolean): void;
+    setActiveNamespace(chain: ChainNamespace | undefined): void;
+    setActiveCaipNetwork(caipNetwork: AdapterNetworkState["caipNetwork"]): void;
+    addCaipNetwork(caipNetwork: AdapterNetworkState["caipNetwork"]): void;
+    switchActiveNamespace(namespace: ChainNamespace | undefined): Promise<void>;
+    switchActiveNetwork(network: CaipNetwork): Promise<void>;
+    getNetworkControllerClient(chainNamespace?: ChainNamespace): NetworkControllerClient;
+    getConnectionControllerClient(_chain?: ChainNamespace): ConnectionControllerClient;
+    getAccountProp<K extends keyof AccountControllerState>(key: K, _chain?: ChainNamespace): AccountControllerState[K] | undefined;
+    getNetworkProp<K extends keyof AdapterNetworkState>(key: K, namespace: ChainNamespace): AdapterNetworkState[K] | undefined;
+    getRequestedCaipNetworks(chainToFilter: ChainNamespace): CaipNetwork[];
+    getAllRequestedCaipNetworks(): CaipNetwork[];
+    setRequestedCaipNetworks(requestedCaipNetworks: CaipNetwork[], chain: ChainNamespace): void;
+    getAllApprovedCaipNetworkIds(): CaipNetworkId[];
+    getActiveCaipNetwork(): CaipNetwork | undefined;
+    getActiveCaipAddress(): `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | `bip122:${string}:${string}` | `bip122:${number}:${string}` | undefined;
+    getApprovedCaipNetworkIds(namespace: ChainNamespace): CaipNetworkId[];
+    setApprovedCaipNetworksData(namespace: ChainNamespace): Promise<void>;
+    checkIfSupportedNetwork(namespace: ChainNamespace, caipNetwork?: CaipNetwork): boolean;
+    checkIfSupportedChainId(chainId: number | string): boolean;
+    setSmartAccountEnabledNetworks(smartAccountEnabledNetworks: number[], chain: ChainNamespace): void;
+    checkIfSmartAccountEnabled(): boolean;
+    getActiveNetworkTokenAddress(): string;
+    showUnsupportedChainUI(): void;
+    checkIfNamesSupported(): boolean;
+    resetNetwork(namespace: ChainNamespace): void;
+    resetAccount(chain: ChainNamespace | undefined): void;
+    disconnect(): Promise<void>;
+    setIsSwitchingNamespace(isSwitchingNamespace: boolean): void;
+    getFirstCaipNetworkSupportsAuthConnector(): CaipNetwork | undefined;
+    getAccountData(chainNamespace?: ChainNamespace): AccountControllerState | undefined;
+    getNetworkData(chainNamespace?: ChainNamespace): AdapterNetworkState | undefined;
+    getCaipNetworkByNamespace(chainNamespace: ChainNamespace | undefined, chainId?: string | number | undefined): CaipNetwork | undefined;
+    /**
+     * Get the requested CaipNetwork IDs for a given namespace. If namespace is not provided, all requested CaipNetwork IDs will be returned
+     * @param namespace - The namespace to get the requested CaipNetwork IDs for
+     * @returns The requested CaipNetwork IDs
+     */
+    getRequestedCaipNetworkIds(): (`eip155:${string}` | `eip155:${number}` | `solana:${string}` | `solana:${number}` | `polkadot:${string}` | `polkadot:${number}` | `bip122:${string}` | `bip122:${number}`)[];
+};
+export {};

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

@@ -0,0 +1,86 @@
+import { type CaipNetwork, type ChainNamespace } from '@reown/appkit-common';
+import type { W3mFrameTypes } from '@reown/appkit-wallet';
+import type { Connector, EstimateGasTransactionArgs, SendTransactionArgs, WalletGetAssetsParams, WalletGetAssetsResponse, WcWallet, WriteContractArgs } from '../utils/TypeUtil.js';
+export interface ConnectExternalOptions {
+    id: Connector['id'];
+    type: Connector['type'];
+    provider?: Connector['provider'];
+    info?: Connector['info'];
+    chain?: ChainNamespace;
+    chainId?: number | string;
+    caipNetwork?: CaipNetwork;
+}
+export interface ConnectionControllerClient {
+    connectWalletConnect?: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    signMessage: (message: string) => Promise<string>;
+    sendTransaction: (args: SendTransactionArgs) => Promise<string | null>;
+    estimateGas: (args: EstimateGasTransactionArgs) => Promise<bigint>;
+    parseUnits: (value: string, decimals: number) => bigint;
+    formatUnits: (value: bigint, decimals: number) => string;
+    connectExternal?: (options: ConnectExternalOptions) => Promise<void>;
+    reconnectExternal?: (options: ConnectExternalOptions) => Promise<void>;
+    checkInstalled?: (ids?: string[]) => boolean;
+    writeContract: (args: WriteContractArgs) => Promise<`0x${string}` | null>;
+    getEnsAddress: (value: string) => Promise<false | string>;
+    getEnsAvatar: (value: string) => Promise<false | string>;
+    grantPermissions: (params: readonly unknown[] | object) => Promise<unknown>;
+    revokePermissions: (params: {
+        pci: string;
+        permissions: unknown[];
+        expiry: number;
+        address: `0x${string}`;
+    }) => Promise<`0x${string}`>;
+    getCapabilities: (params: string) => Promise<unknown>;
+    walletGetAssets: (params: WalletGetAssetsParams) => Promise<WalletGetAssetsResponse>;
+}
+export interface ConnectionControllerState {
+    _client?: ConnectionControllerClient;
+    wcUri?: string;
+    wcPairingExpiry?: number;
+    wcLinking?: {
+        href: string;
+        name: string;
+    };
+    wcBasic?: boolean;
+    wcError?: boolean;
+    recentWallet?: WcWallet;
+    buffering: boolean;
+    status?: 'connecting' | 'connected' | 'disconnected';
+    connectionControllerClient?: ConnectionControllerClient;
+}
+type StateKey = keyof ConnectionControllerState;
+export declare const ConnectionController: {
+    state: ConnectionControllerState;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: ConnectionControllerState[K]) => void): () => void;
+    _getClient(): ConnectionControllerClient | undefined;
+    setClient(client: ConnectionControllerClient): void;
+    connectWalletConnect(): Promise<void>;
+    connectExternal(options: ConnectExternalOptions, chain: ChainNamespace, setChain?: boolean): Promise<void>;
+    reconnectExternal(options: ConnectExternalOptions): Promise<void>;
+    setPreferredAccountType(accountType: W3mFrameTypes.AccountType): Promise<void>;
+    signMessage(message: string): Promise<string | undefined>;
+    parseUnits(value: string, decimals: number): bigint | undefined;
+    formatUnits(value: bigint, decimals: number): string | undefined;
+    sendTransaction(args: SendTransactionArgs): Promise<string | null | undefined>;
+    getCapabilities(params: string): Promise<unknown>;
+    grantPermissions(params: object | readonly unknown[]): Promise<unknown>;
+    walletGetAssets(params: WalletGetAssetsParams): Promise<WalletGetAssetsResponse>;
+    estimateGas(args: EstimateGasTransactionArgs): Promise<bigint | undefined>;
+    writeContract(args: WriteContractArgs): Promise<`0x${string}` | null | undefined>;
+    getEnsAddress(value: string): Promise<string | false | undefined>;
+    getEnsAvatar(value: string): Promise<string | false | undefined>;
+    checkInstalled(ids?: string[]): boolean;
+    resetWcConnection(): void;
+    resetUri(): void;
+    finalizeWcConnection(): void;
+    setWcBasic(wcBasic: ConnectionControllerState["wcBasic"]): void;
+    setUri(uri: string): void;
+    setWcLinking(wcLinking: ConnectionControllerState["wcLinking"]): void;
+    setWcError(wcError: ConnectionControllerState["wcError"]): void;
+    setRecentWallet(wallet: ConnectionControllerState["recentWallet"]): void;
+    setBuffering(buffering: ConnectionControllerState["buffering"]): void;
+    setStatus(status: ConnectionControllerState["status"]): void;
+    disconnect(): Promise<void>;
+};
+export {};

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

@@ -0,0 +1,61 @@
+import { type ChainNamespace } from '@reown/appkit-common';
+import type { AuthConnector, Connector, WcWallet } from '../utils/TypeUtil.js';
+export interface ConnectorWithProviders extends Connector {
+    connectors?: Connector[];
+}
+export interface ConnectorControllerState {
+    allConnectors: Connector[];
+    connectors: ConnectorWithProviders[];
+    activeConnector: Connector | undefined;
+    filterByNamespace: ChainNamespace | undefined;
+    activeConnectorIds: Record<ChainNamespace, string | undefined>;
+}
+type StateKey = keyof ConnectorControllerState;
+export declare const ConnectorController: {
+    state: ConnectorControllerState;
+    subscribe(callback: (value: ConnectorControllerState) => void): () => void;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: ConnectorControllerState[K]) => void): () => void;
+    initialize(namespaces: ChainNamespace[]): void;
+    setActiveConnector(connector: ConnectorControllerState["activeConnector"]): void;
+    setConnectors(connectors: ConnectorControllerState["connectors"]): void;
+    removeAdapter(namespace: ChainNamespace): void;
+    mergeMultiChainConnectors(connectors: Connector[]): ConnectorWithProviders[];
+    generateConnectorMapByName(connectors: Connector[]): Map<string, Connector[]>;
+    getConnectorName(name: string | undefined): string | undefined;
+    getUniqueConnectorsByName(connectors: Connector[]): Connector[];
+    addConnector(connector: Connector | AuthConnector): void;
+    getAuthConnector(chainNamespace?: ChainNamespace): AuthConnector | undefined;
+    getAnnouncedConnectorRdns(): (string | undefined)[];
+    getConnectorById(id: string): Connector | undefined;
+    getConnector(id: string, rdns?: string | null): Connector | undefined;
+    syncIfAuthConnector(connector: Connector | AuthConnector): void;
+    /**
+     * Returns the connectors filtered by namespace.
+     * @param namespace - The namespace to filter the connectors by.
+     * @returns ConnectorWithProviders[].
+     */
+    getConnectorsByNamespace(namespace: ChainNamespace): ConnectorWithProviders[];
+    selectWalletConnector(wallet: WcWallet): void;
+    /**
+     * Returns the connectors. If a namespace is provided, the connectors are filtered by namespace.
+     * @param namespace - The namespace to filter the connectors by. If not provided, all connectors are returned.
+     * @returns ConnectorWithProviders[].
+     */
+    getConnectors(namespace?: ChainNamespace): ConnectorWithProviders[];
+    /**
+     * Sets the filter by namespace and updates the connectors.
+     * @param namespace - The namespace to filter the connectors by.
+     */
+    setFilterByNamespace(namespace: ChainNamespace): void;
+    /**
+     * Clears the filter by namespace and updates the connectors.
+     * If the current filterByNamespace has a value, it will fetch the recommended wallets with all requested chains.
+     */
+    clearNamespaceFilter(): void;
+    setConnectorId(connectorId: string, namespace: ChainNamespace): void;
+    removeConnectorId(namespace: ChainNamespace): void;
+    getConnectorId(namespace: ChainNamespace | undefined): string | undefined;
+    isConnected(namespace?: ChainNamespace): boolean;
+    resetConnectorIds(): void;
+};
+export {};

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

@@ -0,0 +1,26 @@
+type Suggestion = {
+    name: string;
+    registered: boolean;
+};
+export type ReownName = `${string}.reown.id` | `${string}.wcn.id`;
+export interface EnsControllerState {
+    suggestions: Suggestion[];
+    loading: boolean;
+}
+type StateKey = keyof EnsControllerState;
+export declare const EnsController: {
+    state: EnsControllerState;
+    subscribe(callback: (newState: EnsControllerState) => void): () => void;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: EnsControllerState[K]) => void): () => void;
+    resolveName(name: string): Promise<import("../utils/TypeUtil.js").BlockchainApiLookupEnsName | {
+        addresses: {};
+        attributes: never[];
+    }>;
+    isNameRegistered(name: string): Promise<boolean>;
+    getSuggestions(value: string): Promise<Suggestion[]>;
+    getNamesForAddress(address: string): Promise<import("../utils/TypeUtil.js").BlockchainApiLookupEnsName[]>;
+    registerName(name: ReownName): Promise<void>;
+    validateName(name: string): boolean;
+    parseEnsApiError(error: unknown, defaultError: string): string;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import type { Event } from '../utils/TypeUtil.js';
+export interface EventsControllerState {
+    timestamp: number;
+    reportedErrors: Record<string, boolean>;
+    data: Event;
+}
+export declare const EventsController: {
+    state: EventsControllerState;
+    subscribe(callback: (newState: EventsControllerState) => void): () => void;
+    getSdkProperties(): {
+        projectId: string;
+        st: "appkit";
+        sv: import("../utils/TypeUtil.js").SdkVersion;
+    };
+    _sendAnalyticsEvent(payload: EventsControllerState): Promise<void>;
+    sendEvent(data: EventsControllerState["data"]): void;
+};

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

@@ -0,0 +1,27 @@
+import type { ChainNamespace } from '@reown/appkit-common';
+import type { RouterControllerState } from './RouterController.js';
+export interface ModalControllerState {
+    loading: boolean;
+    loadingNamespaceMap: Map<ChainNamespace, boolean>;
+    open: boolean;
+    shake: boolean;
+    namespace: ChainNamespace | undefined;
+}
+export interface ModalControllerArguments {
+    open: {
+        view?: RouterControllerState['view'];
+        namespace?: ChainNamespace;
+    };
+}
+type StateKey = keyof ModalControllerState;
+export declare const ModalController: {
+    state: ModalControllerState;
+    subscribe(callback: (newState: ModalControllerState) => void): () => void;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: ModalControllerState[K]) => void): () => void;
+    open(options?: ModalControllerArguments["open"]): Promise<void>;
+    close(): void;
+    setLoading(loading: ModalControllerState["loading"], namespace?: ChainNamespace): void;
+    clearLoading(): void;
+    shake(): void;
+};
+export {};

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

@@ -0,0 +1,55 @@
+import type { PaymentCurrency, PurchaseCurrency } from '../utils/TypeUtil.js';
+export type OnRampProviderOption = 'coinbase' | 'moonpay' | 'stripe' | 'paypal' | 'meld';
+export type OnRampProvider = {
+    label: string;
+    name: OnRampProviderOption;
+    feeRange: string;
+    url: string;
+    supportedChains: string[];
+};
+export interface OnRampControllerState {
+    selectedProvider: OnRampProvider | null;
+    purchaseCurrency: PurchaseCurrency;
+    paymentCurrency: PaymentCurrency;
+    purchaseCurrencies: PurchaseCurrency[];
+    paymentCurrencies: PaymentCurrency[];
+    purchaseAmount?: number;
+    paymentAmount?: number;
+    providers: OnRampProvider[];
+    error: string | null;
+    quotesLoading: boolean;
+}
+type StateKey = keyof OnRampControllerState;
+export declare const USDC_CURRENCY_DEFAULT: {
+    id: string;
+    name: string;
+    symbol: string;
+    networks: {
+        name: string;
+        display_name: string;
+        chain_id: string;
+        contract_address: string;
+    }[];
+};
+export declare const USD_CURRENCY_DEFAULT: {
+    id: string;
+    payment_method_limits: {
+        id: string;
+        min: string;
+        max: string;
+    }[];
+};
+export declare const OnRampController: {
+    state: OnRampControllerState;
+    subscribe(callback: (newState: OnRampControllerState) => void): () => void;
+    subscribeKey<K extends StateKey>(key: K, callback: (value: OnRampControllerState[K]) => void): () => void;
+    setSelectedProvider(provider: OnRampProvider | null): void;
+    setPurchaseCurrency(currency: PurchaseCurrency): void;
+    setPaymentCurrency(currency: PaymentCurrency): void;
+    setPurchaseAmount(amount: number): void;
+    setPaymentAmount(amount: number): void;
+    getAvailableCurrencies(): Promise<void>;
+    getQuote(): Promise<import("../utils/TypeUtil.js").OnrampQuote | null>;
+    resetState(): void;
+};
+export {};