@reown/appkit 1.8.15-viem-upgrade.0 → 1.8.15-wc-linking-reset-headless.0

package/dist/types/exports/auth-provider.d.ts

@@ -0,0 +1 @@
+export * from '../src/auth-provider/index.js';

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

@@ -0,0 +1 @@
+export declare const PACKAGE_VERSION = "1.8.15-wc-linking-reset-headless.0";

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

@@ -0,0 +1,8 @@
+import { AppKit } from '../src/client/appkit-core.js';
+import type { AppKitOptions } from '../src/utils/TypesUtil.js';
+export type * from '@reown/appkit-controllers';
+export type { CaipNetwork, CaipAddress, CaipNetworkId, CustomCaipNetwork, InferredCaipNetwork } from '@reown/appkit-common';
+export type CreateAppKit = Omit<AppKitOptions, 'sdkType' | 'sdkVersion' | 'basic'>;
+export declare function createAppKit(options: CreateAppKit): AppKit;
+export { AppKit };
+export type { AppKitOptions };

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

@@ -0,0 +1,10 @@
+import { AppKit } from '../src/client/appkit.js';
+import type { AppKitOptions } from '../src/utils/TypesUtil.js';
+export * from '../src/utils/index.js';
+export type * from '@reown/appkit-controllers';
+export type { CaipNetwork, CaipAddress, CaipNetworkId } from '@reown/appkit-common';
+export { CoreHelperUtil } from '@reown/appkit-controllers';
+export type CreateAppKit = Omit<AppKitOptions, 'sdkType' | 'sdkVersion' | 'basic'>;
+export declare function createAppKit(options: CreateAppKit): AppKit;
+export { AppKit };
+export type { AppKitOptions };

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

@@ -0,0 +1 @@
+export * from '../../src/library/react/index.js';

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

@@ -0,0 +1 @@
+export * from '../../src/library/vue/index.js';

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

@@ -0,0 +1 @@
+export * from '../src/networks/index.js';

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

@@ -0,0 +1,16 @@
+import { type UseAppKitNetworkReturn } from '@reown/appkit-controllers';
+import { AppKit } from '../src/client/appkit-core.js';
+import type { AppKitOptions } from '../src/utils/TypesUtil.js';
+export * from '../src/library/react/index.js';
+export * from '../src/utils/index.js';
+export type * from '@reown/appkit-controllers';
+export type { CaipNetwork, CaipAddress, CaipNetworkId } from '@reown/appkit-common';
+export { CoreHelperUtil } from '@reown/appkit-controllers';
+export declare let modal: AppKit | undefined;
+export type CreateAppKit = Omit<AppKitOptions, 'sdkType' | 'sdkVersion' | 'basic'>;
+export declare function createAppKit(options: CreateAppKit): AppKit;
+export { AppKit };
+export type { AppKitOptions };
+export * from '../src/library/react/index.js';
+export declare function useAppKitNetwork(): UseAppKitNetworkReturn;
+export { useAppKitAccount } from '@reown/appkit-controllers/react';

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

@@ -0,0 +1,30 @@
+import { type UseAppKitNetworkReturn } from '@reown/appkit-controllers';
+import { AppKit } from '../src/client/appkit.js';
+import type { AppKitOptions } from '../src/utils/TypesUtil.js';
+export * from '../src/library/react/index.js';
+export * from '../src/utils/index.js';
+export type * from '@reown/appkit-controllers';
+export type { CaipNetwork, CaipAddress, CaipNetworkId } from '@reown/appkit-common';
+export type { AppKitBaseClient, OpenOptions, Views } from '../src/client/appkit-base-client.js';
+export { CoreHelperUtil } from '@reown/appkit-controllers';
+export declare let modal: AppKit | undefined;
+export type CreateAppKit = Omit<AppKitOptions, 'sdkType' | 'sdkVersion' | 'basic'>;
+export declare function createAppKit(options: CreateAppKit): AppKit;
+export { AppKit };
+export type { AppKitOptions };
+export * from '../src/library/react/index.js';
+export { useAppKitProvider } from '@reown/appkit-controllers/react';
+export declare function useAppKitNetwork(): UseAppKitNetworkReturn;
+export declare function useAppKitBalance(): {
+    fetchBalance: () => Promise<{
+        data: import("@reown/appkit-controllers").AdapterBlueprint.GetBalanceResult | undefined;
+        error: string | null;
+        isSuccess: boolean;
+        isError: boolean;
+    }>;
+};
+export { useAppKitAccount, useAppKitWallets } from '@reown/appkit-controllers/react';
+export type * from '@reown/appkit-controllers/react';
+export { AppKitButton, AppKitNetworkButton, AppKitConnectButton, AppKitAccountButton } from '../src/library/react/components.js';
+export { AppKitProvider } from '../src/library/react/providers.js';
+export type { AppKitProviderProps } from '../src/library/react/providers.js';

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

@@ -0,0 +1,7 @@
+export declare const mockProjectId = "mockProjectId";
+export declare const mainnetCaipNetwork: import("@reown/appkit-common").CaipNetwork;
+export declare const polygonCaipNetwork: import("@reown/appkit-common").CaipNetwork;
+export declare const solanaCaipNetwork: import("@reown/appkit-common").CaipNetwork;
+export declare const solanaTestnetCaipNetwork: import("@reown/appkit-common").CaipNetwork;
+export declare const bitcoinCaipNetwork: import("@reown/appkit-common").CaipNetwork;
+export declare const bitcoinTestnetCaipNetwork: import("@reown/appkit-common").CaipNetwork;

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

@@ -0,0 +1 @@
+export * from '../src/utils/index.js';

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

@@ -0,0 +1,15 @@
+import { type Ref } from 'vue';
+import { type UseAppKitNetworkReturn } from '@reown/appkit-controllers';
+import { AppKit } from '../src/client/appkit-core.js';
+import type { AppKitOptions } from '../src/utils/TypesUtil.js';
+export * from '../src/library/vue/index.js';
+export * from '../src/utils/index.js';
+export type * from '@reown/appkit-controllers';
+export type { CaipNetwork, CaipAddress, CaipNetworkId } from '@reown/appkit-common';
+export { CoreHelperUtil } from '@reown/appkit-controllers';
+export type CreateAppKit = Omit<AppKitOptions, 'sdkType' | 'sdkVersion' | 'basic'>;
+export declare function createAppKit(options: CreateAppKit): AppKit;
+export { AppKit };
+export type { AppKitOptions };
+export declare function useAppKitNetwork(): Ref<UseAppKitNetworkReturn>;
+export * from '../src/library/vue/index.js';

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

@@ -0,0 +1,23 @@
+import { type Ref } from 'vue';
+import { type UseAppKitNetworkReturn } from '@reown/appkit-controllers';
+import { AppKit } from '../src/client/appkit.js';
+import type { AppKitOptions } from '../src/utils/TypesUtil.js';
+export * from '../src/library/vue/index.js';
+export * from '../src/utils/index.js';
+export type * from '@reown/appkit-controllers';
+export type { CaipNetwork, CaipAddress, CaipNetworkId } from '@reown/appkit-common';
+export { CoreHelperUtil } from '@reown/appkit-controllers';
+export type CreateAppKit = Omit<AppKitOptions, 'sdkType' | 'sdkVersion' | 'basic'>;
+export declare function createAppKit(options: CreateAppKit): AppKit;
+export { AppKit };
+export type { AppKitOptions };
+export declare function useAppKitNetwork(): Ref<UseAppKitNetworkReturn>;
+export declare function useAppKitBalance(): {
+    fetchBalance: () => Promise<{
+        data: import("@reown/appkit-controllers").AdapterBlueprint.GetBalanceResult | undefined;
+        error: string | null;
+        isSuccess: boolean;
+        isError: boolean;
+    }>;
+};
+export * from '../src/library/vue/index.js';

package/dist/types/src/auth-provider/W3MFrameProviderSingleton.d.ts

@@ -0,0 +1,17 @@
+import type { CaipNetwork, CaipNetworkId, ChainNamespace, EmbeddedWalletTimeoutReason } from '@reown/appkit-common';
+import { W3mFrameProvider } from '@reown/appkit-wallet';
+interface W3mFrameProviderConfig {
+    projectId: string;
+    chainId: number | CaipNetworkId | undefined;
+    enableLogger?: boolean;
+    onTimeout?: (reason: EmbeddedWalletTimeoutReason) => void;
+    abortController: AbortController;
+    getActiveCaipNetwork: (namespace?: ChainNamespace) => CaipNetwork | undefined;
+    getCaipNetworks: () => CaipNetwork[];
+}
+export declare class W3mFrameProviderSingleton {
+    private static instance;
+    private constructor();
+    static getInstance({ projectId, chainId, enableLogger, onTimeout, abortController, getActiveCaipNetwork, getCaipNetworks }: W3mFrameProviderConfig): W3mFrameProvider;
+}
+export {};

package/dist/types/src/auth-provider/index.d.ts

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

package/dist/types/src/client/appkit-base-client.d.ts

@@ -0,0 +1,322 @@
+import type { SessionTypes } from '@walletconnect/types';
+import UniversalProvider from '@walletconnect/universal-provider';
+import type { AppKitNetwork, AppKitSdkVersion, CaipAddress, CaipNetwork, CaipNetworkId, ChainNamespace, SdkVersion } from '@reown/appkit-common';
+import type { AccountState, AdapterBlueprint, Adapters, ChainAdapterConnector, ConnectExternalOptions, ConnectMethod, ConnectedWalletInfo, ConnectionControllerClient, ConnectionControllerState, ConnectorType, EventsControllerState, Features, ModalControllerState, NamespaceTypeMap, OptionsControllerState, PublicStateControllerState, RemoteFeatures, RouterControllerState, SIWXConfig, SocialProvider, ThemeControllerState, UseAppKitAccountReturn, UseAppKitNetworkReturn, User, WalletFeature } from '@reown/appkit-controllers';
+import { AssetUtil, BlockchainApiController, ChainController, ConnectionController, ConnectorController, EnsController, OptionsController, type ProviderControllerState, StorageUtil } from '@reown/appkit-controllers';
+import type { AppKitOptions } from '../utils/index.js';
+export interface AppKitOptionsWithSdk extends AppKitOptions {
+    sdkVersion: SdkVersion | AppKitSdkVersion;
+}
+export type Views = 'Account' | 'Connect' | 'Networks' | 'ApproveTransaction' | 'OnRampProviders' | 'ConnectingWalletConnectBasic' | 'Swap' | 'WhatIsAWallet' | 'WhatIsANetwork' | 'AllWallets' | 'WalletSend';
+type ViewArguments = {
+    Swap: NonNullable<RouterControllerState['data']>['swap'];
+    WalletSend: NonNullable<RouterControllerState['data']>['send'];
+};
+export interface OpenOptions<V extends Views | undefined = Views> {
+    view?: V;
+    uri?: string;
+    namespace?: ChainNamespace;
+    arguments?: V extends 'Swap' ? ViewArguments['Swap'] : V extends 'WalletSend' ? ViewArguments['WalletSend'] : never;
+}
+interface AppKitSwitchNetworkOptions {
+    throwOnFailure?: boolean;
+}
+export declare abstract class AppKitBaseClient {
+    protected universalProvider?: UniversalProvider;
+    protected connectionControllerClient?: ConnectionControllerClient;
+    protected static instance?: AppKitBaseClient;
+    protected universalProviderInitPromise?: Promise<void>;
+    protected caipNetworks?: [CaipNetwork, ...CaipNetwork[]];
+    protected defaultCaipNetwork?: CaipNetwork;
+    chainAdapters: Adapters;
+    chainNamespaces: ChainNamespace[];
+    options: AppKitOptions;
+    features: Features;
+    remoteFeatures: RemoteFeatures;
+    version: SdkVersion | AppKitSdkVersion;
+    reportedAlertErrors: Record<string, boolean>;
+    private readyPromise?;
+    constructor(options: AppKitOptionsWithSdk);
+    private getChainNamespacesSet;
+    protected initialize(options: AppKitOptionsWithSdk): Promise<void>;
+    private openSend;
+    private toModalOptions;
+    private checkAllowedOrigins;
+    private createCleanupHandler;
+    private sendInitializeEvent;
+    protected initControllers(options: AppKitOptionsWithSdk): void;
+    protected initAdapterController(): void;
+    protected initializeThemeController(options: AppKitOptions): void;
+    protected initializeChainController(options: AppKitOptions): void;
+    protected initializeConnectionController(options: AppKitOptions): void;
+    protected initializeConnectorController(): void;
+    protected initializeProjectSettings(options: AppKitOptionsWithSdk): void;
+    protected initializeOptionsController(options: AppKitOptionsWithSdk): void;
+    protected getDefaultMetaData(): {
+        name: string;
+        description: string;
+        url: string;
+        icons: string[];
+    } | null;
+    protected setUnsupportedNetwork(chainId: string | number): void;
+    protected getDefaultNetwork(): CaipNetwork | undefined;
+    protected extendCaipNetwork(network: AppKitNetwork, options: AppKitOptions): CaipNetwork;
+    protected extendCaipNetworks(options: AppKitOptions): [CaipNetwork, ...CaipNetwork[]];
+    protected extendDefaultCaipNetwork(options: AppKitOptions): CaipNetwork | undefined;
+    /**
+     * Disconnects a connector with the given namespace and id. If the connector id is not provided, disconnects the adapter (namespace).
+     * @param namespace ChainNamespace
+     * @param id string
+     * @returns
+     */
+    private disconnectConnector;
+    protected createClients(): void;
+    protected onConnectExternal(params: ConnectExternalOptions): Promise<{
+        address: string;
+        connectedCaipNetwork: CaipNetwork | undefined;
+    } | undefined>;
+    protected connectInactiveNamespaces(params: ConnectExternalOptions, connectResult: {
+        address: string;
+        connectedCaipNetwork: CaipNetwork | undefined;
+    } | undefined): Promise<void>;
+    protected getApprovedCaipNetworksData(): {
+        supportsAllNetworks: boolean;
+        approvedCaipNetworkIds: CaipNetworkId[];
+    };
+    protected switchCaipNetwork(caipNetwork: CaipNetwork): Promise<void>;
+    protected getChainsFromNamespaces(namespaces?: SessionTypes.Namespaces): CaipNetworkId[];
+    protected createAdapters(blueprints?: AdapterBlueprint[]): Adapters;
+    protected initChainAdapter(namespace: ChainNamespace): Promise<void>;
+    protected initChainAdapters(): Promise<void>;
+    protected onConnectors(chainNamespace: ChainNamespace): void;
+    protected listenAdapter(chainNamespace: ChainNamespace): void;
+    /**
+     * Checks the incoming connector and handles the previous connection in the connector's namespace, and if necessary (i.e multi-wallet is disabled) disconnects the previous connector
+     * @param connector
+     */
+    protected handlePreviousConnectorConnection(connector: ChainAdapterConnector | undefined): Promise<void>;
+    protected createUniversalProviderForAdapter(chainNamespace: ChainNamespace): Promise<void>;
+    protected abstract injectModalUi(): Promise<void>;
+    abstract syncIdentity(params: Pick<AdapterBlueprint.ConnectResult, 'address' | 'chainId'> & {
+        chainNamespace: ChainNamespace;
+    }): Promise<void>;
+    protected syncExistingConnection(): Promise<void>;
+    protected unSyncExistingConnection(): Promise<void>;
+    protected reconnectWalletConnect(): Promise<void>;
+    protected syncNamespaceConnection(namespace: ChainNamespace): Promise<void>;
+    protected onDisconnectNamespace(options: {
+        chainNamespace: ChainNamespace;
+        closeModal?: boolean;
+    }): void;
+    protected syncAdapterConnections(): Promise<void>;
+    protected syncAdapterConnection(namespace: ChainNamespace): Promise<void>;
+    protected syncWalletConnectAccount(): Promise<void>;
+    protected syncProvider({ type, provider, id, chainNamespace }: Pick<AdapterBlueprint.ConnectResult, 'type' | 'provider' | 'id'> & {
+        chainNamespace: ChainNamespace;
+    }): void;
+    protected syncAccount(params: Pick<AdapterBlueprint.ConnectResult, 'address' | 'chainId'> & {
+        chainNamespace: ChainNamespace;
+    }): Promise<void>;
+    private syncAccountInfo;
+    protected syncReownName(address: string, chainNamespace: ChainNamespace): Promise<void>;
+    protected syncConnectedWalletInfo(chainNamespace: ChainNamespace): void;
+    protected syncBalance(params: {
+        address: string;
+        chainId: string | number | undefined;
+        chainNamespace: ChainNamespace;
+    }): Promise<void>;
+    ready(): Promise<void>;
+    updateNativeBalance(address: string, chainId: string | number, namespace: ChainNamespace): Promise<AdapterBlueprint.GetBalanceResult | undefined>;
+    protected initializeUniversalAdapter(): Promise<void>;
+    protected listenWalletConnect(): void;
+    protected createUniversalProvider(): Promise<void> | undefined;
+    getUniversalProvider(): Promise<UniversalProvider | undefined>;
+    getDisabledCaipNetworks(): CaipNetwork[];
+    protected handleAlertError(error: Error): void;
+    protected getAdapter(namespace?: ChainNamespace): AdapterBlueprint<ChainAdapterConnector> | undefined;
+    protected createAdapter(blueprint: AdapterBlueprint): void;
+    getCaipNetwork: (chainNamespace?: ChainNamespace, id?: string | number) => CaipNetwork | undefined;
+    getCaipNetworkId: <T extends number | string>() => T | undefined;
+    getCaipNetworks: (namespace?: ChainNamespace) => CaipNetwork[];
+    getActiveChainNamespace: () => ChainNamespace | undefined;
+    setRequestedCaipNetworks: (typeof ChainController)['setRequestedCaipNetworks'];
+    getApprovedCaipNetworkIds: (typeof ChainController)['getAllApprovedCaipNetworkIds'];
+    getCaipAddress: (chainNamespace?: ChainNamespace) => `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | `bip122:${string}:${string}` | `bip122:${number}:${string}` | `cosmos:${string}:${string}` | `cosmos:${number}:${string}` | `sui:${string}:${string}` | `sui:${number}:${string}` | `stacks:${string}:${string}` | `stacks:${number}:${string}` | `ton:${string}:${string}` | `ton:${number}:${string}` | undefined;
+    setClientId: (typeof BlockchainApiController)['setClientId'];
+    getProvider: <T>(namespace: ChainNamespace) => T | undefined;
+    getProviderType: (namespace: ChainNamespace) => ConnectorType | undefined;
+    getPreferredAccountType: (namespace: ChainNamespace) => "payment" | "eoa" | "smartAccount" | "ordinal" | "stx" | undefined;
+    setCaipAddress: (caipAddress: CaipAddress | null, chain: ChainNamespace, shouldRefresh?: boolean) => void;
+    setBalance: (balance: string, balanceSymbol: string, chain: ChainNamespace) => void;
+    setProfileName: (profileName: string | null, chain: ChainNamespace) => void;
+    setProfileImage: (profileImage: string | null, chain: ChainNamespace) => void;
+    setUser: (user: User | null, chain: ChainNamespace) => void;
+    resetAccount: (chain: ChainNamespace) => void;
+    setCaipNetwork: (typeof ChainController)['setActiveCaipNetwork'];
+    setCaipNetworkOfNamespace: (caipNetwork: CaipNetwork, chainNamespace: ChainNamespace) => void;
+    setStatus: (status: AccountState["status"], chain: ChainNamespace) => void;
+    getAddressByChainNamespace: (chainNamespace: ChainNamespace) => string | undefined;
+    setConnectors: (typeof ConnectorController)['setConnectors'];
+    setConnections: (typeof ConnectionController)['setConnections'];
+    fetchIdentity: (typeof BlockchainApiController)['fetchIdentity'];
+    getReownName: (typeof EnsController)['getNamesForAddress'];
+    getConnectors: (typeof ConnectorController)['getConnectors'];
+    getConnectorImage: (typeof AssetUtil)['getConnectorImage'];
+    getConnections: (namespace: ChainNamespace) => import("@reown/appkit-common").Connection[];
+    getRecentConnections: (namespace: ChainNamespace) => import("@reown/appkit-common").Connection[];
+    switchConnection: (typeof ConnectionController)['switchConnection'];
+    deleteConnection: (typeof StorageUtil)['deleteAddressFromConnection'];
+    setConnectedWalletInfo: (connectedWalletInfo: ConnectedWalletInfo | null, chain: ChainNamespace) => void;
+    open<View extends Views>(options?: OpenOptions<View>): Promise<void | {
+        hash: string;
+    }>;
+    close(): Promise<void>;
+    setLoading(loading: ModalControllerState['loading'], namespace?: ChainNamespace): void;
+    disconnect(chainNamespace?: ChainNamespace): Promise<void>;
+    getSIWX<SIWXConfigInterface = SIWXConfig>(): SIWXConfigInterface | undefined;
+    getError(): string;
+    getChainId(): string | number | undefined;
+    switchNetwork(appKitNetwork: AppKitNetwork, { throwOnFailure }?: AppKitSwitchNetworkOptions): Promise<void>;
+    getWalletProvider(): unknown;
+    getWalletProviderType(): ConnectorType | undefined;
+    subscribeProviders(callback: (providers: ProviderControllerState['providers']) => void): () => void;
+    getThemeMode(): import("@reown/appkit-controllers").ThemeMode;
+    getThemeVariables(): import("@reown/appkit-controllers").ThemeVariables;
+    setThemeMode(themeMode: ThemeControllerState['themeMode']): void;
+    setTermsConditionsUrl(termsConditionsUrl: string): void;
+    setPrivacyPolicyUrl(privacyPolicyUrl: string): void;
+    setThemeVariables(themeVariables: ThemeControllerState['themeVariables']): void;
+    subscribeTheme(callback: (newState: ThemeControllerState) => void): () => void;
+    subscribeConnections(callback: (newState: ConnectionControllerState) => void): () => void;
+    getWalletInfo(namespace?: ChainNamespace): ConnectedWalletInfo | undefined;
+    getAccount(_namespace?: ChainNamespace): {
+        allAccounts: ({
+            namespace: "eip155";
+            address: string;
+            type: "eoa" | "smartAccount";
+            publicKey?: undefined;
+            path?: undefined;
+        } | {
+            namespace: "solana";
+            address: string;
+            type: "eoa";
+            publicKey?: undefined;
+            path?: undefined;
+        } | {
+            namespace: "polkadot";
+            address: string;
+            type: "eoa";
+            publicKey?: undefined;
+            path?: undefined;
+        } | {
+            namespace: "bip122";
+            address: string;
+            type: "payment" | "ordinal" | "stx";
+            publicKey?: string | undefined;
+            path?: string | undefined;
+        } | {
+            namespace: "cosmos";
+            address: string;
+            type: "eoa";
+            publicKey?: undefined;
+            path?: undefined;
+        } | {
+            namespace: "sui";
+            address: string;
+            type: "eoa";
+            publicKey?: undefined;
+            path?: undefined;
+        } | {
+            namespace: "stacks";
+            address: string;
+            type: "eoa";
+            publicKey?: undefined;
+            path?: undefined;
+        } | {
+            namespace: "ton";
+            address: string;
+            type: "eoa";
+            publicKey?: undefined;
+            path?: undefined;
+        })[];
+        caipAddress: `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | `bip122:${string}:${string}` | `bip122:${number}:${string}` | `cosmos:${string}:${string}` | `cosmos:${number}:${string}` | `sui:${string}:${string}` | `sui:${number}:${string}` | `stacks:${string}:${string}` | `stacks:${number}:${string}` | `ton:${string}:${string}` | `ton:${number}:${string}` | undefined;
+        address: `0x${string}` | undefined;
+        isConnected: boolean;
+        status: "reconnecting" | "connected" | "disconnected" | "connecting" | undefined;
+        embeddedWalletInfo: {
+            user: {
+                username: string | undefined;
+                email?: string | null | undefined;
+                accounts?: {
+                    type: "eoa" | "smartAccount";
+                    address: string;
+                }[];
+            } | undefined;
+            authProvider: "email" | import("@reown/appkit-common").SocialProvider;
+            accountType: "payment" | "eoa" | "smartAccount" | "ordinal" | "stx" | undefined;
+            isSmartAccountDeployed: boolean;
+        } | undefined;
+    } | undefined;
+    subscribeAccount(callback: (newState: UseAppKitAccountReturn) => void, namespace?: ChainNamespace): void;
+    subscribeNetwork(callback: (newState: Omit<UseAppKitNetworkReturn, 'switchNetwork'>) => void): () => void;
+    subscribeWalletInfo(callback: (newState?: ConnectedWalletInfo) => void, namespace?: ChainNamespace): () => void;
+    subscribeShouldUpdateToAddress(callback: (newState?: string) => void): void;
+    subscribeCaipNetworkChange(callback: (newState?: CaipNetwork) => void): void;
+    getState(): PublicStateControllerState;
+    getRemoteFeatures(): RemoteFeatures | undefined;
+    subscribeState(callback: (newState: PublicStateControllerState) => void): () => void;
+    subscribeRemoteFeatures(callback: (newState: RemoteFeatures | undefined) => void): () => void;
+    showErrorMessage(message: string): void;
+    showSuccessMessage(message: string): void;
+    getEvent(): {
+        timestamp: number;
+        lastFlush: number;
+        reportedErrors: Record<string, boolean>;
+        data: import("@reown/appkit-controllers").Event;
+        pendingEvents: import("@reown/appkit-controllers").PendingEvent[];
+        subscribedToVisibilityChange: boolean;
+        walletImpressions: (import("@reown/appkit-controllers").WalletImpressionItem | import("@reown/appkit-controllers").ConnectorImpressionItem)[];
+    };
+    subscribeEvents(callback: (newEvent: EventsControllerState) => void): () => void;
+    replace(route: RouterControllerState['view']): void;
+    redirect(route: RouterControllerState['view']): void;
+    popTransactionStack(status: 'cancel' | 'error' | 'success'): void;
+    isOpen(): boolean;
+    isTransactionStackEmpty(): boolean;
+    static getInstance(): AppKitBaseClient | undefined;
+    getIsConnectedState: () => boolean;
+    addAddressLabel: (address: string, label: string, chain: ChainNamespace) => void;
+    removeAddressLabel: (address: string, chain: ChainNamespace) => void;
+    getAddress: (chainNamespace?: ChainNamespace) => string | undefined;
+    resetNetwork: (typeof ChainController)['resetNetwork'];
+    addConnector: (typeof ConnectorController)['addConnector'];
+    resetWcConnection: (typeof ConnectionController)['resetWcConnection'];
+    setAddressExplorerUrl: (addressExplorerUrl: string, chain: ChainNamespace) => void;
+    setSmartAccountDeployed: (isDeployed: boolean, chain: ChainNamespace) => void;
+    setPreferredAccountType: (preferredAccountType: NamespaceTypeMap[ChainNamespace], chain: ChainNamespace) => void;
+    setEIP6963Enabled: (typeof OptionsController)['setEIP6963Enabled'];
+    handleUnsafeRPCRequest: () => void;
+    updateFeatures(newFeatures: Partial<Features>): void;
+    updateRemoteFeatures(newRemoteFeatures: Partial<RemoteFeatures>): void;
+    updateOptions(newOptions: Partial<OptionsControllerState>): void;
+    setConnectMethodsOrder(connectMethodsOrder: ConnectMethod[]): void;
+    setWalletFeaturesOrder(walletFeaturesOrder: WalletFeature[]): void;
+    setCollapseWallets(collapseWallets: boolean): void;
+    setSocialsOrder(socialsOrder: SocialProvider[]): void;
+    getConnectMethodsOrder(): ConnectMethod[];
+    /**
+     * Adds a network to an existing adapter in AppKit.
+     * @param namespace - The chain namespace to add the network to (e.g. 'eip155', 'solana')
+     * @param network - The network configuration to add
+     * @throws Error if adapter for namespace doesn't exist
+     */
+    addNetwork(namespace: ChainNamespace, network: AppKitNetwork): void;
+    /**
+     * Removes a network from an existing adapter in AppKit.
+     * @param namespace - The chain namespace the network belongs to
+     * @param networkId - The network ID to remove
+     * @throws Error if adapter for namespace doesn't exist or if removing last network
+     */
+    removeNetwork(namespace: ChainNamespace, networkId: string | number): void;
+}
+export {};

package/dist/types/src/client/appkit-core.d.ts

@@ -0,0 +1,27 @@
+import { type ChainNamespace } from '@reown/appkit-common';
+import type { ChainAdapter } from '@reown/appkit-controllers';
+import type { AdapterBlueprint } from '@reown/appkit-controllers';
+import { AppKitBaseClient, type OpenOptions as BaseOpenOptions, type Views } from './appkit-base-client.js';
+declare global {
+    interface Window {
+        ethereum?: Record<string, unknown>;
+    }
+}
+export type OpenOptions<View extends Views> = Omit<BaseOpenOptions<View>, 'namespace'>;
+export declare class AppKit extends AppKitBaseClient {
+    activeAdapter?: AdapterBlueprint;
+    adapters?: ChainAdapter[];
+    activeChainNamespace?: ChainNamespace;
+    adapter?: ChainAdapter;
+    open<View extends Views>(options?: OpenOptions<View>): Promise<void>;
+    close(): Promise<void>;
+    syncIdentity(_request: Pick<AdapterBlueprint.ConnectResult, 'address' | 'chainId'> & {
+        chainNamespace: ChainNamespace;
+    }): Promise<void>;
+    syncBalance(_params: {
+        address: string;
+        chainId: string | number | undefined;
+        chainNamespace: ChainNamespace;
+    }): Promise<void>;
+    protected injectModalUi(): Promise<void>;
+}

package/dist/types/src/client/appkit.d.ts

@@ -0,0 +1,28 @@
+import { type CaipNetwork, type ChainNamespace } from '@reown/appkit-common';
+import type { AdapterBlueprint } from '@reown/appkit-controllers';
+import { AppKitBaseClient, type AppKitOptionsWithSdk } from './appkit-base-client.js';
+declare global {
+    interface Window {
+        ethereum?: Record<string, unknown>;
+    }
+}
+export declare class AppKit extends AppKitBaseClient {
+    static instance?: AppKit;
+    private authProvider?;
+    private onAuthProviderConnected;
+    private setupAuthConnectorListeners;
+    private syncAuthConnectorTheme;
+    private syncAuthConnector;
+    private checkExistingTelegramSocialConnection;
+    private createAuthProvider;
+    private createAuthProviderForAdapter;
+    protected initControllers(options: AppKitOptionsWithSdk): void;
+    protected switchCaipNetwork(caipNetwork: CaipNetwork): Promise<void>;
+    protected initialize(options: AppKitOptionsWithSdk): Promise<void>;
+    syncIdentity({ address, chainId, chainNamespace }: Pick<AdapterBlueprint.ConnectResult, 'address' | 'chainId'> & {
+        chainNamespace: ChainNamespace;
+    }): Promise<void>;
+    protected syncConnectedWalletInfo(chainNamespace: ChainNamespace): void;
+    protected injectModalUi(): Promise<void>;
+    private loadModalComponents;
+}

package/dist/types/src/library/react/components.d.ts

@@ -0,0 +1,5 @@
+import { AppKitAccountButton as AppKitAccountButtonComponent, AppKitButton as AppKitButtonComponent, AppKitConnectButton as AppKitConnectButtonComponent, AppKitNetworkButton as AppKitNetworkButtonComponent } from '@reown/appkit-scaffold-ui';
+export declare const AppKitButton: import("@lit/react").ReactWebComponent<AppKitButtonComponent, {}>;
+export declare const AppKitNetworkButton: import("@lit/react").ReactWebComponent<AppKitNetworkButtonComponent, {}>;
+export declare const AppKitConnectButton: import("@lit/react").ReactWebComponent<AppKitConnectButtonComponent, {}>;
+export declare const AppKitAccountButton: import("@lit/react").ReactWebComponent<AppKitAccountButtonComponent, {}>;

package/dist/types/src/library/react/index.d.ts

@@ -0,0 +1,78 @@
+import type { ChainNamespace } from '@reown/appkit-common';
+import type { AppKitAccountButton, AppKitButton, AppKitConnectButton, AppKitNetworkButton, W3mAccountButton, W3mButton, W3mConnectButton, W3mNetworkButton } from '@reown/appkit-scaffold-ui';
+import type { AppKitBaseClient as AppKit, OpenOptions, Views } from '../../client/appkit-base-client.js';
+import type { AppKitOptions } from '../../utils/TypesUtil.js';
+type ThemeModeOptions = AppKitOptions['themeMode'];
+type ThemeVariablesOptions = AppKitOptions['themeVariables'];
+interface AppKitElements {
+    'appkit-modal': {
+        class?: string;
+    };
+    'appkit-button': Pick<AppKitButton, 'size' | 'label' | 'loadingLabel' | 'disabled' | 'balance' | 'namespace'>;
+    'appkit-connect-button': Pick<AppKitConnectButton, 'size' | 'label' | 'loadingLabel'>;
+    'appkit-account-button': Pick<AppKitAccountButton, 'disabled' | 'balance'>;
+    'appkit-network-button': Pick<AppKitNetworkButton, 'disabled'>;
+    'w3m-connect-button': Pick<W3mConnectButton, 'size' | 'label' | 'loadingLabel'>;
+    'w3m-account-button': Pick<W3mAccountButton, 'disabled' | 'balance'>;
+    'w3m-button': Pick<W3mButton, 'size' | 'label' | 'loadingLabel' | 'disabled' | 'balance'>;
+    'w3m-network-button': Pick<W3mNetworkButton, 'disabled'>;
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements extends AppKitElements {
+        }
+    }
+}
+type __BuiltinIntrinsics = JSX.IntrinsicElements;
+declare module 'react' {
+    namespace JSX {
+        interface IntrinsicElements extends __BuiltinIntrinsics, AppKitElements {
+        }
+    }
+}
+export declare function getAppKit(appKit: AppKit): void;
+export * from '@reown/appkit-controllers/react';
+export declare function useAppKitTheme(): {
+    themeMode: "dark" | "light";
+    themeVariables: import("@reown/appkit-controllers").ThemeVariables;
+    setThemeMode: (themeMode: ThemeModeOptions) => void;
+    setThemeVariables: (themeVariables: ThemeVariablesOptions) => void;
+};
+export declare function useAppKit(): {
+    open: <View extends Views>(options?: OpenOptions<View>) => Promise<void | {
+        hash: string;
+    } | undefined>;
+    close: () => Promise<void>;
+};
+export declare function useWalletInfo(namespace?: ChainNamespace): {
+    walletInfo: import("@reown/appkit-controllers").ConnectedWalletInfo | undefined;
+};
+export declare function useAppKitState(): {
+    swaps?: import("@reown/appkit-common").SwapProvider[] | false;
+    email?: boolean;
+    socials?: import("@reown/appkit-controllers").SocialProvider[] | false;
+    activity?: boolean;
+    reownBranding?: boolean;
+    multiWallet?: boolean;
+    emailCapture?: import("@reown/appkit-controllers").EmailCaptureOptions[] | boolean;
+    reownAuthentication?: boolean;
+    payWithExchange?: boolean;
+    payments?: boolean;
+    onramp?: import("@reown/appkit-common").OnRampProvider[] | false;
+    headless?: boolean;
+    initialized: boolean;
+    loading: boolean;
+    open: boolean;
+    selectedNetworkId?: import("@reown/appkit-common").CaipNetworkId | undefined;
+    activeChain?: ChainNamespace | undefined;
+    connectingWallet: import("@reown/appkit-controllers").WalletItem | undefined;
+};
+export declare function useAppKitEvents(): {
+    timestamp: number;
+    lastFlush: number;
+    reportedErrors: Record<string, boolean>;
+    data: import("@reown/appkit-controllers").Event;
+    pendingEvents: import("@reown/appkit-controllers").PendingEvent[];
+    subscribedToVisibilityChange: boolean;
+    walletImpressions: (import("@reown/appkit-controllers").WalletImpressionItem | import("@reown/appkit-controllers").ConnectorImpressionItem)[];
+};

package/dist/types/src/library/react/providers.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+import { type CreateAppKit } from '../../../exports/react.js';
+export type AppKitProviderProps = CreateAppKit & {
+    children: ReactNode;
+};
+export declare function memoizeCreateAppKit(config: CreateAppKit): import("../../client/appkit.js").AppKit;
+export declare function AppKitProvider({ children, ...props }: AppKitProviderProps): ReactNode;