@reown/appkit-core 0.0.3

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

@@ -0,0 +1,48 @@
+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 { NetworkController } from '../src/controllers/NetworkController.js';
+export type { NetworkControllerClient, NetworkControllerState } from '../src/controllers/NetworkController.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 } 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 { OptionsControllerState } 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 { 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 type * from '../src/utils/TypeUtil.js';

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

@@ -0,0 +1,19 @@
+export declare function useWeb3ModalNetwork(): {
+    caipNetwork: {
+        readonly id: `eip155:${string}` | `eip155:${number}` | `solana:${string}` | `solana:${number}` | `polkadot:${string}` | `polkadot:${number}`;
+        readonly chainId: import("@reown/appkit-common").ChainId;
+        readonly chainNamespace: import("@reown/appkit-common").ChainNamespace;
+        readonly name: string;
+        readonly currency: string;
+        readonly explorerUrl: string;
+        readonly rpcUrl: string;
+        readonly imageUrl?: string | undefined;
+        readonly imageId?: string | undefined;
+    } | undefined;
+    chainId: import("@reown/appkit-common").ChainId | undefined;
+};
+export declare function useWeb3ModalAccount(): {
+    address: string | undefined;
+    isConnected: boolean;
+    status: "reconnecting" | "connected" | "disconnected" | "connecting" | undefined;
+};

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

@@ -0,0 +1,59 @@
+import type { AccountType, CombinedProvider, ConnectedWalletInfo, Provider, SocialProvider } from '../utils/TypeUtil.js';
+import type { CaipAddress, ChainNamespace } from '@reown/appkit-common';
+import type { Balance } from '@reown/appkit-common';
+import type { W3mFrameTypes } from '@reown/appkit-wallet';
+import type UniversalProvider from '@walletconnect/universal-provider';
+export interface AccountControllerState {
+    isConnected: boolean;
+    currentTab: number;
+    caipAddress?: CaipAddress;
+    address?: string;
+    addressLabels: Map<string, string>;
+    allAccounts: AccountType[];
+    balance?: string;
+    balanceSymbol?: string;
+    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;
+    provider?: UniversalProvider | Provider | CombinedProvider;
+    status?: 'reconnecting' | 'connected' | 'disconnected' | 'connecting';
+    siweStatus?: 'uninitialized' | 'ready' | 'loading' | 'success' | 'rejected' | 'error';
+}
+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;
+    setIsConnected(isConnected: AccountControllerState['isConnected'], chain: ChainNamespace | undefined): void;
+    setStatus(status: AccountControllerState['status'], chain: ChainNamespace | undefined): void;
+    getChainIsConnected(chain: ChainNamespace | undefined): boolean | undefined;
+    setProvider(provider: AccountControllerState['provider'], chain: ChainNamespace | undefined): void;
+    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;
+    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(accounts: AccountType[], chain: ChainNamespace | undefined): 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(): Promise<void>;
+    resetAccount(chain: ChainNamespace): void;
+    setSiweStatus(status: AccountControllerState['siweStatus']): void;
+};

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

@@ -0,0 +1,43 @@
+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[];
+}
+export declare const ApiController: {
+    state: ApiControllerState;
+    subscribeKey<K extends keyof ApiControllerState>(key: K, callback: (value: ApiControllerState[K]) => void): () => void;
+    _getApiHeaders(): {
+        'x-project-id': string;
+        'x-sdk-type': "w3m";
+        'x-sdk-version': 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>;
+    searchWalletByIds({ ids }: {
+        ids: string[];
+    }): Promise<void>;
+    searchWallet({ search }: Pick<ApiGetWalletsRequest, 'search'>): Promise<void>;
+    reFetchWallets(): Promise<void>;
+    prefetch(): void;
+    fetchAnalyticsConfig(): Promise<void>;
+};

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

@@ -0,0 +1,20 @@
+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>;
+}
+export declare const AssetController: {
+    state: AssetControllerState;
+    subscribeNetworkImages(callback: (value: AssetControllerState['networkImages']) => void): () => void;
+    subscribeKey<K extends keyof AssetControllerState>(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;
+};

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

@@ -0,0 +1,49 @@
+import { FetchUtil } from '../utils/FetchUtil.js';
+import type { BlockchainApiTransactionsRequest, BlockchainApiTransactionsResponse, BlockchainApiSwapTokensRequest, BlockchainApiSwapTokensResponse, BlockchainApiGenerateSwapCalldataRequest, BlockchainApiGenerateSwapCalldataResponse, BlockchainApiGenerateApproveCalldataRequest, BlockchainApiGenerateApproveCalldataResponse, BlockchainApiSwapQuoteRequest, BlockchainApiSwapQuoteResponse, BlockchainApiSwapAllowanceRequest, BlockchainApiSwapAllowanceResponse, BlockchainApiGasPriceRequest, BlockchainApiGasPriceResponse, BlockchainApiTokenPriceRequest, BlockchainApiTokenPriceResponse, BlockchainApiIdentityRequest, BlockchainApiIdentityResponse, GenerateOnRampUrlArgs, GetQuoteArgs, OnrampQuote, BlockchainApiBalanceResponse, BlockchainApiLookupEnsName, BlockchainApiSuggestionResponse, BlockchainApiRegisterNameParams } from '../utils/TypeUtil.js';
+export interface BlockchainApiControllerState {
+    clientId: string | null;
+    api: FetchUtil;
+}
+export declare const BlockchainApiController: {
+    state: BlockchainApiControllerState;
+    fetchIdentity({ address }: BlockchainApiIdentityRequest): Promise<BlockchainApiIdentityResponse>;
+    fetchTransactions({ account, projectId, cursor, onramp, signal, cache, chainId }: BlockchainApiTransactionsRequest): Promise<BlockchainApiTransactionsResponse>;
+    fetchSwapQuote({ projectId, amount, userAddress, from, to, gasPrice }: BlockchainApiSwapQuoteRequest): Promise<BlockchainApiSwapQuoteResponse>;
+    fetchSwapTokens({ projectId, chainId }: BlockchainApiSwapTokensRequest): Promise<BlockchainApiSwapTokensResponse>;
+    fetchTokenPrice({ projectId, addresses }: BlockchainApiTokenPriceRequest): Promise<BlockchainApiTokenPriceResponse>;
+    fetchSwapAllowance({ projectId, tokenAddress, userAddress }: BlockchainApiSwapAllowanceRequest): Promise<BlockchainApiSwapAllowanceResponse>;
+    fetchGasPrice({ projectId, chainId }: BlockchainApiGasPriceRequest): Promise<BlockchainApiGasPriceResponse>;
+    generateSwapCalldata({ amount, from, projectId, to, userAddress }: BlockchainApiGenerateSwapCalldataRequest): Promise<BlockchainApiGenerateSwapCalldataResponse>;
+    generateApproveCalldata({ from, projectId, to, userAddress }: BlockchainApiGenerateApproveCalldataRequest): Promise<BlockchainApiGenerateApproveCalldataResponse>;
+    getBalance(address: string, chainId?: string, forceUpdate?: string): Promise<BlockchainApiBalanceResponse>;
+    lookupEnsName(name: string): Promise<BlockchainApiLookupEnsName>;
+    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<{
+        purchaseCurrencies: {
+            id: string;
+            name: string;
+            symbol: string;
+            networks: {
+                name: string;
+                display_name: string;
+                chain_id: string;
+                contract_address: string;
+            }[];
+        }[];
+        paymentCurrencies: {
+            id: string;
+            payment_method_limits: {
+                id: string;
+                min: string;
+                max: string;
+            }[];
+        }[];
+    }>;
+    getOnrampQuote({ purchaseCurrency, paymentCurrency, amount, network }: GetQuoteArgs): Promise<OnrampQuote>;
+    setClientId(clientId: string | null): void;
+};

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

@@ -0,0 +1,42 @@
+import type { ChainAdapter, Connector } from '../utils/TypeUtil.js';
+import { type NetworkControllerState } from './NetworkController.js';
+import { type AccountControllerState } from './AccountController.js';
+import { type CaipNetwork, type ChainNamespace } from '@reown/appkit-common';
+export interface ChainControllerState {
+    activeChain: ChainNamespace | undefined;
+    activeCaipNetwork?: CaipNetwork;
+    chains: Map<ChainNamespace, ChainAdapter>;
+    activeConnector?: Connector;
+    universalAdapter: Pick<ChainAdapter, 'networkControllerClient' | 'connectionControllerClient'>;
+    noAdapters: boolean;
+}
+type ChainsInitializerAdapter = Pick<ChainAdapter, 'connectionControllerClient' | 'networkControllerClient' | 'defaultNetwork' | 'chainNamespace' | 'adapterType'>;
+export declare const ChainController: {
+    state: ChainControllerState;
+    subscribeKey<K extends keyof ChainControllerState>(key: K, callback: (value: ChainControllerState[K]) => void): () => void;
+    subscribeChainProp<K_1 extends keyof ChainAdapter>(property: K_1, callback: (value: ChainAdapter[K_1] | undefined) => void, chain?: ChainNamespace): () => void;
+    initialize(adapters: ChainsInitializerAdapter[]): void;
+    initializeUniversalAdapter(adapter: ChainsInitializerAdapter, adapters: ChainsInitializerAdapter[]): void;
+    setChainNetworkData(chain: ChainNamespace | undefined, props: Partial<NetworkControllerState>, replaceState?: boolean): void;
+    setChainAccountData(chain: ChainNamespace | undefined, accountProps: Partial<AccountControllerState>, replaceState?: boolean): void;
+    setAccountProp(prop: keyof AccountControllerState, value: AccountControllerState[keyof AccountControllerState], chain: ChainNamespace | undefined, replaceState?: boolean): void;
+    setActiveChain(chain: ChainNamespace | undefined): void;
+    setActiveCaipNetwork(caipNetwork: NetworkControllerState['caipNetwork']): void;
+    /**
+     * The setCaipNetwork function is being called for different purposes and it needs to be controlled if it should replace the NetworkController state or not.
+     * While we initializing the adapters, we need to set the caipNetwork without replacing the state.
+     * But when we switch the network, we need to replace the state.
+     * @param chain
+     * @param caipNetwork
+     * @param shouldReplace - if true, it will replace the NetworkController state
+     */
+    setCaipNetwork(chain: ChainNamespace | undefined, caipNetwork: NetworkControllerState['caipNetwork'], shouldReplace?: boolean): void;
+    setActiveConnector(connector: ChainControllerState['activeConnector']): void;
+    getNetworkControllerClient(): import("./NetworkController.js").NetworkControllerClient;
+    getConnectionControllerClient(_chain?: ChainNamespace): import("./ConnectionController.js").ConnectionControllerClient;
+    getAccountProp<K_2 extends keyof AccountControllerState>(key: K_2, _chain?: ChainNamespace): AccountControllerState[K_2] | undefined;
+    getNetworkProp<K_3 extends keyof NetworkControllerState>(key: K_3, _chain?: ChainNamespace): NetworkControllerState[K_3] | undefined;
+    getAllApprovedCaipNetworks(): NetworkControllerState['approvedCaipNetworkIds'];
+    resetAccount(chain: ChainNamespace | undefined): void;
+};
+export {};

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

@@ -0,0 +1,63 @@
+import type { Connector, EstimateGasTransactionArgs, SendTransactionArgs, WcWallet, WriteContractArgs } from '../utils/TypeUtil.js';
+import { type W3mFrameTypes } from '@reown/appkit-wallet';
+import type { ChainNamespace } from '@reown/appkit-common';
+export interface ConnectExternalOptions {
+    id: Connector['id'];
+    type: Connector['type'];
+    provider?: Connector['provider'];
+    info?: Connector['info'];
+}
+export interface ConnectionControllerClient {
+    connectWalletConnect?: (onUri: (uri: string) => void) => 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>;
+}
+export interface ConnectionControllerState {
+    _client?: ConnectionControllerClient;
+    wcUri?: string;
+    wcPairingExpiry?: number;
+    wcLinking?: {
+        href: string;
+        name: string;
+    };
+    wcError?: boolean;
+    recentWallet?: WcWallet;
+    buffering: boolean;
+    status?: 'connecting' | 'connected' | 'disconnected';
+}
+export declare const ConnectionController: {
+    state: ConnectionControllerState;
+    subscribeKey<K extends keyof ConnectionControllerState>(key: K, callback: (value: ConnectionControllerState[K]) => void): () => void;
+    _getClient(chain?: ChainNamespace): ConnectionControllerClient;
+    setClient(client: ConnectionControllerClient): void;
+    connectWalletConnect(): Promise<void>;
+    connectExternal(options: ConnectExternalOptions, chain: ChainNamespace): Promise<void>;
+    reconnectExternal(options: ConnectExternalOptions): Promise<void>;
+    setPreferredAccountType(accountType: W3mFrameTypes.AccountType): Promise<void>;
+    signMessage(message: string): Promise<string>;
+    parseUnits(value: string, decimals: number): bigint;
+    formatUnits(value: bigint, decimals: number): string;
+    sendTransaction(args: SendTransactionArgs): Promise<string | null>;
+    estimateGas(args: EstimateGasTransactionArgs): Promise<bigint>;
+    writeContract(args: WriteContractArgs): Promise<`0x${string}` | null>;
+    getEnsAddress(value: string): Promise<string | false>;
+    getEnsAvatar(value: string): Promise<string | false>;
+    checkInstalled(ids?: string[], chain?: ChainNamespace): boolean;
+    resetWcConnection(): 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>;
+};

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

@@ -0,0 +1,24 @@
+import type { AuthConnector, Connector } from '../utils/TypeUtil.js';
+interface ConnectorWithProviders extends Connector {
+    providers?: Connector[];
+}
+export interface ConnectorControllerState {
+    unMergedConnectors: Connector[];
+    connectors: ConnectorWithProviders[];
+}
+export declare const ConnectorController: {
+    state: ConnectorControllerState;
+    subscribeKey<K extends keyof ConnectorControllerState>(key: K, callback: (value: ConnectorControllerState[K]) => void): () => void;
+    setConnectors(connectors: ConnectorControllerState['connectors']): 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(): AuthConnector | undefined;
+    getAnnouncedConnectorRdns(): (string | undefined)[];
+    getConnectors(): ConnectorWithProviders[];
+    getConnector(id: string, rdns?: string | null): ConnectorWithProviders | undefined;
+    syncIfAuthConnector(connector: Connector | AuthConnector): void;
+};
+export {};

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

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

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

@@ -0,0 +1,16 @@
+import type { Event } from '../utils/TypeUtil.js';
+export interface EventsControllerState {
+    timestamp: number;
+    data: Event;
+}
+export declare const EventsController: {
+    state: EventsControllerState;
+    subscribe(callback: (newState: EventsControllerState) => void): () => void;
+    _getApiHeaders(): {
+        'x-project-id': string;
+        'x-sdk-type': "w3m";
+        'x-sdk-version': 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,20 @@
+import type { RouterControllerState } from './RouterController.js';
+export interface ModalControllerState {
+    loading: boolean;
+    open: boolean;
+    shake: boolean;
+}
+export interface ModalControllerArguments {
+    open: {
+        view?: RouterControllerState['view'];
+    };
+}
+export declare const ModalController: {
+    state: ModalControllerState;
+    subscribe(callback: (newState: ModalControllerState) => void): () => void;
+    subscribeKey<K extends keyof ModalControllerState>(key: K, callback: (value: ModalControllerState[K]) => void): () => void;
+    open(options?: ModalControllerArguments['open']): Promise<void>;
+    close(): void;
+    setLoading(loading: ModalControllerState['loading']): void;
+    shake(): void;
+};

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

@@ -0,0 +1,42 @@
+import { type CaipNetwork, type CaipNetworkId, type ChainNamespace } from '@reown/appkit-common';
+export interface NetworkControllerClient {
+    switchCaipNetwork: (network: NetworkControllerState['caipNetwork']) => Promise<void>;
+    getApprovedCaipNetworksData: () => Promise<{
+        approvedCaipNetworkIds: NetworkControllerState['approvedCaipNetworkIds'];
+        supportsAllNetworks: NetworkControllerState['supportsAllNetworks'];
+    }>;
+}
+export interface NetworkControllerState {
+    supportsAllNetworks: boolean;
+    isDefaultCaipNetwork: boolean;
+    isUnsupportedChain?: boolean;
+    _client?: NetworkControllerClient;
+    caipNetwork?: CaipNetwork;
+    requestedCaipNetworks?: CaipNetwork[];
+    approvedCaipNetworkIds?: CaipNetworkId[];
+    allowUnsupportedCaipNetwork?: boolean;
+    smartAccountEnabledNetworks?: number[];
+}
+export declare const NetworkController: {
+    state: NetworkControllerState;
+    replaceState(newState: NetworkControllerState | undefined): void;
+    subscribeKey<K extends keyof NetworkControllerState>(property: K, callback: (val: NetworkControllerState[K]) => void): () => void;
+    _getClient(): NetworkControllerClient;
+    initializeDefaultNetwork(): void;
+    setDefaultCaipNetwork(caipNetwork: NetworkControllerState['caipNetwork']): void;
+    setActiveCaipNetwork(caipNetwork: NetworkControllerState['caipNetwork']): void;
+    setCaipNetwork(caipNetwork: NetworkControllerState['caipNetwork']): void;
+    setRequestedCaipNetworks(requestedNetworks: NetworkControllerState['requestedCaipNetworks'], chain: ChainNamespace | undefined): void;
+    setAllowUnsupportedChain(allowUnsupportedCaipNetwork: NetworkControllerState['allowUnsupportedCaipNetwork'], chain: ChainNamespace | undefined): void;
+    setSmartAccountEnabledNetworks(smartAccountEnabledNetworks: NetworkControllerState['smartAccountEnabledNetworks'], chain: ChainNamespace | undefined): void;
+    getRequestedCaipNetworks(chainToFilter?: ChainNamespace): CaipNetwork[];
+    switchActiveNetwork(network: NetworkControllerState['caipNetwork']): Promise<void>;
+    getApprovedCaipNetworkIds(chainToFilter?: ChainNamespace): (`eip155:${string}` | `eip155:${number}` | `solana:${string}` | `solana:${number}` | `polkadot:${string}` | `polkadot:${number}`)[] | undefined;
+    setApprovedCaipNetworksData(chain: ChainNamespace | undefined): Promise<void>;
+    checkIfSupportedNetwork(): boolean;
+    checkIfSmartAccountEnabled(): boolean;
+    resetNetwork(): void;
+    getSupportsAllNetworks(): boolean | undefined;
+    showUnsupportedChainUI(): void;
+    getActiveNetworkTokenAddress(): string;
+};

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

@@ -0,0 +1,53 @@
+import type { PurchaseCurrency, PaymentCurrency } 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;
+}
+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 keyof OnRampControllerState>(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;
+};

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

@@ -0,0 +1,43 @@
+import type { CustomWallet, Features, Metadata, ProjectId, SdkVersion, Tokens } from '../utils/TypeUtil.js';
+export interface OptionsControllerState {
+    projectId: ProjectId;
+    sdkType: 'w3m';
+    sdkVersion: SdkVersion;
+    allWallets?: 'SHOW' | 'HIDE' | 'ONLY_MOBILE';
+    featuredWalletIds?: string[];
+    includeWalletIds?: string[];
+    excludeWalletIds?: string[];
+    tokens?: Tokens;
+    customWallets?: CustomWallet[];
+    termsConditionsUrl?: string;
+    privacyPolicyUrl?: string;
+    isSiweEnabled?: boolean;
+    metadata?: Metadata;
+    disableAppend?: boolean;
+    enableEIP6963?: boolean;
+    isUniversalProvider?: boolean;
+    hasMultipleAddresses?: boolean;
+    features: Features;
+}
+export declare const OptionsController: {
+    state: OptionsControllerState;
+    subscribeKey<K extends keyof OptionsControllerState>(key: K, callback: (value: OptionsControllerState[K]) => void): () => void;
+    setOptions(options: OptionsControllerState): void;
+    setFeatures(features: OptionsControllerState['features'] | undefined): void;
+    setProjectId(projectId: OptionsControllerState['projectId']): void;
+    setAllWallets(allWallets: OptionsControllerState['allWallets']): void;
+    setIncludeWalletIds(includeWalletIds: OptionsControllerState['includeWalletIds']): void;
+    setExcludeWalletIds(excludeWalletIds: OptionsControllerState['excludeWalletIds']): void;
+    setFeaturedWalletIds(featuredWalletIds: OptionsControllerState['featuredWalletIds']): void;
+    setTokens(tokens: OptionsControllerState['tokens']): void;
+    setTermsConditionsUrl(termsConditionsUrl: OptionsControllerState['termsConditionsUrl']): void;
+    setPrivacyPolicyUrl(privacyPolicyUrl: OptionsControllerState['privacyPolicyUrl']): void;
+    setCustomWallets(customWallets: OptionsControllerState['customWallets']): void;
+    setIsSiweEnabled(isSiweEnabled: OptionsControllerState['isSiweEnabled']): void;
+    setIsUniversalProvider(isUniversalProvider: OptionsControllerState['isUniversalProvider']): void;
+    setSdkVersion(sdkVersion: OptionsControllerState['sdkVersion']): void;
+    setMetadata(metadata: OptionsControllerState['metadata']): void;
+    setDisableAppend(disableAppend: OptionsControllerState['disableAppend']): void;
+    setEIP6963Enabled(enableEIP6963: OptionsControllerState['enableEIP6963']): void;
+    setHasMultipleAddresses(hasMultipleAddresses: OptionsControllerState['hasMultipleAddresses']): void;
+};

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

@@ -0,0 +1,12 @@
+import type { CaipNetworkId } from '@reown/appkit-common';
+export interface PublicStateControllerState {
+    loading: boolean;
+    open: boolean;
+    selectedNetworkId?: CaipNetworkId;
+    activeChain?: string;
+}
+export declare const PublicStateController: {
+    state: PublicStateControllerState;
+    subscribe(callback: (newState: PublicStateControllerState) => void): () => void;
+    set(newState: Partial<PublicStateControllerState>): void;
+};