@web3auth/no-modal 10.0.0-alpha.1 → 10.0.0-alpha.2

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

@@ -1,16 +1,21 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { LOGIN_PROVIDER, UX_MODE, WEB3AUTH_NETWORK, Auth, SUPPORTED_KEY_CURVES } from '@web3auth/auth';
+import { SecurePubSub } from '@toruslabs/secure-pub-sub';
+import { BUILD_ENV, UX_MODE, Auth, SDK_MODE, SUPPORTED_KEY_CURVES, randomId, createHandler, PopupHandler } from '@web3auth/auth';
 import deepmerge from 'deepmerge';
-import { CONNECTOR_NAMESPACES, CHAIN_NAMESPACES } from '../../base/chain/IChainInterface.js';
 import { WalletInitializationError, WalletLoginError, Web3AuthError } from '../../base/errors/index.js';
+import { CONNECTOR_NAMESPACES } from '../../base/chain/IChainInterface.js';
+import { BaseConnector } from '../../base/connector/baseConnector.js';
+import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import 'jwt-decode';
 import { log } from '../../base/loglevel.js';
-import { cloneDeep } from '@toruslabs/base-controllers';
+import '../../base/plugin/errors.js';
+import '../../base/plugin/IPlugin.js';
+import { cloneDeep, CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
 import '@toruslabs/constants';
 import '@toruslabs/http-helpers';
 import { WALLET_CONNECTORS } from '../../base/wallet/index.js';
-import { BaseConnector } from '../../base/connector/baseConnector.js';
-import { CONNECTOR_CATEGORY, CONNECTOR_STATUS, CONNECTOR_EVENTS } from '../../base/connector/constants.js';
+import { getAuthConnectionConfig } from './config/authConnectionConfig.js';
 
 class AuthConnector extends BaseConnector {
   constructor(params) {
@@ -23,15 +28,17 @@ class AuthConnector extends BaseConnector {
     _defineProperty(this, "privateKeyProvider", null);
     _defineProperty(this, "authOptions", void 0);
     _defineProperty(this, "loginSettings", {
-      loginProvider: ""
+      authConnection: ""
     });
-    _defineProperty(this, "wsSettings", {});
+    _defineProperty(this, "wsSettings", void 0);
     _defineProperty(this, "wsEmbedInstance", null);
+    _defineProperty(this, "authConnectionConfig", []);
     this.authOptions = params.connectorSettings;
     this.loginSettings = params.loginSettings || {
-      loginProvider: ""
+      authConnection: ""
     };
     this.wsSettings = params.walletServicesSettings || {};
+    this.authConnectionConfig = params.authConnectionConfig || [];
   }
   get provider() {
     if (this.status !== CONNECTOR_STATUS.NOT_READY) {
@@ -49,7 +56,13 @@ class AuthConnector extends BaseConnector {
     throw new Error("Not implemented");
   }
   async init(options) {
-    const chainConfig = this.coreOptions.chains.find(x => x.chainId === options.chainId);
+    const {
+      chains
+    } = this.coreOptions;
+    const {
+      chainId
+    } = options;
+    const chainConfig = chains.find(x => x.chainId === chainId);
     super.checkInitializationRequirements({
       chainConfig
     });
@@ -60,14 +73,14 @@ class AuthConnector extends BaseConnector {
       replaceUrlOnRedirect: isRedirectResult,
       useCoreKitKey: this.coreOptions.useCoreKitKey
     });
-    const web3AuthNetwork = this.coreOptions.web3AuthNetwork || WEB3AUTH_NETWORK.SAPPHIRE_MAINNET;
     this.authInstance = new Auth(_objectSpread(_objectSpread({}, this.authOptions), {}, {
       clientId: this.coreOptions.clientId,
-      network: web3AuthNetwork
+      network: this.coreOptions.web3AuthNetwork,
+      sdkMode: SDK_MODE.IFRAME,
+      authConnectionConfig: this.authConnectionConfig
     }));
-    log.debug("initializing auth connector init");
+    log.debug("initializing auth connector init", this.authOptions);
     await this.authInstance.init();
-
     // Use this for xrpl, mpc cases
     if (this.coreOptions.privateKeyProvider) {
       this.privateKeyProvider = this.coreOptions.privateKeyProvider;
@@ -82,13 +95,13 @@ class AuthConnector extends BaseConnector {
             } = await import('@web3auth/ws-embed');
             this.wsEmbedInstance = new WsEmbed({
               web3AuthClientId: this.coreOptions.clientId,
-              web3AuthNetwork,
+              web3AuthNetwork: this.coreOptions.web3AuthNetwork,
               modalZIndex: this.wsSettings.modalZIndex
             });
-            // TODO: once support multiple chains, only pass chains of solana and EVM
+            const wsSupportedChains = chains.filter(x => x.chainNamespace === CHAIN_NAMESPACES.EIP155 || x.chainNamespace === CHAIN_NAMESPACES.SOLANA);
             await this.wsEmbedInstance.init(_objectSpread(_objectSpread({}, this.wsSettings), {}, {
-              chainConfig: chainConfig,
-              // TODO: upgrade ws-embed to support custom chain config
+              chains: wsSupportedChains,
+              chainId,
               whiteLabel: _objectSpread(_objectSpread({}, this.authOptions.whiteLabel), this.wsSettings.whiteLabel)
             }));
             break;
@@ -138,11 +151,12 @@ class AuthConnector extends BaseConnector {
       await this.connectWithProvider(params);
       return this.provider;
     } catch (error) {
+      var _error$message;
       log.error("Failed to connect with auth provider", error);
       // ready again to be connected
       this.status = CONNECTOR_STATUS.READY;
       this.emit(CONNECTOR_EVENTS.ERRORED, error);
-      if (error !== null && error !== void 0 && error.message.includes("user closed popup")) {
+      if (error !== null && error !== void 0 && (_error$message = error.message) !== null && _error$message !== void 0 && _error$message.includes("user closed popup")) {
         throw WalletLoginError.popupClosed();
       } else if (error instanceof Web3AuthError) {
         throw error;
@@ -151,7 +165,7 @@ class AuthConnector extends BaseConnector {
     }
   }
   async enableMFA(params = {
-    loginProvider: ""
+    authConnection: ""
   }) {
     if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet");
     if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
@@ -166,7 +180,7 @@ class AuthConnector extends BaseConnector {
     }
   }
   async manageMFA(params = {
-    loginProvider: ""
+    authConnection: ""
   }) {
     if (this.status !== CONNECTOR_STATUS.CONNECTED) throw WalletLoginError.notConnectedError("Not connected with wallet");
     if (!this.authInstance) throw WalletInitializationError.notReady("authInstance is not ready");
@@ -213,7 +227,6 @@ class AuthConnector extends BaseConnector {
     const userInfo = this.authInstance.getUserInfo();
     return userInfo;
   }
-
   // we don't support switching between different namespaces, except for solana and evm
   async switchChain(params, init = false) {
     super.checkSwitchChainRequirements(params, init);
@@ -230,7 +243,6 @@ class AuthConnector extends BaseConnector {
     const {
       chainNamespace: newNamespace
     } = this.getChain(newChainId);
-
     // skip if chainId is the same
     if (currentChainId === newChainId) return;
     if (currentNamespace === CHAIN_NAMESPACES.SOLANA || currentNamespace === CHAIN_NAMESPACES.EIP155) {
@@ -277,21 +289,19 @@ class AuthConnector extends BaseConnector {
     const {
       chainNamespace
     } = chainConfig;
-
     // if not logged in then login
     const keyAvailable = chainNamespace === CHAIN_NAMESPACES.EIP155 || chainNamespace === CHAIN_NAMESPACES.SOLANA ? (_this$authInstance = this.authInstance) === null || _this$authInstance === void 0 ? void 0 : _this$authInstance.sessionId : this._getFinalPrivKey();
     if (!keyAvailable || (_params$extraLoginOpt = params.extraLoginOptions) !== null && _params$extraLoginOpt !== void 0 && _params$extraLoginOpt.id_token) {
       var _params$extraLoginOpt2;
       // always use "other" curve to return token with all keys encoded so wallet service can switch between evm and solana namespace
       this.loginSettings.curve = SUPPORTED_KEY_CURVES.OTHER;
-      if (!params.loginProvider && !this.loginSettings.loginProvider) throw WalletInitializationError.invalidParams("loginProvider is required for login");
-      await this.authInstance.login(deepmerge.all([this.loginSettings, params, {
-        extraLoginOptions: _objectSpread(_objectSpread({}, params.extraLoginOptions || {}), {}, {
-          login_hint: params.login_hint || ((_params$extraLoginOpt2 = params.extraLoginOptions) === null || _params$extraLoginOpt2 === void 0 ? void 0 : _params$extraLoginOpt2.login_hint)
-        })
-      }]));
+      const loginParams = deepmerge(this.loginSettings, params);
+      if ((_params$extraLoginOpt2 = params.extraLoginOptions) !== null && _params$extraLoginOpt2 !== void 0 && _params$extraLoginOpt2.id_token) {
+        await this.connectWithJwtLogin(loginParams);
+      } else {
+        await this.connectWithSocialLogin(loginParams);
+      }
     }
-
     // setup WS embed if chainNamespace is EIP155 or SOLANA
     if (chainNamespace === CHAIN_NAMESPACES.EIP155 || chainNamespace === CHAIN_NAMESPACES.SOLANA) {
       const {
@@ -333,6 +343,117 @@ class AuthConnector extends BaseConnector {
       }
     }
   }
+  async connectWithSocialLogin(params) {
+    var _params$extraLoginOpt3, _params$extraLoginOpt4;
+    const providerConfig = this.getOAuthProviderConfig({
+      authConnection: params.authConnection,
+      authConnectionId: params.authConnectionId,
+      groupedAuthConnectionId: params.groupedAuthConnectionId
+    });
+    if (!(providerConfig !== null && providerConfig !== void 0 && providerConfig.authConnection)) throw WalletLoginError.connectionError("Login provider is not available");
+    const jwtParams = _objectSpread(_objectSpread(_objectSpread({}, providerConfig.jwtParameters), params.extraLoginOptions || {}), {}, {
+      login_hint: params.login_hint || ((_params$extraLoginOpt3 = params.extraLoginOptions) === null || _params$extraLoginOpt3 === void 0 ? void 0 : _params$extraLoginOpt3.login_hint)
+    });
+    const nonce = randomId();
+    // post a message to the auth provider to indicate that login has been initiated.
+    const loginParams = cloneDeep(params);
+    loginParams.extraLoginOptions = _objectSpread(_objectSpread({}, loginParams.extraLoginOptions || {}), {}, {
+      login_hint: params.login_hint || ((_params$extraLoginOpt4 = params.extraLoginOptions) === null || _params$extraLoginOpt4 === void 0 ? void 0 : _params$extraLoginOpt4.login_hint)
+    });
+    delete loginParams.chainId;
+    const popupParams = {
+      authConnection: params.authConnection,
+      authConnectionId: providerConfig.authConnectionId,
+      clientId: providerConfig.clientId,
+      groupedAuthConnectionId: providerConfig.groupedAuthConnectionId,
+      redirect_uri: `${this.authInstance.baseUrl}/auth`,
+      jwtParams,
+      customState: {
+        nonce,
+        dapp_redirect_url: this.authOptions.redirectUrl,
+        appState: params.appState,
+        uxMode: this.authOptions.uxMode,
+        whiteLabel: JSON.stringify(this.authOptions.whiteLabel),
+        loginParams: JSON.stringify(loginParams)
+      },
+      web3AuthClientId: this.coreOptions.clientId,
+      web3AuthNetwork: this.coreOptions.web3AuthNetwork
+    };
+    const loginHandler = createHandler(popupParams);
+    const verifierWindow = new PopupHandler({
+      url: loginHandler.finalURL,
+      timeout: 0
+    });
+    if (this.authOptions.uxMode === UX_MODE.REDIRECT) return verifierWindow.redirect(this.authOptions.replaceUrlOnRedirect);
+    let isClosedWindow = false;
+    return new Promise((resolve, reject) => {
+      verifierWindow.open().catch(error => {
+        log.error("Error during login with social", error);
+        this.authInstance.postLoginCancelledMessage(nonce);
+        reject(error);
+      });
+      // this is to close the popup when the login is finished.
+      const securePubSub = new SecurePubSub({
+        sameIpCheck: true
+      });
+      securePubSub.subscribe(`web3auth-login-${nonce}`).then(data => {
+        const parsedData = JSON.parse(data || "{}");
+        if ((parsedData === null || parsedData === void 0 ? void 0 : parsedData.message) === "login_finished") {
+          if (parsedData !== null && parsedData !== void 0 && parsedData.error) {
+            this.authInstance.postLoginCancelledMessage(nonce);
+            reject(parsedData.error);
+          }
+          isClosedWindow = true;
+          securePubSub.cleanup();
+          verifierWindow.close();
+        }
+        return true;
+      }).catch(error => {
+        // swallow the error, dont need to throw.
+        log.error("Error during login with social", error);
+      });
+      verifierWindow.once("close", () => {
+        if (!isClosedWindow) {
+          securePubSub.cleanup();
+          this.authInstance.postLoginCancelledMessage(nonce);
+          reject(WalletLoginError.popupClosed());
+        }
+      });
+      this.authInstance.postLoginInitiatedMessage(loginParams, nonce).then(resolve).catch(reject);
+    });
+  }
+  connectWithJwtLogin(params) {
+    var _params$extraLoginOpt5;
+    const loginConfig = this.getOAuthProviderConfig({
+      authConnection: params.authConnection,
+      authConnectionId: params.authConnectionId,
+      groupedAuthConnectionId: params.groupedAuthConnectionId
+    });
+    if (!(loginConfig !== null && loginConfig !== void 0 && loginConfig.authConnection)) throw WalletLoginError.connectionError("Login provider is not available");
+    const loginParams = cloneDeep(params);
+    loginParams.extraLoginOptions = _objectSpread(_objectSpread({}, loginParams.extraLoginOptions || {}), {}, {
+      login_hint: params.login_hint || ((_params$extraLoginOpt5 = params.extraLoginOptions) === null || _params$extraLoginOpt5 === void 0 ? void 0 : _params$extraLoginOpt5.login_hint)
+    });
+    delete loginParams.chainId;
+    return this.authInstance.postLoginInitiatedMessage(loginParams);
+  }
+  getOAuthProviderConfig(params) {
+    const {
+      authConnection,
+      authConnectionId,
+      groupedAuthConnectionId
+    } = params;
+    const providerConfig = this.authConnectionConfig.find(x => {
+      if (groupedAuthConnectionId) {
+        return x.authConnection === authConnection && x.groupedAuthConnectionId === groupedAuthConnectionId;
+      }
+      if (authConnectionId) {
+        return x.authConnection === authConnection && x.authConnectionId === authConnectionId;
+      }
+      return x.authConnection === authConnection;
+    });
+    return providerConfig;
+  }
 }
 const authConnector = params => {
   return ({
@@ -343,46 +464,36 @@ const authConnector = params => {
     // Connector settings
     const connectorSettings = {};
     const {
-      sms_otp_enabled: smsOtpEnabled,
-      whitelist
+      whitelist,
+      whitelabel
     } = projectConfig;
-    if (smsOtpEnabled !== undefined) {
-      connectorSettings.loginConfig = {
-        [LOGIN_PROVIDER.SMS_PASSWORDLESS]: {
-          showOnModal: smsOtpEnabled,
-          showOnDesktop: smsOtpEnabled,
-          showOnMobile: smsOtpEnabled,
-          showOnSocialBackupFactor: smsOtpEnabled
-        }
-      };
-    }
     if (whitelist) connectorSettings.originData = whitelist.signed_urls;
     if ((_coreOptions$uiConfig = coreOptions.uiConfig) !== null && _coreOptions$uiConfig !== void 0 && _coreOptions$uiConfig.uxMode) connectorSettings.uxMode = coreOptions.uiConfig.uxMode;
-    const uiConfig = deepmerge(cloneDeep((projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.whitelabel) || {}), coreOptions.uiConfig || {});
+    const uiConfig = deepmerge(cloneDeep(whitelabel || {}), coreOptions.uiConfig || {});
     if (!uiConfig.mode) uiConfig.mode = "light";
     connectorSettings.whiteLabel = uiConfig;
     const finalConnectorSettings = deepmerge.all([{
-      uxMode: UX_MODE.POPUP
+      uxMode: UX_MODE.POPUP,
+      buildEnv: BUILD_ENV.PRODUCTION
     },
     // default settings
     (params === null || params === void 0 ? void 0 : params.connectorSettings) || {}, connectorSettings]);
-
     // WS settings
     const isKeyExportEnabled = typeof projectConfig.key_export_enabled === "boolean" ? projectConfig.key_export_enabled : true;
     const finalWsSettings = _objectSpread(_objectSpread({}, coreOptions.walletServicesConfig), {}, {
       whiteLabel: _objectSpread(_objectSpread({}, uiConfig), (_coreOptions$walletSe = coreOptions.walletServicesConfig) === null || _coreOptions$walletSe === void 0 ? void 0 : _coreOptions$walletSe.whiteLabel),
       accountAbstractionConfig: coreOptions.accountAbstractionConfig,
       enableLogging: coreOptions.enableLogging
-      // enableKeyExport: keyExportEnabled, TODO: add this to ws embed and implement in WS
+      // enableKeyExport: keyExportEnabled,
     });
-
     // Core options
     if (coreOptions.privateKeyProvider) coreOptions.privateKeyProvider.setKeyExportFlag(isKeyExportEnabled);
     return new AuthConnector({
       connectorSettings: finalConnectorSettings,
       walletServicesSettings: finalWsSettings,
       loginSettings: params === null || params === void 0 ? void 0 : params.loginSettings,
-      coreOptions
+      coreOptions,
+      authConnectionConfig: getAuthConnectionConfig(finalConnectorSettings.buildEnv, coreOptions.web3AuthNetwork)
     });
   };
 };

package/dist/lib.esm/connectors/auth-connector/config/authConnectionConfig.js

@@ -0,0 +1,214 @@
+import { AUTH_CONNECTION, EMAIL_FLOW } from '@web3auth/auth';
+import { configBuild } from './config-build.js';
+import { configEnv } from './config-env.js';
+
+const getAuthConnectionConfig = (environment, network) => {
+  const currentConfigEnv = configEnv[network];
+  const currentBuildEnv = configBuild[environment];
+  if (!currentConfigEnv || !currentBuildEnv) {
+    throw new Error("Invalid environment settings");
+  }
+  return [{
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.googleVerifier,
+    authConnection: AUTH_CONNECTION.GOOGLE,
+    name: AUTH_CONNECTION.GOOGLE,
+    description: "login.verifier-google-desc",
+    clientId: currentConfigEnv.googleClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.googleVerifier : "",
+    mainOption: true,
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletGoogleVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.facebookVerifier,
+    authConnection: AUTH_CONNECTION.FACEBOOK,
+    name: AUTH_CONNECTION.FACEBOOK,
+    description: "",
+    clientId: currentConfigEnv.facebookClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.facebookVerifier : "",
+    mainOption: true,
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletFacebookVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.twitterVerifier,
+    authConnection: AUTH_CONNECTION.TWITTER,
+    name: AUTH_CONNECTION.TWITTER,
+    description: "",
+    clientId: currentConfigEnv.twitterClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.twitterVerifier : "",
+    mainOption: true,
+    jwtParameters: {
+      domain: currentConfigEnv.loginDomain,
+      connection: "twitter",
+      isUserIdCaseSensitive: false
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletTwitterVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.discordVerifier,
+    authConnection: AUTH_CONNECTION.DISCORD,
+    name: AUTH_CONNECTION.DISCORD,
+    description: "",
+    clientId: currentConfigEnv.discordClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.discordVerifier : "",
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletDiscordVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.lineVerifier,
+    authConnection: AUTH_CONNECTION.LINE,
+    name: AUTH_CONNECTION.LINE,
+    description: "",
+    clientId: currentConfigEnv.lineClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.lineVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentConfigEnv.loginDomain,
+      connection: "line",
+      prompt: "consent"
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletLineVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.redditVerifier,
+    authConnection: AUTH_CONNECTION.REDDIT,
+    name: AUTH_CONNECTION.REDDIT,
+    description: "",
+    clientId: currentConfigEnv.redditClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.redditVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentConfigEnv.loginDomain,
+      userIdField: "name",
+      connection: "Reddit"
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletRedditVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.appleVerifier,
+    authConnection: AUTH_CONNECTION.APPLE,
+    name: AUTH_CONNECTION.APPLE,
+    description: "",
+    clientId: currentConfigEnv.appleClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.appleVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentConfigEnv.loginDomain,
+      connection: "apple"
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletAppleVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.githubVerifier,
+    authConnection: AUTH_CONNECTION.GITHUB,
+    description: "",
+    name: AUTH_CONNECTION.GITHUB,
+    clientId: currentConfigEnv.githubClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.githubVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentConfigEnv.loginDomain,
+      connection: "github",
+      isUserIdCaseSensitive: false
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletGithubVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.twitchVerifier,
+    authConnection: AUTH_CONNECTION.TWITCH,
+    description: "",
+    name: AUTH_CONNECTION.TWITCH,
+    clientId: currentConfigEnv.twitchClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.twitchVerifier : "",
+    mainOption: false,
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletTwitchVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.linkedinVerifier,
+    authConnection: AUTH_CONNECTION.LINKEDIN,
+    description: "",
+    name: AUTH_CONNECTION.LINKEDIN,
+    clientId: currentConfigEnv.linkedinClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.linkedinVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentConfigEnv.loginDomain,
+      connection: "linkedin"
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletLinkedinVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.wechatVerifier,
+    authConnection: AUTH_CONNECTION.WECHAT,
+    description: "",
+    name: AUTH_CONNECTION.WECHAT,
+    clientId: currentConfigEnv.wechatClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.wechatVerifier : "",
+    mainOption: false,
+    showOnSocialBackupFactor: true,
+    jwtParameters: {
+      domain: currentConfigEnv.loginDomain,
+      connection: "Wechat"
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletWechatVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.kakaoVerifier,
+    authConnection: AUTH_CONNECTION.KAKAO,
+    description: "",
+    name: AUTH_CONNECTION.KAKAO,
+    clientId: currentConfigEnv.kakaoClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.kakaoVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentConfigEnv.loginDomain,
+      connection: "Kakao"
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletKakaoVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.hostedEmailPasswordlessVerifier,
+    description: "login.verifier-email-desc",
+    authConnection: AUTH_CONNECTION.EMAIL_PASSWORDLESS,
+    name: "email",
+    clientId: currentConfigEnv.hostedEmailPasswordlessClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.hostedEmailPasswordlessVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentBuildEnv.passwordlessHost,
+      userIdField: "name",
+      isUserIdCaseSensitive: false,
+      flow_type: EMAIL_FLOW.code
+    },
+    // For torus only
+    walletAuthConnectionId: currentConfigEnv.walletHostedEmailPasswordlessVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.hostedSmsPasswordlessVerifier,
+    description: "login.verifier-sms-desc-2",
+    authConnection: AUTH_CONNECTION.SMS_PASSWORDLESS,
+    name: "mobile",
+    clientId: currentConfigEnv.hostedSmsPasswordlessClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.hostedSmsPasswordlessVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentBuildEnv.passwordlessHost,
+      userIdField: "name",
+      isVerifierIdCaseSensitive: false
+    },
+    // for torus only.
+    walletAuthConnectionId: currentConfigEnv.walletHostedSmsPasswordlessVerifier
+  }, {
+    authConnectionId: currentConfigEnv.verifierSubIdentifier || currentConfigEnv.hostedFarcasterVerifier,
+    description: "",
+    authConnection: AUTH_CONNECTION.FARCASTER,
+    name: "Farcaster",
+    clientId: currentConfigEnv.hostedFarcasterClientId,
+    groupedAuthConnectionId: currentConfigEnv.verifierSubIdentifier ? currentConfigEnv.hostedFarcasterVerifier : "",
+    mainOption: false,
+    jwtParameters: {
+      domain: currentConfigEnv.farcasterLoginDomain
+    },
+    // For torus only
+    walletAuthConnectionId: ""
+  }];
+};
+
+export { getAuthConnectionConfig };

package/dist/lib.esm/connectors/auth-connector/config/config-build.js

@@ -0,0 +1,48 @@
+import { BUILD_ENV } from '@web3auth/auth';
+
+// Passwordless backend service
+const PASSWORDLESS_SERVER_API_URL = "https://api.web3auth.io/passwordless-service";
+const DEVELOP_PASSWORDLESS_SERVER_API_URL = "https://api-develop.web3auth.io/passwordless-service";
+// Auth backend service
+const AUTH_SERVER_URL = "https://api.web3auth.io/auth-service";
+const DEVELOP_AUTH_SERVER_URL = "https://api-develop.web3auth.io/auth-service";
+const configBuild = {
+  [BUILD_ENV.DEVELOPMENT]: {
+    apiHost: `${DEVELOP_AUTH_SERVER_URL}`,
+    logLevel: "debug",
+    passwordlessBackendHost: `${DEVELOP_PASSWORDLESS_SERVER_API_URL}/api/v3/`,
+    passwordlessHost: "https://develop-passwordless.web3auth.io",
+    sentrySampleRate: "0",
+    sentryTransactionSampleRate: "0",
+    supportsVersioning: false
+  },
+  [BUILD_ENV.STAGING]: {
+    apiHost: AUTH_SERVER_URL,
+    logLevel: "debug",
+    passwordlessBackendHost: `${PASSWORDLESS_SERVER_API_URL}/api/v3/`,
+    passwordlessHost: "https://staging-passwordless.web3auth.io/v6",
+    sentrySampleRate: "0.1",
+    sentryTransactionSampleRate: "0.1",
+    supportsVersioning: true
+  },
+  [BUILD_ENV.PRODUCTION]: {
+    apiHost: AUTH_SERVER_URL,
+    logLevel: "error",
+    passwordlessBackendHost: `${PASSWORDLESS_SERVER_API_URL}/api/v3/`,
+    passwordlessHost: "https://passwordless.web3auth.io/v6",
+    sentrySampleRate: "0.5",
+    sentryTransactionSampleRate: "0.001",
+    supportsVersioning: true
+  },
+  [BUILD_ENV.TESTING]: {
+    apiHost: DEVELOP_AUTH_SERVER_URL,
+    logLevel: "debug",
+    passwordlessBackendHost: `${DEVELOP_PASSWORDLESS_SERVER_API_URL}/api/v3/`,
+    passwordlessHost: "https://develop-passwordless.web3auth.io",
+    sentrySampleRate: "1",
+    sentryTransactionSampleRate: "0.1",
+    supportsVersioning: false
+  }
+};
+
+export { AUTH_SERVER_URL, DEVELOP_AUTH_SERVER_URL, DEVELOP_PASSWORDLESS_SERVER_API_URL, PASSWORDLESS_SERVER_API_URL, configBuild };