@reown/appkit 1.6.6-basic-test.1.0 → 1.6.6-basic-test.3.0

package/dist/esm/src/{client.js → client/core.js}

@@ -1,52 +1,44 @@
 import UniversalProvider from '@walletconnect/universal-provider';
-import { ConstantsUtil, NetworkUtil, ParseUtil, getW3mThemeVariables } from '@reown/appkit-common';
-import { ConstantsUtil as CoreConstantsUtil } from '@reown/appkit-core';
-import { AccountController, AlertController, ApiController, AssetUtil, BlockchainApiController, ChainController, ConnectionController, ConnectorController, CoreHelperUtil, EnsController, EventsController, ModalController, OptionsController, PublicStateController, RouterController, SnackController, StorageUtil, ThemeController } from '@reown/appkit-core';
+import { ConstantsUtil, NetworkUtil, ParseUtil } from '@reown/appkit-common';
+import { AccountController, AlertController, ApiController, AssetUtil, BlockchainApiController, ChainController, ConnectionController, ConnectorController, ConstantsUtil as CoreConstantsUtil, CoreHelperUtil, EnsController, EventsController, ModalController, OptionsController, PublicStateController, RouterController, SnackController, StorageUtil, ThemeController } from '@reown/appkit-core';
 import { WalletUtil } from '@reown/appkit-scaffold-ui/utils';
 import { setColorTheme, setThemeVariables } from '@reown/appkit-ui';
 import { CaipNetworksUtil, ErrorUtil, HelpersUtil, LoggerUtil, ConstantsUtil as UtilConstantsUtil } from '@reown/appkit-utils';
-import { W3mFrameHelpers, W3mFrameProvider, W3mFrameRpcConstants } from '@reown/appkit-wallet';
-import { W3mFrameProviderSingleton } from './auth-provider/W3MFrameProviderSingleton.js';
-import { ProviderUtil } from './store/ProviderUtil.js';
-import { UniversalAdapter, UniversalAdapter as UniversalAdapterClient } from './universal-adapter/client.js';
-import { WcHelpersUtil } from './utils/HelpersUtil.js';
-// -- Export Controllers -------------------------------------------------------
-export { AccountController };
-// -- Helpers -------------------------------------------------------------------
-let isInitialized = false;
-// -- Client --------------------------------------------------------------------
-export class AppKit {
+import { ProviderUtil } from '../store/ProviderUtil.js';
+import { UniversalAdapter } from '../universal-adapter/client.js';
+import { WcHelpersUtil } from '../utils/index.js';
+export class AppKitCore {
     constructor(options) {
         this.chainNamespaces = [];
-        this.initPromise = undefined;
         this.reportedAlertErrors = {};
-        this.setStatus = (status, chain) => {
-            StorageUtil.setConnectionStatus(status);
-            AccountController.setStatus(status, chain);
-        };
-        this.getIsConnectedState = () => Boolean(ChainController.state.activeCaipAddress);
-        this.setAllAccounts = (addresses, chain) => {
-            AccountController.setAllAccounts(addresses, chain);
-            OptionsController.setHasMultipleAddresses(addresses?.length > 1);
+        // -- Public Internal ---------------------------------------------------
+        this.getCaipNetwork = (chainNamespace) => {
+            if (chainNamespace) {
+                return ChainController.getRequestedCaipNetworks(chainNamespace).filter(c => c.chainNamespace === chainNamespace)?.[0];
+            }
+            return ChainController.state.activeCaipNetwork || this.defaultCaipNetwork;
         };
-        this.addAddressLabel = (address, label, chain) => {
-            AccountController.addAddressLabel(address, label, chain);
+        this.getCaipNetworkId = () => {
+            const network = this.getCaipNetwork();
+            if (network) {
+                return network.id;
+            }
+            return undefined;
         };
-        this.removeAddressLabel = (address, chain) => {
-            AccountController.removeAddressLabel(address, chain);
+        this.getCaipNetworks = (namespace) => ChainController.getRequestedCaipNetworks(namespace);
+        this.getActiveChainNamespace = () => ChainController.state.activeChain;
+        this.setRequestedCaipNetworks = (requestedCaipNetworks, chain) => {
+            ChainController.setRequestedCaipNetworks(requestedCaipNetworks, chain);
         };
+        this.getApprovedCaipNetworkIds = () => ChainController.getAllApprovedCaipNetworkIds();
         this.getCaipAddress = (chainNamespace) => {
             if (ChainController.state.activeChain === chainNamespace || !chainNamespace) {
                 return ChainController.state.activeCaipAddress;
             }
             return ChainController.getAccountProp('caipAddress', chainNamespace);
         };
-        this.getAddressByChainNamespace = (chainNamespace) => ChainController.getAccountProp('address', chainNamespace);
-        this.getAddress = (chainNamespace) => {
-            if (ChainController.state.activeChain === chainNamespace || !chainNamespace) {
-                return AccountController.state.address;
-            }
-            return ChainController.getAccountProp('address', chainNamespace);
+        this.setClientId = clientId => {
+            BlockchainApiController.setClientId(clientId);
         };
         this.getProvider = (namespace) => ProviderUtil.getProvider(namespace);
         this.getProviderType = (namespace) => ProviderUtil.state.providerIds[namespace];
@@ -72,64 +64,64 @@ export class AppKit {
         this.setCaipNetwork = caipNetwork => {
             ChainController.setActiveCaipNetwork(caipNetwork);
         };
-        this.getCaipNetwork = (chainNamespace) => {
-            if (chainNamespace) {
-                return ChainController.getRequestedCaipNetworks(chainNamespace).filter(c => c.chainNamespace === chainNamespace)?.[0];
-            }
-            return ChainController.state.activeCaipNetwork || this.defaultCaipNetwork;
+        this.setAllAccounts = (addresses, chain) => {
+            AccountController.setAllAccounts(addresses, chain);
+            OptionsController.setHasMultipleAddresses(addresses?.length > 1);
         };
-        this.getCaipNetworkId = () => {
-            const network = this.getCaipNetwork();
-            if (network) {
-                return network.id;
-            }
-            return undefined;
+        this.setStatus = (status, chain) => {
+            StorageUtil.setConnectionStatus(status);
+            AccountController.setStatus(status, chain);
         };
-        this.getCaipNetworks = (namespace) => ChainController.getRequestedCaipNetworks(namespace);
-        this.getActiveChainNamespace = () => ChainController.state.activeChain;
-        this.setRequestedCaipNetworks = (requestedCaipNetworks, chain) => {
-            ChainController.setRequestedCaipNetworks(requestedCaipNetworks, chain);
+        this.getAddressByChainNamespace = (chainNamespace) => ChainController.getAccountProp('address', chainNamespace);
+        this.setConnectors = connectors => {
+            const allConnectors = [...ConnectorController.getConnectors(), ...connectors];
+            ConnectorController.setConnectors(allConnectors);
+        };
+        this.fetchIdentity = request => BlockchainApiController.fetchIdentity(request);
+        this.getReownName = address => EnsController.getNamesForAddress(address);
+        this.getConnectors = () => ConnectorController.getConnectors();
+        this.getConnectorImage = connector => AssetUtil.getConnectorImage(connector);
+        this.setConnectedWalletInfo = (connectedWalletInfo, chain) => {
+            AccountController.setConnectedWalletInfo(connectedWalletInfo, chain);
+        };
+        this.getIsConnectedState = () => Boolean(ChainController.state.activeCaipAddress);
+        this.addAddressLabel = (address, label, chain) => {
+            AccountController.addAddressLabel(address, label, chain);
+        };
+        this.removeAddressLabel = (address, chain) => {
+            AccountController.removeAddressLabel(address, chain);
+        };
+        this.getAddress = (chainNamespace) => {
+            if (ChainController.state.activeChain === chainNamespace || !chainNamespace) {
+                return AccountController.state.address;
+            }
+            return ChainController.getAccountProp('address', chainNamespace);
         };
-        this.getApprovedCaipNetworkIds = () => ChainController.getAllApprovedCaipNetworkIds();
         this.setApprovedCaipNetworksData = namespace => ChainController.setApprovedCaipNetworksData(namespace);
         this.resetNetwork = (namespace) => {
             ChainController.resetNetwork(namespace);
         };
-        this.setConnectors = connectors => {
-            const allConnectors = [...ConnectorController.getConnectors(), ...connectors];
-            ConnectorController.setConnectors(allConnectors);
-        };
         this.addConnector = connector => {
             ConnectorController.addConnector(connector);
         };
-        this.getConnectors = () => ConnectorController.getConnectors();
         this.resetWcConnection = () => {
             ConnectionController.resetWcConnection();
         };
-        this.fetchIdentity = request => BlockchainApiController.fetchIdentity(request);
         this.setAddressExplorerUrl = (addressExplorerUrl, chain) => {
             AccountController.setAddressExplorerUrl(addressExplorerUrl, chain);
         };
         this.setSmartAccountDeployed = (isDeployed, chain) => {
             AccountController.setSmartAccountDeployed(isDeployed, chain);
         };
-        this.setConnectedWalletInfo = (connectedWalletInfo, chain) => {
-            AccountController.setConnectedWalletInfo(connectedWalletInfo, chain);
-        };
         this.setSmartAccountEnabledNetworks = (smartAccountEnabledNetworks, chain) => {
             ChainController.setSmartAccountEnabledNetworks(smartAccountEnabledNetworks, chain);
         };
         this.setPreferredAccountType = (preferredAccountType, chain) => {
             AccountController.setPreferredAccountType(preferredAccountType, chain);
         };
-        this.getReownName = address => EnsController.getNamesForAddress(address);
         this.setEIP6963Enabled = enabled => {
             OptionsController.setEIP6963Enabled(enabled);
         };
-        this.setClientId = clientId => {
-            BlockchainApiController.setClientId(clientId);
-        };
-        this.getConnectorImage = connector => AssetUtil.getConnectorImage(connector);
         this.handleUnsafeRPCRequest = () => {
             if (this.isOpen()) {
                 // If we are on the modal but there is no transaction stack, close the modal
@@ -154,9 +146,6 @@ export class AppKit {
         this.chainAdapters = this.createAdapters(options.adapters);
         this.initialize(options);
     }
-    static getInstance() {
-        return this.instance;
-    }
     async initialize(options) {
         this.initControllers(options);
         await this.initChainAdapters();
@@ -177,323 +166,141 @@ export class AppKit {
         });
         PublicStateController.set({ initialized: true });
     }
-    // -- Public -------------------------------------------------------------------
-    async open(options) {
-        await this.injectModalUi();
-        if (options?.uri && this.universalAdapter) {
-            ConnectionController.setUri(options.uri);
+    // -- Controllers initialization ---------------------------------------------------
+    initControllers(options) {
+        this.initializeOptionsController(options);
+        this.initializeChainController(options);
+        this.initializeThemeController(options);
+        this.initializeBlockchainApiController(options);
+        if (options.excludeWalletIds) {
+            ApiController.initializeExcludedWalletRdns({ ids: options.excludeWalletIds });
         }
-        ModalController.open(options);
-    }
-    async close() {
-        await this.injectModalUi();
-        ModalController.close();
     }
-    setLoading(loading) {
-        ModalController.setLoading(loading);
+    initializeThemeController(options) {
+        if (options.themeMode) {
+            ThemeController.setThemeMode(options.themeMode);
+        }
+        if (options.themeVariables) {
+            ThemeController.setThemeVariables(options.themeVariables);
+        }
     }
-    // -- Adapter Methods ----------------------------------------------------------
-    getError() {
-        return '';
+    initializeChainController(options) {
+        if (!this.connectionControllerClient || !this.networkControllerClient) {
+            throw new Error('ConnectionControllerClient and NetworkControllerClient must be set');
+        }
+        ChainController.initialize(options.adapters ?? [], this.caipNetworks, {
+            connectionControllerClient: this.connectionControllerClient,
+            networkControllerClient: this.networkControllerClient
+        });
+        const network = this.getDefaultNetwork();
+        if (network) {
+            ChainController.setActiveCaipNetwork(network);
+        }
     }
-    getChainId() {
-        return ChainController.state.activeCaipNetwork?.id;
+    async initializeBlockchainApiController(options) {
+        await BlockchainApiController.getSupportedNetworks({
+            projectId: options.projectId
+        });
     }
-    switchNetwork(appKitNetwork) {
-        const network = this.caipNetworks?.find(n => n.id === appKitNetwork.id);
-        if (!network) {
-            AlertController.open(ErrorUtil.ALERT_ERRORS.SWITCH_NETWORK_NOT_FOUND, 'error');
+    initializeOptionsController(options) {
+        OptionsController.setDebug(options.debug !== false);
+        if (!options.projectId) {
+            AlertController.open(ErrorUtil.ALERT_ERRORS.PROJECT_ID_NOT_CONFIGURED, 'error');
             return;
         }
-        ChainController.switchActiveNetwork(network);
+        // On by default
+        OptionsController.setEnableWalletConnect(options.enableWalletConnect !== false);
+        OptionsController.setEnableWalletGuide(options.enableWalletGuide !== false);
+        OptionsController.setEnableWallets(options.enableWallets !== false);
+        OptionsController.setEIP6963Enabled(options.enableEIP6963 !== false);
+        OptionsController.setEnableAuthLogger(options.enableAuthLogger !== false);
+        OptionsController.setSdkVersion(options.sdkVersion);
+        OptionsController.setProjectId(options.projectId);
+        OptionsController.setEnableEmbedded(options.enableEmbedded);
+        OptionsController.setAllWallets(options.allWallets);
+        OptionsController.setIncludeWalletIds(options.includeWalletIds);
+        OptionsController.setExcludeWalletIds(options.excludeWalletIds);
+        OptionsController.setFeaturedWalletIds(options.featuredWalletIds);
+        OptionsController.setTokens(options.tokens);
+        OptionsController.setTermsConditionsUrl(options.termsConditionsUrl);
+        OptionsController.setPrivacyPolicyUrl(options.privacyPolicyUrl);
+        OptionsController.setCustomWallets(options.customWallets);
+        OptionsController.setFeatures(options.features);
+        OptionsController.setAllowUnsupportedChain(options.allowUnsupportedChain);
+        OptionsController.setDefaultAccountTypes(options.defaultAccountTypes);
+        const defaultMetaData = this.getDefaultMetaData();
+        if (!options.metadata && defaultMetaData) {
+            options.metadata = defaultMetaData;
+        }
+        OptionsController.setMetadata(options.metadata);
+        OptionsController.setDisableAppend(options.disableAppend);
+        OptionsController.setEnableEmbedded(options.enableEmbedded);
+        OptionsController.setSIWX(options.siwx);
+        const evmAdapter = options.adapters?.find(adapter => adapter.namespace === ConstantsUtil.CHAIN.EVM);
+        // Set the SIWE client for EVM chains
+        if (evmAdapter) {
+            if (options.siweConfig) {
+                if (options.siwx) {
+                    throw new Error('Cannot set both `siweConfig` and `siwx` options');
+                }
+                OptionsController.setSIWX(options.siweConfig.mapToSIWX());
+            }
+        }
     }
-    getWalletProvider() {
-        return ChainController.state.activeChain
-            ? ProviderUtil.state.providers[ChainController.state.activeChain]
-            : null;
+    getDefaultMetaData() {
+        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+            return {
+                name: document.getElementsByTagName('title')?.[0]?.textContent || '',
+                description: document.querySelector('meta[property="og:description"]')?.content || '',
+                url: window.location.origin,
+                icons: [document.querySelector('link[rel~="icon"]')?.href || '']
+            };
+        }
+        return null;
     }
-    getWalletProviderType() {
-        return ChainController.state.activeChain
-            ? ProviderUtil.state.providerIds[ChainController.state.activeChain]
-            : null;
+    // -- Network Initialization ---------------------------------------------------
+    getUnsupportedNetwork(caipNetworkId) {
+        return {
+            id: caipNetworkId.split(':')[1],
+            caipNetworkId,
+            name: ConstantsUtil.UNSUPPORTED_NETWORK_NAME,
+            chainNamespace: caipNetworkId.split(':')[0],
+            nativeCurrency: {
+                name: '',
+                decimals: 0,
+                symbol: ''
+            },
+            rpcUrls: {
+                default: {
+                    http: []
+                }
+            }
+        };
     }
-    subscribeProviders(callback) {
-        return ProviderUtil.subscribeProviders(callback);
+    setUnsupportedNetwork(chainId) {
+        const namespace = this.getActiveChainNamespace();
+        if (namespace) {
+            const unsupportedNetwork = this.getUnsupportedNetwork(`${namespace}:${chainId}`);
+            ChainController.setActiveCaipNetwork(unsupportedNetwork);
+        }
     }
-    getThemeMode() {
-        return ThemeController.state.themeMode;
+    getDefaultNetwork() {
+        const caipNetworkId = StorageUtil.getActiveCaipNetworkId();
+        if (caipNetworkId) {
+            const caipNetwork = this.caipNetworks?.find(n => n.caipNetworkId === caipNetworkId);
+            if (caipNetwork) {
+                return caipNetwork;
+            }
+            return this.getUnsupportedNetwork(caipNetworkId);
+        }
+        return this.caipNetworks?.[0];
     }
-    getThemeVariables() {
-        return ThemeController.state.themeVariables;
-    }
-    setThemeMode(themeMode) {
-        ThemeController.setThemeMode(themeMode);
-        setColorTheme(ThemeController.state.themeMode);
-    }
-    setTermsConditionsUrl(termsConditionsUrl) {
-        OptionsController.setTermsConditionsUrl(termsConditionsUrl);
-    }
-    setPrivacyPolicyUrl(privacyPolicyUrl) {
-        OptionsController.setPrivacyPolicyUrl(privacyPolicyUrl);
-    }
-    setThemeVariables(themeVariables) {
-        ThemeController.setThemeVariables(themeVariables);
-        setThemeVariables(ThemeController.state.themeVariables);
-    }
-    subscribeTheme(callback) {
-        return ThemeController.subscribe(callback);
-    }
-    getWalletInfo() {
-        return AccountController.state.connectedWalletInfo;
-    }
-    subscribeAccount(callback) {
-        const authConnector = ConnectorController.getAuthConnector();
-        function updateVal() {
-            callback({
-                allAccounts: AccountController.state.allAccounts,
-                caipAddress: ChainController.state.activeCaipAddress,
-                address: CoreHelperUtil.getPlainAddress(ChainController.state.activeCaipAddress),
-                isConnected: Boolean(ChainController.state.activeCaipAddress),
-                status: AccountController.state.status,
-                embeddedWalletInfo: authConnector
-                    ? {
-                        user: AccountController.state.user,
-                        authProvider: AccountController.state.socialProvider || 'email',
-                        accountType: AccountController.state.preferredAccountType,
-                        isSmartAccountDeployed: Boolean(AccountController.state.smartAccountDeployed)
-                    }
-                    : undefined
-            });
-        }
-        ChainController.subscribe(updateVal);
-        AccountController.subscribe(updateVal);
-    }
-    subscribeNetwork(callback) {
-        return ChainController.subscribe(({ activeCaipNetwork }) => {
-            callback({
-                caipNetwork: activeCaipNetwork,
-                chainId: activeCaipNetwork?.id,
-                caipNetworkId: activeCaipNetwork?.caipNetworkId
-            });
-        });
-    }
-    subscribeWalletInfo(callback) {
-        return AccountController.subscribeKey('connectedWalletInfo', callback);
-    }
-    subscribeShouldUpdateToAddress(callback) {
-        AccountController.subscribeKey('shouldUpdateToAddress', callback);
-    }
-    subscribeCaipNetworkChange(callback) {
-        ChainController.subscribeKey('activeCaipNetwork', callback);
-    }
-    getState() {
-        return PublicStateController.state;
-    }
-    subscribeState(callback) {
-        return PublicStateController.subscribe(callback);
-    }
-    showErrorMessage(message) {
-        SnackController.showError(message);
-    }
-    showSuccessMessage(message) {
-        SnackController.showSuccess(message);
-    }
-    getEvent() {
-        return { ...EventsController.state };
-    }
-    subscribeEvents(callback) {
-        return EventsController.subscribe(callback);
-    }
-    replace(route) {
-        RouterController.replace(route);
-    }
-    redirect(route) {
-        RouterController.push(route);
-    }
-    popTransactionStack(cancel) {
-        RouterController.popTransactionStack(cancel);
-    }
-    isOpen() {
-        return ModalController.state.open;
-    }
-    isTransactionStackEmpty() {
-        return RouterController.state.transactionStack.length === 0;
-    }
-    isTransactionShouldReplaceView() {
-        return RouterController.state.transactionStack[RouterController.state.transactionStack.length - 1]?.replace;
-    }
-    updateFeatures(newFeatures) {
-        OptionsController.setFeatures(newFeatures);
-    }
-    updateOptions(newOptions) {
-        const currentOptions = OptionsController.state || {};
-        const updatedOptions = { ...currentOptions, ...newOptions };
-        OptionsController.setOptions(updatedOptions);
-    }
-    setConnectMethodsOrder(connectMethodsOrder) {
-        OptionsController.setConnectMethodsOrder(connectMethodsOrder);
-    }
-    setWalletFeaturesOrder(walletFeaturesOrder) {
-        OptionsController.setWalletFeaturesOrder(walletFeaturesOrder);
-    }
-    setCollapseWallets(collapseWallets) {
-        OptionsController.setCollapseWallets(collapseWallets);
-    }
-    setSocialsOrder(socialsOrder) {
-        OptionsController.setSocialsOrder(socialsOrder);
-    }
-    async disconnect() {
-        await ConnectionController.disconnect();
-    }
-    getConnectMethodsOrder() {
-        return WalletUtil.getConnectOrderMethod(OptionsController.state.features, ConnectorController.getConnectors());
-    }
-    /**
-     * Removes an adapter from the AppKit.
-     * @param namespace - The namespace of the adapter to remove.
-     */
-    removeAdapter(namespace) {
-        const isConnected = this.getIsConnectedState();
-        const adapter = this.getAdapter(namespace);
-        if (!adapter || !this.chainAdapters || isConnected) {
-            return;
-        }
-        const newCaipNetworks = this.caipNetworks?.filter(network => network.chainNamespace !== namespace);
-        ChainController.removeAdapter(namespace);
-        ConnectorController.removeAdapter(namespace);
-        this.chainNamespaces = this.chainNamespaces.filter(n => n !== namespace);
-        this.caipNetworks = newCaipNetworks;
-        adapter.removeAllEventListeners();
-        Reflect.deleteProperty(this.chainAdapters, namespace);
-    }
-    /**
-     * Adds an adapter to the AppKit.
-     * @param adapter - The adapter instance.
-     * @param networks - The list of networks that this adapter supports / uses.
-     */
-    addAdapter(adapter, networks) {
-        const namespace = adapter.namespace;
-        if (!this.connectionControllerClient || !this.networkControllerClient) {
-            return;
-        }
-        if (!this.chainAdapters || !namespace) {
-            return;
-        }
-        const extendedAdapterNetworks = this.extendCaipNetworks({ ...this.options, networks });
-        this.caipNetworks = [...(this.caipNetworks || []), ...extendedAdapterNetworks];
-        this.createAdapter(adapter);
-        this.initChainAdapter(namespace);
-        ChainController.addAdapter(adapter, {
-            connectionControllerClient: this.connectionControllerClient,
-            networkControllerClient: this.networkControllerClient
-        }, extendedAdapterNetworks);
-    }
-    // -- Private ------------------------------------------------------------------
-    initializeOptionsController(options) {
-        OptionsController.setDebug(options.debug !== false);
-        OptionsController.setBasic(options.basic === true);
-        if (!options.projectId) {
-            AlertController.open(ErrorUtil.ALERT_ERRORS.PROJECT_ID_NOT_CONFIGURED, 'error');
-            return;
-        }
-        // On by default
-        OptionsController.setEnableWalletConnect(options.enableWalletConnect !== false);
-        OptionsController.setEnableWalletGuide(options.enableWalletGuide !== false);
-        OptionsController.setEnableWallets(options.enableWallets !== false);
-        OptionsController.setEIP6963Enabled(options.enableEIP6963 !== false);
-        OptionsController.setEnableAuthLogger(options.enableAuthLogger !== false);
-        OptionsController.setSdkVersion(options.sdkVersion);
-        OptionsController.setProjectId(options.projectId);
-        OptionsController.setEnableEmbedded(options.enableEmbedded);
-        OptionsController.setAllWallets(options.allWallets);
-        OptionsController.setIncludeWalletIds(options.includeWalletIds);
-        OptionsController.setExcludeWalletIds(options.excludeWalletIds);
-        OptionsController.setFeaturedWalletIds(options.featuredWalletIds);
-        OptionsController.setTokens(options.tokens);
-        OptionsController.setTermsConditionsUrl(options.termsConditionsUrl);
-        OptionsController.setPrivacyPolicyUrl(options.privacyPolicyUrl);
-        OptionsController.setCustomWallets(options.customWallets);
-        OptionsController.setFeatures(options.features);
-        OptionsController.setAllowUnsupportedChain(options.allowUnsupportedChain);
-        OptionsController.setDefaultAccountTypes(options.defaultAccountTypes);
-        const defaultMetaData = this.getDefaultMetaData();
-        if (!options.metadata && defaultMetaData) {
-            options.metadata = defaultMetaData;
-        }
-        OptionsController.setMetadata(options.metadata);
-        OptionsController.setDisableAppend(options.disableAppend);
-        OptionsController.setEnableEmbedded(options.enableEmbedded);
-        OptionsController.setSIWX(options.siwx);
-        const evmAdapter = options.adapters?.find(adapter => adapter.namespace === ConstantsUtil.CHAIN.EVM);
-        // Set the SIWE client for EVM chains
-        if (evmAdapter) {
-            if (options.siweConfig) {
-                if (options.siwx) {
-                    throw new Error('Cannot set both `siweConfig` and `siwx` options');
-                }
-                OptionsController.setSIWX(options.siweConfig.mapToSIWX());
-            }
-        }
-    }
-    initializeThemeController(options) {
-        if (options.themeMode) {
-            ThemeController.setThemeMode(options.themeMode);
-        }
-        if (options.themeVariables) {
-            ThemeController.setThemeVariables(options.themeVariables);
-        }
-    }
-    initializeChainController(options) {
-        if (!this.connectionControllerClient || !this.networkControllerClient) {
-            throw new Error('ConnectionControllerClient and NetworkControllerClient must be set');
-        }
-        ChainController.initialize(options.adapters ?? [], this.caipNetworks, {
-            connectionControllerClient: this.connectionControllerClient,
-            networkControllerClient: this.networkControllerClient
-        });
-        const network = this.getDefaultNetwork();
-        if (network) {
-            ChainController.setActiveCaipNetwork(network);
-        }
-    }
-    async initializeBlockchainApiController(options) {
-        await BlockchainApiController.getSupportedNetworks({
-            projectId: options.projectId
-        });
-    }
-    initControllers(options) {
-        this.initializeOptionsController(options);
-        this.initializeChainController(options);
-        this.initializeThemeController(options);
-        this.initializeBlockchainApiController(options);
-        if (options.excludeWalletIds) {
-            ApiController.initializeExcludedWalletRdns({ ids: options.excludeWalletIds });
-        }
-    }
-    getDefaultMetaData() {
-        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
-            return {
-                name: document.getElementsByTagName('title')?.[0]?.textContent || '',
-                description: document.querySelector('meta[property="og:description"]')?.content || '',
-                url: window.location.origin,
-                icons: [document.querySelector('link[rel~="icon"]')?.href || '']
-            };
-        }
-        return null;
-    }
-    setUnsupportedNetwork(chainId) {
-        const namespace = this.getActiveChainNamespace();
-        if (namespace) {
-            const unsupportedNetwork = this.getUnsupportedNetwork(`${namespace}:${chainId}`);
-            ChainController.setActiveCaipNetwork(unsupportedNetwork);
-        }
-    }
-    extendCaipNetworks(options) {
-        const extendedNetworks = CaipNetworksUtil.extendCaipNetworks(options.networks, {
-            customNetworkImageUrls: options.chainImages,
-            projectId: options.projectId
-        });
-        return extendedNetworks;
+    extendCaipNetworks(options) {
+        const extendedNetworks = CaipNetworksUtil.extendCaipNetworks(options.networks, {
+            customNetworkImageUrls: options.chainImages,
+            projectId: options.projectId
+        });
+        return extendedNetworks;
     }
     extendDefaultCaipNetwork(options) {
         const defaultNetwork = options.networks.find(n => n.id === options.defaultNetwork?.id);
@@ -505,6 +312,7 @@ export class AppKit {
             : undefined;
         return extendedNetwork;
     }
+    // -- Client Initialization ---------------------------------------------------
     createClients() {
         this.connectionControllerClient = {
             connectWalletConnect: async () => {
@@ -665,260 +473,115 @@ export class AppKit {
             }
         };
         this.networkControllerClient = {
-            switchCaipNetwork: async (caipNetwork) => {
-                if (!caipNetwork) {
-                    return;
-                }
-                if (AccountController.state.address &&
-                    caipNetwork.chainNamespace === ChainController.state.activeChain) {
-                    const adapter = this.getAdapter(ChainController.state.activeChain);
-                    const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
-                    const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
-                    await adapter?.switchNetwork({ caipNetwork, provider, providerType });
-                    this.setCaipNetwork(caipNetwork);
-                    await this.syncAccount({
-                        address: AccountController.state.address,
-                        chainId: caipNetwork.id,
-                        chainNamespace: caipNetwork.chainNamespace
-                    });
-                }
-                else if (AccountController.state.address) {
-                    const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
-                    if (providerType === UtilConstantsUtil.CONNECTOR_TYPE_AUTH) {
-                        try {
-                            ChainController.state.activeChain = caipNetwork.chainNamespace;
-                            await this.connectionControllerClient?.connectExternal?.({
-                                id: ConstantsUtil.CONNECTOR_ID.AUTH,
-                                provider: this.authProvider,
-                                chain: caipNetwork.chainNamespace,
-                                chainId: caipNetwork.id,
-                                type: UtilConstantsUtil.CONNECTOR_TYPE_AUTH,
-                                caipNetwork
-                            });
-                            this.setCaipNetwork(caipNetwork);
-                        }
-                        catch (error) {
-                            const adapter = this.getAdapter(caipNetwork.chainNamespace);
-                            await adapter?.switchNetwork({
-                                caipNetwork,
-                                provider: this.authProvider,
-                                providerType
-                            });
-                        }
-                    }
-                    else if (providerType === 'WALLET_CONNECT') {
-                        this.setCaipNetwork(caipNetwork);
-                        this.syncWalletConnectAccount();
-                    }
-                    else {
-                        this.setCaipNetwork(caipNetwork);
-                        const address = this.getAddressByChainNamespace(caipNetwork.chainNamespace);
-                        if (address) {
-                            this.syncAccount({
-                                address,
-                                chainId: caipNetwork.id,
-                                chainNamespace: caipNetwork.chainNamespace
-                            });
-                        }
-                    }
-                }
-                else {
-                    this.setCaipNetwork(caipNetwork);
-                }
-            },
+            switchCaipNetwork: async (caipNetwork) => await this.switchCaipNetwork(caipNetwork),
             // eslint-disable-next-line @typescript-eslint/require-await
-            getApprovedCaipNetworksData: async () => {
-                const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
-                if (providerType === UtilConstantsUtil.CONNECTOR_TYPE_WALLET_CONNECT) {
-                    const namespaces = this.universalProvider?.session?.namespaces;
-                    return {
-                        /*
-                         * MetaMask Wallet only returns 1 namespace in the session object. This makes it imposible
-                         * to switch to other networks. Setting supportsAllNetworks to true for MetaMask Wallet
-                         * will make it possible to switch to other networks.
-                         */
-                        supportsAllNetworks: this.universalProvider?.session?.peer?.metadata.name === 'MetaMask Wallet',
-                        approvedCaipNetworkIds: this.getChainsFromNamespaces(namespaces)
-                    };
-                }
-                return { supportsAllNetworks: true, approvedCaipNetworkIds: [] };
-            }
+            getApprovedCaipNetworksData: async () => this.getApprovedCaipNetworksData()
         };
         ConnectionController.setClient(this.connectionControllerClient);
     }
-    setupAuthConnectorListeners(provider) {
-        provider.onRpcRequest((request) => {
-            if (W3mFrameHelpers.checkIfRequestExists(request)) {
-                if (!W3mFrameHelpers.checkIfRequestIsSafe(request)) {
-                    this.handleUnsafeRPCRequest();
-                }
-            }
-            else {
-                this.open();
-                // eslint-disable-next-line no-console
-                console.error(W3mFrameRpcConstants.RPC_METHOD_NOT_ALLOWED_MESSAGE, {
-                    method: request.method
+    getApprovedCaipNetworksData() {
+        const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
+        if (providerType === UtilConstantsUtil.CONNECTOR_TYPE_WALLET_CONNECT) {
+            const namespaces = this.universalProvider?.session?.namespaces;
+            return {
+                /*
+                 * MetaMask Wallet only returns 1 namespace in the session object. This makes it imposible
+                 * to switch to other networks. Setting supportsAllNetworks to true for MetaMask Wallet
+                 * will make it possible to switch to other networks.
+                 */
+                supportsAllNetworks: this.universalProvider?.session?.peer?.metadata.name === 'MetaMask Wallet',
+                approvedCaipNetworkIds: this.getChainsFromNamespaces(namespaces)
+            };
+        }
+        return { supportsAllNetworks: true, approvedCaipNetworkIds: [] };
+    }
+    async switchCaipNetwork(caipNetwork) {
+        if (!caipNetwork) {
+            return;
+        }
+        if (AccountController.state.address) {
+            if (caipNetwork.chainNamespace === ChainController.state.activeChain) {
+                const adapter = this.getAdapter(ChainController.state.activeChain);
+                const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
+                const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
+                await adapter?.switchNetwork({ caipNetwork, provider, providerType });
+                this.setCaipNetwork(caipNetwork);
+                await this.syncAccount({
+                    address: AccountController.state.address,
+                    chainId: caipNetwork.id,
+                    chainNamespace: caipNetwork.chainNamespace
                 });
-                setTimeout(() => {
-                    this.showErrorMessage(W3mFrameRpcConstants.RPC_METHOD_NOT_ALLOWED_UI_MESSAGE);
-                }, 300);
-                provider.rejectRpcRequests();
             }
-        });
-        provider.onRpcError(() => {
-            const isModalOpen = this.isOpen();
-            if (isModalOpen) {
-                if (this.isTransactionStackEmpty()) {
-                    this.close();
+            else {
+                const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
+                this.setCaipNetwork(caipNetwork);
+                if (providerType === 'WALLET_CONNECT') {
+                    this.syncWalletConnectAccount();
                 }
                 else {
-                    this.popTransactionStack(true);
+                    const address = this.getAddressByChainNamespace(caipNetwork.chainNamespace);
+                    if (address) {
+                        this.syncAccount({
+                            address,
+                            chainId: caipNetwork.id,
+                            chainNamespace: caipNetwork.chainNamespace
+                        });
+                    }
                 }
             }
+        }
+        else {
+            this.setCaipNetwork(caipNetwork);
+        }
+    }
+    getChainsFromNamespaces(namespaces = {}) {
+        return Object.values(namespaces).flatMap((namespace) => {
+            const chains = (namespace.chains || []);
+            const accountsChains = namespace.accounts.map(account => {
+                const { chainId, chainNamespace } = ParseUtil.parseCaipAddress(account);
+                return `${chainNamespace}:${chainId}`;
+            });
+            return Array.from(new Set([...chains, ...accountsChains]));
         });
-        provider.onRpcSuccess((_, request) => {
-            const isSafeRequest = W3mFrameHelpers.checkIfRequestIsSafe(request);
-            if (isSafeRequest) {
-                return;
-            }
-            if (this.isTransactionStackEmpty()) {
-                this.close();
-                if (AccountController.state.address && ChainController.state.activeCaipNetwork?.id) {
-                    this.updateNativeBalance();
-                }
+    }
+    // -- Adapter Initialization ---------------------------------------------------
+    createAdapters(blueprints) {
+        this.createClients();
+        return this.chainNamespaces.reduce((adapters, namespace) => {
+            const blueprint = blueprints?.find(b => b.namespace === namespace);
+            if (blueprint) {
+                adapters[namespace] = blueprint;
+                adapters[namespace].namespace = namespace;
+                adapters[namespace].construct({
+                    namespace,
+                    projectId: this.options?.projectId,
+                    networks: this.caipNetworks
+                });
             }
             else {
-                this.popTransactionStack();
-                if (AccountController.state.address && ChainController.state.activeCaipNetwork?.id) {
-                    this.updateNativeBalance();
-                }
-            }
-        });
-        provider.onNotConnected(() => {
-            const namespace = ChainController.state.activeChain;
-            const connectorId = StorageUtil.getConnectedConnectorId(namespace);
-            const isConnectedWithAuth = connectorId === ConstantsUtil.CONNECTOR_ID.AUTH;
-            if (isConnectedWithAuth) {
-                this.setCaipAddress(undefined, namespace);
-                this.setLoading(false);
-            }
-        });
-        provider.onConnect(async (user) => {
-            const namespace = ChainController.state.activeChain;
-            // To keep backwards compatibility, eip155 chainIds are numbers and not actual caipChainIds
-            const caipAddress = namespace === ConstantsUtil.CHAIN.EVM
-                ? `eip155:${user.chainId}:${user.address}`
-                : `${user.chainId}:${user.address}`;
-            this.setSmartAccountDeployed(Boolean(user.smartAccountDeployed), namespace);
-            if (!HelpersUtil.isLowerCaseMatch(user.address, AccountController.state.address)) {
-                this.syncIdentity({
-                    address: user.address,
-                    chainId: user.chainId,
-                    chainNamespace: namespace
+                adapters[namespace] = new UniversalAdapter({
+                    namespace,
+                    networks: this.caipNetworks
                 });
             }
-            this.setCaipAddress(caipAddress, namespace);
-            this.setUser({ ...(AccountController.state.user || {}), email: user.email });
-            const preferredAccountType = (user.preferredAccountType ||
-                OptionsController.state.defaultAccountTypes[namespace]);
-            this.setPreferredAccountType(preferredAccountType, namespace);
-            const userAccounts = user.accounts?.map(account => CoreHelperUtil.createAccount(namespace, account.address, account.type || OptionsController.state.defaultAccountTypes[namespace]));
-            this.setAllAccounts(userAccounts || [
-                CoreHelperUtil.createAccount(namespace, user.address, preferredAccountType)
-            ], namespace);
-            await provider.getSmartAccountEnabledNetworks();
-            this.setLoading(false);
-        });
-        provider.onSocialConnected(({ userName }) => {
-            this.setUser({ ...(AccountController.state.user || {}), username: userName });
-        });
-        provider.onGetSmartAccountEnabledNetworks(networks => {
-            this.setSmartAccountEnabledNetworks(networks, ChainController.state.activeChain);
-        });
-        provider.onSetPreferredAccount(({ address, type }) => {
-            if (!address) {
-                return;
-            }
-            this.setPreferredAccountType(type, ChainController.state.activeChain);
-        });
+            return adapters;
+            // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
+        }, {});
     }
-    async syncAuthConnector(provider) {
-        this.setLoading(true);
-        const isLoginEmailUsed = provider.getLoginEmailUsed();
-        this.setLoading(isLoginEmailUsed);
-        if (isLoginEmailUsed) {
-            this.setStatus('connecting', ChainController.state.activeChain);
-        }
-        const email = provider.getEmail();
-        const username = provider.getUsername();
-        this.setUser({ ...(AccountController.state?.user || {}), username, email });
-        this.setupAuthConnectorListeners(provider);
-        const { isConnected } = await provider.isConnected();
-        const theme = ThemeController.getSnapshot();
-        const options = OptionsController.getSnapshot();
-        provider.syncDappData({
-            metadata: options.metadata,
-            sdkVersion: options.sdkVersion,
-            projectId: options.projectId,
-            sdkType: options.sdkType
-        });
-        provider.syncTheme({
-            themeMode: theme.themeMode,
-            themeVariables: theme.themeVariables,
-            w3mThemeVariables: getW3mThemeVariables(theme.themeVariables, theme.themeMode)
-        });
-        const namespace = StorageUtil.getActiveNamespace();
-        if (namespace) {
-            if (isConnected && this.connectionControllerClient?.connectExternal) {
-                await this.connectionControllerClient?.connectExternal({
-                    id: ConstantsUtil.CONNECTOR_ID.AUTH,
-                    info: { name: ConstantsUtil.CONNECTOR_ID.AUTH },
-                    type: UtilConstantsUtil.CONNECTOR_TYPE_AUTH,
-                    provider,
-                    chainId: ChainController.state.activeCaipNetwork?.id,
-                    chain: namespace
-                });
-                this.setStatus('connected', namespace);
-            }
-            else if (StorageUtil.getConnectedConnectorId(namespace) === ConstantsUtil.CONNECTOR_ID.AUTH) {
-                this.setStatus('disconnected', namespace);
-                StorageUtil.removeConnectedNamespace(namespace);
-            }
-        }
-        this.setLoading(false);
+    async initChainAdapter(namespace) {
+        this.onConnectors(namespace);
+        this.listenAdapter(namespace);
+        this.chainAdapters?.[namespace].syncConnectors(this.options, this);
+        await this.createUniversalProviderForAdapter(namespace);
     }
-    listenWalletConnect() {
-        if (this.universalProvider) {
-            this.universalProvider.on('display_uri', ConnectionController.setUri.bind(ConnectionController));
-            this.universalProvider.on('disconnect', () => {
-                this.chainNamespaces.forEach(namespace => {
-                    this.resetAccount(namespace);
-                });
-                ConnectionController.resetWcConnection();
-            });
-            this.universalProvider.on('chainChanged', (chainId) => {
-                // eslint-disable-next-line eqeqeq
-                const caipNetwork = this.caipNetworks?.find(c => c.id == chainId);
-                const currentCaipNetwork = this.getCaipNetwork();
-                if (!caipNetwork) {
-                    this.setUnsupportedNetwork(chainId);
-                    return;
-                }
-                if (currentCaipNetwork?.id !== caipNetwork?.id) {
-                    this.setCaipNetwork(caipNetwork);
-                }
-            });
-            this.universalProvider.on('session_event', (callbackData) => {
-                if (WcHelpersUtil.isSessionEventData(callbackData)) {
-                    const { name, data } = callbackData.params.event;
-                    if (name === 'accountsChanged' &&
-                        Array.isArray(data) &&
-                        CoreHelperUtil.isCaipAddress(data[0])) {
-                        this.syncAccount(ParseUtil.parseCaipAddress(data[0]));
-                    }
-                }
-            });
-        }
+    async initChainAdapters() {
+        await Promise.all(this.chainNamespaces.map(async (namespace) => {
+            await this.initChainAdapter(namespace);
+        }));
+    }
+    onConnectors(chainNamespace) {
+        const adapter = this.getAdapter(chainNamespace);
+        adapter?.on('connectors', this.setConnectors.bind(this));
     }
     listenAdapter(chainNamespace) {
         const adapter = this.getAdapter(chainNamespace);
@@ -978,31 +641,78 @@ export class AppKit {
             }
         });
     }
-    async updateNativeBalance() {
-        const adapter = this.getAdapter(ChainController.state.activeChain);
-        if (adapter && ChainController.state.activeChain && AccountController.state.address) {
-            const balance = await adapter.getBalance({
-                address: AccountController.state.address,
-                chainId: ChainController.state.activeCaipNetwork?.id,
-                caipNetwork: this.getCaipNetwork(),
-                tokens: this.options.tokens
-            });
-            this.setBalance(balance.balance, balance.symbol, ChainController.state.activeChain);
+    async createUniversalProviderForAdapter(chainNamespace) {
+        await this.getUniversalProvider();
+        if (this.universalProvider) {
+            this.chainAdapters?.[chainNamespace]?.setUniversalProvider?.(this.universalProvider);
         }
     }
-    getChainsFromNamespaces(namespaces = {}) {
-        return Object.values(namespaces).flatMap((namespace) => {
-            const chains = (namespace.chains || []);
-            const accountsChains = namespace.accounts.map(account => {
-                const { chainId, chainNamespace } = ParseUtil.parseCaipAddress(account);
-                return `${chainNamespace}:${chainId}`;
+    // -- Connection Sync ---------------------------------------------------
+    async syncExistingConnection() {
+        await Promise.allSettled(this.chainNamespaces.map(namespace => this.syncNamespaceConnection(namespace)));
+    }
+    async syncNamespaceConnection(namespace) {
+        try {
+            const connectorId = StorageUtil.getConnectedConnectorId(namespace);
+            this.setStatus('connecting', namespace);
+            switch (connectorId) {
+                case ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT:
+                    await this.syncWalletConnectAccount();
+                    break;
+                case ConstantsUtil.CONNECTOR_ID.AUTH:
+                    // Handled during initialization of adapters' auth provider
+                    break;
+                default:
+                    await this.syncAdapterConnection(namespace);
+            }
+        }
+        catch (err) {
+            console.warn("AppKit couldn't sync existing connection", err);
+            StorageUtil.deleteConnectedConnectorId(namespace);
+            this.setStatus('disconnected', namespace);
+        }
+    }
+    async syncAdapterConnection(namespace) {
+        const adapter = this.getAdapter(namespace);
+        const connectorId = StorageUtil.getConnectedConnectorId(namespace);
+        const caipNetwork = this.getCaipNetwork();
+        try {
+            if (!adapter || !connectorId) {
+                throw new Error(`Adapter or connectorId not found for namespace ${namespace}`);
+            }
+            const connection = await adapter?.syncConnection({
+                namespace,
+                id: connectorId,
+                chainId: caipNetwork?.id,
+                rpcUrl: caipNetwork?.rpcUrls?.default?.http?.[0]
             });
-            return Array.from(new Set([...chains, ...accountsChains]));
-        });
+            if (connection) {
+                const accounts = await adapter?.getAccounts({
+                    namespace,
+                    id: connectorId
+                });
+                if (accounts && accounts.accounts.length > 0) {
+                    this.setAllAccounts(accounts.accounts, namespace);
+                }
+                else {
+                    this.setAllAccounts([CoreHelperUtil.createAccount(namespace, connection.address, 'eoa')], namespace);
+                }
+                this.syncProvider({ ...connection, chainNamespace: namespace });
+                await this.syncAccount({ ...connection, chainNamespace: namespace });
+                this.setStatus('connected', namespace);
+            }
+            else {
+                this.setStatus('disconnected', namespace);
+            }
+        }
+        catch (e) {
+            StorageUtil.deleteConnectedConnectorId(namespace);
+            this.setStatus('disconnected', namespace);
+        }
     }
     async syncWalletConnectAccount() {
-        const adapter = this.getAdapter(ChainController.state.activeChain);
         this.chainNamespaces.forEach(async (chainNamespace) => {
+            const adapter = this.getAdapter(chainNamespace);
             const namespaceAccounts = this.universalProvider?.session?.namespaces?.[chainNamespace]?.accounts || [];
             // We try and find the address for this network in the session object.
             const activeChainId = ChainController.state.activeCaipNetwork?.id;
@@ -1113,20 +823,60 @@ export class AppKit {
             await this.syncBalance({ address, chainId: network?.id, chainNamespace });
         }
     }
-    async syncBalance(params) {
-        const caipNetwork = NetworkUtil.getNetworksByNamespace(this.caipNetworks, params.chainNamespace).find(n => n.id.toString() === params.chainId?.toString());
-        if (!caipNetwork) {
+    async syncIdentity({ address, chainId, chainNamespace }) {
+        const activeCaipNetwork = this.caipNetworks?.find(n => n.caipNetworkId === `${chainNamespace}:${chainId}`);
+        if (chainNamespace !== ConstantsUtil.CHAIN.EVM || activeCaipNetwork?.testnet) {
             return;
         }
-        const isApiBalanceSupported = CoreConstantsUtil.BALANCE_SUPPORTED_CHAINS.includes(caipNetwork?.chainNamespace);
-        if (caipNetwork.testnet || !isApiBalanceSupported) {
-            await this.updateNativeBalance();
-            return;
+        try {
+            const { name, avatar } = await this.fetchIdentity({
+                address
+            });
+            this.setProfileName(name, chainNamespace);
+            this.setProfileImage(avatar, chainNamespace);
+            if (!name) {
+                await this.syncReownName(address, chainNamespace);
+                const adapter = this.getAdapter(chainNamespace);
+                const result = await adapter?.getProfile({
+                    address,
+                    chainId: Number(chainId)
+                });
+                if (result?.profileName) {
+                    this.setProfileName(result.profileName, chainNamespace);
+                    if (result.profileImage) {
+                        this.setProfileImage(result.profileImage, chainNamespace);
+                    }
+                }
+                else {
+                    await this.syncReownName(address, chainNamespace);
+                    this.setProfileImage(null, chainNamespace);
+                }
+            }
+        }
+        catch {
+            if (chainId === 1) {
+                await this.syncReownName(address, chainNamespace);
+            }
+            else {
+                await this.syncReownName(address, chainNamespace);
+                this.setProfileImage(null, chainNamespace);
+            }
+        }
+    }
+    async syncReownName(address, chainNamespace) {
+        try {
+            const registeredWcNames = await this.getReownName(address);
+            if (registeredWcNames[0]) {
+                const wcName = registeredWcNames[0];
+                this.setProfileName(wcName.name, chainNamespace);
+            }
+            else {
+                this.setProfileName(null, chainNamespace);
+            }
+        }
+        catch {
+            this.setProfileName(null, chainNamespace);
         }
-        const balances = await AccountController.fetchTokenBalance(() => this.setBalance('0.00', caipNetwork.nativeCurrency.symbol, caipNetwork.chainNamespace));
-        const balance = balances.find(b => b.chainId === `${params.chainNamespace}:${params.chainId}` &&
-            b.symbol === caipNetwork.nativeCurrency.symbol);
-        this.setBalance(balance?.quantity?.numeric || '0.00', caipNetwork.nativeCurrency.symbol, params.chainNamespace);
     }
     syncConnectedWalletInfo(chainNamespace) {
         const connectorId = StorageUtil.getConnectedConnectorId(chainNamespace);
@@ -1142,384 +892,383 @@ export class AppKit {
                 }
             }
         }
-        else if (providerType === UtilConstantsUtil.CONNECTOR_TYPE_WALLET_CONNECT) {
-            const provider = ProviderUtil.getProvider(chainNamespace);
-            if (provider?.session) {
-                this.setConnectedWalletInfo({
-                    ...provider.session.peer.metadata,
-                    name: provider.session.peer.metadata.name,
-                    icon: provider.session.peer.metadata.icons?.[0]
-                }, chainNamespace);
+        else if (providerType === UtilConstantsUtil.CONNECTOR_TYPE_WALLET_CONNECT) {
+            const provider = ProviderUtil.getProvider(chainNamespace);
+            if (provider?.session) {
+                this.setConnectedWalletInfo({
+                    ...provider.session.peer.metadata,
+                    name: provider.session.peer.metadata.name,
+                    icon: provider.session.peer.metadata.icons?.[0]
+                }, chainNamespace);
+            }
+        }
+        else if (connectorId) {
+            if (connectorId === ConstantsUtil.CONNECTOR_ID.COINBASE) {
+                const connector = this.getConnectors().find(c => c.id === ConstantsUtil.CONNECTOR_ID.COINBASE);
+                this.setConnectedWalletInfo({ name: 'Coinbase Wallet', icon: this.getConnectorImage(connector) }, chainNamespace);
+            }
+            this.setConnectedWalletInfo({ name: connectorId }, chainNamespace);
+        }
+    }
+    async syncBalance(params) {
+        const caipNetwork = NetworkUtil.getNetworksByNamespace(this.caipNetworks, params.chainNamespace).find(n => n.id.toString() === params.chainId?.toString());
+        if (!caipNetwork) {
+            return;
+        }
+        const isApiBalanceSupported = CoreConstantsUtil.BALANCE_SUPPORTED_CHAINS.includes(caipNetwork?.chainNamespace);
+        if (caipNetwork.testnet || !isApiBalanceSupported) {
+            await this.updateNativeBalance();
+            return;
+        }
+        const balances = await AccountController.fetchTokenBalance(() => this.setBalance('0.00', caipNetwork.nativeCurrency.symbol, caipNetwork.chainNamespace));
+        const balance = balances.find(b => b.chainId === `${params.chainNamespace}:${params.chainId}` &&
+            b.symbol === caipNetwork.nativeCurrency.symbol);
+        this.setBalance(balance?.quantity?.numeric || '0.00', caipNetwork.nativeCurrency.symbol, params.chainNamespace);
+    }
+    async updateNativeBalance() {
+        const adapter = this.getAdapter(ChainController.state.activeChain);
+        if (adapter && ChainController.state.activeChain && AccountController.state.address) {
+            const balance = await adapter.getBalance({
+                address: AccountController.state.address,
+                chainId: ChainController.state.activeCaipNetwork?.id,
+                caipNetwork: this.getCaipNetwork(),
+                tokens: this.options.tokens
+            });
+            this.setBalance(balance.balance, balance.symbol, ChainController.state.activeChain);
+        }
+    }
+    // -- Universal Provider ---------------------------------------------------
+    async initializeUniversalAdapter() {
+        const logger = LoggerUtil.createLogger((error, ...args) => {
+            if (error) {
+                this.handleAlertError(error);
+            }
+            // eslint-disable-next-line no-console
+            console.error(...args);
+        });
+        const universalProviderOptions = {
+            projectId: this.options?.projectId,
+            metadata: {
+                name: this.options?.metadata ? this.options?.metadata.name : '',
+                description: this.options?.metadata ? this.options?.metadata.description : '',
+                url: this.options?.metadata ? this.options?.metadata.url : '',
+                icons: this.options?.metadata ? this.options?.metadata.icons : ['']
+            },
+            logger
+        };
+        OptionsController.setUsingInjectedUniversalProvider(Boolean(this.options?.universalProvider));
+        this.universalProvider =
+            this.options.universalProvider ?? (await UniversalProvider.init(universalProviderOptions));
+        this.listenWalletConnect();
+    }
+    listenWalletConnect() {
+        if (this.universalProvider) {
+            this.universalProvider.on('display_uri', ConnectionController.setUri.bind(ConnectionController));
+            this.universalProvider.on('disconnect', () => {
+                this.chainNamespaces.forEach(namespace => {
+                    this.resetAccount(namespace);
+                });
+                ConnectionController.resetWcConnection();
+            });
+            this.universalProvider.on('chainChanged', (chainId) => {
+                // eslint-disable-next-line eqeqeq
+                const caipNetwork = this.caipNetworks?.find(c => c.id == chainId);
+                const currentCaipNetwork = this.getCaipNetwork();
+                if (!caipNetwork) {
+                    this.setUnsupportedNetwork(chainId);
+                    return;
+                }
+                if (currentCaipNetwork?.id !== caipNetwork?.id) {
+                    this.setCaipNetwork(caipNetwork);
+                }
+            });
+            this.universalProvider.on('session_event', (callbackData) => {
+                if (WcHelpersUtil.isSessionEventData(callbackData)) {
+                    const { name, data } = callbackData.params.event;
+                    if (name === 'accountsChanged' &&
+                        Array.isArray(data) &&
+                        CoreHelperUtil.isCaipAddress(data[0])) {
+                        this.syncAccount(ParseUtil.parseCaipAddress(data[0]));
+                    }
+                }
+            });
+        }
+    }
+    createUniversalProvider() {
+        if (!this.universalProviderInitPromise &&
+            CoreHelperUtil.isClient() &&
+            this.options?.projectId) {
+            this.universalProviderInitPromise = this.initializeUniversalAdapter();
+        }
+        return this.universalProviderInitPromise;
+    }
+    async getUniversalProvider() {
+        if (!this.universalProvider) {
+            try {
+                await this.createUniversalProvider();
+            }
+            catch (error) {
+                throw new Error('AppKit:getUniversalProvider - Cannot create provider');
             }
         }
-        else if (connectorId) {
-            if (connectorId === ConstantsUtil.CONNECTOR_ID.COINBASE) {
-                const connector = this.getConnectors().find(c => c.id === ConstantsUtil.CONNECTOR_ID.COINBASE);
-                this.setConnectedWalletInfo({ name: 'Coinbase Wallet', icon: this.getConnectorImage(connector) }, chainNamespace);
+        return this.universalProvider;
+    }
+    // - Utils -------------------------------------------------------------------
+    handleAlertError(error) {
+        const matchedUniversalProviderError = Object.entries(ErrorUtil.UniversalProviderErrors).find(([, { message }]) => error.message.includes(message));
+        const [errorKey, errorValue] = matchedUniversalProviderError ?? [];
+        const { message, alertErrorKey } = errorValue ?? {};
+        if (errorKey && message && !this.reportedAlertErrors[errorKey]) {
+            const alertError = ErrorUtil.ALERT_ERRORS[alertErrorKey];
+            if (alertError) {
+                AlertController.open(alertError, 'error');
+                this.reportedAlertErrors[errorKey] = true;
             }
-            this.setConnectedWalletInfo({ name: connectorId }, chainNamespace);
         }
     }
-    async syncIdentity({ address, chainId, chainNamespace }) {
-        const activeCaipNetwork = this.caipNetworks?.find(n => n.caipNetworkId === `${chainNamespace}:${chainId}`);
-        if (chainNamespace !== ConstantsUtil.CHAIN.EVM || activeCaipNetwork?.testnet) {
+    getAdapter(namespace) {
+        if (!namespace) {
+            return undefined;
+        }
+        return this.chainAdapters?.[namespace];
+    }
+    createAdapter(blueprint) {
+        if (!blueprint) {
             return;
         }
-        try {
-            const { name, avatar } = await this.fetchIdentity({
-                address
-            });
-            this.setProfileName(name, chainNamespace);
-            this.setProfileImage(avatar, chainNamespace);
-            if (!name) {
-                await this.syncReownName(address, chainNamespace);
-                const adapter = this.getAdapter(chainNamespace);
-                const result = await adapter?.getProfile({
-                    address,
-                    chainId: Number(chainId)
-                });
-                if (result?.profileName) {
-                    this.setProfileName(result.profileName, chainNamespace);
-                    if (result.profileImage) {
-                        this.setProfileImage(result.profileImage, chainNamespace);
-                    }
-                }
-                else {
-                    await this.syncReownName(address, chainNamespace);
-                    this.setProfileImage(null, chainNamespace);
-                }
-            }
+        const namespace = blueprint.namespace;
+        if (!namespace) {
+            return;
         }
-        catch {
-            if (chainId === 1) {
-                await this.syncReownName(address, chainNamespace);
-            }
-            else {
-                await this.syncReownName(address, chainNamespace);
-                this.setProfileImage(null, chainNamespace);
-            }
+        this.createClients();
+        const adapterBlueprint = blueprint;
+        adapterBlueprint.namespace = namespace;
+        adapterBlueprint.construct({
+            namespace,
+            projectId: this.options?.projectId,
+            networks: this.caipNetworks
+        });
+        if (!this.chainNamespaces.includes(namespace)) {
+            this.chainNamespaces.push(namespace);
+        }
+        if (this.chainAdapters) {
+            this.chainAdapters[namespace] = adapterBlueprint;
         }
     }
-    async syncReownName(address, chainNamespace) {
-        try {
-            const registeredWcNames = await this.getReownName(address);
-            if (registeredWcNames[0]) {
-                const wcName = registeredWcNames[0];
-                this.setProfileName(wcName.name, chainNamespace);
-            }
-            else {
-                this.setProfileName(null, chainNamespace);
-            }
+    // -- Public -------------------------------------------------------------------
+    async open(options) {
+        await this.injectModalUi();
+        if (options?.uri && this.universalProvider) {
+            ConnectionController.setUri(options.uri);
         }
-        catch {
-            this.setProfileName(null, chainNamespace);
+        ModalController.open(options);
+    }
+    async close() {
+        await this.injectModalUi();
+        ModalController.close();
+    }
+    setLoading(loading) {
+        ModalController.setLoading(loading);
+    }
+    async disconnect() {
+        await ConnectionController.disconnect();
+    }
+    // -- review these -------------------------------------------------------------------
+    getError() {
+        return '';
+    }
+    getChainId() {
+        return ChainController.state.activeCaipNetwork?.id;
+    }
+    switchNetwork(appKitNetwork) {
+        const network = this.caipNetworks?.find(n => n.id === appKitNetwork.id);
+        if (!network) {
+            AlertController.open(ErrorUtil.ALERT_ERRORS.SWITCH_NETWORK_NOT_FOUND, 'error');
+            return;
         }
+        ChainController.switchActiveNetwork(network);
     }
-    async syncAdapterConnection(namespace) {
-        const adapter = this.getAdapter(namespace);
-        const connectorId = StorageUtil.getConnectedConnectorId(namespace);
-        const caipNetwork = this.getCaipNetwork();
-        try {
-            if (!adapter || !connectorId) {
-                throw new Error(`Adapter or connectorId not found for namespace ${namespace}`);
-            }
-            const connection = await adapter?.syncConnection({
-                namespace,
-                id: connectorId,
-                chainId: caipNetwork?.id,
-                rpcUrl: caipNetwork?.rpcUrls?.default?.http?.[0]
+    getWalletProvider() {
+        return ChainController.state.activeChain
+            ? ProviderUtil.state.providers[ChainController.state.activeChain]
+            : null;
+    }
+    getWalletProviderType() {
+        return ChainController.state.activeChain
+            ? ProviderUtil.state.providerIds[ChainController.state.activeChain]
+            : null;
+    }
+    subscribeProviders(callback) {
+        return ProviderUtil.subscribeProviders(callback);
+    }
+    getThemeMode() {
+        return ThemeController.state.themeMode;
+    }
+    getThemeVariables() {
+        return ThemeController.state.themeVariables;
+    }
+    setThemeMode(themeMode) {
+        ThemeController.setThemeMode(themeMode);
+        setColorTheme(ThemeController.state.themeMode);
+    }
+    setTermsConditionsUrl(termsConditionsUrl) {
+        OptionsController.setTermsConditionsUrl(termsConditionsUrl);
+    }
+    setPrivacyPolicyUrl(privacyPolicyUrl) {
+        OptionsController.setPrivacyPolicyUrl(privacyPolicyUrl);
+    }
+    setThemeVariables(themeVariables) {
+        ThemeController.setThemeVariables(themeVariables);
+        setThemeVariables(ThemeController.state.themeVariables);
+    }
+    subscribeTheme(callback) {
+        return ThemeController.subscribe(callback);
+    }
+    getWalletInfo() {
+        return AccountController.state.connectedWalletInfo;
+    }
+    subscribeAccount(callback) {
+        function updateVal() {
+            const authConnector = ConnectorController.getAuthConnector();
+            callback({
+                allAccounts: AccountController.state.allAccounts,
+                caipAddress: ChainController.state.activeCaipAddress,
+                address: CoreHelperUtil.getPlainAddress(ChainController.state.activeCaipAddress),
+                isConnected: Boolean(ChainController.state.activeCaipAddress),
+                status: AccountController.state.status,
+                embeddedWalletInfo: authConnector
+                    ? {
+                        user: AccountController.state.user,
+                        authProvider: AccountController.state.socialProvider || 'email',
+                        accountType: AccountController.state.preferredAccountType,
+                        isSmartAccountDeployed: Boolean(AccountController.state.smartAccountDeployed)
+                    }
+                    : undefined
             });
-            if (connection) {
-                const accounts = await adapter?.getAccounts({
-                    namespace,
-                    id: connectorId
-                });
-                if (accounts && accounts.accounts.length > 0) {
-                    this.setAllAccounts(accounts.accounts, namespace);
-                }
-                else {
-                    this.setAllAccounts([CoreHelperUtil.createAccount(namespace, connection.address, 'eoa')], namespace);
-                }
-                this.syncProvider({ ...connection, chainNamespace: namespace });
-                await this.syncAccount({ ...connection, chainNamespace: namespace });
-                this.setStatus('connected', namespace);
-            }
-            else {
-                this.setStatus('disconnected', namespace);
-            }
-        }
-        catch (e) {
-            StorageUtil.deleteConnectedConnectorId(namespace);
-            this.setStatus('disconnected', namespace);
         }
+        ChainController.subscribe(updateVal);
+        AccountController.subscribe(updateVal);
+        ConnectorController.subscribe(updateVal);
+    }
+    subscribeNetwork(callback) {
+        return ChainController.subscribe(({ activeCaipNetwork }) => {
+            callback({
+                caipNetwork: activeCaipNetwork,
+                chainId: activeCaipNetwork?.id,
+                caipNetworkId: activeCaipNetwork?.caipNetworkId
+            });
+        });
+    }
+    subscribeWalletInfo(callback) {
+        return AccountController.subscribeKey('connectedWalletInfo', callback);
+    }
+    subscribeShouldUpdateToAddress(callback) {
+        AccountController.subscribeKey('shouldUpdateToAddress', callback);
+    }
+    subscribeCaipNetworkChange(callback) {
+        ChainController.subscribeKey('activeCaipNetwork', callback);
+    }
+    getState() {
+        return PublicStateController.state;
+    }
+    subscribeState(callback) {
+        return PublicStateController.subscribe(callback);
+    }
+    showErrorMessage(message) {
+        SnackController.showError(message);
+    }
+    showSuccessMessage(message) {
+        SnackController.showSuccess(message);
     }
-    async syncNamespaceConnection(namespace) {
-        try {
-            const connectorId = StorageUtil.getConnectedConnectorId(namespace);
-            const isEmailUsed = this.authProvider?.getLoginEmailUsed();
-            if (isEmailUsed) {
-                return;
-            }
-            this.setStatus('connecting', namespace);
-            switch (connectorId) {
-                case ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT:
-                    await this.syncWalletConnectAccount();
-                    break;
-                case ConstantsUtil.CONNECTOR_ID.AUTH:
-                    // Handled during initialization of adapters' auth provider
-                    break;
-                default:
-                    await this.syncAdapterConnection(namespace);
-            }
-        }
-        catch (err) {
-            console.warn("AppKit couldn't sync existing connection", err);
-            StorageUtil.deleteConnectedConnectorId(namespace);
-            this.setStatus('disconnected', namespace);
-        }
+    getEvent() {
+        return { ...EventsController.state };
     }
-    async syncExistingConnection() {
-        await Promise.allSettled(this.chainNamespaces.map(namespace => this.syncNamespaceConnection(namespace)));
+    subscribeEvents(callback) {
+        return EventsController.subscribe(callback);
     }
-    getAdapter(namespace) {
-        if (!namespace) {
-            return undefined;
-        }
-        return this.chainAdapters?.[namespace];
+    replace(route) {
+        RouterController.replace(route);
     }
-    createUniversalProvider() {
-        if (!this.universalProviderInitPromise &&
-            CoreHelperUtil.isClient() &&
-            this.options?.projectId) {
-            this.universalProviderInitPromise = this.initializeUniversalAdapter();
-        }
-        return this.universalProviderInitPromise;
+    redirect(route) {
+        RouterController.push(route);
     }
-    handleAlertError(error) {
-        const matchedUniversalProviderError = Object.entries(ErrorUtil.UniversalProviderErrors).find(([, { message }]) => error.message.includes(message));
-        const [errorKey, errorValue] = matchedUniversalProviderError ?? [];
-        const { message, alertErrorKey } = errorValue ?? {};
-        if (errorKey && message && !this.reportedAlertErrors[errorKey]) {
-            const alertError = ErrorUtil.ALERT_ERRORS[alertErrorKey];
-            if (alertError) {
-                AlertController.open(alertError, 'error');
-                this.reportedAlertErrors[errorKey] = true;
-            }
-        }
+    popTransactionStack(cancel) {
+        RouterController.popTransactionStack(cancel);
     }
-    async initializeUniversalAdapter() {
-        const logger = LoggerUtil.createLogger((error, ...args) => {
-            if (error) {
-                this.handleAlertError(error);
-            }
-            // eslint-disable-next-line no-console
-            console.error(...args);
-        });
-        const universalProviderOptions = {
-            projectId: this.options?.projectId,
-            metadata: {
-                name: this.options?.metadata ? this.options?.metadata.name : '',
-                description: this.options?.metadata ? this.options?.metadata.description : '',
-                url: this.options?.metadata ? this.options?.metadata.url : '',
-                icons: this.options?.metadata ? this.options?.metadata.icons : ['']
-            },
-            logger
-        };
-        OptionsController.setUsingInjectedUniversalProvider(Boolean(this.options?.universalProvider));
-        this.universalProvider =
-            this.options.universalProvider ?? (await UniversalProvider.init(universalProviderOptions));
-        this.listenWalletConnect();
+    isOpen() {
+        return ModalController.state.open;
     }
-    async getUniversalProvider() {
-        if (!this.universalProvider) {
-            try {
-                await this.createUniversalProvider();
-            }
-            catch (error) {
-                throw new Error('AppKit:getUniversalProvider - Cannot create provider');
-            }
-        }
-        return this.universalProvider;
+    isTransactionStackEmpty() {
+        return RouterController.state.transactionStack.length === 0;
     }
-    createAuthProvider() {
-        const isEmailEnabled = this.options?.features?.email === undefined
-            ? CoreConstantsUtil.DEFAULT_FEATURES.email
-            : this.options?.features?.email;
-        const isSocialsEnabled = this.options?.features?.socials
-            ? this.options?.features?.socials?.length > 0
-            : CoreConstantsUtil.DEFAULT_FEATURES.socials;
-        const isAuthEnabled = isEmailEnabled || isSocialsEnabled;
-        if (!this.authProvider && this.options?.projectId && isAuthEnabled) {
-            this.authProvider = W3mFrameProviderSingleton.getInstance({
-                projectId: this.options.projectId,
-                enableLogger: this.options.enableAuthLogger,
-                chainId: this.getCaipNetwork()?.caipNetworkId,
-                onTimeout: () => {
-                    AlertController.open(ErrorUtil.ALERT_ERRORS.SOCIALS_TIMEOUT, 'error');
-                }
-            });
-            this.subscribeState(val => {
-                if (!val.open) {
-                    this.authProvider?.rejectRpcRequests();
-                }
-            });
-            this.syncAuthConnector(this.authProvider);
-        }
+    isTransactionShouldReplaceView() {
+        return RouterController.state.transactionStack[RouterController.state.transactionStack.length - 1]?.replace;
     }
-    async createUniversalProviderForAdapter(chainNamespace) {
-        await this.getUniversalProvider();
-        if (this.universalProvider) {
-            this.chainAdapters?.[chainNamespace]?.setUniversalProvider?.(this.universalProvider);
-        }
+    static getInstance() {
+        return this.instance;
     }
-    createAuthProviderForAdapter(chainNamespace) {
-        this.createAuthProvider();
-        if (this.authProvider) {
-            this.chainAdapters?.[chainNamespace]?.setAuthProvider?.(this.authProvider);
-        }
+    updateFeatures(newFeatures) {
+        OptionsController.setFeatures(newFeatures);
     }
-    createAdapter(blueprint) {
-        if (!blueprint) {
-            return;
-        }
-        const namespace = blueprint.namespace;
-        if (!namespace) {
-            return;
-        }
-        this.createClients();
-        const adapterBlueprint = blueprint;
-        adapterBlueprint.namespace = namespace;
-        adapterBlueprint.construct({
-            namespace,
-            projectId: this.options?.projectId,
-            networks: this.caipNetworks
-        });
-        if (!this.chainNamespaces.includes(namespace)) {
-            this.chainNamespaces.push(namespace);
-        }
-        if (this.chainAdapters) {
-            this.chainAdapters[namespace] = adapterBlueprint;
-        }
+    updateOptions(newOptions) {
+        const currentOptions = OptionsController.state || {};
+        const updatedOptions = { ...currentOptions, ...newOptions };
+        OptionsController.setOptions(updatedOptions);
     }
-    createAdapters(blueprints) {
-        this.createClients();
-        return this.chainNamespaces.reduce((adapters, namespace) => {
-            const blueprint = blueprints?.find(b => b.namespace === namespace);
-            if (blueprint) {
-                adapters[namespace] = blueprint;
-                adapters[namespace].namespace = namespace;
-                adapters[namespace].construct({
-                    namespace,
-                    projectId: this.options?.projectId,
-                    networks: this.caipNetworks
-                });
-            }
-            else {
-                adapters[namespace] = new UniversalAdapter({
-                    namespace,
-                    networks: this.caipNetworks
-                });
-            }
-            return adapters;
-            // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
-        }, {});
+    setConnectMethodsOrder(connectMethodsOrder) {
+        OptionsController.setConnectMethodsOrder(connectMethodsOrder);
     }
-    onConnectors(chainNamespace) {
-        const adapter = this.getAdapter(chainNamespace);
-        adapter?.on('connectors', this.setConnectors.bind(this));
+    setWalletFeaturesOrder(walletFeaturesOrder) {
+        OptionsController.setWalletFeaturesOrder(walletFeaturesOrder);
     }
-    async initChainAdapter(namespace) {
-        this.onConnectors(namespace);
-        this.listenAdapter(namespace);
-        this.chainAdapters?.[namespace].syncConnectors(this.options, this);
-        await this.createUniversalProviderForAdapter(namespace);
-        this.createAuthProviderForAdapter(namespace);
+    setCollapseWallets(collapseWallets) {
+        OptionsController.setCollapseWallets(collapseWallets);
     }
-    async initChainAdapters() {
-        await Promise.all(this.chainNamespaces.map(async (namespace) => {
-            await this.initChainAdapter(namespace);
-        }));
+    setSocialsOrder(socialsOrder) {
+        OptionsController.setSocialsOrder(socialsOrder);
     }
-    getUnsupportedNetwork(caipNetworkId) {
-        return {
-            id: caipNetworkId.split(':')[1],
-            caipNetworkId,
-            name: ConstantsUtil.UNSUPPORTED_NETWORK_NAME,
-            chainNamespace: caipNetworkId.split(':')[0],
-            nativeCurrency: {
-                name: '',
-                decimals: 0,
-                symbol: ''
-            },
-            rpcUrls: {
-                default: {
-                    http: []
-                }
-            }
-        };
+    getConnectMethodsOrder() {
+        return WalletUtil.getConnectOrderMethod(OptionsController.state.features, ConnectorController.getConnectors());
     }
-    getDefaultNetwork() {
-        const caipNetworkId = StorageUtil.getActiveCaipNetworkId();
-        if (caipNetworkId) {
-            const caipNetwork = this.caipNetworks?.find(n => n.caipNetworkId === caipNetworkId);
-            if (caipNetwork) {
-                return caipNetwork;
-            }
-            return this.getUnsupportedNetwork(caipNetworkId);
+    /**
+     * Removes an adapter from the AppKit.
+     * @param namespace - The namespace of the adapter to remove.
+     */
+    removeAdapter(namespace) {
+        const isConnected = this.getIsConnectedState();
+        const adapter = this.getAdapter(namespace);
+        if (!adapter || !this.chainAdapters || isConnected) {
+            return;
         }
-        return this.caipNetworks?.[0];
+        const newCaipNetworks = this.caipNetworks?.filter(network => network.chainNamespace !== namespace);
+        ChainController.removeAdapter(namespace);
+        ConnectorController.removeAdapter(namespace);
+        this.chainNamespaces = this.chainNamespaces.filter(n => n !== namespace);
+        this.caipNetworks = newCaipNetworks;
+        adapter.removeAllEventListeners();
+        Reflect.deleteProperty(this.chainAdapters, namespace);
     }
-    async injectModalUi() {
-        if (!this.initPromise && !isInitialized && CoreHelperUtil.isClient()) {
-            isInitialized = true;
-            this.initPromise = new Promise(async (resolve) => {
-                const { features, basic } = OptionsController.state;
-                if (basic) {
-                    // Import only basic views
-                    await import('@reown/appkit-scaffold-ui/basic');
-                }
-                else {
-                    // Import all views
-                    await import('@reown/appkit-scaffold-ui');
-                }
-                // Selectively import views based on feature flags
-                if (features) {
-                    const usingEmbeddedWallet = features.email || (features.socials && features.socials.length);
-                    if (usingEmbeddedWallet) {
-                        await import('@reown/appkit-scaffold-ui/embedded-wallet');
-                    }
-                    if (features.email) {
-                        await import('@reown/appkit-scaffold-ui/email');
-                    }
-                    if (features.socials) {
-                        await import('@reown/appkit-scaffold-ui/socials');
-                    }
-                    if (features.swaps) {
-                        await import('@reown/appkit-scaffold-ui/swaps');
-                    }
-                    if (features.send) {
-                        await import('@reown/appkit-scaffold-ui/send');
-                    }
-                    if (features.receive) {
-                        await import('@reown/appkit-scaffold-ui/receive');
-                    }
-                    if (features.onramp) {
-                        await import('@reown/appkit-scaffold-ui/onramp');
-                    }
-                    if (features.history) {
-                        await import('@reown/appkit-scaffold-ui/transactions');
-                    }
-                }
-                // Import core modal
-                await import('@reown/appkit-scaffold-ui/w3m-modal');
-                const modal = document.createElement('w3m-modal');
-                if (!OptionsController.state.disableAppend && !OptionsController.state.enableEmbedded) {
-                    document.body.insertAdjacentElement('beforeend', modal);
-                }
-                resolve();
-            });
+    /**
+     * Adds an adapter to the AppKit.
+     * @param adapter - The adapter instance.
+     * @param networks - The list of networks that this adapter supports / uses.
+     */
+    addAdapter(adapter, networks) {
+        const namespace = adapter.namespace;
+        if (!this.connectionControllerClient || !this.networkControllerClient) {
+            return;
+        }
+        if (!this.chainAdapters || !namespace) {
+            return;
         }
-        return this.initPromise;
+        const extendedAdapterNetworks = this.extendCaipNetworks({ ...this.options, networks });
+        this.caipNetworks = [...(this.caipNetworks || []), ...extendedAdapterNetworks];
+        this.createAdapter(adapter);
+        this.initChainAdapter(namespace);
+        ChainController.addAdapter(adapter, {
+            connectionControllerClient: this.connectionControllerClient,
+            networkControllerClient: this.networkControllerClient
+        }, extendedAdapterNetworks);
     }
 }
-//# sourceMappingURL=client.js.map
+//# sourceMappingURL=core.js.map