@reown/appkit 1.3.2 → 1.4.1

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

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

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

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "1.3.2";
+export declare const PACKAGE_VERSION = "1.4.1";

package/dist/types/src/adapters/ChainAdapterBlueprint.d.ts

@@ -0,0 +1,324 @@
+import { type CaipAddress, type CaipNetwork, type ChainNamespace } from '@reown/appkit-common';
+import type { ChainAdapterConnector } from './ChainAdapterConnector.js';
+import { type Connector as AppKitConnector, type Tokens } from '@reown/appkit-core';
+import type UniversalProvider from '@walletconnect/universal-provider';
+import type { W3mFrameProvider } from '@reown/appkit-wallet';
+import type { AppKitOptions } from '../utils/index.js';
+import type { AppKit } from '../client.js';
+type EventName = 'disconnect' | 'accountChanged' | 'switchNetwork';
+type EventData = {
+    disconnect: () => void;
+    accountChanged: {
+        address: string;
+        chainId?: number | string;
+    };
+    switchNetwork: {
+        address?: string;
+        chainId: number | string;
+    };
+};
+type EventCallback<T extends EventName> = (data: EventData[T]) => void;
+/**
+ * Abstract class representing a chain adapter blueprint.
+ * @template Connector - The type of connector extending ChainAdapterConnector
+ */
+export declare abstract class AdapterBlueprint<Connector extends ChainAdapterConnector = ChainAdapterConnector> {
+    namespace: ChainNamespace | undefined;
+    caipNetworks?: CaipNetwork[];
+    projectId?: string;
+    protected availableConnectors: Connector[];
+    protected connector?: Connector;
+    protected provider?: Connector['provider'];
+    private eventListeners;
+    /**
+     * Creates an instance of AdapterBlueprint.
+     * @param {AdapterBlueprint.Params} params - The parameters for initializing the adapter
+     */
+    constructor(params?: AdapterBlueprint.Params);
+    /**
+     * Initializes the adapter with the given parameters.
+     * @param {AdapterBlueprint.Params} params - The parameters for initializing the adapter
+     */
+    construct(params: AdapterBlueprint.Params): void;
+    /**
+     * Gets the available connectors.
+     * @returns {Connector[]} An array of available connectors
+     */
+    get connectors(): Connector[];
+    /**
+     * Gets the supported networks.
+     * @returns {CaipNetwork[]} An array of supported networks
+     */
+    get networks(): CaipNetwork[];
+    /**
+     * Sets the universal provider for WalletConnect.
+     * @param {UniversalProvider} universalProvider - The universal provider instance
+     */
+    setUniversalProvider(universalProvider: UniversalProvider): void;
+    /**
+     * Sets the auth provider.
+     * @param {W3mFrameProvider} authProvider - The auth provider instance
+     */
+    setAuthProvider(authProvider: W3mFrameProvider): void;
+    /**
+     * Adds one or more connectors to the available connectors list.
+     * @param {...Connector} connectors - The connectors to add
+     */
+    protected addConnector(...connectors: Connector[]): void;
+    /**
+     * Adds an event listener for a specific event.
+     * @template T
+     * @param {T} eventName - The name of the event
+     * @param {EventCallback<T>} callback - The callback function to be called when the event is emitted
+     */
+    on<T extends EventName>(eventName: T, callback: EventCallback<T>): void;
+    /**
+     * Removes an event listener for a specific event.
+     * @template T
+     * @param {T} eventName - The name of the event
+     * @param {EventCallback<T>} callback - The callback function to be removed
+     */
+    off<T extends EventName>(eventName: T, callback: EventCallback<T>): void;
+    /**
+     * Emits an event with the given name and optional data.
+     * @template T
+     * @param {T} eventName - The name of the event to emit
+     * @param {EventData[T]} [data] - The optional data to be passed to the event listeners
+     */
+    protected emit<T extends EventName>(eventName: T, data?: EventData[T]): void;
+    /**
+     * Connects to WalletConnect.
+     * @param {(uri: string) => void} onUri - Callback function to handle the WalletConnect URI
+     * @param {number | string} [chainId] - Optional chain ID to connect to
+     */
+    abstract connectWalletConnect(onUri: (uri: string) => void, chainId?: number | string): Promise<void>;
+    /**
+     * Connects to a wallet.
+     * @param {AdapterBlueprint.ConnectParams} params - Connection parameters
+     * @returns {Promise<AdapterBlueprint.ConnectResult>} Connection result
+     */
+    abstract connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;
+    /**
+     * Switches the network.
+     * @param {AdapterBlueprint.SwitchNetworkParams} params - Network switching parameters
+     */
+    abstract switchNetwork(params: AdapterBlueprint.SwitchNetworkParams): Promise<void>;
+    /**
+     * Disconnects the current wallet.
+     */
+    abstract disconnect(params?: AdapterBlueprint.DisconnectParams): Promise<void>;
+    /**
+     * Gets the balance for a given address and chain ID.
+     * @param {AdapterBlueprint.GetBalanceParams} params - Balance retrieval parameters
+     * @returns {Promise<AdapterBlueprint.GetBalanceResult>} Balance result
+     */
+    abstract getBalance(params: AdapterBlueprint.GetBalanceParams): Promise<AdapterBlueprint.GetBalanceResult>;
+    /**
+     * Gets the profile for a given address and chain ID.
+     * @param {AdapterBlueprint.GetProfileParams} params - Profile retrieval parameters
+     * @returns {Promise<AdapterBlueprint.GetProfileResult>} Profile result
+     */
+    abstract getProfile(params: AdapterBlueprint.GetProfileParams): Promise<AdapterBlueprint.GetProfileResult>;
+    /**
+     * Synchronizes the connectors with the given options and AppKit instance.
+     * @param {AppKitOptions} [options] - Optional AppKit options
+     * @param {AppKit} [appKit] - Optional AppKit instance
+     */
+    abstract syncConnectors(options?: AppKitOptions, appKit?: AppKit): void;
+    /**
+     * Synchronizes the connection with the given parameters.
+     * @param {AdapterBlueprint.SyncConnectionParams} params - Synchronization parameters
+     * @returns {Promise<AdapterBlueprint.ConnectResult>} Connection result
+     */
+    abstract syncConnection(params: AdapterBlueprint.SyncConnectionParams): Promise<AdapterBlueprint.ConnectResult>;
+    /**
+     * Signs a message with the connected wallet.
+     * @param {AdapterBlueprint.SignMessageParams} params - Parameters including message to sign, address, and optional provider
+     * @returns {Promise<AdapterBlueprint.SignMessageResult>} Object containing the signature
+     */
+    abstract signMessage(params: AdapterBlueprint.SignMessageParams): Promise<AdapterBlueprint.SignMessageResult>;
+    /**
+     * Estimates gas for a transaction.
+     * @param {AdapterBlueprint.EstimateGasTransactionArgs} params - Parameters including address, to, data, and optional provider
+     * @returns {Promise<AdapterBlueprint.EstimateGasTransactionResult>} Object containing the gas estimate
+     */
+    abstract estimateGas(params: AdapterBlueprint.EstimateGasTransactionArgs): Promise<AdapterBlueprint.EstimateGasTransactionResult>;
+    /**
+     * Sends a transaction.
+     * @param {AdapterBlueprint.SendTransactionParams} params - Parameters including address, to, data, value, gasPrice, gas, and optional provider
+     * @returns {Promise<AdapterBlueprint.SendTransactionResult>} Object containing the transaction hash
+     */
+    abstract sendTransaction(params: AdapterBlueprint.SendTransactionParams): Promise<AdapterBlueprint.SendTransactionResult>;
+    /**
+     * Writes a contract transaction.
+     * @param {AdapterBlueprint.WriteContractParams} params - Parameters including receiver address, token amount, token address, from address, method, and ABI
+     * @returns {Promise<AdapterBlueprint.WriteContractResult>} Object containing the transaction hash
+     */
+    abstract writeContract(params: AdapterBlueprint.WriteContractParams): Promise<AdapterBlueprint.WriteContractResult>;
+    /**
+     * Gets the ENS address for a given name.
+     * @param {AdapterBlueprint.GetEnsAddressParams} params - Parameters including name
+     * @returns {Promise<AdapterBlueprint.GetEnsAddressResult>} Object containing the ENS address
+     */
+    abstract getEnsAddress(params: AdapterBlueprint.GetEnsAddressParams): Promise<AdapterBlueprint.GetEnsAddressResult>;
+    /**
+     * Parses a decimal string value into a bigint with the specified number of decimals.
+     * @param {AdapterBlueprint.ParseUnitsParams} params - Parameters including value and decimals
+     * @returns {AdapterBlueprint.ParseUnitsResult} The parsed bigint value
+     */
+    abstract parseUnits(params: AdapterBlueprint.ParseUnitsParams): AdapterBlueprint.ParseUnitsResult;
+    /**
+     * Formats a bigint value into a decimal string with the specified number of decimals.
+     * @param {AdapterBlueprint.FormatUnitsParams} params - Parameters including value and decimals
+     * @returns {AdapterBlueprint.FormatUnitsResult} The formatted decimal string
+     */
+    abstract formatUnits(params: AdapterBlueprint.FormatUnitsParams): AdapterBlueprint.FormatUnitsResult;
+    /**
+     * Gets the WalletConnect provider.
+     * @param {AdapterBlueprint.GetWalletConnectProviderParams} params - Parameters including provider, caip networks, and active caip network
+     * @returns {AdapterBlueprint.GetWalletConnectProviderResult} The WalletConnect provider
+     */
+    abstract getWalletConnectProvider(params: AdapterBlueprint.GetWalletConnectProviderParams): AdapterBlueprint.GetWalletConnectProviderResult;
+    /**
+     * Reconnects to a wallet.
+     * @param {AdapterBlueprint.ReconnectParams} params - Reconnection parameters
+     */
+    reconnect?(params: AdapterBlueprint.ReconnectParams): Promise<void>;
+    abstract getCapabilities(params: AdapterBlueprint.GetCapabilitiesParams): Promise<unknown>;
+    abstract grantPermissions(params: AdapterBlueprint.GrantPermissionsParams): Promise<unknown>;
+    abstract revokePermissions(params: AdapterBlueprint.RevokePermissionsParams): Promise<`0x${string}`>;
+}
+export declare namespace AdapterBlueprint {
+    type Params = {
+        namespace?: ChainNamespace;
+        networks?: CaipNetwork[];
+        projectId?: string;
+    };
+    type SwitchNetworkParams = {
+        caipNetwork: CaipNetwork;
+        provider?: AppKitConnector['provider'];
+        providerType?: AppKitConnector['type'];
+    };
+    type GetBalanceParams = {
+        address: string;
+        chainId: number | string;
+        caipNetwork?: CaipNetwork;
+        tokens?: Tokens;
+    };
+    type GetProfileParams = {
+        address: string;
+        chainId: number | string;
+    };
+    type DisconnectParams = {
+        provider?: AppKitConnector['provider'];
+        providerType?: AppKitConnector['type'];
+    };
+    type ConnectParams = {
+        id: string;
+        provider?: unknown;
+        info?: unknown;
+        type: string;
+        chain?: ChainNamespace;
+        chainId?: number | string;
+        rpcUrl?: string;
+    };
+    type ReconnectParams = ConnectParams;
+    type SyncConnectionParams = {
+        id: string;
+        namespace: ChainNamespace;
+        chainId?: number | string;
+        rpcUrl: string;
+    };
+    type SignMessageParams = {
+        message: string;
+        address: string;
+        provider?: AppKitConnector['provider'];
+    };
+    type SignMessageResult = {
+        signature: string;
+    };
+    type EstimateGasTransactionArgs = {
+        address: string;
+        to: string;
+        data: string;
+        caipNetwork: CaipNetwork;
+        provider?: AppKitConnector['provider'];
+    };
+    type EstimateGasTransactionResult = {
+        gas: bigint;
+    };
+    type WriteContractParams = {
+        receiverAddress: string;
+        tokenAmount: bigint;
+        tokenAddress: string;
+        fromAddress: string;
+        method: 'send' | 'transfer' | 'call';
+        abi: any;
+        caipNetwork: CaipNetwork;
+        provider?: AppKitConnector['provider'];
+        caipAddress: CaipAddress;
+    };
+    type WriteContractResult = {
+        hash: string;
+    };
+    type ParseUnitsParams = {
+        value: string;
+        decimals: number;
+    };
+    type ParseUnitsResult = bigint;
+    type FormatUnitsParams = {
+        value: bigint;
+        decimals: number;
+    };
+    type FormatUnitsResult = string;
+    type GetWalletConnectProviderParams = {
+        provider: AppKitConnector['provider'];
+        caipNetworks: CaipNetwork[];
+        activeCaipNetwork: CaipNetwork;
+    };
+    type GetWalletConnectProviderResult = AppKitConnector['provider'];
+    type GetCapabilitiesParams = string;
+    type GrantPermissionsParams = object | readonly unknown[];
+    type RevokePermissionsParams = {
+        pci: string;
+        permissions: unknown[];
+        expiry: number;
+        address: `0x${string}`;
+    };
+    type SendTransactionParams = {
+        address: `0x${string}`;
+        to: string;
+        data: string;
+        value: bigint | number;
+        gasPrice: bigint | number;
+        gas?: bigint | number;
+        caipNetwork?: CaipNetwork;
+        provider?: AppKitConnector['provider'];
+    };
+    type SendTransactionResult = {
+        hash: string;
+    };
+    type GetEnsAddressParams = {
+        name: string;
+        caipNetwork: CaipNetwork;
+    };
+    type GetEnsAddressResult = {
+        address: string | false;
+    };
+    type GetBalanceResult = {
+        balance: string;
+        symbol: string;
+    };
+    type GetProfileResult = {
+        profileImage?: string;
+        profileName?: string;
+    };
+    type ConnectResult = {
+        id: AppKitConnector['id'];
+        type: AppKitConnector['type'];
+        provider: AppKitConnector['provider'];
+        chainId: number | string;
+        address: string;
+    };
+}
+export {};

package/dist/types/src/adapters/ChainAdapterConnector.d.ts

@@ -0,0 +1,5 @@
+import type { CaipNetwork } from '@reown/appkit-common';
+import type { Connector } from '@reown/appkit-core';
+export interface ChainAdapterConnector extends Connector {
+    chains: CaipNetwork[];
+}

package/dist/types/src/adapters/index.d.ts

@@ -0,0 +1 @@
+export { AdapterBlueprint } from './ChainAdapterBlueprint.js';

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

@@ -1,22 +1,40 @@
-import type { EventsControllerState, PublicStateControllerState, ThemeControllerState, ModalControllerState, ConnectedWalletInfo, RouterControllerState, ChainAdapter, SdkVersion, UseAppKitAccountReturn, UseAppKitNetworkReturn } from '@reown/appkit-core';
+import { type EventsControllerState, type PublicStateControllerState, type ThemeControllerState, type ModalControllerState, type ConnectedWalletInfo, type RouterControllerState, type ChainAdapter, type SdkVersion, type UseAppKitAccountReturn, type UseAppKitNetworkReturn, type ConnectorType, type Provider } from '@reown/appkit-core';
 import { AccountController, BlockchainApiController, ConnectionController, ConnectorController, ChainController, EnsController, OptionsController, AssetUtil } from '@reown/appkit-core';
 import { type CaipNetwork, type ChainNamespace } from '@reown/appkit-common';
 import type { AppKitOptions } from './utils/TypesUtil.js';
-import { UniversalAdapterClient } from './universal-adapter/client.js';
-import type { W3mFrameTypes } from '@reown/appkit-wallet';
+import { UniversalAdapter as UniversalAdapterClient } from './universal-adapter/client.js';
+import { type W3mFrameTypes } from '@reown/appkit-wallet';
 import type { AppKitNetwork } from '@reown/appkit/networks';
+import type { AdapterBlueprint } from './adapters/ChainAdapterBlueprint.js';
+import UniversalProvider from '@walletconnect/universal-provider';
+declare global {
+    interface Window {
+        ethereum?: Record<string, unknown>;
+    }
+}
 export { AccountController };
 export interface OpenOptions {
     view: 'Account' | 'Connect' | 'Networks' | 'ApproveTransaction' | 'OnRampProviders';
 }
+type Adapters = Record<ChainNamespace, AdapterBlueprint>;
 export declare class AppKit {
     private static instance?;
-    version: SdkVersion;
-    adapter?: ChainAdapter;
+    activeAdapter?: AdapterBlueprint;
+    options: AppKitOptions;
     adapters?: ChainAdapter[];
+    activeChainNamespace?: ChainNamespace;
+    chainNamespaces: ChainNamespace[];
+    chainAdapters?: Adapters;
     universalAdapter?: UniversalAdapterClient;
+    private universalProvider?;
+    private connectionControllerClient?;
+    private networkControllerClient?;
+    private universalProviderInitPromise?;
+    private authProvider?;
     private initPromise?;
-    private caipNetworks;
+    version?: SdkVersion;
+    adapter?: ChainAdapter;
+    private caipNetworks?;
     private defaultCaipNetwork?;
     constructor(options: AppKitOptions & {
         adapters?: ChainAdapter[];
@@ -24,6 +42,7 @@ export declare class AppKit {
         sdkVersion: SdkVersion;
     });
     static getInstance(): AppKit | undefined;
+    private initialize;
     open(options?: OpenOptions): Promise<void>;
     close(): Promise<void>;
     setLoading(loading: ModalControllerState['loading']): void;
@@ -31,7 +50,7 @@ export declare class AppKit {
     getChainId(): string | number | undefined;
     switchNetwork(appKitNetwork: AppKitNetwork): void;
     getWalletProvider(): unknown;
-    getWalletProviderType(): import("./store/ProviderUtil.js").ProviderIdType | null | undefined;
+    getWalletProviderType(): ConnectorType | null | undefined;
     subscribeProvider(): null;
     getThemeMode(): import("@reown/appkit-core").ThemeMode;
     getThemeVariables(): import("@reown/appkit-core").ThemeVariables;
@@ -65,8 +84,9 @@ export declare class AppKit {
     addAddressLabel: (typeof AccountController)['addAddressLabel'];
     removeAddressLabel: (typeof AccountController)['removeAddressLabel'];
     getCaipAddress: (chainNamespace?: ChainNamespace) => `eip155:${string}:${string}` | `eip155:${number}:${string}` | `solana:${string}:${string}` | `solana:${number}:${string}` | `polkadot:${string}:${string}` | `polkadot:${number}:${string}` | undefined;
+    getAddressByChainNamespace: (chainNamespace: ChainNamespace) => string | undefined;
     getAddress: (chainNamespace?: ChainNamespace) => string | undefined;
-    getProvider: () => import("@walletconnect/universal-provider").default | import("@reown/appkit-core").Provider | import("@reown/appkit-core").CombinedProvider | undefined;
+    getProvider: () => Provider | UniversalProvider | import("@reown/appkit-core").CombinedProvider | undefined;
     getPreferredAccountType: () => W3mFrameTypes.AccountType;
     setCaipAddress: (typeof AccountController)['setCaipAddress'];
     setProvider: (typeof AccountController)['setProvider'];
@@ -94,7 +114,6 @@ export declare class AppKit {
     setSmartAccountEnabledNetworks: (typeof ChainController)['setSmartAccountEnabledNetworks'];
     setPreferredAccountType: (typeof AccountController)['setPreferredAccountType'];
     getReownName: (typeof EnsController)['getNamesForAddress'];
-    resolveReownName: (name: string) => Promise<string | false>;
     setEIP6963Enabled: (typeof OptionsController)['setEIP6963Enabled'];
     setClientId: (typeof BlockchainApiController)['setClientId'];
     getConnectorImage: (typeof AssetUtil)['getConnectorImage'];
@@ -103,8 +122,28 @@ export declare class AppKit {
     private getDefaultMetaData;
     private extendCaipNetworks;
     private extendDefaultCaipNetwork;
+    private createClients;
+    private handleDisconnect;
+    private listenAuthConnector;
+    private listenWalletConnect;
+    private listenAdapter;
+    private getChainsFromNamespaces;
+    private syncWalletConnectAccount;
+    private syncWalletConnectAccounts;
+    private syncProvider;
+    private syncAccount;
+    private syncConnectedWalletInfo;
+    private syncIdentity;
+    private syncReownName;
+    private syncRequestedNetworks;
+    private syncExistingConnection;
+    private getAdapter;
+    private createUniversalProvider;
     private initializeUniversalAdapter;
-    private initializeAdapters;
+    getUniversalProvider(): Promise<UniversalProvider | undefined>;
+    private createAuthProvider;
+    private createAdapters;
+    private initChainAdapters;
     private setDefaultNetwork;
     private initOrContinue;
 }

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

@@ -25,7 +25,7 @@ export declare function getAppKit(appKit: AppKit): void;
 export * from '@reown/appkit-core/react';
 export declare function useAppKitProvider<T>(chainNamespace: ChainNamespace): {
     walletProvider: T;
-    walletProviderType: import("../../store/ProviderUtil.js").ProviderIdType | undefined;
+    walletProviderType: import("@reown/appkit-core").ConnectorType | undefined;
 };
 export declare function useAppKitTheme(): {
     themeMode: "dark" | "light";

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

@@ -28,7 +28,7 @@ export declare function getAppKit(appKit: AppKit): void;
 export * from '@reown/appkit-core/vue';
 export declare function useAppKitProvider<T>(chainNamespace: ChainNamespace): {
     walletProvider: T | undefined;
-    walletProviderType: import("../../store/ProviderUtil.js").ProviderIdType | undefined;
+    walletProviderType: import("@reown/appkit-core").ConnectorType | undefined;
 };
 export declare function useAppKitTheme(): {
     setThemeMode: (themeMode: ThemeModeOptions) => void;

package/dist/types/src/store/ProviderUtil.d.ts

@@ -1,18 +1,19 @@
 import type UniversalProvider from '@walletconnect/universal-provider';
 import type { ChainNamespace } from '@reown/appkit-common';
+import type { ConnectorType } from '@reown/appkit-core';
 export interface ProviderStoreUtilState {
     providers: Record<ChainNamespace, UniversalProvider | unknown | undefined>;
-    providerIds: Record<ChainNamespace, ProviderIdType | undefined>;
+    providerIds: Record<ChainNamespace, ConnectorType | undefined>;
 }
-export type ProviderIdType = 'walletConnect' | 'injected' | 'coinbaseWallet' | 'eip6963' | 'w3mAuth' | 'coinbaseWalletSDK';
+export type ProviderType = 'walletConnect' | 'injected' | 'coinbaseWallet' | 'eip6963' | 'ID_AUTH' | 'coinbaseWalletSDK';
 export declare const ProviderUtil: {
     state: ProviderStoreUtilState;
     subscribeKey<K extends keyof ProviderStoreUtilState>(key: K, callback: (value: ProviderStoreUtilState[K]) => void): () => void;
     subscribeProviders(callback: (providers: ProviderStoreUtilState['providers']) => void): () => void;
     setProvider<T = UniversalProvider>(chainNamespace: ChainNamespace, provider: T): void;
     getProvider<T_1 = UniversalProvider>(chainNamespace: ChainNamespace): T_1 | undefined;
-    setProviderId(chainNamespace: ChainNamespace, providerId: ProviderIdType): void;
-    getProviderId(chainNamespace: ChainNamespace): ProviderIdType | undefined;
+    setProviderId(chainNamespace: ChainNamespace, providerId: ConnectorType): void;
+    getProviderId(chainNamespace: ChainNamespace): ConnectorType | undefined;
     reset(): void;
     resetChain(chainNamespace: ChainNamespace): void;
 };

package/dist/types/src/store/index.d.ts

@@ -1,2 +1,2 @@
 export { ProviderUtil } from './ProviderUtil.js';
-export type { ProviderStoreUtilState, ProviderIdType } from './ProviderUtil.js';
+export type { ProviderStoreUtilState, ProviderType } from './ProviderUtil.js';

package/dist/types/src/universal-adapter/client.d.ts

@@ -1,46 +1,34 @@
-import { type ConnectionControllerClient, type NetworkControllerClient } from '@reown/appkit-core';
-import UniversalProvider from '@walletconnect/universal-provider';
-import type { AppKit } from '../client.js';
-import type { CaipNetwork, ChainNamespace, AdapterType } from '@reown/appkit-common';
-import type { AppKitOptions, AppKitOptionsWithCaipNetworks } from '../utils/TypesUtil.js';
-type Metadata = {
-    name: string;
-    description: string;
-    url: string;
-    icons: string[];
-};
-export declare class UniversalAdapterClient {
-    private walletConnectProviderInitPromise?;
-    private appKit;
-    caipNetworks: [CaipNetwork, ...CaipNetwork[]];
-    walletConnectProvider?: UniversalProvider;
-    metadata?: Metadata;
-    isUniversalAdapterClient: boolean;
-    chainNamespace: ChainNamespace;
-    networkControllerClient: NetworkControllerClient;
-    connectionControllerClient: ConnectionControllerClient;
-    options: AppKitOptions | undefined;
-    adapterType: AdapterType;
-    reportedAlertErrors: Record<string, boolean>;
-    constructor(options: AppKitOptionsWithCaipNetworks);
-    construct(appkit: AppKit, options: AppKitOptionsWithCaipNetworks): void;
-    switchNetwork(caipNetwork: CaipNetwork): void;
+import type UniversalProvider from '@walletconnect/universal-provider';
+import { AdapterBlueprint } from '../adapters/ChainAdapterBlueprint.js';
+export declare class UniversalAdapter extends AdapterBlueprint {
+    connectWalletConnect(onUri: (uri: string) => void): Promise<void>;
+    connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;
     disconnect(): Promise<void>;
-    getWalletConnectProvider(): Promise<UniversalProvider | undefined>;
-    private syncBalance;
-    private createProvider;
-    private handleAlertError;
-    private initWalletConnectProvider;
-    private syncRequestedNetworks;
-    private checkActiveWalletConnectProvider;
-    private setWalletConnectProvider;
-    private setDefaultNetwork;
-    private watchWalletConnect;
-    private getProviderData;
-    private syncAccount;
-    private syncAccounts;
-    private syncConnectedWalletInfo;
-    private syncConnectors;
-    private parseWalletCapabilities;
+    syncConnectors(): Promise<void>;
+    getBalance(): Promise<AdapterBlueprint.GetBalanceResult>;
+    signMessage(params: AdapterBlueprint.SignMessageParams): Promise<AdapterBlueprint.SignMessageResult>;
+    /**
+     *
+     * These methods are supported only on `wagmi` and `ethers` since the Solana SDK does not support them in the same way.
+     * These function definition is to have a type parity between the clients. Currently not in use.
+     */
+    estimateGas(): Promise<AdapterBlueprint.EstimateGasTransactionResult>;
+    getProfile(): Promise<AdapterBlueprint.GetProfileResult>;
+    sendTransaction(): Promise<AdapterBlueprint.SendTransactionResult>;
+    writeContract(): Promise<AdapterBlueprint.WriteContractResult>;
+    getEnsAddress(): Promise<AdapterBlueprint.GetEnsAddressResult>;
+    parseUnits(): AdapterBlueprint.ParseUnitsResult;
+    formatUnits(): AdapterBlueprint.FormatUnitsResult;
+    getCapabilities(): Promise<unknown>;
+    grantPermissions(): Promise<unknown>;
+    revokePermissions(): Promise<`0x${string}`>;
+    syncConnection(): Promise<{
+        id: string;
+        type: "WALLET_CONNECT";
+        chainId: number;
+        provider: UniversalProvider;
+        address: string;
+    }>;
+    switchNetwork(params: AdapterBlueprint.SwitchNetworkParams): Promise<void>;
+    getWalletConnectProvider(): UniversalProvider;
 }
-export {};

package/dist/types/src/universal-adapter/index.d.ts

@@ -1 +1 @@
-export { UniversalAdapterClient } from './client.js';
+export { UniversalAdapter } from './client.js';

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

@@ -4,5 +4,6 @@ import type { SessionTypes } from '@walletconnect/types';
 export declare const WcHelpersUtil: {
     getMethodsByChainNamespace(chainNamespace: ChainNamespace): string[];
     createNamespaces(caipNetworks: CaipNetwork[]): NamespaceConfig;
+    resolveReownName: (name: string) => Promise<string | false>;
     getChainsFromNamespaces(namespaces?: SessionTypes.Namespaces): CaipNetworkId[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reown/appkit",
-  "version": "1.3.2",
+  "version": "1.4.1",
   "type": "module",
   "main": "./dist/esm/exports/index.js",
   "types": "./dist/types/exports/index.d.ts",
@@ -53,6 +53,11 @@
       "types": "./dist/types/exports/auth-provider.d.ts",
       "import": "./dist/esm/exports/auth-provider.js",
       "default": "./dist/esm/exports/auth-provider.js"
+    },
+    "./adapters": {
+      "types": "./dist/types/exports/adapters.d.ts",
+      "import": "./dist/esm/exports/adapters.js",
+      "default": "./dist/esm/exports/adapters.js"
     }
   },
   "typesVersions": {
@@ -77,6 +82,9 @@
       ],
       "auth-provider": [
         "./dist/types/exports/auth-provider.d.ts"
+      ],
+      "adapters": [
+        "./dist/types/exports/adapters.d.ts"
       ]
     }
   },
@@ -87,14 +95,14 @@
     "bs58": "6.0.0",
     "valtio": "1.11.2",
     "viem": "2.x",
-    "@reown/appkit-common": "1.3.2",
-    "@reown/appkit-core": "1.3.2",
-    "@reown/appkit-polyfills": "1.3.2",
-    "@reown/appkit-scaffold-ui": "1.3.2",
-    "@reown/appkit-siwe": "1.3.2",
-    "@reown/appkit-ui": "1.3.2",
-    "@reown/appkit-utils": "1.3.2",
-    "@reown/appkit-wallet": "1.3.2"
+    "@reown/appkit-common": "1.4.1",
+    "@reown/appkit-core": "1.4.1",
+    "@reown/appkit-polyfills": "1.4.1",
+    "@reown/appkit-scaffold-ui": "1.4.1",
+    "@reown/appkit-siwe": "1.4.1",
+    "@reown/appkit-ui": "1.4.1",
+    "@reown/appkit-utils": "1.4.1",
+    "@reown/appkit-wallet": "1.4.1"
   },
   "devDependencies": {
     "@types/react": "18.3.1",