@reown/appkit 1.6.2 → 1.6.3-rc.0

package/dist/esm/exports/constants.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '1.6.2';
+export const PACKAGE_VERSION = '1.6.3-rc.0';
 //# sourceMappingURL=constants.js.map

package/dist/esm/exports/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../exports/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAA"}
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../exports/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,eAAe,GAAG,YAAY,CAAA"}

package/dist/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@reown/appkit",
-    "version": "1.6.2",
+    "version": "1.6.3-rc.0",
     "type": "module",
     "main": "./dist/esm/exports/index.js",
     "types": "./dist/types/exports/index.d.ts",

package/dist/esm/src/auth-provider/W3MFrameProviderSingleton.js

@@ -2,9 +2,14 @@ import { W3mFrameProvider } from '@reown/appkit-wallet';
 export class W3mFrameProviderSingleton {
     // eslint-disable-next-line @typescript-eslint/no-empty-function -- This is a singleton
     constructor() { }
-    static getInstance({ projectId, chainId, onTimeout }) {
+    static getInstance({ projectId, chainId, enableLogger, onTimeout }) {
         if (!W3mFrameProviderSingleton.instance) {
-            W3mFrameProviderSingleton.instance = new W3mFrameProvider({ projectId, chainId, onTimeout });
+            W3mFrameProviderSingleton.instance = new W3mFrameProvider({
+                projectId,
+                chainId,
+                enableLogger,
+                onTimeout
+            });
         }
         return W3mFrameProviderSingleton.instance;
     }

package/dist/esm/src/auth-provider/W3MFrameProviderSingleton.js.map

@@ -1 +1 @@
-{"version":3,"file":"W3MFrameProviderSingleton.js","sourceRoot":"","sources":["../../../../src/auth-provider/W3MFrameProviderSingleton.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAQvD,MAAM,OAAO,yBAAyB;IAGpC,uFAAuF;IACvF,gBAAuB,CAAC;IAEjB,MAAM,CAAC,WAAW,CAAC,EACxB,SAAS,EACT,OAAO,EACP,SAAS,EACc;QACvB,IAAI,CAAC,yBAAyB,CAAC,QAAQ,EAAE,CAAC;YACxC,yBAAyB,CAAC,QAAQ,GAAG,IAAI,gBAAgB,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAA;QAC9F,CAAC;QAED,OAAO,yBAAyB,CAAC,QAAQ,CAAA;IAC3C,CAAC;CACF"}
+{"version":3,"file":"W3MFrameProviderSingleton.js","sourceRoot":"","sources":["../../../../src/auth-provider/W3MFrameProviderSingleton.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AASvD,MAAM,OAAO,yBAAyB;IAGpC,uFAAuF;IACvF,gBAAuB,CAAC;IAEjB,MAAM,CAAC,WAAW,CAAC,EACxB,SAAS,EACT,OAAO,EACP,YAAY,EACZ,SAAS,EACc;QACvB,IAAI,CAAC,yBAAyB,CAAC,QAAQ,EAAE,CAAC;YACxC,yBAAyB,CAAC,QAAQ,GAAG,IAAI,gBAAgB,CAAC;gBACxD,SAAS;gBACT,OAAO;gBACP,YAAY;gBACZ,SAAS;aACV,CAAC,CAAA;QACJ,CAAC;QAED,OAAO,yBAAyB,CAAC,QAAQ,CAAA;IAC3C,CAAC;CACF"}

package/dist/esm/src/client.js

@@ -4,7 +4,7 @@ import { AccountController, BlockchainApiController, ConnectionController, Conne
 import { setColorTheme, setThemeVariables } from '@reown/appkit-ui';
 import { NetworkUtil, ConstantsUtil, ParseUtil } from '@reown/appkit-common';
 import { UniversalAdapter, UniversalAdapter as UniversalAdapterClient } from './universal-adapter/client.js';
-import { CaipNetworksUtil, ErrorUtil, LoggerUtil, ConstantsUtil as UtilConstantsUtil } from '@reown/appkit-utils';
+import { CaipNetworksUtil, ErrorUtil, HelpersUtil, LoggerUtil, ConstantsUtil as UtilConstantsUtil } from '@reown/appkit-utils';
 import { W3mFrameHelpers, W3mFrameRpcConstants } from '@reown/appkit-wallet';
 import { ProviderUtil } from './store/ProviderUtil.js';
 import UniversalProvider from '@walletconnect/universal-provider';
@@ -114,7 +114,7 @@ export class AppKit {
             if (chainNamespace) {
                 return ChainController.getRequestedCaipNetworks(chainNamespace).filter(c => c.chainNamespace === chainNamespace)?.[0];
             }
-            return ChainController.state.activeCaipNetwork;
+            return ChainController.state.activeCaipNetwork || this.defaultCaipNetwork;
         };
         this.getCaipNetworkId = () => {
             const network = this.getCaipNetwork();
@@ -371,7 +371,7 @@ export class AppKit {
         OptionsController.setSocialsOrder(socialsOrder);
     }
     async disconnect() {
-        await ChainController.disconnect();
+        await ConnectionController.disconnect();
     }
     getConnectMethodsOrder() {
         return WalletUtil.getConnectOrderMethod(OptionsController.state.features, ConnectorController.getConnectors());
@@ -410,6 +410,7 @@ export class AppKit {
         OptionsController.setEnableWalletGuide(options.enableWalletGuide !== false);
         OptionsController.setEnableWallets(options.enableWallets !== false);
         OptionsController.setEIP6963Enabled(options.enableEIP6963 !== false);
+        OptionsController.setEnableAuthLogger(options.enableAuthLogger !== false);
         if (options.metadata) {
             OptionsController.setMetadata(options.metadata);
         }
@@ -505,6 +506,7 @@ export class AppKit {
                 }
                 else {
                     await adapter?.connectWalletConnect(onUri, this.getCaipNetwork()?.id);
+                    StorageUtil.setConnectedNamespaces([...ChainController.state.chains.keys()]);
                 }
                 await this.syncWalletConnectAccount();
             },
@@ -530,6 +532,7 @@ export class AppKit {
                     rpcUrl: caipNetwork?.rpcUrls?.default?.http?.[0] ||
                         this.getCaipNetwork()?.rpcUrls?.default?.http?.[0]
                 });
+                StorageUtil.addConnectedNamespace(chainToUse);
                 if (res) {
                     this.syncProvider({
                         ...res,
@@ -549,18 +552,22 @@ export class AppKit {
                 }
             },
             reconnectExternal: async ({ id, info, type, provider }) => {
-                const adapter = this.getAdapter(ChainController.state.activeChain);
+                const namespace = ChainController.state.activeChain;
+                const adapter = this.getAdapter(namespace);
                 if (adapter?.reconnect) {
                     await adapter?.reconnect({ id, info, type, provider, chainId: this.getCaipNetwork()?.id });
+                    StorageUtil.addConnectedNamespace(namespace);
                 }
             },
             disconnect: async () => {
-                const adapter = this.getAdapter(ChainController.state.activeChain);
-                const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
-                const providerType = ProviderUtil.state.providerIds[ChainController.state.activeChain];
+                const namespace = ChainController.state.activeChain;
+                const adapter = this.getAdapter(namespace);
+                const provider = ProviderUtil.getProvider(namespace);
+                const providerType = ProviderUtil.state.providerIds[namespace];
                 await adapter?.disconnect({ provider, providerType });
-                ProviderUtil.resetChain(ChainController.state.activeChain);
-                this.setStatus('disconnected', ChainController.state.activeChain);
+                StorageUtil.removeConnectedNamespace(namespace);
+                ProviderUtil.resetChain(namespace);
+                this.setStatus('disconnected', namespace);
             },
             checkInstalled: (ids) => {
                 if (!ids) {
@@ -578,7 +585,7 @@ export class AppKit {
                 return result?.signature || '';
             },
             sendTransaction: async (args) => {
-                if (args.chainNamespace === 'eip155') {
+                if (args.chainNamespace === ConstantsUtil.CHAIN.EVM) {
                     const adapter = this.getAdapter(ChainController.state.activeChain);
                     const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
                     const result = await adapter?.sendTransaction({ ...args, provider });
@@ -587,7 +594,7 @@ export class AppKit {
                 return '';
             },
             estimateGas: async (args) => {
-                if (args.chainNamespace === 'eip155') {
+                if (args.chainNamespace === ConstantsUtil.CHAIN.EVM) {
                     const adapter = this.getAdapter(ChainController.state.activeChain);
                     const provider = ProviderUtil.getProvider(ChainController.state.activeChain);
                     const caipNetwork = this.getCaipNetwork();
@@ -797,15 +804,17 @@ export class AppKit {
             }
         });
         provider.onNotConnected(() => {
-            const connectorId = StorageUtil.getConnectedConnectorId();
+            const namespace = ChainController.state.activeChain;
+            const connectorId = StorageUtil.getConnectedConnectorId(namespace);
             const isConnectedWithAuth = connectorId === ConstantsUtil.CONNECTOR_ID.AUTH;
             if (!isConnected && isConnectedWithAuth) {
-                this.setCaipAddress(undefined, ChainController.state.activeChain);
+                this.setCaipAddress(undefined, namespace);
                 this.setLoading(false);
             }
         });
         provider.onIsConnected(() => {
             provider.connect();
+            StorageUtil.addConnectedNamespace(ChainController.state.activeChain);
         });
         provider.onConnect(async (user) => {
             const namespace = ChainController.state.activeChain;
@@ -816,14 +825,21 @@ export class AppKit {
                 chainNamespace: namespace
             });
             // To keep backwards compatibility, eip155 chainIds are numbers and not actual caipChainIds
-            const caipAddress = namespace === 'eip155'
+            const caipAddress = namespace === ConstantsUtil.CHAIN.EVM
                 ? `eip155:${user.chainId}:${user.address}`
                 : `${user.chainId}:${user.address}`;
-            this.setCaipAddress(caipAddress, namespace);
             this.setSmartAccountDeployed(Boolean(user.smartAccountDeployed), namespace);
+            if (!HelpersUtil.isLowerCaseMatch(user.address, AccountController.state.address)) {
+                this.syncIdentity({
+                    address: user.address,
+                    chainId: user.chainId,
+                    chainNamespace: namespace
+                });
+            }
+            this.setCaipAddress(caipAddress, namespace);
             const preferredAccountType = (user.preferredAccountType || 'eoa');
             this.setPreferredAccountType(preferredAccountType, namespace);
-            const userAccounts = user.accounts?.map(account => CoreHelperUtil.createAccount(namespace, account.address, namespace === 'eip155' ? account.type : 'eoa'));
+            const userAccounts = user.accounts?.map(account => CoreHelperUtil.createAccount(namespace, account.address, namespace === ConstantsUtil.CHAIN.EVM ? account.type : 'eoa'));
             this.setAllAccounts(userAccounts || [
                 CoreHelperUtil.createAccount(namespace, user.address, preferredAccountType)
             ], namespace);
@@ -839,6 +855,7 @@ export class AppKit {
             }
             this.setPreferredAccountType(type, ChainController.state.activeChain);
         });
+        const namespace = ChainController.state.activeChain;
         if (isConnected && this.connectionControllerClient?.connectExternal) {
             await this.connectionControllerClient?.connectExternal({
                 id: ConstantsUtil.CONNECTOR_ID.AUTH,
@@ -848,11 +865,12 @@ export class AppKit {
                 chainId: ChainController.state.activeCaipNetwork?.id
             });
             this.setLoading(false);
-            this.setStatus('connected', ChainController.state.activeChain);
+            this.setStatus('connected', namespace);
         }
         else {
             this.setLoading(false);
-            this.setStatus('disconnected', ChainController.state.activeChain);
+            this.setStatus('disconnected', namespace);
+            StorageUtil.removeConnectedNamespace(namespace);
         }
     }
     listenWalletConnect() {
@@ -975,7 +993,7 @@ export class AppKit {
                 ProviderUtil.setProviderId(chainNamespace, UtilConstantsUtil.CONNECTOR_TYPE_WALLET_CONNECT);
                 if (this.caipNetworks &&
                     ChainController.state.activeCaipNetwork &&
-                    adapter?.namespace !== 'eip155') {
+                    adapter?.namespace !== ConstantsUtil.CHAIN.EVM) {
                     const provider = adapter?.getWalletConnectProvider({
                         caipNetworks: this.caipNetworks,
                         provider: this.universalProvider,
@@ -986,7 +1004,8 @@ export class AppKit {
                 else {
                     ProviderUtil.setProvider(chainNamespace, this.universalProvider);
                 }
-                StorageUtil.setConnectedConnectorId(ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT);
+                StorageUtil.setConnectedConnectorId(chainNamespace, ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT);
+                StorageUtil.addConnectedNamespace(chainNamespace);
                 let address = '';
                 if (caipAddress.split(':').length === 3) {
                     address = caipAddress.split(':')[2];
@@ -1041,13 +1060,14 @@ export class AppKit {
     syncProvider({ type, provider, id, chainNamespace }) {
         ProviderUtil.setProviderId(chainNamespace, type);
         ProviderUtil.setProvider(chainNamespace, provider);
-        StorageUtil.setConnectedConnectorId(id);
+        StorageUtil.setConnectedConnectorId(chainNamespace, id);
     }
-    async syncAccount({ address, chainId, chainNamespace }) {
+    async syncAccount(params) {
+        const { address, chainId, chainNamespace } = params;
         const { namespace: activeNamespace, chainId: activeChainId } = StorageUtil.getActiveNetworkProps();
         const chainIdToUse = chainId || activeChainId;
         // Only update state when needed
-        if (address?.toLowerCase() !== AccountController.state.address?.toLowerCase()) {
+        if (!HelpersUtil.isLowerCaseMatch(address, AccountController.state.address)) {
             this.setCaipAddress(`${chainNamespace}:${chainId}:${address}`, chainNamespace);
             await this.syncIdentity({ address, chainId, chainNamespace });
         }
@@ -1066,6 +1086,10 @@ export class AppKit {
         if (!caipNetwork) {
             return;
         }
+        if (caipNetwork.testnet) {
+            this.setBalance('0.00', caipNetwork.nativeCurrency.symbol, caipNetwork.chainNamespace);
+            return;
+        }
         const balance = await adapter?.getBalance({
             address: params.address,
             chainId: params.chainId,
@@ -1077,14 +1101,16 @@ export class AppKit {
         }
     }
     syncConnectedWalletInfo(chainNamespace) {
-        const connectorId = StorageUtil.getConnectedConnectorId();
+        const connectorId = StorageUtil.getConnectedConnectorId(chainNamespace);
         const providerType = ProviderUtil.state.providerIds[chainNamespace];
         if (providerType === UtilConstantsUtil.CONNECTOR_TYPE_ANNOUNCED ||
             providerType === UtilConstantsUtil.CONNECTOR_TYPE_INJECTED) {
             if (connectorId) {
                 const connector = this.getConnectors().find(c => c.id === connectorId);
-                if (connector?.info) {
-                    this.setConnectedWalletInfo({ ...connector.info }, chainNamespace);
+                if (connector) {
+                    const { info, name, imageUrl } = connector;
+                    const icon = imageUrl || this.getConnectorImage(connector);
+                    this.setConnectedWalletInfo({ name, icon, ...info }, chainNamespace);
                 }
             }
         }
@@ -1107,7 +1133,8 @@ export class AppKit {
         }
     }
     async syncIdentity({ address, chainId, chainNamespace }) {
-        if (chainNamespace !== 'eip155') {
+        const activeCaipNetwork = this.caipNetworks?.find(n => n.caipNetworkId === `${chainNamespace}:${chainId}`);
+        if (chainNamespace !== ConstantsUtil.CHAIN.EVM || activeCaipNetwork?.testnet) {
             return;
         }
         try {
@@ -1168,56 +1195,78 @@ export class AppKit {
         uniqueChainNamespaces.forEach(chainNamespace => this.setRequestedCaipNetworks(this.caipNetworks?.filter(caipNetwork => caipNetwork.chainNamespace === chainNamespace) ??
             [], chainNamespace));
     }
-    async syncExistingConnection() {
+    async syncAdapterConnection(namespace) {
+        const adapter = this.getAdapter(namespace);
+        const connectorId = StorageUtil.getConnectedConnectorId(namespace);
+        const caipNetwork = this.getCaipNetwork();
         try {
-            const connectorId = StorageUtil.getConnectedConnectorId();
-            const activeNamespace = StorageUtil.getActiveNamespace();
-            if (connectorId === ConstantsUtil.CONNECTOR_ID.WALLET_CONNECT && activeNamespace) {
-                this.syncWalletConnectAccount();
+            if (!adapter || !connectorId) {
+                throw new Error(`Adapter or connectorId not found for namespace ${namespace}`);
             }
-            else if (connectorId &&
-                connectorId !== ConstantsUtil.CONNECTOR_ID.AUTH &&
-                activeNamespace) {
-                this.setStatus('connecting', activeNamespace);
-                const adapter = this.getAdapter(activeNamespace);
-                const res = await adapter?.syncConnection({
-                    id: connectorId,
-                    chainId: this.getCaipNetwork()?.id,
-                    namespace: activeNamespace,
-                    rpcUrl: this.getCaipNetwork()?.rpcUrls?.default?.http?.[0]
+            const connection = await adapter?.syncConnection({
+                namespace,
+                id: connectorId,
+                chainId: caipNetwork?.id,
+                rpcUrl: caipNetwork?.rpcUrls?.default?.http?.[0]
+            });
+            if (connection) {
+                const accounts = await adapter?.getAccounts({
+                    namespace,
+                    id: connectorId
                 });
-                if (res) {
-                    const accounts = await adapter?.getAccounts({
-                        namespace: activeNamespace,
-                        id: connectorId
-                    });
-                    if (!accounts || accounts.accounts.length === 0) {
-                        throw new Error('No accounts found');
-                    }
-                    this.syncProvider({ ...res, chainNamespace: activeNamespace });
-                    await this.syncAccount({ ...res, chainNamespace: activeNamespace });
-                    this.setAllAccounts(accounts.accounts, activeNamespace);
-                    this.setStatus('connected', activeNamespace);
+                if (accounts && accounts.accounts.length > 0) {
+                    this.setAllAccounts(accounts.accounts, namespace);
                 }
                 else {
-                    this.setStatus('disconnected', activeNamespace);
-                }
-                if (!this.caipNetworks?.some(network => network.id === res?.chainId)) {
-                    if (res?.chainId) {
-                        this.setUnsupportedNetwork(res.chainId);
-                    }
+                    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 if (connectorId !== ConstantsUtil.CONNECTOR_ID.AUTH) {
-                this.setStatus('disconnected', ChainController.state.activeChain);
+            else {
+                this.setStatus('disconnected', namespace);
+            }
+        }
+        catch (e) {
+            console.warn(`Error syncing connection for namespace ${namespace}`, e);
+            StorageUtil.deleteConnectedConnectorId(namespace);
+            this.setStatus('disconnected', namespace);
+        }
+    }
+    async syncNamespaceConnection(namespace) {
+        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);
+        }
+    }
+    async syncExistingConnection() {
+        const connectedNamespaces = StorageUtil.getConnectedNamespaces();
+        try {
+            if (connectedNamespaces?.length > 0) {
+                await Promise.all(connectedNamespaces.map(namespace => this.syncNamespaceConnection(namespace)));
             }
         }
         catch (err) {
             // eslint-disable-next-line no-console
-            console.log("AppKit:syncExistingConnection - couldn't sync existing connection", err);
+            console.warn("AppKit couldn't sync existing connection", err);
             this.disconnect().finally(() => {
-                StorageUtil.deleteConnectedConnectorId();
-                this.setStatus('disconnected', ChainController.state.activeChain);
+                connectedNamespaces.forEach(namespace => {
+                    StorageUtil.deleteConnectedConnectorId(namespace);
+                    this.setStatus('disconnected', namespace);
+                });
             });
         }
     }
@@ -1285,9 +1334,11 @@ export class AppKit {
         const isSocialsEnabled = this.options?.features?.socials
             ? this.options?.features?.socials?.length > 0
             : CoreConstantsUtil.DEFAULT_FEATURES.socials;
-        if (!this.authProvider && this.options?.projectId && (isEmailEnabled || isSocialsEnabled)) {
+        const isAuthEnabled = isEmailEnabled || isSocialsEnabled;
+        if (!this.authProvider && this.options?.projectId && isAuthEnabled) {
             this.authProvider = W3mFrameProviderSingleton.getInstance({
                 projectId: this.options.projectId,
+                enableLogger: this.options.enableAuthLogger,
                 onTimeout: () => {
                     AlertController.open(ErrorUtil.ALERT_ERRORS.SOCIALS_TIMEOUT, 'error');
                 }