@web3auth/no-modal 11.0.0-beta.2 → 11.0.1

package/dist/lib.esm/account-linking/errors.js

@@ -0,0 +1,92 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { Web3AuthError } from '../base/errors/index.js';
+
+class AccountLinkingError extends Web3AuthError {
+  constructor(code, message, cause) {
+    super(code, message, cause);
+    Object.defineProperty(this, "name", {
+      value: "AccountLinkingError",
+      configurable: true
+    });
+  }
+  static fromCode(code, extraMessage = "", cause) {
+    return new AccountLinkingError(code, `${AccountLinkingError.messages[code]}. ${extraMessage}`, cause);
+  }
+  static requestFailed(extraMessage = "", cause) {
+    return AccountLinkingError.fromCode(5401, extraMessage, cause);
+  }
+  static serverNotConfigured(extraMessage = "", cause) {
+    return AccountLinkingError.fromCode(5402, extraMessage, cause);
+  }
+  static primaryTokenNotAvailable(extraMessage = "", cause) {
+    return AccountLinkingError.fromCode(5403, extraMessage, cause);
+  }
+  static walletProofFailed(extraMessage = "", cause) {
+    return AccountLinkingError.fromCode(5404, extraMessage, cause);
+  }
+  static unsupportedConnector(extraMessage = "", cause) {
+    return AccountLinkingError.fromCode(5405, extraMessage, cause);
+  }
+  static cannotUnlinkActiveAccount() {
+    return AccountLinkingError.fromCode(5406);
+  }
+  static accountNotLinked(message = "", cause) {
+    return AccountLinkingError.fromCode(5407, message, cause);
+  }
+  static cannotUnlinkPrimaryAccount() {
+    return AccountLinkingError.fromCode(5408);
+  }
+  toString() {
+    return `[${this.code}] ${this.message}`;
+  }
+}
+_defineProperty(AccountLinkingError, "messages", {
+  5000: "Custom",
+  5401: "Account linking request failed",
+  5402: "Citadel server URL is not configured",
+  5403: "Primary identity token is not available",
+  5404: "Failed to obtain wallet proof token",
+  5405: "Connector is not supported for wallet linking",
+  5406: "Cannot unlink active account",
+  5407: "Account not linked",
+  5408: "Cannot unlink primary account"
+});
+async function getAccountLinkingRequestError(error) {
+  if (error instanceof AccountLinkingError) {
+    return error;
+  }
+  if (error instanceof Response) {
+    if (error.status === 409) {
+      return AccountLinkingError.requestFailed("This wallet address is already registered on this dApp");
+    }
+    if (error.json && typeof error.json === "function") {
+      try {
+        var _json$message;
+        const json = await error.json();
+        return AccountLinkingError.requestFailed((_json$message = json.message) !== null && _json$message !== void 0 ? _json$message : "Failed to link account");
+      } catch {
+        // continue
+      }
+    }
+  }
+  return AccountLinkingError.requestFailed(error instanceof Error ? error.message : JSON.stringify(error), error);
+}
+function formatAccountLinkingErrorMessage(error, fallbackMessage = "Unknown error during the operation.") {
+  if (error instanceof AccountLinkingError) {
+    return error.toString();
+  }
+  if (error instanceof Web3AuthError) {
+    return `[${error.code}] Account linking error: ${error.message || fallbackMessage}`;
+  }
+  if (error instanceof Error) {
+    return `Account linking error: ${error.message || fallbackMessage}`;
+  }
+  try {
+    const stringifiedError = JSON.stringify(error);
+    return stringifiedError;
+  } catch {
+    return fallbackMessage;
+  }
+}
+
+export { AccountLinkingError, formatAccountLinkingErrorMessage, getAccountLinkingRequestError };

package/dist/lib.esm/account-linking/index.js

@@ -1 +1,2 @@
+export { AccountLinkingError, formatAccountLinkingErrorMessage, getAccountLinkingRequestError } from './errors.js';
 export { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from './rest.js';

package/dist/lib.esm/account-linking/rest.js

@@ -1,5 +1,5 @@
 import { post } from '@toruslabs/http-helpers';
-import { AccountLinkingError } from '../base/errors/index.js';
+import { getAccountLinkingRequestError, AccountLinkingError } from './errors.js';
 
 /**
  * Send both identity proofs to the Citadel account-linking endpoint and
@@ -17,8 +17,8 @@ async function makeAccountLinkingRequest(authServerUrl, accessToken, payload) {
       }
     });
   } catch (cause) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    throw AccountLinkingError.requestFailed(message, cause);
+    const accountLinkingError = await getAccountLinkingRequestError(cause);
+    throw accountLinkingError;
   }
   if (!result.success) {
     var _result$message;

package/dist/lib.esm/account-linking/vue.js

@@ -20,7 +20,6 @@ const useLinkAccount = () => {
       linkedAccounts.value = result.linkedAccounts;
       return result;
     } catch (err) {
-      log.error("Error linking account", err);
       error.value = err;
     } finally {
       loading.value = false;

package/dist/lib.esm/base/connector/constants.js

@@ -1,5 +1,6 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 
+const WEB3AUTH_CONNECTOR_ID = "web3auth";
 const CONNECTOR_STATUS = {
   NOT_READY: "not_ready",
   READY: "ready",
@@ -31,4 +32,4 @@ const CONNECTOR_INITIAL_AUTHENTICATION_MODE = {
   CONNECT_AND_SIGN: "connect-and-sign"
 };
 
-export { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_STATUS };
+export { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_STATUS, WEB3AUTH_CONNECTOR_ID };

package/dist/lib.esm/base/errors/index.js

@@ -188,7 +188,11 @@ class WalletOperationsError extends Web3AuthError {
     });
   }
   static fromCode(code, extraMessage = "", cause) {
-    return new WalletOperationsError(code, `${WalletOperationsError.messages[code]}, ${extraMessage}`, cause);
+    let message = WalletOperationsError.messages[code];
+    if (extraMessage) {
+      message = `${message}, ${extraMessage}`;
+    }
+    return new WalletOperationsError(code, message, cause);
   }
 
   // Custom methods
@@ -201,58 +205,16 @@ class WalletOperationsError extends Web3AuthError {
   static chainNamespaceNotAllowed(extraMessage = "", cause) {
     return WalletOperationsError.fromCode(5203, extraMessage, cause);
   }
+  static userRejected(extraMessage = "", cause) {
+    return WalletOperationsError.fromCode(5204, extraMessage, cause);
+  }
 }
 _defineProperty(WalletOperationsError, "messages", {
   5000: "Custom",
   5201: "Provided chainId is not allowed",
-  5202: "This operation is not allowed"
-});
-class AccountLinkingError extends Web3AuthError {
-  constructor(code, message, cause) {
-    super(code, message, cause);
-    Object.defineProperty(this, "name", {
-      value: "AccountLinkingError",
-      configurable: true
-    });
-  }
-  static fromCode(code, extraMessage = "", cause) {
-    return new AccountLinkingError(code, `${AccountLinkingError.messages[code]}. ${extraMessage}`, cause);
-  }
-  static requestFailed(extraMessage = "", cause) {
-    return AccountLinkingError.fromCode(5401, extraMessage, cause);
-  }
-  static serverNotConfigured(extraMessage = "", cause) {
-    return AccountLinkingError.fromCode(5402, extraMessage, cause);
-  }
-  static primaryTokenNotAvailable(extraMessage = "", cause) {
-    return AccountLinkingError.fromCode(5403, extraMessage, cause);
-  }
-  static walletProofFailed(extraMessage = "", cause) {
-    return AccountLinkingError.fromCode(5404, extraMessage, cause);
-  }
-  static unsupportedConnector(extraMessage = "", cause) {
-    return AccountLinkingError.fromCode(5405, extraMessage, cause);
-  }
-  static cannotUnlinkActiveAccount() {
-    return AccountLinkingError.fromCode(5406);
-  }
-  static accountNotLinked(message = "", cause) {
-    return AccountLinkingError.fromCode(5407, message, cause);
-  }
-  static cannotUnlinkPrimaryAccount() {
-    return AccountLinkingError.fromCode(5408);
-  }
-}
-_defineProperty(AccountLinkingError, "messages", {
-  5000: "Custom",
-  5401: "Account linking request failed",
-  5402: "Citadel server URL is not configured",
-  5403: "Primary identity token is not available",
-  5404: "Failed to obtain wallet proof token",
-  5405: "Connector is not supported for wallet linking",
-  5406: "Cannot unlink active account",
-  5407: "Account not linked",
-  5408: "Cannot unlink primary account"
+  5202: "This operation is not allowed",
+  5203: "Chain namespace is not allowed",
+  5204: "User rejected the request"
 });
 class WalletProviderError extends Web3AuthError {
   constructor(code, message, cause) {
@@ -286,5 +248,14 @@ _defineProperty(WalletProviderError, "messages", {
   5302: "'args.method' must be a non-empty string.",
   5303: "'args.params' must be an object or array if provided."
 });
+function isUserRejectedError(error) {
+  if (error instanceof Web3AuthError && error.code === 5203) return true;
+  if (error instanceof Error) {
+    var _error$message;
+    const normalizedMessage = ((_error$message = error.message) === null || _error$message === void 0 ? void 0 : _error$message.toLowerCase()) || "";
+    return normalizedMessage.includes("user rejected the request");
+  }
+  return false;
+}
 
-export { AccountLinkingError, WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError };
+export { WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError, isUserRejectedError };

package/dist/lib.esm/base/utils.js

@@ -149,7 +149,7 @@ const getWalletServicesAnalyticsProperties = walletServicesConfig => {
     ws_default_portfolio: walletServicesConfig === null || walletServicesConfig === void 0 || (_walletServicesConfig10 = walletServicesConfig.whiteLabel) === null || _walletServicesConfig10 === void 0 ? void 0 : _walletServicesConfig10.defaultPortfolio
   };
 };
-const sdkVersion = "11.0.0-beta.2";
+const sdkVersion = "11.0.1";
 const getErrorAnalyticsProperties = error => {
   try {
     const code = error instanceof Web3AuthError ? error.code : error === null || error === void 0 ? void 0 : error.code;

package/dist/lib.esm/connectors/auth-connector/authConnector.js

@@ -1,15 +1,15 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { CHAIN_NAMESPACES, getCaipChainId, cloneDeep } from '@toruslabs/base-controllers';
 import { CITADEL_SERVER_MAP } from '@toruslabs/constants';
 import { get, put } from '@toruslabs/http-helpers';
 import { SecurePubSub } from '@toruslabs/secure-pub-sub';
 import { BUILD_ENV, UX_MODE, Auth, SDK_MODE, SUPPORTED_KEY_CURVES, generateRecordId, version, createHandler, PopupHandler, getUserId } from '@web3auth/auth';
 import { WS_EMBED_LOGIN_MODE } from '@web3auth/ws-embed';
 import deepmerge from 'deepmerge';
-import { numberToHex } from 'viem';
 import { generateNonce, parseToken } from '../utils.js';
 import { AuthSolanaWallet } from './authSolanaWallet.js';
-import { WalletLoginError, WalletInitializationError, Web3AuthError, AccountLinkingError } from '../../base/errors/index.js';
+import { WalletLoginError, WalletInitializationError, Web3AuthError } from '../../base/errors/index.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
@@ -18,8 +18,8 @@ import { CONNECTED_STATUSES } from '../../base/connector/connectorStatus.js';
 import { log } from '../../base/loglevel.js';
 import { Analytics, ANALYTICS_EVENTS } from '../../base/analytics.js';
 import { citadelServerUrl, getErrorAnalyticsProperties, parseChainNamespaceFromCitadelResponse } from '../../base/utils.js';
+import { AccountLinkingError } from '../../account-linking/errors.js';
 import { makeAccountLinkingRequest, makeAccountUnlinkingRequest } from '../../account-linking/rest.js';
-import { CHAIN_NAMESPACES, cloneDeep } from '@toruslabs/base-controllers';
 
 // Auth connections that have been deprecated and are no longer supported by the SDK.
 // Passing any of these as `authConnection` results in a hard error so consumers
@@ -312,6 +312,7 @@ class AuthConnector extends BaseConnector {
     });
   }
   async getLinkedAccounts() {
+    var _citadelUserInfo$acco, _this$solanaWallet;
     const accessToken = await this.authInstance.authSessionManager.getAccessToken();
     if (!accessToken) throw WalletLoginError.connectionError("Could not obtain an access token from the current AUTH session.");
     const citadelUserInfo = await get(`${citadelServerUrl(this.coreOptions.authBuildEnv)}/v1/user`, {
@@ -319,11 +320,28 @@ class AuthConnector extends BaseConnector {
         Authorization: `Bearer ${accessToken}`
       }
     });
-    const linkedAccounts = (citadelUserInfo === null || citadelUserInfo === void 0 ? void 0 : citadelUserInfo.accounts) || [];
-    return linkedAccounts.map(account => _objectSpread(_objectSpread({}, account), {}, {
-      // by default, the primary account is the active account
-      active: account.isPrimary
-    }));
+    if (!(citadelUserInfo !== null && citadelUserInfo !== void 0 && (_citadelUserInfo$acco = citadelUserInfo.accounts) !== null && _citadelUserInfo$acco !== void 0 && _citadelUserInfo$acco.length)) return [];
+    const currentChainNamespace = ((_this$solanaWallet = this.solanaWallet) === null || _this$solanaWallet === void 0 ? void 0 : _this$solanaWallet.accounts.length) > 0 ? CHAIN_NAMESPACES.SOLANA : "evm"; // Note: citadel chain namespace is "evm" for EVM chains
+    const filteredLinkedAccounts = [];
+    for (const account of citadelUserInfo.accounts) {
+      const {
+        chainNamespace,
+        isPrimary,
+        accountType
+      } = account;
+
+      // for now, we will take all primary accounts as a **SINGLE** linked account
+      // we don't wanna populate the multiple primary accounts as different linked accounts
+      // so, we hide the primary accounts for other chain namespaces
+      // also, linked `account_abstraction` accounts are derived from the primary account, so we don't need to show them separately
+      // TODO: revisit this logic once we have a concrete plan for handling multiple primary accounts
+      if (isPrimary && chainNamespace && chainNamespace !== currentChainNamespace || accountType === "account_abstraction") continue;
+      filteredLinkedAccounts.push(_objectSpread(_objectSpread({}, account), {}, {
+        // by default, the primary account is the active account
+        active: isPrimary
+      }));
+    }
+    return filteredLinkedAccounts;
   }
   async switchChain(params, init = false) {
     super.checkSwitchChainRequirements(params, init);
@@ -339,13 +357,11 @@ class AuthConnector extends BaseConnector {
     if (newChainConfig.chainNamespace === CHAIN_NAMESPACES.SOLANA || newChainConfig.chainNamespace === CHAIN_NAMESPACES.EIP155) {
       var _this$wsEmbedInstance;
       if (!((_this$wsEmbedInstance = this.wsEmbedInstance) !== null && _this$wsEmbedInstance !== void 0 && _this$wsEmbedInstance.provider)) throw WalletInitializationError.notReady("Wallet embed is not ready");
-      const chainIdNum = parseInt(newChainConfig.chainId, 16);
-      // WsEmbed expects the chainId in hex format
-      const chainIdHex = numberToHex(chainIdNum);
+      const caipChainId = getCaipChainId(newChainConfig);
       await this.wsEmbedInstance.provider.request({
         method: "wallet_switchChain",
         params: {
-          chainId: chainIdHex
+          chainId: caipChainId
         }
       });
     } else {
@@ -460,9 +476,7 @@ class AuthConnector extends BaseConnector {
         }
       }
     } catch (error) {
-      if (error instanceof AccountLinkingError) {
-        throw error;
-      }
+      if (error instanceof Web3AuthError) throw error;
       throw AccountLinkingError.walletProofFailed(error instanceof Error ? error.message : String(error), error);
     }
     const trackData = {

package/dist/lib.esm/connectors/base-evm-connector/baseEvmConnector.js

@@ -1,6 +1,7 @@
 import { signChallenge } from '@toruslabs/base-controllers';
 import { bytesToHexPrefixedString, utf8ToBytes } from '@toruslabs/metadata-helpers';
 import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
+import { checksumAddress } from 'viem';
 import { generateSiweNonce } from 'viem/siwe';
 import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
 import { citadelServerUrl } from '../../base/utils.js';
@@ -54,9 +55,9 @@ class BaseEvmConnector extends BaseConnector {
     } = currentChainConfig;
     const authServer = authServerUrl || citadelServerUrl(this.coreOptions.authBuildEnv);
     const payload = {
-      domain: window.location.origin,
+      domain: window.location.host,
       uri: window.location.href,
-      address: accountsToUse[0],
+      address: checksumAddress(accountsToUse[0]),
       chainId: parseInt(chainId, 16),
       version: "1",
       nonce: generateSiweNonce(),

package/dist/lib.esm/connectors/base-solana-connector/baseSolanaConnector.js

@@ -2,9 +2,9 @@ import { CHAIN_NAMESPACES, signChallenge } from '@toruslabs/base-controllers';
 import { generateSiweNonce } from 'viem/siwe';
 import { WalletLoginError, WalletInitializationError } from '../../base/errors/index.js';
 import { citadelServerUrl } from '../../base/utils.js';
-import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
 
 class BaseSolanaConnector extends BaseConnector {
   async init(_) {}

package/dist/lib.esm/connectors/metamask-connector/metamaskConnector.js

@@ -12,11 +12,11 @@ import { getSiteName } from '../utils.js';
 import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
 import { getCaipChainId, citadelServerUrl } from '../../base/utils.js';
-import { WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { WalletLoginError, isUserRejectedError, WalletOperationsError, Web3AuthError } from '../../base/errors/index.js';
 import { ANALYTICS_EVENTS } from '../../base/analytics.js';
+import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
 import { BaseConnector } from '../../base/connector/baseConnector.js';
 import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
-import { getSolanaChainByChainConfig, walletSignMessage } from '../../base/wallet/solana.js';
 
 /**
  * Configuration options for the MetaMask connector using \@metamask/connect-evm
@@ -113,7 +113,11 @@ class MetaMaskConnector extends BaseConnector {
           supportedNetworks: caipSupportedNetworks
         },
         ui,
-        debug: (_this$connectorSettin0 = this.connectorSettings) === null || _this$connectorSettin0 === void 0 ? void 0 : _this$connectorSettin0.debug
+        debug: (_this$connectorSettin0 = this.connectorSettings) === null || _this$connectorSettin0 === void 0 ? void 0 : _this$connectorSettin0.debug,
+        analytics: {
+          integrationType: "web3auth",
+          enabled: !this.coreOptions.disableAnalytics
+        }
       });
 
       // Listen for QR code URI from the multichain client (for mobile wallet connection)
@@ -133,19 +137,27 @@ class MetaMaskConnector extends BaseConnector {
           dapp,
           eventHandlers: {
             accountsChanged: _accounts => {
-              if (_accounts.length === 0) {
+              if (_accounts.length === 0 && this.connected) {
                 this.disconnect();
               }
             },
             chainChanged: _chainId => {},
             connect: _result => {},
-            disconnect: () => this.disconnect()
+            disconnect: () => {
+              if (this.connected) {
+                this.disconnect();
+              }
+            }
           },
           api: {
             supportedNetworks: hexSupportedNetworks
           },
           ui,
-          debug: (_this$connectorSettin1 = this.connectorSettings) === null || _this$connectorSettin1 === void 0 ? void 0 : _this$connectorSettin1.debug
+          debug: (_this$connectorSettin1 = this.connectorSettings) === null || _this$connectorSettin1 === void 0 ? void 0 : _this$connectorSettin1.debug,
+          analytics: {
+            integrationType: "web3auth",
+            enabled: !this.coreOptions.disableAnalytics
+          }
         });
         this.evmProvider = this.evmClient.getProvider();
       }
@@ -157,7 +169,11 @@ class MetaMaskConnector extends BaseConnector {
           api: {
             supportedNetworks: solanaSupportedNetworks
           },
-          skipAutoRegister: true
+          skipAutoRegister: true,
+          analytics: {
+            integrationType: "web3auth",
+            enabled: !this.coreOptions.disableAnalytics
+          }
         });
         this.solanaProvider = this.solanaClient.getWallet();
       }
@@ -172,32 +188,20 @@ class MetaMaskConnector extends BaseConnector {
       return;
     }
     const coreStatus = this.multichainClient.status;
-    if (coreStatus === "connected") {
+    // only connect if the multichain client is connected and autoConnect is true (i.e during the rehydration)
+    if (coreStatus === "connected" && options.autoConnect) {
       this.status = CONNECTOR_STATUS.CONNECTED;
       this.rehydrated = true;
-      if (options.autoConnect) {
-        this.emit(CONNECTOR_EVENTS.CONNECTED, {
-          connectorName: WALLET_CONNECTORS.METAMASK,
-          reconnected: this.rehydrated,
-          ethereumProvider: this.evmProvider,
-          solanaWallet: this.solanaProvider
-        });
-        if (options.getAuthTokenInfo) {
-          await this.getAuthTokenInfo();
-        }
-      }
-    } else if (coreStatus === "loaded" || coreStatus === "disconnected") {
-      this.status = CONNECTOR_STATUS.READY;
-      this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
-    } else if (coreStatus === "pending") {
-      // 'pending' implies that a transport failed to resume the connection
-      // if (options.autoConnect) {
-      //   this.rehydrated = false;
-      //   this.emit(CONNECTOR_EVENTS.REHYDRATION_ERROR, new Error("Failed to resume existing MetaMask Connect session.") as Web3AuthError);
-      // } else {
+      this.emit(CONNECTOR_EVENTS.CONNECTED, {
+        connectorName: WALLET_CONNECTORS.METAMASK,
+        reconnected: true,
+        ethereumProvider: this.evmProvider,
+        solanaWallet: this.solanaProvider
+      });
+      if (options.getAuthTokenInfo) await this.getAuthTokenInfo();
+    } else if (coreStatus === "connected" || coreStatus === "loaded" || coreStatus === "disconnected" || coreStatus === "pending") {
       this.status = CONNECTOR_STATUS.READY;
       this.emit(CONNECTOR_EVENTS.READY, WALLET_CONNECTORS.METAMASK);
-      // }
     } else {
       // Something unexpected happened
       this.status = CONNECTOR_STATUS.ERRORED;
@@ -234,11 +238,15 @@ class MetaMaskConnector extends BaseConnector {
           connector: WALLET_CONNECTORS.METAMASK
         });
         const evmConnectedPromise = new Promise(resolve => {
-          var _this$evmProvider;
-          // Wait for EVM provider to be ready
-          (_this$evmProvider = this.evmProvider) === null || _this$evmProvider === void 0 || _this$evmProvider.once("connect", () => {
+          if (this.evmClient.status === "connected") {
             resolve();
-          });
+          } else {
+            var _this$evmProvider;
+            // Wait for EVM provider to be ready
+            (_this$evmProvider = this.evmProvider) === null || _this$evmProvider === void 0 || _this$evmProvider.once("connect", () => {
+              resolve();
+            });
+          }
         });
 
         // Connect using the multichain client
@@ -308,6 +316,7 @@ class MetaMaskConnector extends BaseConnector {
           duration: Date.now() - startTime
         }));
       }
+      if (isUserRejectedError(error)) throw WalletOperationsError.userRejected();
       if (error instanceof Web3AuthError) throw error;
       throw WalletLoginError.connectionError("Failed to login with MetaMask wallet", error);
     }

package/dist/lib.esm/index.js

@@ -1,7 +1,7 @@
 export { Web3AuthNoModal } from './noModal.js';
 export { ANALYTICS_EVENTS, ANALYTICS_INTEGRATION_TYPE, ANALYTICS_SDK_TYPE, Analytics } from './base/analytics.js';
 export { AUTH_CONNECTION, MFA_FACTOR, MFA_LEVELS, UX_MODE, WEB3AUTH_NETWORK, getED25519Key } from '@web3auth/auth';
-export { AccountLinkingError, WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError } from './base/errors/index.js';
+export { AccountLinkingError, formatAccountLinkingErrorMessage, getAccountLinkingRequestError } from './account-linking/errors.js';
 export { BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@web3auth/ws-embed';
 export { BaseConnector } from './base/connector/baseConnector.js';
 export { BaseEvmConnector } from './connectors/base-evm-connector/baseEvmConnector.js';
@@ -10,7 +10,7 @@ export { BaseSolanaConnector } from './connectors/base-solana-connector/baseSola
 export { BiconomySmartAccount, KernelSmartAccount, MetamaskSmartAccount, NexusSmartAccount, SMART_ACCOUNT, SafeSmartAccount, TrustSmartAccount } from '@toruslabs/ethereum-controllers';
 export { CAN_AUTHORIZE_STATUSES, CAN_LOGOUT_STATUSES, CONNECTED_STATUSES } from './base/connector/connectorStatus.js';
 export { CHAIN_NAMESPACES, cloneDeep } from '@toruslabs/base-controllers';
-export { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_STATUS } from './base/connector/constants.js';
+export { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_STATUS, WEB3AUTH_CONNECTOR_ID } from './base/connector/constants.js';
 export { CONNECTOR_NAMES, EVM_CONNECTORS, MULTI_CHAIN_CONNECTORS, SOLANA_CONNECTORS, WALLET_CONNECTORS, WEB3AUTH_ICON } from './base/wallet/index.js';
 export { CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
 export { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
@@ -21,6 +21,7 @@ export { EIP_7702_SUPPORTED_SMART_ACCOUNTS, LOGIN_MODE, MODAL_SIGN_IN_METHODS, S
 export { EVM_PLUGINS, PLUGIN_EVENTS, PLUGIN_NAMESPACES, PLUGIN_STATUS, SOLANA_PLUGINS, WALLET_PLUGINS } from './base/plugin/IPlugin.js';
 export { PROVIDER_EVENTS } from './base/provider/IProvider.js';
 export { WalletConnectV2Provider } from './connectors/wallet-connect-v2-connector/WalletConnectV2Provider.js';
+export { WalletInitializationError, WalletLoginError, WalletOperationsError, WalletProviderError, Web3AuthError, isUserRejectedError } from './base/errors/index.js';
 export { WalletServicesPluginError } from './base/plugin/errors.js';
 export { Web3AuthContextKey } from './base/composables/index.js';
 export { accountAbstractionProvider, toEoaProvider } from './providers/account-abstraction-provider/providers/AccountAbstractionProvider.js';

package/dist/lib.esm/noModal.js

@@ -3,11 +3,11 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { CHAIN_NAMESPACES, BUTTON_POSITION, CONFIRMATION_STRATEGY } from '@toruslabs/base-controllers';
 import { SMART_ACCOUNT_EIP_STANDARD, EIP7702_SUPPORTED_SMART_ACCOUNT_TYPES } from '@toruslabs/ethereum-controllers';
-import { SafeEventEmitter, serializeError, UX_MODE, cloneDeep, CookieStorage, LocalStorageAdapter, MemoryStorage } from '@web3auth/auth';
+import { SafeEventEmitter, BUILD_ENV, serializeError, UX_MODE, cloneDeep, CookieStorage, LocalStorageAdapter, MemoryStorage } from '@web3auth/auth';
 import deepmerge from 'deepmerge';
 import { deserialize } from './base/deserialize.js';
-import { WalletInitializationError, WalletLoginError, AccountLinkingError } from './base/errors/index.js';
 import { LOGIN_MODE, SMART_ACCOUNT_WALLET_SCOPE, WEB3AUTH_STATE_STORAGE_KEY } from './base/constants.js';
+import { WalletInitializationError, WalletLoginError } from './base/errors/index.js';
 import { log } from './base/loglevel.js';
 import { CONNECTOR_STATUS, CONNECTOR_INITIAL_AUTHENTICATION_MODE, CONNECTOR_EVENTS } from './base/connector/constants.js';
 import { Analytics, ANALYTICS_INTEGRATION_TYPE, ANALYTICS_SDK_TYPE, ANALYTICS_EVENTS } from './base/analytics.js';
@@ -16,6 +16,7 @@ import { WALLET_CONNECTORS } from './base/wallet/index.js';
 import { CONNECTOR_NAMESPACES } from './base/chain/IChainInterface.js';
 import { CONNECTED_STATUSES, CAN_LOGOUT_STATUSES, CAN_AUTHORIZE_STATUSES } from './base/connector/connectorStatus.js';
 import { assertAuthConnector, authConnector, isAuthConnector } from './connectors/auth-connector/authConnector.js';
+import { AccountLinkingError } from './account-linking/errors.js';
 import { CommonJRPCProvider } from './providers/base-provider/CommonJRPCProvider.js';
 import { walletServicesPlugin } from './plugins/wallet-services-plugin/plugin.js';
 import { metaMaskConnector } from './connectors/metamask-connector/metamaskConnector.js';
@@ -54,7 +55,9 @@ class Web3AuthNoModal extends SafeEventEmitter {
     if (!options.clientId) throw WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
     if (options.enableLogging) log.enableAll();else log.setLevel("error");
     if (!options.initialAuthenticationMode) options.initialAuthenticationMode = CONNECTOR_INITIAL_AUTHENTICATION_MODE.CONNECT_AND_SIGN;
-    this.coreOptions = options;
+    this.coreOptions = _objectSpread(_objectSpread({}, options), {}, {
+      authBuildEnv: options.authBuildEnv || BUILD_ENV.PRODUCTION
+    });
     this.storage = this.getStorageMethod();
     this.analytics = new Analytics();
     if (options.disableAnalytics) {
@@ -952,7 +955,8 @@ class Web3AuthNoModal extends SafeEventEmitter {
         activeAccount,
         currentChainId
       } = this.state;
-      // if the active account is not the primary account, i.e. not `null`, create an isolated connector and connect to the chain
+      let rehydrateWithLinkedAccount = false;
+      // for rehydration, if the active account is not the primary account, i.e. not `null`, create an isolated connector and connect to the chain
       if (activeAccount && !activeAccount.isPrimary && activeAccount.connector !== WALLET_CONNECTORS.AUTH) {
         var _ref3, _walletConnector$prov, _linkedAccountConnect, _ref4, _walletConnector$sola, _linkedAccountConnect2;
         const accountLinkingConnector = isAuthConnector(connector) ? connector : this.getConnector(WALLET_CONNECTORS.AUTH);
@@ -977,6 +981,7 @@ class Web3AuthNoModal extends SafeEventEmitter {
         });
         this.setConnectedWalletConnectorState(connectedWalletState, activeAccount);
         this.setActiveWalletConnectorKey(activeAccount);
+        rehydrateWithLinkedAccount = true;
       }
       if (ethereumProvider) {
         await this.bindPrimaryEthereumSigningProxy(ethereumProvider, data.connectorName);
@@ -1014,12 +1019,19 @@ class Web3AuthNoModal extends SafeEventEmitter {
             connector: data.connectorName
           }));
         }
+
         // `pendingUserConsent` signals listeners (LoginModal, React/Vue contexts) to skip processing this CONNECTED event,
         // so the upcoming AUTHORIZED -> CONSENT_REQUIRING transition is not overridden by a late CONNECTED handler in CONNECT_AND_SIGN mode.
         this.emit(CONNECTOR_EVENTS.CONNECTED, _objectSpread(_objectSpread({}, data), {}, {
           loginMode: this.loginMode,
           pendingUserConsent
         }));
+
+        // if we're rehydrating with a linked account, we need to emit a CONNECTION_UPDATED event
+        // so that upstream listeners and context are updated with the linked connection.
+        if (rehydrateWithLinkedAccount) {
+          this.emit(CONNECTOR_EVENTS.CONNECTION_UPDATED, this.connection);
+        }
       }
     });
     connector.on(CONNECTOR_EVENTS.DISCONNECTED, async data => {
@@ -1239,7 +1251,15 @@ class Web3AuthNoModal extends SafeEventEmitter {
     return activeChainId;
   }
   async createLinkingWalletConnector(connectorName, chainId, config) {
-    return this.createIsolatedWalletConnector(connectorName, chainId, config);
+    try {
+      const linkingConnector = await this.createIsolatedWalletConnector(connectorName, chainId, config);
+      return linkingConnector;
+    } catch (error) {
+      if (error instanceof AccountLinkingError && error.code === 5405) {
+        throw error;
+      }
+      throw AccountLinkingError.walletProofFailed(error instanceof Error ? error.message : String(error), error);
+    }
   }
   async createSwitchingWalletConnector(connectorName, chainId, config) {
     return this.createIsolatedWalletConnector(connectorName, chainId, config);