@web3auth/no-modal 10.0.0-alpha.2 → 10.0.0-beta.0

package/dist/lib.cjs/noModal.js

@@ -1,12 +1,13 @@
 'use strict';
 
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var auth = require('@web3auth/auth');
+var deepmerge = require('deepmerge');
 var authConnector = require('./connectors/auth-connector/authConnector.js');
-var config = require('./base/chain/config.js');
-var IChainInterface = require('./base/chain/IChainInterface.js');
 var index = require('./base/errors/index.js');
+var IChainInterface = require('./base/chain/IChainInterface.js');
 var index$1 = require('./base/wallet/index.js');
 var constants = require('./base/connector/constants.js');
 var utils$1 = require('./base/connector/utils.js');
@@ -18,7 +19,9 @@ var baseControllers = require('@toruslabs/base-controllers');
 require('./providers/base-provider/utils.js');
 var CommonJRPCProvider = require('./providers/base-provider/CommonJRPCProvider.js');
 require('./providers/base-provider/commonPrivateKeyProvider.js');
+var metamaskConnector = require('./connectors/metamask-connector/metamaskConnector.js');
 
+const _excluded = ["walletScope"];
 const CONNECTOR_CACHE_KEY = "Web3Auth-cachedConnector";
 const CURRENT_CHAIN_CACHE_KEY = "Web3Auth-currentChain";
 class Web3AuthNoModal extends auth.SafeEventEmitter {
@@ -35,25 +38,13 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     _defineProperty(this, "storage", "localStorage");
     if (!options.clientId) throw index.WalletInitializationError.invalidParams("Please provide a valid clientId in constructor");
     if (options.enableLogging) loglevel.log.enableAll();else loglevel.log.setLevel("error");
-    // TODO: This is fine. we get chains from project config. we can throw in init instead
-    if (!options.chains || options.chains.length === 0) {
-      throw index.WalletInitializationError.invalidParams("Please provide chains");
-    }
-    const {
-      chains
-    } = options;
-    // validate chain namespace of each chain config
-    for (const chain of chains) {
-      if (!chain.chainNamespace || !Object.values(baseControllers.CHAIN_NAMESPACES).includes(chain.chainNamespace)) throw index.WalletInitializationError.invalidParams("Please provide a valid chainNamespace in chains");
-    }
     if (options.storageType === "session") this.storage = "sessionStorage";
-    this.coreOptions = _objectSpread(_objectSpread({}, options), {}, {
-      chains: chains.map(chain => _objectSpread(_objectSpread({}, config.getChainConfig(chain === null || chain === void 0 ? void 0 : chain.chainNamespace, chain === null || chain === void 0 ? void 0 : chain.chainId, options.clientId) || {}), chain))
-    });
-    this.currentChainId = options.defaultChainId || chains[0].chainId;
+    this.coreOptions = options;
+    this.currentChainId = options.defaultChainId;
   }
   get currentChain() {
-    return this.coreOptions.chains.find(chain => chain.chainId === this.currentChainId);
+    var _this$coreOptions$cha;
+    return (_this$coreOptions$cha = this.coreOptions.chains) === null || _this$coreOptions$cha === void 0 ? void 0 : _this$coreOptions$cha.find(chain => chain.chainId === this.currentChainId);
   }
   get connected() {
     return Boolean(this.connectedConnector);
@@ -72,7 +63,6 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     throw new Error("Not implemented");
   }
   async init() {
-    this.initCachedConnectorAndChainId();
     // get project config
     let projectConfig;
     try {
@@ -82,6 +72,10 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       loglevel.log.error("Failed to fetch project configurations", e);
       throw index.WalletInitializationError.notReady("failed to fetch project configurations", e);
     }
+    // init config
+    this.initAccountAbstractionConfig(projectConfig);
+    this.initChainsConfig(projectConfig);
+    this.initCachedConnectorAndChainId();
     // setup common JRPC provider
     await this.setupCommonJRPCProvider();
     // initialize connectors
@@ -118,7 +112,8 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
     this.cachedConnector = null;
   }
   async switchChain(params) {
-    if (params.chainId === this.currentChain.chainId) return;
+    var _this$currentChain2;
+    if (params.chainId === ((_this$currentChain2 = this.currentChain) === null || _this$currentChain2 === void 0 ? void 0 : _this$currentChain2.chainId)) return;
     const newChainConfig = this.coreOptions.chains.find(x => x.chainId === params.chainId);
     if (!newChainConfig) throw index.WalletInitializationError.invalidParams("Invalid chainId");
     if (this.status === constants.CONNECTOR_STATUS.CONNECTED && this.connectedConnector) {
@@ -184,6 +179,89 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
   getPlugin(name) {
     return this.plugins[name] || null;
   }
+  initChainsConfig(projectConfig) {
+    // merge chains from project config with core options, core options chains will take precedence over project config chains
+    const chainMap = new Map();
+    const allChains = [...(projectConfig.chains || []), ...(this.coreOptions.chains || [])];
+    for (const chain of allChains) {
+      const existingChain = chainMap.get(chain.chainId);
+      if (!existingChain) chainMap.set(chain.chainId, chain);else chainMap.set(chain.chainId, _objectSpread(_objectSpread({}, existingChain), chain));
+    }
+    this.coreOptions.chains = Array.from(chainMap.values());
+    // validate chains and namespaces
+    if (this.coreOptions.chains.length === 0) {
+      loglevel.log.error("chain info not found. Please configure chains on dashboard at https://dashboard.web3auth.io");
+      throw index.WalletInitializationError.invalidParams("Please configure chains on dashboard at https://dashboard.web3auth.io");
+    }
+    const validChainNamespaces = new Set(Object.values(baseControllers.CHAIN_NAMESPACES));
+    for (const chain of this.coreOptions.chains) {
+      if (!chain.chainNamespace || !validChainNamespaces.has(chain.chainNamespace)) {
+        loglevel.log.error(`Please provide a valid chainNamespace in chains for chain ${chain.chainId}`);
+        throw index.WalletInitializationError.invalidParams(`Please provide a valid chainNamespace in chains for chain ${chain.chainId}`);
+      }
+      if (chain.chainNamespace !== baseControllers.CHAIN_NAMESPACES.OTHER && !utils.isHexStrict(chain.chainId)) {
+        loglevel.log.error(`Please provide a valid chainId in chains for chain ${chain.chainId}`);
+        throw index.WalletInitializationError.invalidParams(`Please provide a valid chainId as hex string in chains for chain ${chain.chainId}`);
+      }
+      if (chain.chainNamespace !== baseControllers.CHAIN_NAMESPACES.OTHER) {
+        try {
+          new URL(chain.rpcTarget);
+        } catch (error) {
+          // TODO: add support for chain.wsTarget
+          loglevel.log.error(`Please provide a valid rpcTarget in chains for chain ${chain.chainId}`, error);
+          throw index.WalletInitializationError.invalidParams(`Please provide a valid rpcTarget in chains for chain ${chain.chainId}`);
+        }
+      }
+    }
+    // if AA is enabled, filter out chains that are not AA-supported
+    if (this.coreOptions.accountAbstractionConfig) {
+      // write a for loop over accountAbstractionConfig.chains and check if the chainId is valid
+      for (const chain of this.coreOptions.accountAbstractionConfig.chains) {
+        if (!utils.isHexStrict(chain.chainId)) {
+          loglevel.log.error(`Please provide a valid chainId in accountAbstractionConfig.chains for chain ${chain.chainId}`);
+          throw index.WalletInitializationError.invalidParams(`Please provide a valid chainId in accountAbstractionConfig.chains for chain ${chain.chainId}`);
+        }
+        try {
+          var _chain$bundlerConfig;
+          new URL((_chain$bundlerConfig = chain.bundlerConfig) === null || _chain$bundlerConfig === void 0 ? void 0 : _chain$bundlerConfig.url);
+        } catch (error) {
+          loglevel.log.error(`Please provide a valid bundlerConfig.url in accountAbstractionConfig.chains for chain ${chain.chainId}`, error);
+          throw index.WalletInitializationError.invalidParams(`Please provide a valid bundlerConfig.url in accountAbstractionConfig.chains for chain ${chain.chainId}`);
+        }
+        if (!chainMap.has(chain.chainId)) {
+          loglevel.log.error(`Please provide chain config for AA chain in accountAbstractionConfig.chains for chain ${chain.chainId}`);
+          throw index.WalletInitializationError.invalidParams(`Please provide chain config for AA chain in accountAbstractionConfig.chains for chain ${chain.chainId}`);
+        }
+      }
+      // const aaSupportedChainIds = new Set(
+      //   this.coreOptions.accountAbstractionConfig?.chains
+      //     ?.filter((chain) => chain.chainId && chain.bundlerConfig?.url)
+      //     .map((chain) => chain.chainId) || []
+      // );
+      // this.coreOptions.chains = this.coreOptions.chains.filter(
+      //   (chain) => chain.chainNamespace !== CHAIN_NAMESPACES.EIP155 || aaSupportedChainIds.has(chain.chainId)
+      // );
+      // if (this.coreOptions.chains.length === 0) {
+      //   log.error("Account Abstraction is enabled but no supported chains found");
+      //   throw WalletInitializationError.invalidParams("Account Abstraction is enabled but no supported chains found");
+      // }
+    }
+  }
+  initAccountAbstractionConfig(projectConfig) {
+    const isAAEnabled = Boolean(this.coreOptions.accountAbstractionConfig || (projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.smartAccounts));
+    if (!isAAEnabled) return;
+    // merge project config with core options, code config take precedence over project config
+    const _ref = (projectConfig === null || projectConfig === void 0 ? void 0 : projectConfig.smartAccounts) || {},
+      {
+        walletScope
+      } = _ref,
+      configWithoutWalletScope = _objectWithoutProperties(_ref, _excluded);
+    this.coreOptions.accountAbstractionConfig = deepmerge(configWithoutWalletScope || {}, this.coreOptions.accountAbstractionConfig || {});
+    // determine if we should use AA with external wallet
+    if (this.coreOptions.useAAWithExternalWallet === undefined) {
+      this.coreOptions.useAAWithExternalWallet = walletScope === constants.SMART_ACCOUNT_WALLET_SCOPE.ALL;
+    }
+  }
   initCachedConnectorAndChainId() {
     this.cachedConnector = utils$1.storageAvailable(this.storage) ? window[this.storage].getItem(CONNECTOR_CACHE_KEY) : null;
     // init chainId using cached chainId if it exists and is valid, otherwise use the defaultChainId or the first chain
@@ -222,7 +300,8 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
       coreOptions: this.coreOptions
     };
     // add injected connectors
-    const isMipdEnabled = (_this$coreOptions$mul = this.coreOptions.multiInjectedProviderDiscovery) !== null && _this$coreOptions$mul !== void 0 ? _this$coreOptions$mul : true;
+    const isExternalWalletEnabled = Boolean(projectConfig.externalWalletAuth);
+    const isMipdEnabled = isExternalWalletEnabled && ((_this$coreOptions$mul = this.coreOptions.multiInjectedProviderDiscovery) !== null && _this$coreOptions$mul !== void 0 ? _this$coreOptions$mul : true);
     const chainNamespaces = new Set(this.coreOptions.chains.map(chain => chain.chainNamespace));
     if (isMipdEnabled) {
       // Solana chains
@@ -255,8 +334,10 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
         connectorFns.push(...evmMipd.getProviders().map(injectedEvmConnector));
       }
     }
-    // add WalletConnectV2 connector if enabled
-    if (projectConfig.wallet_connect_enabled && projectConfig.wallet_connect_project_id && (chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.SOLANA) || chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.EIP155))) {
+    // it's safe to add it here as if there is a MetaMask injected provider, this won't override it
+    connectorFns.push(metamaskConnector.metaMaskConnector());
+    // add WalletConnectV2 connector if external wallets are enabled
+    if (isExternalWalletEnabled && (chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.SOLANA) || chainNamespaces.has(baseControllers.CHAIN_NAMESPACES.EIP155))) {
       const {
         walletConnectV2Connector
       } = await Promise.resolve().then(function () { return require('./connectors/wallet-connect-v2-connector/index.js'); });
@@ -291,16 +372,24 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
   }
   subscribeToConnectorEvents(connector) {
     connector.on(constants.CONNECTOR_EVENTS.CONNECTED, async data => {
+      var _this$currentChain3, _accountAbstractionCo;
       if (!this.commonJRPCProvider) throw index.WalletInitializationError.notFound(`CommonJrpcProvider not found`);
       const {
         provider
       } = data;
       let finalProvider = provider.provider || provider;
-      // setup aa provider for external wallets on EVM chains, for in app wallet, it uses WS provider which already supports AA
+      // setup AA provider for external wallets on EVM chains, no need for app wallet as it uses WS provider which already supports AA
       const {
         accountAbstractionConfig
       } = this.coreOptions;
-      if (this.currentChain.chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155 && accountAbstractionConfig && data.connector !== index$1.WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet) {
+      const doesAASupportCurrentChain = ((_this$currentChain3 = this.currentChain) === null || _this$currentChain3 === void 0 ? void 0 : _this$currentChain3.chainNamespace) === baseControllers.CHAIN_NAMESPACES.EIP155 && (accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo = accountAbstractionConfig.chains) === null || _accountAbstractionCo === void 0 ? void 0 : _accountAbstractionCo.some(chain => {
+        var _this$currentChain4;
+        return chain.chainId === ((_this$currentChain4 = this.currentChain) === null || _this$currentChain4 === void 0 ? void 0 : _this$currentChain4.chainId);
+      }));
+      const isExternalWalletAndAAEnabled = data.connector !== index$1.WALLET_CONNECTORS.AUTH && this.coreOptions.useAAWithExternalWallet;
+      if (isExternalWalletAndAAEnabled && doesAASupportCurrentChain) {
+        var _accountAbstractionCo2;
+        const aaChainIds = new Set((accountAbstractionConfig === null || accountAbstractionConfig === void 0 || (_accountAbstractionCo2 = accountAbstractionConfig.chains) === null || _accountAbstractionCo2 === void 0 ? void 0 : _accountAbstractionCo2.map(chain => chain.chainId)) || []);
         const {
           accountAbstractionProvider
         } = await Promise.resolve().then(function () { return require('./providers/account-abstraction-provider/index.js'); });
@@ -308,10 +397,9 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
           accountAbstractionConfig,
           provider,
           chain: this.currentChain,
-          chains: this.coreOptions.chains
+          chains: this.coreOptions.chains.filter(chain => aaChainIds.has(chain.chainId))
         });
         finalProvider = aaProvider;
-        // TODO: when switching chains to Solana or other chains, we need to switch to the non-AA provider
       }
       this.commonJRPCProvider.updateProviderEngineProxy(finalProvider);
       this.connectedConnectorName = data.connector;
@@ -378,8 +466,9 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
    * @throws WalletInitializationError If no chain is found for the connector's namespace
    */
   getInitialChainIdForConnector(connector) {
+    var _initialChain;
     let initialChain = this.currentChain;
-    if (initialChain.chainNamespace !== connector.connectorNamespace && connector.connectorNamespace !== IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN) {
+    if (((_initialChain = initialChain) === null || _initialChain === void 0 ? void 0 : _initialChain.chainNamespace) !== connector.connectorNamespace && connector.connectorNamespace !== IChainInterface.CONNECTOR_NAMESPACES.MULTICHAIN) {
       initialChain = this.coreOptions.chains.find(x => x.chainNamespace === connector.connectorNamespace);
       if (!initialChain) throw index.WalletInitializationError.invalidParams(`No chain found for ${connector.connectorNamespace}`);
     }
@@ -405,10 +494,11 @@ class Web3AuthNoModal extends auth.SafeEventEmitter {
   connectToPlugins(data) {
     Object.values(this.plugins).map(async plugin => {
       try {
+        var _this$currentChain5;
         // skip if it's not compatible with the connector
         if (!plugin.SUPPORTED_CONNECTORS.includes("all") && !plugin.SUPPORTED_CONNECTORS.includes(data.connector)) return;
         // skip if it's not compatible with the current chain
-        if (plugin.pluginNamespace !== IPlugin.PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== this.currentChain.chainNamespace) return;
+        if (plugin.pluginNamespace !== IPlugin.PLUGIN_NAMESPACES.MULTICHAIN && plugin.pluginNamespace !== ((_this$currentChain5 = this.currentChain) === null || _this$currentChain5 === void 0 ? void 0 : _this$currentChain5.chainNamespace)) return;
         // skip if it's already connected
         if (plugin.status === IPlugin.PLUGIN_STATUS.CONNECTED) return;
         await plugin.initWithWeb3Auth(this, this.coreOptions.uiConfig);

package/dist/lib.cjs/plugins/wallet-services-plugin/plugin.js

@@ -36,7 +36,7 @@ class WalletServicesPlugin extends auth.SafeEventEmitter {
     if (!web3auth) throw errors.WalletServicesPluginError.web3authRequired();
     if (web3auth.provider && !this.SUPPORTED_CONNECTORS.includes(web3auth.connectedConnectorName)) throw errors.WalletServicesPluginError.notInitialized();
     const currentChainConfig = web3auth.currentChain;
-    if (![baseControllers.CHAIN_NAMESPACES.EIP155, baseControllers.CHAIN_NAMESPACES.SOLANA].includes(currentChainConfig.chainNamespace)) throw errors.WalletServicesPluginError.unsupportedChainNamespace();
+    if (![baseControllers.CHAIN_NAMESPACES.EIP155, baseControllers.CHAIN_NAMESPACES.SOLANA].includes(currentChainConfig === null || currentChainConfig === void 0 ? void 0 : currentChainConfig.chainNamespace)) throw errors.WalletServicesPluginError.unsupportedChainNamespace();
     // Not connected yet to auth
     if (web3auth.provider) {
       this.provider = web3auth.provider;

package/dist/lib.cjs/providers/account-abstraction-provider/providers/AccountAbstractionProvider.js

@@ -65,7 +65,7 @@ class AccountAbstractionProvider extends baseProvider.BaseProvider {
     });
   }
   async setupProvider(eoaProvider) {
-    var _this$config$bundlerC;
+    var _bundlerConfig$transp;
     const {
       currentChain
     } = this;
@@ -73,6 +73,12 @@ class AccountAbstractionProvider extends baseProvider.BaseProvider {
       chainNamespace
     } = currentChain;
     if (chainNamespace !== this.PROVIDER_CHAIN_NAMESPACE) throw index.WalletInitializationError.incompatibleChainNameSpace("Invalid chain namespace");
+    const bundlerAndPaymasterConfig = this.config.smartAccountChainsConfig.find(config => config.chainId === currentChain.chainId);
+    if (!bundlerAndPaymasterConfig) throw index.WalletInitializationError.invalidProviderConfigError(`Bundler and paymaster config not found for chain ${currentChain.chainId}`);
+    const {
+      bundlerConfig,
+      paymasterConfig
+    } = bundlerAndPaymasterConfig;
     const chain = viem.defineChain({
       id: Number.parseInt(currentChain.chainId, 16),
       // id in number form
@@ -106,16 +112,16 @@ class AccountAbstractionProvider extends baseProvider.BaseProvider {
       client: this._publicClient
     });
     // setup bundler and paymaster
-    if (this.config.paymasterConfig) {
-      var _this$config$paymaste;
-      this._paymasterClient = accountAbstraction.createPaymasterClient(_objectSpread(_objectSpread({}, this.config.paymasterConfig), {}, {
-        transport: (_this$config$paymaste = this.config.paymasterConfig.transport) !== null && _this$config$paymaste !== void 0 ? _this$config$paymaste : viem.http(this.config.paymasterConfig.url)
+    if (paymasterConfig) {
+      var _paymasterConfig$tran;
+      this._paymasterClient = accountAbstraction.createPaymasterClient(_objectSpread(_objectSpread({}, paymasterConfig), {}, {
+        transport: (_paymasterConfig$tran = paymasterConfig.transport) !== null && _paymasterConfig$tran !== void 0 ? _paymasterConfig$tran : viem.http(paymasterConfig.url)
       }));
     }
-    this._bundlerClient = accountAbstraction.createBundlerClient(_objectSpread(_objectSpread({}, this.config.bundlerConfig), {}, {
+    this._bundlerClient = accountAbstraction.createBundlerClient(_objectSpread(_objectSpread({}, bundlerConfig), {}, {
       account: this.smartAccount,
       client: this._publicClient,
-      transport: (_this$config$bundlerC = this.config.bundlerConfig.transport) !== null && _this$config$bundlerC !== void 0 ? _this$config$bundlerC : viem.http(this.config.bundlerConfig.url),
+      transport: (_bundlerConfig$transp = bundlerConfig.transport) !== null && _bundlerConfig$transp !== void 0 ? _bundlerConfig$transp : viem.http(bundlerConfig.url),
       paymaster: this._paymasterClient
     }));
     const providerHandlers = utils.getProviderHandlers({
@@ -176,10 +182,11 @@ const accountAbstractionProvider = async ({
   let smartAccountInit;
   const {
     smartAccountType,
-    smartAccountConfig,
-    bundlerConfig,
-    paymasterConfig
+    chains: smartAccountChainsConfig
   } = accountAbstractionConfig;
+  const {
+    smartAccountConfig
+  } = smartAccountChainsConfig.find(config => config.chainId === chain.chainId) || {};
   switch (smartAccountType) {
     case ethereumControllers.SMART_ACCOUNT.BICONOMY:
       {
@@ -229,8 +236,7 @@ const accountAbstractionProvider = async ({
     smartAccountInit,
     chain,
     chains,
-    bundlerConfig,
-    paymasterConfig
+    smartAccountChainsConfig
   });
 };
 

package/dist/lib.cjs/providers/solana-provider/rpc/solanaRpcMiddlewares.js

@@ -75,7 +75,7 @@ function createSolanaMiddleware(providerHandlers) {
     requestAccounts
   }), createGetAccountsMiddleware({
     getAccounts
-  }), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SIGN_TRANSACTION, signTransaction), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SEND_TRANSACTION, signAndSendTransaction), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SIGN_ALL_TRANSACTIONS, signAllTransactions), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SIGN_MESSAGE, signMessage), createGenericJRPCMiddleware("solanaPrivateKey", getPrivateKey), createGenericJRPCMiddleware("private_key", getPrivateKey), createGenericJRPCMiddleware("public_key", getPublicKey), createGenericJRPCMiddleware("solanaPublicKey", getPublicKey), createGenericJRPCMiddleware("solanaSecretKey", getSecretKey)]);
+  }), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SIGN_TRANSACTION, signTransaction), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SEND_TRANSACTION, signAndSendTransaction), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SIGN_ALL_TRANSACTIONS, signAllTransactions), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SIGN_MESSAGE, signMessage), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.SOLANA_PRIVATE_KEY, getPrivateKey), createGenericJRPCMiddleware(wsEmbed.SOLANA_METHOD_TYPES.PRIVATE_KEY, getPrivateKey), createGenericJRPCMiddleware("public_key", getPublicKey), createGenericJRPCMiddleware("solanaPublicKey", getPublicKey), createGenericJRPCMiddleware("solanaSecretKey", getSecretKey)]);
 }
 function createSolanaChainSwitchMiddleware({
   switchSolanaChain

package/dist/lib.cjs/types/base/chain/IChainInterface.d.ts

@@ -1,5 +1,4 @@
-import { CHAIN_NAMESPACES, type ChainNamespaceType } from "@toruslabs/base-controllers";
-export { CHAIN_NAMESPACES, type ChainNamespaceType };
+import { CHAIN_NAMESPACES, type ChainNamespaceType, type ProviderConfig } from "@toruslabs/base-controllers";
 export declare const CONNECTOR_NAMESPACES: {
     readonly EIP155: "eip155";
     readonly SOLANA: "solana";
@@ -8,46 +7,5 @@ export declare const CONNECTOR_NAMESPACES: {
     readonly MULTICHAIN: "multichain";
 };
 export type ConnectorNamespaceType = (typeof CONNECTOR_NAMESPACES)[keyof typeof CONNECTOR_NAMESPACES];
-export type CustomChainConfig = {
-    chainNamespace: ChainNamespaceType;
-    /**
-     * The chain id of the chain
-     */
-    chainId: string;
-    /**
-     * RPC target Url for the chain
-     */
-    rpcTarget: string;
-    /**
-     * web socket target Url for the chain
-     */
-    wsTarget?: string;
-    /**
-     * Display Name for the chain
-     */
-    displayName?: string;
-    /**
-     * Url of the block explorer
-     */
-    blockExplorerUrl?: string;
-    /**
-     * Default currency ticker of the network (e.g: ETH)
-     */
-    ticker?: string;
-    /**
-     * Name for currency ticker (e.g: `Ethereum`)
-     */
-    tickerName?: string;
-    /**
-     * Number of decimals for the currency ticker (e.g: 18)
-     */
-    decimals?: number;
-    /**
-     * Logo for the token
-     */
-    logo?: string;
-    /**
-     * Whether the network is testnet or not
-     */
-    isTestnet?: boolean;
-};
+export { CHAIN_NAMESPACES, type ChainNamespaceType };
+export type CustomChainConfig = ProviderConfig;

package/dist/lib.cjs/types/base/connector/constants.d.ts

@@ -23,3 +23,7 @@ export declare const CONNECTOR_CATEGORY: {
     readonly EXTERNAL: "external";
     readonly IN_APP: "in_app";
 };
+export declare const SMART_ACCOUNT_WALLET_SCOPE: {
+    readonly EMBEDDED: "embedded";
+    readonly ALL: "all";
+};

package/dist/lib.cjs/types/base/connector/interfaces.d.ts

@@ -1,8 +1,8 @@
-import { AUTH_CONNECTION_TYPE, AuthUserInfo, JRPCRequest, JRPCResponse, Maybe, RequestArguments, SafeEventEmitter, SendCallBack, UX_MODE, type UX_MODE_TYPE, WEB3AUTH_NETWORK, type WEB3AUTH_NETWORK_TYPE } from "@web3auth/auth";
+import { AUTH_CONNECTION_TYPE, AuthUserInfo, ExtraLoginOptions, JRPCRequest, JRPCResponse, Maybe, RequestArguments, SafeEventEmitter, SendCallBack, UX_MODE, type UX_MODE_TYPE, WEB3AUTH_NETWORK, type WEB3AUTH_NETWORK_TYPE } from "@web3auth/auth";
 import { ConnectorNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
 import { IWeb3AuthCoreOptions } from "../core/IWeb3Auth";
 import { Web3AuthError } from "../errors";
-import { PROJECT_CONFIG_RESPONSE } from "../interfaces";
+import { ProjectConfig } from "../interfaces";
 import { ProviderEvents, SafeEventEmitterProvider } from "../provider/IProvider";
 import { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_STATUS } from "./constants";
 export type UserInfo = AuthUserInfo;
@@ -67,7 +67,7 @@ export interface IConnector<T> extends SafeEventEmitter {
     authenticateUser(): Promise<UserAuthInfo>;
 }
 export type ConnectorParams = {
-    projectConfig?: PROJECT_CONFIG_RESPONSE;
+    projectConfig?: ProjectConfig;
     coreOptions: IWeb3AuthCoreOptions;
 };
 export type ConnectorFn = (params: ConnectorParams) => IConnector<unknown>;
@@ -147,6 +147,10 @@ export type LoginMethodConfig = Partial<Record<AUTH_CONNECTION_TYPE, {
      * Grouped auth connection id of the provider.
      */
     groupedAuthConnectionId?: string;
+    /**
+     * ExtraLoginOption params to be used for social login.
+     */
+    extraLoginOptions?: ExtraLoginOptions;
 }>>;
 export type WalletConnectV2Data = {
     uri: string;

package/dist/lib.cjs/types/base/core/IWeb3Auth.d.ts

@@ -1,5 +1,5 @@
-import { type AccountAbstractionConfig } from "@toruslabs/ethereum-controllers";
-import { SafeEventEmitter, UX_MODE_TYPE, type WhiteLabelData } from "@web3auth/auth";
+import { type AccountAbstractionMultiChainConfig } from "@toruslabs/ethereum-controllers";
+import { type BUILD_ENV_TYPE, SafeEventEmitter, UX_MODE_TYPE, type WhiteLabelData } from "@web3auth/auth";
 import { type WsEmbedParams } from "@web3auth/ws-embed";
 import { type CustomChainConfig } from "../chain/IChainInterface";
 import { CONNECTOR_EVENTS, type CONNECTOR_STATUS_TYPE, ConnectorEvents, type ConnectorFn, type IBaseProvider, type IConnector, type IProvider, type UserAuthInfo, type UserInfo, type WEB3AUTH_NETWORK_TYPE } from "../connector";
@@ -78,7 +78,7 @@ export interface IWeb3AuthCoreOptions {
     /**
      * Account abstraction config for your chain namespace
      */
-    accountAbstractionConfig?: AccountAbstractionConfig;
+    accountAbstractionConfig?: AccountAbstractionMultiChainConfig;
     /**
      * Whether to use AA with external wallet
      */
@@ -104,11 +104,17 @@ export interface IWeb3AuthCoreOptions {
      * Private key provider for xrpl, mpc cases
      */
     privateKeyProvider?: IBaseProvider<string>;
+    /**
+     * Build environment for Auth connector
+     * @internal
+     * @defaultValue BUILD_ENV.PRODUCTION
+     */
+    authBuildEnv?: BUILD_ENV_TYPE;
 }
 export interface IWeb3AuthCore extends SafeEventEmitter {
     readonly coreOptions: IWeb3AuthCoreOptions;
     connectedConnectorName: string | null;
-    currentChain: CustomChainConfig;
+    currentChain: CustomChainConfig | undefined;
     status: CONNECTOR_STATUS_TYPE;
     provider: IProvider | null;
     init(): Promise<void>;

package/dist/lib.cjs/types/base/interfaces.d.ts

@@ -1,17 +1,74 @@
-import { AuthConnectionConfig, WhiteLabelData } from "@web3auth/auth";
-import { ChainNamespaceType } from "./chain/IChainInterface";
+import { type BUTTON_POSITION_TYPE } from "@toruslabs/base-controllers";
+import { type SmartAccountType } from "@toruslabs/ethereum-controllers";
+import { AuthConnectionConfigItem, type WhiteLabelData } from "@web3auth/auth";
+import { type ChainNamespaceType, type CustomChainConfig } from "./chain/IChainInterface";
+import { SMART_ACCOUNT_WALLET_SCOPE } from "./connector";
 export interface WhitelistResponse {
     urls: string[];
     signed_urls: Record<string, string>;
 }
-export interface PROJECT_CONFIG_RESPONSE {
-    whitelabel?: WhiteLabelData;
-    sms_otp_enabled: boolean;
-    wallet_connect_enabled: boolean;
-    wallet_connect_project_id?: string;
+export type ChainsConfig = CustomChainConfig[];
+export interface ExternalWalletsConfig {
+    disableAllRecommendedWallets?: boolean;
+    disableAllOtherWallets?: boolean;
+    disabledWallets?: string[];
+}
+export type SmartAccountWalletScope = (typeof SMART_ACCOUNT_WALLET_SCOPE)[keyof typeof SMART_ACCOUNT_WALLET_SCOPE];
+export interface SmartAccountsConfig {
+    smartAccountType: SmartAccountType;
+    walletScope: SmartAccountWalletScope;
+    chains: {
+        chainId: string;
+        bundlerConfig: {
+            url: string;
+        };
+        paymasterConfig?: {
+            url: string;
+        };
+    }[];
+}
+export interface WalletUiConfig {
+    enablePortfolioWidget?: boolean;
+    enableConfirmationModal?: boolean;
+    enableWalletConnect?: boolean;
+    enableTokenDisplay?: boolean;
+    enableNftDisplay?: boolean;
+    enableShowAllTokensButton?: boolean;
+    enableBuyButton?: boolean;
+    enableSendButton?: boolean;
+    enableSwapButton?: boolean;
+    enableReceiveButton?: boolean;
+    portfolioWidgetPosition?: BUTTON_POSITION_TYPE;
+    defaultPortfolio?: "token" | "nft";
+}
+export interface LoginModalConfig {
+    widgetType?: "embed" | "modal";
+    logoAlignment?: "left" | "center";
+    borderRadiusType?: "small" | "medium" | "large";
+    buttonRadiusType?: "pill" | "rounded" | "square";
+    tncLink?: string;
+    privacyPolicy?: string;
+    enableMainSocialLoginButton?: boolean;
+    signInMethods?: ("social" | "passwordless" | "externalWallets")[];
+    addPreviousLoginHint?: boolean;
+    displayInstalledExternalWallets?: boolean;
+    displayExternalWalletsCount?: boolean;
+}
+export interface ProjectConfig {
+    userDataIncludedInToken?: boolean;
+    sessionTime?: number;
+    enableKeyExport?: boolean;
+    walletConnectProjectId?: string;
     whitelist?: WhitelistResponse;
-    key_export_enabled?: boolean;
-    auth_connection_config?: AuthConnectionConfig;
+    chains?: ChainsConfig;
+    smartAccounts?: SmartAccountsConfig;
+    walletUi?: WalletUiConfig;
+    externalWalletAuth?: ExternalWalletsConfig;
+    embeddedWalletAuth?: (AuthConnectionConfigItem & {
+        isDefault?: boolean;
+    })[];
+    whitelabel?: WhiteLabelData;
+    loginModal?: LoginModalConfig;
 }
 export interface WalletRegistryItem {
     name: string;

package/dist/lib.cjs/types/base/utils.d.ts

@@ -1,9 +1,9 @@
 import { cloneDeep } from "@toruslabs/base-controllers";
 import { type WEB3AUTH_NETWORK_TYPE } from "./connector";
-import type { PROJECT_CONFIG_RESPONSE, WalletRegistry } from "./interfaces";
+import type { ProjectConfig, WalletRegistry } from "./interfaces";
 export declare const isHexStrict: (hex: string) => boolean;
 export declare const signerHost: (web3AuthNetwork?: WEB3AUTH_NETWORK_TYPE) => string;
-export declare const fetchProjectConfig: (clientId: string, web3AuthNetwork: WEB3AUTH_NETWORK_TYPE, aaProvider?: string) => Promise<PROJECT_CONFIG_RESPONSE>;
+export declare const fetchProjectConfig: (clientId: string, web3AuthNetwork: WEB3AUTH_NETWORK_TYPE, aaProvider?: string) => Promise<ProjectConfig>;
 export declare const fetchWalletRegistry: (url?: string) => Promise<WalletRegistry>;
 export declare const normalizeWalletName: (name: string) => string;
 export { cloneDeep };

package/dist/lib.cjs/types/base/wallet/index.d.ts

@@ -13,12 +13,14 @@ export declare const EVM_CONNECTORS: {
     WALLET_CONNECT_V2: string;
     SFA: string;
     COINBASE: string;
+    METAMASK: string;
 };
 export declare const WALLET_CONNECTORS: {
     AUTH: string;
     WALLET_CONNECT_V2: string;
     SFA: string;
     COINBASE: string;
+    METAMASK: string;
 };
 export type WALLET_CONNECTOR_TYPE = (typeof WALLET_CONNECTORS)[keyof typeof WALLET_CONNECTORS];
 export type SOLANA_CONNECTOR_TYPE = (typeof SOLANA_CONNECTORS)[keyof typeof SOLANA_CONNECTORS];

package/dist/lib.cjs/types/connectors/auth-connector/authConnector.d.ts

@@ -1,4 +1,4 @@
-import { Auth, LoginParams } from "@web3auth/auth";
+import { Auth, type LoginParams } from "@web3auth/auth";
 import { type default as WsEmbed } from "@web3auth/ws-embed";
 import { BaseConnector, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorFn, ConnectorInitOptions, ConnectorNamespaceType, IProvider, UserInfo } from "../../base";
 import type { AuthConnectorOptions, PrivateKeyProvider } from "./interface";
@@ -44,6 +44,9 @@ declare class AuthConnector extends BaseConnector<AuthLoginParams> {
     private connectWithJwtLogin;
     private getOAuthProviderConfig;
 }
-export declare const authConnector: (params?: Omit<AuthConnectorOptions, "coreOptions" | "authConnectionConfig">) => ConnectorFn;
+type AuthConnectorFuncParams = Omit<AuthConnectorOptions, "coreOptions" | "authConnectionConfig" | "connectorSettings"> & {
+    connectorSettings?: Omit<AuthConnectorOptions["connectorSettings"], "buildEnv">;
+};
+export declare const authConnector: (params?: AuthConnectorFuncParams) => ConnectorFn;
 export type AuthConnectorType = AuthConnector;
 export {};

package/dist/lib.cjs/types/connectors/auth-connector/interface.d.ts

@@ -1,4 +1,4 @@
-import { AuthConnectionConfig, type AuthOptions, type LoginParams } from "@web3auth/auth";
+import { type AuthConnectionConfigItem, type AuthOptions, type LoginParams } from "@web3auth/auth";
 import { type WsEmbedParams } from "@web3auth/ws-embed";
 import { type BaseConnectorSettings, type IBaseProvider } from "../../base";
 export type LoginSettings = Partial<LoginParams>;
@@ -10,6 +10,8 @@ export interface AuthConnectorOptions extends BaseConnectorSettings {
     connectorSettings?: Omit<AuthOptions, "clientId" | "network" | "authConnectionConfig">;
     loginSettings?: LoginSettings;
     walletServicesSettings?: WalletServicesSettings;
-    authConnectionConfig?: AuthConnectionConfig;
+    authConnectionConfig?: (AuthConnectionConfigItem & {
+        isDefault?: boolean;
+    })[];
 }
 export { AUTH_CONNECTION, type AUTH_CONNECTION_TYPE, type AuthConnectionConfig, type AuthOptions, type AuthUserInfo, type LoginParams, } from "@web3auth/auth";

package/dist/lib.cjs/types/connectors/metamask-connector/index.d.ts

@@ -0,0 +1 @@
+export { metaMaskConnector } from "./metamaskConnector";

package/dist/lib.cjs/types/connectors/metamask-connector/metamaskConnector.d.ts

@@ -0,0 +1,6 @@
+import { type MetaMaskSDKOptions } from "@metamask/sdk";
+import { type BaseConnectorSettings, type ConnectorFn } from "../../base";
+export interface MetaMaskConnectorOptions extends BaseConnectorSettings {
+    connectorSettings?: MetaMaskSDKOptions;
+}
+export declare const metaMaskConnector: (params?: MetaMaskSDKOptions) => ConnectorFn;