@web3auth/no-modal 10.16.0 → 11.0.0-beta.1

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

@@ -2,30 +2,34 @@
 
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var constants$1 = require('@toruslabs/constants');
+var httpHelpers = require('@toruslabs/http-helpers');
 var securePubSub = require('@toruslabs/secure-pub-sub');
 var auth = require('@web3auth/auth');
 var wsEmbed = require('@web3auth/ws-embed');
 var deepmerge = require('deepmerge');
-require('@segment/analytics-next');
-var loglevel = require('../../base/loglevel.js');
+var rest = require('../../account-linking/rest.js');
+var analytics = require('../../base/analytics.js');
 var IChainInterface = require('../../base/chain/IChainInterface.js');
 var baseConnector = require('../../base/connector/baseConnector.js');
 var connectorStatus = require('../../base/connector/connectorStatus.js');
 var constants = require('../../base/connector/constants.js');
 require('jwt-decode');
-var index$1 = require('../../base/errors/index.js');
+require('../../base/constants.js');
+var index = require('../../base/errors/index.js');
+var loglevel = require('../../base/loglevel.js');
 require('../../base/plugin/errors.js');
 require('../../base/plugin/IPlugin.js');
+var utils = require('../../base/utils.js');
+var index$1 = require('../../base/wallet/index.js');
+var utils$1 = require('../utils.js');
+var authSolanaWallet = require('./authSolanaWallet.js');
 var baseControllers = require('@toruslabs/base-controllers');
-require('@toruslabs/constants');
-require('@toruslabs/http-helpers');
-var index = require('../../base/wallet/index.js');
-var utils = require('../utils.js');
 
 class AuthConnector extends baseConnector.BaseConnector {
   constructor(params) {
     super(params);
-    _defineProperty(this, "name", index.WALLET_CONNECTORS.AUTH);
+    _defineProperty(this, "name", index$1.WALLET_CONNECTORS.AUTH);
     _defineProperty(this, "connectorNamespace", IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN);
     _defineProperty(this, "type", constants.CONNECTOR_CATEGORY.IN_APP);
     _defineProperty(this, "authInstance", null);
@@ -39,6 +43,8 @@ class AuthConnector extends baseConnector.BaseConnector {
     _defineProperty(this, "wsEmbedInstance", null);
     _defineProperty(this, "authConnectionConfig", []);
     _defineProperty(this, "wsEmbedInstancePromise", null);
+    _defineProperty(this, "_solanaWallet", null);
+    _defineProperty(this, "analytics", void 0);
     this.authOptions = params.connectorSettings;
     this.loginSettings = params.loginSettings || {
       authConnection: ""
@@ -47,6 +53,7 @@ class AuthConnector extends baseConnector.BaseConnector {
       loginMode: wsEmbed.WS_EMBED_LOGIN_MODE.PLUGIN
     };
     this.authConnectionConfig = params.authConnectionConfig || [];
+    this.analytics = params.analytics || new analytics.Analytics();
   }
   get provider() {
     if (this.status !== constants.CONNECTOR_STATUS.NOT_READY) {
@@ -60,6 +67,9 @@ class AuthConnector extends baseConnector.BaseConnector {
   get wsEmbed() {
     return this.wsEmbedInstance;
   }
+  get solanaWallet() {
+    return this._solanaWallet;
+  }
   set provider(_) {
     throw new Error("Not implemented");
   }
@@ -74,9 +84,9 @@ class AuthConnector extends baseConnector.BaseConnector {
     super.checkInitializationRequirements({
       chainConfig
     });
-    if (!this.coreOptions.clientId) throw index$1.WalletInitializationError.invalidParams("clientId is required before auth's initialization");
-    if (!this.authOptions) throw index$1.WalletInitializationError.invalidParams("authOptions is required before auth's initialization");
-    if (this.authConnectionConfig.length === 0) throw index$1.WalletInitializationError.invalidParams("authConnectionConfig is required before auth's initialization");
+    if (!this.coreOptions.clientId) throw index.WalletInitializationError.invalidParams("clientId is required before auth's initialization");
+    if (!this.authOptions) throw index.WalletInitializationError.invalidParams("authOptions is required before auth's initialization");
+    if (this.authConnectionConfig.length === 0) throw index.WalletInitializationError.invalidParams("authConnectionConfig is required before auth's initialization");
     const isRedirectResult = this.authOptions.uxMode === auth.UX_MODE.REDIRECT;
     this.authOptions = _objectSpread(_objectSpread({}, this.authOptions), {}, {
       replaceUrlOnRedirect: isRedirectResult,
@@ -92,7 +102,7 @@ class AuthConnector extends baseConnector.BaseConnector {
     loglevel.log.debug("initializing auth connector init", this.authOptions);
     // making it async here to initialize provider.
     const authInstancePromise = this.authInstance.init();
-    // Use this for xrpl, mpc cases
+    // Use this for xrpl cases
     if (this.coreOptions.privateKeyProvider) {
       this.privateKeyProvider = this.coreOptions.privateKeyProvider;
     } else {
@@ -114,6 +124,7 @@ class AuthConnector extends baseConnector.BaseConnector {
               loginMode: wsEmbed.WS_EMBED_LOGIN_MODE.PLUGIN,
               chains: wsSupportedChains,
               chainId,
+              buildEnv: this.authOptions.buildEnv,
               whiteLabel: _objectSpread(_objectSpread({}, this.authOptions.whiteLabel), this.wsSettings.whiteLabel)
             })).then(() => {
               this.wsEmbedInstancePromise = null;
@@ -122,7 +133,7 @@ class AuthConnector extends baseConnector.BaseConnector {
             break;
           }
         case baseControllers.CHAIN_NAMESPACES.XRPL:
-          throw index$1.WalletLoginError.connectionError("Private key provider is required for XRPL");
+          throw index.WalletLoginError.connectionError("Private key provider is required for XRPL");
         default:
           {
             const {
@@ -141,7 +152,7 @@ class AuthConnector extends baseConnector.BaseConnector {
     loglevel.log.debug("initializing auth connector");
     await authInstancePromise;
     this.status = constants.CONNECTOR_STATUS.READY;
-    this.emit(constants.CONNECTOR_EVENTS.READY, index.WALLET_CONNECTORS.AUTH);
+    this.emit(constants.CONNECTOR_EVENTS.READY, index$1.WALLET_CONNECTORS.AUTH);
     try {
       const {
         sessionId
@@ -151,13 +162,13 @@ class AuthConnector extends baseConnector.BaseConnector {
         this.rehydrated = true;
         await this.connect({
           chainId: options.chainId,
-          getIdentityToken: options.getIdentityToken
+          getAuthTokenInfo: options.getAuthTokenInfo
         });
       } else if (!sessionId && options.autoConnect) {
         // if here, this means that the connector is cached but the sessionId is not available.
         // this can happen if the sessionId has expired.
         // we are throwing an error to reset the cached state.
-        throw index$1.WalletLoginError.connectionError("Failed to rehydrate");
+        throw index.WalletLoginError.connectionError("Failed to rehydrate");
       }
     } catch (error) {
       this.emit(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, error);
@@ -167,11 +178,15 @@ class AuthConnector extends baseConnector.BaseConnector {
     super.checkConnectionRequirements();
     this.status = constants.CONNECTOR_STATUS.CONNECTING;
     this.emit(constants.CONNECTOR_EVENTS.CONNECTING, _objectSpread(_objectSpread({}, params), {}, {
-      connector: index.WALLET_CONNECTORS.AUTH
+      connector: index$1.WALLET_CONNECTORS.AUTH
     }));
     try {
       await this.connectWithProvider(params);
-      return this.provider;
+      return {
+        ethereumProvider: this.provider,
+        solanaWallet: this._solanaWallet,
+        connectorName: this.name
+      };
     } catch (error) {
       var _error$message;
       loglevel.log.error("Failed to connect with auth provider", error);
@@ -179,50 +194,50 @@ class AuthConnector extends baseConnector.BaseConnector {
       this.status = constants.CONNECTOR_STATUS.READY;
       this.emit(constants.CONNECTOR_EVENTS.ERRORED, error);
       if (error !== null && error !== void 0 && (_error$message = error.message) !== null && _error$message !== void 0 && _error$message.includes("user closed popup")) {
-        throw index$1.WalletLoginError.popupClosed();
-      } else if (error instanceof index$1.Web3AuthError) {
+        throw index.WalletLoginError.popupClosed();
+      } else if (error instanceof index.Web3AuthError) {
         throw error;
       }
-      throw index$1.WalletLoginError.connectionError("Failed to login with auth", error);
+      throw index.WalletLoginError.connectionError("Failed to login with auth", error);
     }
   }
   async enableMFA(params = {
     authConnection: ""
   }) {
-    if (!this.connected) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
-    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    if (!this.connected) throw index.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
     try {
       const result = await this.authInstance.enableMFA(params);
       // In redirect mode, the result is not available immediately, so we emit the event when the result is available.
       if (result) this.emit(constants.CONNECTOR_EVENTS.MFA_ENABLED, result);
     } catch (error) {
       loglevel.log.error("Failed to enable MFA with auth provider", error);
-      if (error instanceof index$1.Web3AuthError) {
+      if (error instanceof index.Web3AuthError) {
         throw error;
       }
-      throw index$1.WalletLoginError.connectionError("Failed to enable MFA with auth", error);
+      throw index.WalletLoginError.connectionError("Failed to enable MFA with auth", error);
     }
   }
   async manageMFA(params = {
     authConnection: ""
   }) {
-    if (!this.connected) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
-    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    if (!this.connected) throw index.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
     try {
       await this.authInstance.manageMFA(params);
     } catch (error) {
       loglevel.log.error("Failed to manage MFA with auth provider", error);
-      if (error instanceof index$1.Web3AuthError) {
+      if (error instanceof index.Web3AuthError) {
         throw error;
       }
-      throw index$1.WalletLoginError.connectionError("Failed to manage MFA with auth", error);
+      throw index.WalletLoginError.connectionError("Failed to manage MFA with auth", error);
     }
   }
   async disconnect(options = {
     cleanup: false
   }) {
-    if (!this.connected) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
-    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    if (!this.connected) throw index.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
     this.status = constants.CONNECTOR_STATUS.DISCONNECTING;
     await this.authInstance.logout();
     if (this.wsEmbedInstance) await this.wsEmbedInstance.logout();
@@ -236,70 +251,84 @@ class AuthConnector extends baseConnector.BaseConnector {
       this.status = constants.CONNECTOR_STATUS.READY;
     }
     this.rehydrated = false;
-    this.emit(constants.CONNECTOR_EVENTS.DISCONNECTED);
+    this._solanaWallet = null;
+    this.emit(constants.CONNECTOR_EVENTS.DISCONNECTED, {
+      connector: index$1.WALLET_CONNECTORS.AUTH
+    });
   }
-  async getIdentityToken() {
-    if (!this.canAuthorize) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
+  async getAuthTokenInfo() {
+    if (!this.canAuthorize) throw index.WalletLoginError.notConnectedError("Not connected with wallet, Please login/connect first");
     this.status = constants.CONNECTOR_STATUS.AUTHORIZING;
     this.emit(constants.CONNECTOR_EVENTS.AUTHORIZING, {
-      connector: index.WALLET_CONNECTORS.AUTH
+      connector: index$1.WALLET_CONNECTORS.AUTH
     });
     const userInfo = await this.getUserInfo();
     this.status = constants.CONNECTOR_STATUS.AUTHORIZED;
+    const [accessToken, refreshToken] = await Promise.all([this.authInstance.authSessionManager.getAccessToken(), this.authInstance.authSessionManager.getRefreshToken()]);
     this.emit(constants.CONNECTOR_EVENTS.AUTHORIZED, {
-      connector: index.WALLET_CONNECTORS.AUTH,
-      identityTokenInfo: {
-        idToken: userInfo.idToken
+      connector: index$1.WALLET_CONNECTORS.AUTH,
+      authTokenInfo: {
+        idToken: userInfo.idToken,
+        accessToken,
+        refreshToken
       }
     });
     return {
-      idToken: userInfo.idToken
+      idToken: userInfo.idToken,
+      accessToken,
+      refreshToken
     };
   }
   async getUserInfo() {
-    if (!this.canAuthorize) throw index$1.WalletLoginError.notConnectedError("Not connected with wallet");
-    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
-    const userInfo = this.authInstance.getUserInfo();
-    return userInfo;
+    if (!this.canAuthorize) throw index.WalletLoginError.notConnectedError("Not connected with wallet");
+    if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
+    const [userInfo, linkedAccounts] = await Promise.all([this.authInstance.getUserInfo(), this.getLinkedAccounts()]);
+    return _objectSpread(_objectSpread({}, userInfo), {}, {
+      linkedAccounts
+    });
+  }
+  async getLinkedAccounts() {
+    const accessToken = await this.authInstance.authSessionManager.getAccessToken();
+    if (!accessToken) throw index.WalletLoginError.connectionError("Could not obtain an access token from the current AUTH session.");
+    const citadelUserInfo = await httpHelpers.get(`${utils.citadelServerUrl(this.coreOptions.authBuildEnv)}/v1/user`, {
+      headers: {
+        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
+    }));
   }
-  // we don't support switching between different namespaces, except for solana and evm
   async switchChain(params, init = false) {
     super.checkSwitchChainRequirements(params, init);
-    // get chains and namespaces
     const {
       chainId: newChainId
     } = params;
     const {
       chainId: currentChainId
     } = this.provider;
-    const {
-      chainNamespace: currentNamespace
-    } = this.getChain(currentChainId);
-    const {
-      chainNamespace: newNamespace
-    } = this.getChain(newChainId);
-    // skip if chainId is the same
     if (currentChainId === newChainId) return;
-    if (currentNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA || currentNamespace === baseControllers.CHAIN_NAMESPACES.EIP155) {
+    const newChainConfig = this.coreOptions.chains.find(c => c.chainId === newChainId);
+    if (!newChainConfig) throw index.WalletInitializationError.invalidParams("Chain config is not available");
+    if (newChainConfig.chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA || newChainConfig.chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155) {
       var _this$wsEmbedInstance2;
-      // can only switch to solana or evm
-      if (newNamespace !== baseControllers.CHAIN_NAMESPACES.SOLANA && newNamespace !== baseControllers.CHAIN_NAMESPACES.EIP155) throw index$1.WalletLoginError.connectionError("Cannot switch to other chain namespace");
-      const fullChainId = `${newNamespace}:${Number(params.chainId)}`;
-      await ((_this$wsEmbedInstance2 = this.wsEmbedInstance.provider) === null || _this$wsEmbedInstance2 === void 0 ? void 0 : _this$wsEmbedInstance2.request({
+      if (!((_this$wsEmbedInstance2 = this.wsEmbedInstance) !== null && _this$wsEmbedInstance2 !== void 0 && _this$wsEmbedInstance2.provider)) throw index.WalletInitializationError.notReady("Wallet embed is not ready");
+      const fullChainId = utils.getCaipChainId(newChainConfig);
+      await this.wsEmbedInstance.provider.request({
         method: "wallet_switchChain",
         params: {
           chainId: fullChainId
         }
-      }));
+      });
     } else {
       var _this$privateKeyProvi;
-      // cannot switch to other namespaces
-      if (currentNamespace !== newNamespace) throw index$1.WalletLoginError.connectionError("Cannot switch to other chain namespace");
       await ((_this$privateKeyProvi = this.privateKeyProvider) === null || _this$privateKeyProvi === void 0 ? void 0 : _this$privateKeyProvi.switchChain(params));
     }
   }
   async cleanup() {
-    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
     await this.authInstance.cleanup();
     if (this.wsEmbedInstance) {
       this.wsEmbedInstance.clearInit();
@@ -323,8 +352,350 @@ class AuthConnector extends baseConnector.BaseConnector {
     });
     return providerConfig;
   }
-  getChain(chainId) {
-    return this.coreOptions.chains.find(x => x.chainId === chainId);
+  async generateChallengeAndSign() {
+    // we do not support this for auth connector, as of now. since auth login returns a valid idToken
+    throw new Error("Not implemented");
+  }
+  async switchAccount(account, context) {
+    if (!connectorStatus.CONNECTED_STATUSES.includes(this.status)) {
+      throw index.WalletLoginError.notConnectedError("No wallet is connected. Connect with AUTH before switching accounts.");
+    }
+    try {
+      var _userInfo$linkedAccou;
+      const userInfo = await this.getUserInfo();
+      const linkedAccounts = (_userInfo$linkedAccou = userInfo.linkedAccounts) !== null && _userInfo$linkedAccou !== void 0 ? _userInfo$linkedAccou : [];
+      const targetAccount = linkedAccounts.find(candidate => candidate.id === account.id);
+      if (!targetAccount) {
+        throw index.AccountLinkingError.requestFailed(`No connected wallet matches account id "${account.id}". Refresh user info and try again.`);
+      }
+      const currentActiveAccount = context.activeAccount;
+      const isTargetAlreadyActive = currentActiveAccount ? currentActiveAccount.id === targetAccount.id : targetAccount.isPrimary;
+      if (isTargetAlreadyActive) {
+        return;
+      }
+      this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_SWITCH_STARTED, this.getSwitchAccountTrackData(targetAccount));
+      if (targetAccount.connector === index$1.WALLET_CONNECTORS.AUTH && targetAccount.isPrimary) {
+        var _this$provider$chainI, _this$provider;
+        const activeChainId = this.getChainIdForLinkedAccount(targetAccount, (_this$provider$chainI = (_this$provider = this.provider) === null || _this$provider === void 0 ? void 0 : _this$provider.chainId) !== null && _this$provider$chainI !== void 0 ? _this$provider$chainI : context.currentChainId);
+        const ethereumProvider = this.provider;
+        const solanaWallet = this.solanaWallet;
+        if (!ethereumProvider && !solanaWallet) {
+          throw index.AccountLinkingError.requestFailed("Failed to restore the primary AUTH session for account switch.");
+        }
+        return {
+          kind: "primary",
+          targetAccount,
+          activeAccount: null,
+          activeChainId,
+          connectorName: this.name,
+          connectorNamespace: this.connectorNamespace,
+          ethereumProvider,
+          solanaWallet
+        };
+      }
+      return {
+        kind: "external",
+        targetAccount,
+        activeAccount: targetAccount,
+        activeChainId: this.getChainIdForLinkedAccount(targetAccount, context.currentChainId)
+      };
+    } catch (error) {
+      await this.trackSwitchAccountFailed(account, error);
+      throw error;
+    }
+  }
+  async trackSwitchAccountCompleted(account) {
+    await this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_SWITCH_COMPLETED, _objectSpread(_objectSpread({}, this.getSwitchAccountTrackData(account)), {}, {
+      connector: account.connector
+    }));
+  }
+  async trackSwitchAccountFailed(account, error) {
+    await this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_SWITCH_FAILED, _objectSpread(_objectSpread({}, this.getSwitchAccountTrackData(account)), utils.getErrorAnalyticsProperties(error)));
+  }
+  async linkAccount(params) {
+    if (!connectorStatus.CONNECTED_STATUSES.includes(this.status)) {
+      throw index.WalletLoginError.notConnectedError("No wallet is connected. Connect with AUTH before linking an account.");
+    }
+    const {
+      connectorName,
+      chainId,
+      walletConnector
+    } = params;
+    try {
+      if (!walletConnector.connected) {
+        const connection = await walletConnector.connect({
+          chainId,
+          isAccountLinking: true
+        });
+        if (!connection) {
+          throw index.AccountLinkingError.walletProofFailed(`Failed to connect to "${params.connectorName}" for account linking.`);
+        }
+      }
+    } catch (error) {
+      if (error instanceof index.AccountLinkingError) {
+        throw error;
+      }
+      throw index.AccountLinkingError.walletProofFailed(error instanceof Error ? error.message : String(error), error);
+    }
+    const trackData = {
+      connector: this.name,
+      linking_connector: connectorName,
+      chain_id: params.chainId
+    };
+    try {
+      await this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_LINKING_STARTED, trackData);
+      const {
+        accessToken,
+        idToken
+      } = await this.getPrimaryAuthSession(params.authSessionTokens);
+      const walletProof = await this.createWalletLinkingProof(params.walletConnector);
+      const authServerUrl = utils.citadelServerUrl(this.coreOptions.authBuildEnv);
+      const result = await rest.makeAccountLinkingRequest(authServerUrl, accessToken, {
+        idToken,
+        network: walletProof.network,
+        connector: params.connectorName,
+        message: walletProof.challenge,
+        signature: {
+          s: walletProof.signature,
+          t: walletProof.signatureType
+        }
+      });
+      this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_LINKING_COMPLETED, _objectSpread(_objectSpread({}, trackData), {}, {
+        linked_address: walletProof.address
+      }));
+      return result;
+    } catch (error) {
+      this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_LINKING_FAILED, _objectSpread(_objectSpread({}, trackData), utils.getErrorAnalyticsProperties(error)));
+      // disconnect the wallet connector to avoid any leftover state
+      try {
+        await walletConnector.disconnect({
+          cleanup: true
+        });
+      } catch (disconnectError) {
+        loglevel.log.debug("Failed to disconnect wallet connector after linking failure", disconnectError);
+      }
+      throw error;
+    }
+  }
+  async unlinkAccount(params) {
+    if (!connectorStatus.CONNECTED_STATUSES.includes(this.status)) {
+      throw index.WalletLoginError.notConnectedError("No wallet is connected. Connect with AUTH before unlinking an account.");
+    }
+    const {
+      address,
+      authSessionTokens
+    } = params;
+    const trackData = {
+      connector: this.name,
+      address
+    };
+    await this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_UNLINKING_STARTED, trackData);
+    try {
+      const {
+        accessToken,
+        idToken,
+        linkedAccounts
+      } = await this.getPrimaryAuthSession(authSessionTokens, {
+        includeLinkedAccounts: true
+      });
+      const network = this.getNetworkForUnlinkAddress(linkedAccounts, address);
+      const authServerUrl = utils.citadelServerUrl(this.coreOptions.authBuildEnv);
+      const result = await rest.makeAccountUnlinkingRequest(authServerUrl, accessToken, {
+        idToken,
+        address,
+        network
+      });
+      await this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_UNLINKING_COMPLETED, _objectSpread(_objectSpread({}, trackData), {}, {
+        linked_address: address
+      }));
+      return result;
+    } catch (error) {
+      await this.analytics.track(analytics.ANALYTICS_EVENTS.ACCOUNT_UNLINKING_FAILED, _objectSpread(_objectSpread({}, trackData), utils.getErrorAnalyticsProperties(error)));
+      throw error;
+    }
+  }
+  getChainIdForLinkedAccount(account, preferredChainId) {
+    const accountChainNamespace = account.chainNamespace ? utils.parseChainNamespaceFromCitadelResponse(account.chainNamespace) : null;
+    if (preferredChainId) {
+      const preferredChain = this.coreOptions.chains.find(chain => chain.chainId === preferredChainId);
+      if (preferredChain && (!accountChainNamespace || preferredChain.chainNamespace === accountChainNamespace)) {
+        return preferredChainId;
+      }
+    }
+    if (accountChainNamespace) {
+      const namespaceChain = this.coreOptions.chains.find(chain => chain.chainNamespace === accountChainNamespace);
+      if (namespaceChain) {
+        return namespaceChain.chainId;
+      }
+    }
+    throw index.WalletInitializationError.invalidParams(`No compatible chainId found for connector "${account.connector}".`);
+  }
+  async assertSwitchAccountConnectorMatchesTarget(connector, account) {
+    if (!account.chainNamespace) {
+      throw index.AccountLinkingError.requestFailed(`Could not determine the chain namespace for linked account "${account.eoaAddress}".`);
+    }
+    const chainNamespace = utils.parseChainNamespaceFromCitadelResponse(account.chainNamespace);
+    let connectedAddress = null;
+    if (chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155) {
+      var _accounts$;
+      const accounts = connector.provider ? await connector.provider.request({
+        method: "eth_accounts"
+      }) : [];
+      connectedAddress = (_accounts$ = accounts === null || accounts === void 0 ? void 0 : accounts[0]) !== null && _accounts$ !== void 0 ? _accounts$ : null;
+    } else if (chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA) {
+      var _connector$solanaWall, _connector$solanaWall2;
+      connectedAddress = (_connector$solanaWall = (_connector$solanaWall2 = connector.solanaWallet) === null || _connector$solanaWall2 === void 0 || (_connector$solanaWall2 = _connector$solanaWall2.accounts) === null || _connector$solanaWall2 === void 0 || (_connector$solanaWall2 = _connector$solanaWall2[0]) === null || _connector$solanaWall2 === void 0 ? void 0 : _connector$solanaWall2.address) !== null && _connector$solanaWall !== void 0 ? _connector$solanaWall : null;
+    } else {
+      throw index.AccountLinkingError.requestFailed(`Unsupported chain namespace "${account.chainNamespace}" for linked account "${account.eoaAddress}".`);
+    }
+    if (!connectedAddress) {
+      throw index.AccountLinkingError.requestFailed(`Connector "${account.connector}" is not connected to linked account "${account.eoaAddress}". Connect the intended wallet account and try again.`);
+    }
+    const isExpectedAddress = chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155 ? connectedAddress.toLowerCase() === account.eoaAddress.toLowerCase() : connectedAddress === account.eoaAddress;
+    if (!isExpectedAddress) {
+      throw index.AccountLinkingError.requestFailed(`Connector "${account.connector}" is connected to "${connectedAddress}" instead of linked account "${account.eoaAddress}". Connect the intended wallet account and try again.`);
+    }
+  }
+  toSwitchAccountConnectorError(account, error) {
+    if (error instanceof index.AccountLinkingError && error.code === 5401) {
+      return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const isUnavailableConnectorError = error instanceof index.AccountLinkingError && error.code === 5405 || /not available|not initialized|not ready/i.test(message);
+    if (isUnavailableConnectorError) {
+      return index.AccountLinkingError.requestFailed(`Connector "${account.connector}" is not available for linked account "${account.eoaAddress}". Make sure the wallet is installed, unlocked, and accessible, then try again.`, error);
+    }
+    return index.AccountLinkingError.requestFailed(`Failed to connect connector "${account.connector}" for linked account "${account.eoaAddress}". ${message}`, error);
+  }
+  getSwitchAccountTrackData(account) {
+    var _account$eoaAddress;
+    return {
+      connector: this.name,
+      account_id: account.id,
+      account_type: account.accountType,
+      switched_to_address: (_account$eoaAddress = account.eoaAddress) !== null && _account$eoaAddress !== void 0 ? _account$eoaAddress : null
+    };
+  }
+  async getPrimaryAuthSession(authSessionTokens, options = {}) {
+    const {
+      accessToken: cachedAccessToken,
+      idToken: cachedIdToken
+    } = authSessionTokens;
+    const {
+      includeLinkedAccounts = false
+    } = options;
+    let accessToken = cachedAccessToken;
+    let idToken = cachedIdToken;
+    let linkedAccounts = [];
+    if (includeLinkedAccounts) {
+      const userInfoPromise = this.getUserInfo();
+      if (!accessToken || !idToken) {
+        var _userInfo$linkedAccou2;
+        const [tokenInfo, userInfo] = await Promise.all([this.getAuthTokenInfo(), userInfoPromise]);
+        accessToken = tokenInfo.accessToken;
+        idToken = tokenInfo.idToken;
+        linkedAccounts = (_userInfo$linkedAccou2 = userInfo.linkedAccounts) !== null && _userInfo$linkedAccou2 !== void 0 ? _userInfo$linkedAccou2 : [];
+      } else {
+        var _userInfo$linkedAccou3;
+        const userInfo = await userInfoPromise;
+        linkedAccounts = (_userInfo$linkedAccou3 = userInfo.linkedAccounts) !== null && _userInfo$linkedAccou3 !== void 0 ? _userInfo$linkedAccou3 : [];
+      }
+    } else if (!accessToken || !idToken) {
+      const tokenInfo = await this.getAuthTokenInfo();
+      accessToken = tokenInfo.accessToken;
+      idToken = tokenInfo.idToken;
+    }
+    if (!accessToken || !idToken) {
+      throw index.AccountLinkingError.primaryTokenNotAvailable("Could not obtain an identity token from the current AUTH session.");
+    }
+    return {
+      accessToken,
+      idToken,
+      linkedAccounts
+    };
+  }
+  getNetworkForUnlinkAddress(accounts, address) {
+    const matchedAccount = accounts.find(account => {
+      var _account$address, _account$eoaAddress2;
+      if (!account.chainNamespace || utils.parseChainNamespaceFromCitadelResponse(account.chainNamespace) !== baseControllers.CHAIN_NAMESPACES.EIP155) {
+        return false;
+      }
+      const normalizedAddress = address.toLowerCase();
+      return ((_account$address = account.address) === null || _account$address === void 0 ? void 0 : _account$address.toLowerCase()) === normalizedAddress || ((_account$eoaAddress2 = account.eoaAddress) === null || _account$eoaAddress2 === void 0 ? void 0 : _account$eoaAddress2.toLowerCase()) === normalizedAddress;
+    });
+    if (!matchedAccount) {
+      throw index.AccountLinkingError.requestFailed(`No connected wallet matches address "${address}".`);
+    }
+    if (!matchedAccount.chainNamespace) {
+      throw index.AccountLinkingError.requestFailed(`Could not determine the chain namespace for address "${address}".`);
+    }
+    const chainNamespace = utils.parseChainNamespaceFromCitadelResponse(matchedAccount.chainNamespace);
+    if (chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155) {
+      return "ethereum";
+    }
+    if (chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA) {
+      return "solana";
+    }
+    throw index.AccountLinkingError.requestFailed(`Unsupported chain namespace "${matchedAccount.chainNamespace}" for address "${address}".`);
+  }
+  async createWalletLinkingProof(connector) {
+    // Notify listeners that the linking wallet is about to be asked for a signature so the UI
+    // (e.g. modal) can switch from a "connecting" loader to an "authorizing" prompt while the
+    // user reviews the signature request inside their wallet. Emitted on the isolated wallet
+    // connector (not the auth connector) so it doesn't mutate the global SDK status.
+    connector.emit(constants.CONNECTOR_EVENTS.AUTHORIZING, {
+      connector: connector.name
+    });
+    const {
+      challenge,
+      signature,
+      chainNamespace
+    } = await connector.generateChallengeAndSign();
+    const address = await this.getLinkingWalletAddress(connector, chainNamespace);
+    if (chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155) {
+      return {
+        address,
+        challenge,
+        signature,
+        signatureType: "eip191",
+        network: "ethereum"
+      };
+    }
+    if (chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA) {
+      return {
+        address,
+        challenge,
+        signature,
+        signatureType: "sip99",
+        network: "solana"
+      };
+    }
+    throw index.AccountLinkingError.unsupportedConnector(`Connector "${connector.name}" returned unsupported chain namespace "${chainNamespace}".`);
+  }
+  async getLinkingWalletAddress(connector, chainNamespace) {
+    if (chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA) {
+      var _connector$solanaWall3;
+      const address = (_connector$solanaWall3 = connector.solanaWallet) === null || _connector$solanaWall3 === void 0 || (_connector$solanaWall3 = _connector$solanaWall3.accounts) === null || _connector$solanaWall3 === void 0 || (_connector$solanaWall3 = _connector$solanaWall3[0]) === null || _connector$solanaWall3 === void 0 ? void 0 : _connector$solanaWall3.address;
+      if (!address) {
+        throw index.AccountLinkingError.walletProofFailed("No connected Solana account found for account linking.");
+      }
+      return address;
+    }
+    if (!connector.provider) {
+      throw index.AccountLinkingError.walletProofFailed("No connected EVM account found for account linking.");
+    }
+    const accounts = await connector.provider.request({
+      method: "eth_accounts"
+    });
+    if (!(accounts !== null && accounts !== void 0 && accounts.length)) {
+      throw index.AccountLinkingError.walletProofFailed("No connected EVM account found for account linking.");
+    }
+    return accounts[0];
+  }
+  setupSolanaWallet() {
+    const solanaChains = this.coreOptions.chains.filter(c => c.chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA);
+    if (solanaChains.length === 0 || !this.provider) return;
+    this._solanaWallet = new authSolanaWallet.AuthSolanaWallet(this.provider, solanaChains);
   }
   _getFinalPrivKey() {
     if (!this.authInstance) return "";
@@ -335,7 +706,7 @@ class AuthConnector extends baseConnector.BaseConnector {
       // when useSFAKey is set to true.
       // This is to ensure that when there is no user session active, we don't throw an exception.
       if (this.authInstance.privKey && !this.authInstance.coreKitKey) {
-        throw index$1.WalletLoginError.sfaKeyNotFound();
+        throw index.WalletLoginError.sfaKeyNotFound();
       }
       finalPrivKey = this.authInstance.coreKitKey;
     }
@@ -343,9 +714,9 @@ class AuthConnector extends baseConnector.BaseConnector {
   }
   async connectWithProvider(params) {
     var _this$authInstance, _params$extraLoginOpt, _this$authInstance2, _this$authInstance3;
-    if (!this.authInstance) throw index$1.WalletInitializationError.notReady("authInstance is not ready");
+    if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
     const chainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId);
-    if (!chainConfig) throw index$1.WalletLoginError.connectionError("Chain config is not available");
+    if (!chainConfig) throw index.WalletLoginError.connectionError("Chain config is not available");
     const {
       chainNamespace
     } = chainConfig;
@@ -371,7 +742,7 @@ class AuthConnector extends baseConnector.BaseConnector {
       if (this.authInstance.sessionId) {
         await this.authInstance.logout();
       }
-      throw index$1.WalletLoginError.sfaKeyNotFound("This typically occurs when the authentication method used does not provide SFA keys (e.g., default auth connection).");
+      throw index.WalletLoginError.sfaKeyNotFound("This typically occurs when the authentication method used does not provide SFA keys (e.g., default auth connection).");
     }
     // setup WS embed if chainNamespace is EIP155 or SOLANA
     if (chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155 || chainNamespace === baseControllers.CHAIN_NAMESPACES.SOLANA) {
@@ -382,24 +753,26 @@ class AuthConnector extends baseConnector.BaseConnector {
         sessionNamespace
       } = this.authInstance || {};
       if (sessionId) {
-        const isLoggedIn = await this.wsEmbedInstance.loginWithSessionId({
+        this.wsEmbedInstance.setAccessTokenProvider(this.accessTokenProvider.bind(this));
+        const isLoggedIn = await this.wsEmbedInstance.connectWithSession({
           sessionId,
-          sessionNamespace
+          sessionNamespace,
+          idToken: await this.getIdToken()
         });
         if (isLoggedIn) {
           var _this$wsEmbedInstance3;
-          // if getIdentityToken is true, then get the identity token
-          // No need to get the identity token for auth connector as it is already handled
-          let identityTokenInfo;
+          this.setupSolanaWallet();
+          // if getAuthTokenInfo is true, then get auth token info
+          // No need to get auth token info for auth connector as it is already handled
           this.status = constants.CONNECTOR_STATUS.CONNECTED;
           this.emit(constants.CONNECTOR_EVENTS.CONNECTED, {
-            connector: index.WALLET_CONNECTORS.AUTH,
+            connectorName: index$1.WALLET_CONNECTORS.AUTH,
             reconnected: this.rehydrated,
-            provider: this.provider,
-            identityTokenInfo
+            ethereumProvider: this.provider,
+            solanaWallet: this._solanaWallet
           });
-          if (params.getIdentityToken) {
-            identityTokenInfo = await this.getIdentityToken();
+          if (params.getAuthTokenInfo) {
+            await this.getAuthTokenInfo();
           }
           // handle disconnect from ws embed
           (_this$wsEmbedInstance3 = this.wsEmbedInstance) === null || _this$wsEmbedInstance3 === void 0 || _this$wsEmbedInstance3.provider.on("accountsChanged", (accounts = []) => {
@@ -416,9 +789,10 @@ class AuthConnector extends baseConnector.BaseConnector {
         await this.privateKeyProvider.setupProvider(finalPrivKey, params.chainId);
         this.status = constants.CONNECTOR_STATUS.CONNECTED;
         this.emit(constants.CONNECTOR_EVENTS.CONNECTED, {
-          connector: index.WALLET_CONNECTORS.AUTH,
-          reconnected: this.rehydrated,
-          provider: this.provider
+          connectorName: index$1.WALLET_CONNECTORS.AUTH,
+          ethereumProvider: this.provider,
+          solanaWallet: this._solanaWallet,
+          reconnected: this.rehydrated
         });
       }
     }
@@ -430,13 +804,16 @@ class AuthConnector extends baseConnector.BaseConnector {
       authConnectionId: params.authConnectionId,
       groupedAuthConnectionId: params.groupedAuthConnectionId
     });
-    if (!(providerConfig !== null && providerConfig !== void 0 && providerConfig.authConnection)) throw index$1.WalletLoginError.connectionError("Invalid auth connection.");
+    if (!(providerConfig !== null && providerConfig !== void 0 && providerConfig.authConnection)) throw index.WalletLoginError.connectionError("Invalid auth connection.");
     const jwtParams = _objectSpread(_objectSpread(_objectSpread({}, providerConfig.jwtParameters || {}), params.extraLoginOptions || {}), {}, {
       login_hint: params.loginHint || ((_params$extraLoginOpt3 = params.extraLoginOptions) === null || _params$extraLoginOpt3 === void 0 ? void 0 : _params$extraLoginOpt3.login_hint)
     });
-    const nonce = auth.randomId();
+    const nonce = utils$1.generateNonce();
     // post a message to the auth provider to indicate that login has been initiated.
-    const loginParams = baseControllers.cloneDeep(params);
+    const loginParams = _objectSpread(_objectSpread({}, baseControllers.cloneDeep(params)), {}, {
+      recordId: auth.generateRecordId(),
+      loginSource: "web3auth-web"
+    });
     loginParams.extraLoginOptions = _objectSpread(_objectSpread({}, loginParams.extraLoginOptions || {}), {}, {
       login_hint: params.loginHint || ((_params$extraLoginOpt4 = params.extraLoginOptions) === null || _params$extraLoginOpt4 === void 0 ? void 0 : _params$extraLoginOpt4.login_hint)
     });
@@ -459,10 +836,11 @@ class AuthConnector extends baseConnector.BaseConnector {
         version: auth.version.split(".")[0],
         web3AuthNetwork: this.coreOptions.web3AuthNetwork,
         web3AuthClientId: this.coreOptions.clientId,
-        originData: this.authInstance.options.originData ? JSON.stringify(this.authInstance.options.originData) : undefined
+        originData: this.getOriginData()
       },
       web3AuthClientId: this.coreOptions.clientId,
-      web3AuthNetwork: this.coreOptions.web3AuthNetwork
+      web3AuthNetwork: this.coreOptions.web3AuthNetwork,
+      storageServerUrl: this.authInstance.options.storageServerUrl
     };
     const loginHandler = auth.createHandler(popupParams);
     const verifierWindow = new auth.PopupHandler({
@@ -471,6 +849,9 @@ class AuthConnector extends baseConnector.BaseConnector {
     });
     if (this.authOptions.uxMode === auth.UX_MODE.REDIRECT) return verifierWindow.redirect(this.authOptions.replaceUrlOnRedirect);
     let isClosedWindow = false;
+    this.auditOAuditProgress(loginParams).catch(error => {
+      loglevel.log.error("Error reporting `oauthInitiated` audit progress", error);
+    });
     return new Promise((resolve, reject) => {
       verifierWindow.open().catch(error => {
         loglevel.log.error("Error during login with social", error);
@@ -479,7 +860,9 @@ class AuthConnector extends baseConnector.BaseConnector {
       });
       // this is to close the popup when the login is finished.
       const securePubSub$1 = new securePubSub.SecurePubSub({
-        sameIpCheck: true
+        sameIpCheck: true,
+        serverUrl: this.authInstance.options.storageServerUrl,
+        socketUrl: this.authInstance.options.sessionSocketUrl
       });
       securePubSub$1.subscribe(`web3auth-login-${nonce}`).then(data => {
         const parsedData = JSON.parse(data || "{}");
@@ -496,22 +879,61 @@ class AuthConnector extends baseConnector.BaseConnector {
       }).catch(error => {
         // swallow the error, dont need to throw.
         loglevel.log.error("Error during login with social", error);
+        this.auditOAuditProgress(loginParams, "failed").catch(error => {
+          loglevel.log.error("Error reporting `oauthFailed` audit progress", error);
+        });
       });
       verifierWindow.once("close", () => {
         if (!isClosedWindow) {
           securePubSub$1.cleanup();
           this.authInstance.postLoginCancelledMessage(nonce);
-          reject(index$1.WalletLoginError.popupClosed());
+          reject(index.WalletLoginError.popupClosed());
         }
       });
       this.authInstance.postLoginInitiatedMessage(loginParams, nonce).then(resolve).catch(error => {
-        if (error instanceof index$1.Web3AuthError) {
+        this.auditOAuditProgress(loginParams, "failed").catch(error => {
+          loglevel.log.error("Error reporting `oauthFailed` audit progress", error);
+        });
+        if (error instanceof index.Web3AuthError) {
           throw error;
         }
-        reject(index$1.WalletLoginError.connectionError(error instanceof Error ? error.message : error || "Failed to login with social"));
+        reject(index.WalletLoginError.connectionError(error instanceof Error ? error.message : error || "Failed to login with social"));
       });
     });
   }
+  async accessTokenProvider({
+    forceRefresh
+  }) {
+    if (forceRefresh) {
+      await this.authInstance.refreshSession();
+    }
+    return this.authInstance.getAccessToken();
+  }
+  async getIdToken() {
+    if (!this.authInstance) throw index.WalletInitializationError.notReady("authInstance is not ready");
+    return this.authInstance.authSessionManager.getIdToken();
+  }
+  getOriginData() {
+    try {
+      const {
+        originData,
+        redirectUrl
+      } = this.authInstance.options;
+      const origin = new URL(redirectUrl).origin;
+      if (originData) {
+        const dappOriginData = originData[origin];
+        if (dappOriginData) {
+          return JSON.stringify({
+            [origin]: dappOriginData
+          });
+        }
+      }
+      return undefined;
+    } catch (error) {
+      loglevel.log.error("Error getting origin data", error);
+      return undefined;
+    }
+  }
   connectWithJwtLogin(params) {
     var _params$extraLoginOpt5, _params$extraLoginOpt7;
     const loginConfig = this.getOAuthProviderConfig({
@@ -521,7 +943,7 @@ class AuthConnector extends baseConnector.BaseConnector {
     });
     // throw error only when we cannot find the login config and authConnectionId is not provided in the params.
     // otherwise, we will use the params to create a new auth connection config in the auth instance.
-    if (!(loginConfig !== null && loginConfig !== void 0 && loginConfig.authConnection) && !params.authConnectionId) throw index$1.WalletLoginError.connectionError("Invalid auth connection.");
+    if (!(loginConfig !== null && loginConfig !== void 0 && loginConfig.authConnection) && !params.authConnectionId) throw index.WalletLoginError.connectionError("Invalid auth connection.");
     if (!(loginConfig !== null && loginConfig !== void 0 && loginConfig.authConnection)) {
       this.authInstance.options.authConnectionConfig.push({
         authConnection: params.authConnection,
@@ -538,10 +960,10 @@ class AuthConnector extends baseConnector.BaseConnector {
     } else if ((_params$extraLoginOpt7 = params.extraLoginOptions) !== null && _params$extraLoginOpt7 !== void 0 && _params$extraLoginOpt7.id_token) {
       const {
         payload
-      } = utils.parseToken(params.extraLoginOptions.id_token);
+      } = utils$1.parseToken(params.extraLoginOptions.id_token);
       finalUserId = auth.getUserId(payload, loginParams.authConnection, finalExtraLoginOptions.userIdField, finalExtraLoginOptions.isUserIdCaseSensitive);
     } else {
-      throw index$1.WalletLoginError.connectionError("Invalid login hint or id_token");
+      throw index.WalletLoginError.connectionError("Invalid login hint or id_token");
     }
     // Adds the login_hint to the extraLoginOptions.
     loginParams.extraLoginOptions = _objectSpread(_objectSpread({}, finalExtraLoginOptions), {}, {
@@ -550,11 +972,47 @@ class AuthConnector extends baseConnector.BaseConnector {
     delete loginParams.chainId;
     return this.authInstance.postLoginInitiatedMessage(loginParams);
   }
+  async auditOAuditProgress(loginParams, status) {
+    const {
+      authConnection,
+      authConnectionId,
+      groupedAuthConnectionId,
+      recordId,
+      loginSource
+    } = loginParams;
+    const {
+      authBuildEnv = auth.BUILD_ENV.PRODUCTION,
+      web3AuthNetwork,
+      clientId
+    } = this.coreOptions;
+    const auditServerUrl = `${constants$1.CITADEL_SERVER_MAP[authBuildEnv]}/v1/auth/audit`;
+    const progressFlag = {
+      oauthInitiated: true
+    };
+    const auditPayload = _objectSpread({
+      authConnection,
+      authConnectionId,
+      groupedAuthConnectionId,
+      recordId,
+      source: loginSource,
+      web3AuthNetwork,
+      web3AuthClientId: clientId
+    }, progressFlag);
+    if (status === "failed") {
+      auditPayload.oauthFailed = true;
+    } else if (status === "completed") {
+      auditPayload.oauthCompleted = true;
+    } else {
+      auditPayload.oauthInitiated = true;
+    }
+    await httpHelpers.put(auditServerUrl, auditPayload);
+  }
 }
 const authConnector = params => {
   return ({
     projectConfig,
-    coreOptions
+    coreOptions,
+    analytics
   }) => {
     var _coreOptions$uiConfig, _coreOptions$walletSe, _coreOptions$walletSe2, _coreOptions$walletSe3;
     // Connector settings
@@ -596,9 +1054,24 @@ const authConnector = params => {
         mfaLevel: coreOptions.mfaLevel
       }),
       coreOptions,
+      analytics,
       authConnectionConfig: projectConfig.embeddedWalletAuth
     });
   };
 };
+function isAuthConnector(connector) {
+  if (!connector || connector.name !== index$1.WALLET_CONNECTORS.AUTH) {
+    return false;
+  }
+  const maybeAuthConnector = connector;
+  return typeof maybeAuthConnector.switchAccount === "function" && typeof maybeAuthConnector.linkAccount === "function" && typeof maybeAuthConnector.unlinkAccount === "function";
+}
+function assertAuthConnector(connector, errorMessage = "Account linking is only supported when connected with the AUTH connector.") {
+  if (!isAuthConnector(connector)) {
+    throw index.WalletLoginError.unsupportedOperation(errorMessage);
+  }
+}
 
+exports.assertAuthConnector = assertAuthConnector;
 exports.authConnector = authConnector;
+exports.isAuthConnector = isAuthConnector;