@web3auth/no-modal 10.0.0-beta.0 → 10.0.0-beta.10

package/dist/lib.cjs/react/wagmi/provider.js

@@ -0,0 +1,189 @@
+'use strict';
+
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var react = require('react');
+var viem = require('viem');
+var wagmi = require('wagmi');
+var connectors = require('wagmi/connectors');
+var baseControllers = require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@web3auth/auth');
+var index = require('../../base/errors/index.js');
+require('../../base/wallet/index.js');
+require('../../base/connector/constants.js');
+require('jwt-decode');
+var loglevel = require('../../base/loglevel.js');
+require('../../base/plugin/errors.js');
+require('../../base/plugin/IPlugin.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../context/WalletServicesInnerContext.js');
+require('../context/Web3AuthInnerContext.js');
+var useWeb3Auth = require('../hooks/useWeb3Auth.js');
+var useWeb3AuthDisconnect = require('../hooks/useWeb3AuthDisconnect.js');
+var constants = require('./constants.js');
+
+const _excluded = ["children"];
+const WEB3AUTH_CONNECTOR_ID = "web3auth";
+// Helper to initialize connectors for the given wallets
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function setupConnector(provider, config) {
+  let connector = config.connectors.find(c => c.id === WEB3AUTH_CONNECTOR_ID);
+  if (connector) return connector;
+  // Create new connector if not already existing
+  connector = connectors.injected({
+    target: {
+      provider: provider,
+      id: WEB3AUTH_CONNECTOR_ID,
+      name: "Web3Auth"
+    }
+  });
+  const result = config._internal.connectors.setup(connector);
+  config._internal.connectors.setState(current => [...current, result]);
+  return result;
+}
+// Helper to connect a wallet and update wagmi state
+async function connectWeb3AuthWithWagmi(connector, config) {
+  var _config$storage, _config$storage2;
+  await Promise.all([(_config$storage = config.storage) === null || _config$storage === void 0 ? void 0 : _config$storage.removeItem(`${connector.id}.disconnected`), (_config$storage2 = config.storage) === null || _config$storage2 === void 0 ? void 0 : _config$storage2.setItem("recentConnectorId", connector.id)]);
+  let chainId = await connector.getChainId();
+  if (!config.chains.find(c => c.id === chainId)) {
+    chainId = config.chains[0].id;
+  }
+  const accounts = await connector.getAccounts();
+  const connections = new Map([[connector.uid, {
+    accounts: [accounts[0]],
+    chainId,
+    connector
+  }]]);
+  config.setState(state => _objectSpread(_objectSpread({}, state), {}, {
+    chainId,
+    connections,
+    current: connector.uid,
+    status: "connected"
+  }));
+}
+async function disconnectWeb3AuthFromWagmi(config) {
+  config._internal.connectors.setState(prev => prev.filter(c => c.id !== WEB3AUTH_CONNECTOR_ID));
+  config.setState(state => _objectSpread(_objectSpread({}, state), {}, {
+    chainId: state.chainId,
+    connections: new Map(),
+    current: undefined,
+    status: "disconnected"
+  }));
+}
+function Web3AuthWagmiProvider({
+  children
+}) {
+  const {
+    isConnected,
+    provider
+  } = useWeb3Auth.useWeb3Auth();
+  const {
+    disconnect
+  } = useWeb3AuthDisconnect.useWeb3AuthDisconnect();
+  const wagmiConfig = wagmi.useConfig();
+  const {
+    reconnect
+  } = wagmi.useReconnect();
+  wagmi.useAccountEffect({
+    onDisconnect: async () => {
+      loglevel.log.info("Disconnected from wagmi");
+      if (isConnected) await disconnect();
+    }
+  });
+  react.useEffect(() => {
+    (async () => {
+      if (isConnected && provider) {
+        const connector = await setupConnector(provider, wagmiConfig);
+        if (!connector) {
+          throw new Error("Failed to setup connector");
+        }
+        await connectWeb3AuthWithWagmi(connector, wagmiConfig);
+        reconnect();
+      } else if (!isConnected) {
+        if (wagmiConfig.state.status === "connected") {
+          await disconnectWeb3AuthFromWagmi(wagmiConfig);
+        }
+      }
+    })();
+  }, [isConnected, wagmiConfig, provider, reconnect]);
+  return react.createElement(react.Fragment, null, children);
+}
+function WagmiProvider(_ref) {
+  let {
+      children
+    } = _ref,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const {
+    config
+  } = props;
+  const {
+    web3Auth,
+    isInitialized
+  } = useWeb3Auth.useWeb3Auth();
+  const finalConfig = react.useMemo(() => {
+    var _web3Auth$coreOptions;
+    if (!isInitialized) return constants.defaultWagmiConfig;
+    const finalConfig = _objectSpread(_objectSpread({
+      ssr: true
+    }, config), {}, {
+      chains: undefined,
+      connectors: [],
+      transports: {},
+      multiInjectedProviderDiscovery: false,
+      client: undefined
+    });
+    const wagmiChains = [];
+    if (isInitialized && web3Auth !== null && web3Auth !== void 0 && (_web3Auth$coreOptions = web3Auth.coreOptions) !== null && _web3Auth$coreOptions !== void 0 && _web3Auth$coreOptions.chains) {
+      var _web3Auth$currentChai;
+      const defaultChainId = (_web3Auth$currentChai = web3Auth.currentChain) === null || _web3Auth$currentChai === void 0 ? void 0 : _web3Auth$currentChai.chainId;
+      const chains = web3Auth.coreOptions.chains.filter(chain => chain.chainNamespace === baseControllers.CHAIN_NAMESPACES.EIP155);
+      if (chains.length === 0) throw index.WalletInitializationError.invalidParams("No valid chains found in web3auth config for wagmi.");
+      chains.forEach(chain => {
+        const wagmiChain = viem.defineChain({
+          id: Number.parseInt(chain.chainId, 16),
+          // id in number form
+          name: chain.displayName,
+          rpcUrls: {
+            default: {
+              http: [chain.rpcTarget],
+              webSocket: [chain.wsTarget]
+            }
+          },
+          blockExplorers: chain.blockExplorerUrl ? {
+            default: {
+              name: "explorer",
+              // TODO: correct name if chain config has it
+              url: chain.blockExplorerUrl
+            }
+          } : undefined,
+          nativeCurrency: {
+            name: chain.tickerName,
+            symbol: chain.ticker,
+            decimals: chain.decimals || 18
+          }
+        });
+        if (defaultChainId === chain.chainId) {
+          wagmiChains.unshift(wagmiChain);
+        } else {
+          wagmiChains.push(wagmiChain);
+        }
+        finalConfig.transports[wagmiChain.id] = chain.wsTarget ? viem.webSocket(chain.wsTarget) : viem.http(chain.rpcTarget);
+      });
+      finalConfig.chains = [wagmiChains[0], ...wagmiChains.slice(1)];
+    }
+    if (!finalConfig.chains) return;
+    return wagmi.createConfig(finalConfig);
+  }, [config, web3Auth, isInitialized]);
+  return react.createElement(wagmi.WagmiProvider, // typecast to WagmiProviderPropsBase to avoid type error
+  // as we are omitting the config prop from WagmiProviderProps
+  // and creating a new config object with the finalConfig
+  _objectSpread(_objectSpread({}, props), {}, {
+    config: finalConfig,
+    reconnectOnMount: false
+  }), react.createElement(Web3AuthWagmiProvider, null, children));
+}
+
+exports.WagmiProvider = WagmiProvider;

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

@@ -1,14 +1,16 @@
 import { SafeEventEmitter } from "@web3auth/auth";
 import { ConnectorNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
-import type { BaseConnectorSettings, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorEvents, ConnectorInitOptions, IConnector, IProvider, UserAuthInfo, UserInfo } from "./interfaces";
+import { WALLET_CONNECTOR_TYPE } from "../wallet";
+import type { BaseConnectorLoginParams, BaseConnectorSettings, CONNECTOR_CATEGORY_TYPE, CONNECTOR_STATUS_TYPE, ConnectorEvents, ConnectorInitOptions, IConnector, IProvider, UserAuthInfo, UserInfo } from "./interfaces";
 export declare abstract class BaseConnector<T> extends SafeEventEmitter<ConnectorEvents> implements IConnector<T> {
     connectorData?: unknown;
     isInjected?: boolean;
+    icon?: string;
     coreOptions: BaseConnectorSettings["coreOptions"];
     protected rehydrated: boolean;
     abstract connectorNamespace: ConnectorNamespaceType;
     abstract type: CONNECTOR_CATEGORY_TYPE;
-    abstract name: string;
+    abstract name: WALLET_CONNECTOR_TYPE | string;
     abstract status: CONNECTOR_STATUS_TYPE;
     constructor(options: BaseConnectorSettings);
     get connnected(): boolean;
@@ -23,9 +25,7 @@ export declare abstract class BaseConnector<T> extends SafeEventEmitter<Connecto
     }, init?: boolean): void;
     updateConnectorData(data: unknown): void;
     abstract init(options?: ConnectorInitOptions): Promise<void>;
-    abstract connect(params: T & {
-        chainId: string;
-    }): Promise<IProvider | null>;
+    abstract connect(params: T & BaseConnectorLoginParams): Promise<IProvider | null>;
     abstract disconnect(): Promise<void>;
     abstract getUserInfo(): Promise<Partial<UserInfo>>;
     abstract enableMFA(params?: T): Promise<void>;

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

@@ -11,6 +11,8 @@ export declare const CONNECTOR_EVENTS: {
     readonly CONNECTOR_DATA_UPDATED: "connector_data_updated";
     readonly CACHE_CLEAR: "cache_clear";
     readonly CONNECTORS_UPDATED: "connectors_updated";
+    readonly MFA_ENABLED: "mfa_enabled";
+    readonly REHYDRATION_ERROR: "rehydration_error";
     readonly NOT_READY: "not_ready";
     readonly READY: "ready";
     readonly CONNECTING: "connecting";
@@ -23,7 +25,3 @@ 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,9 +1,10 @@
 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 type { ChainNamespaceType, ConnectorNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
+import type { IWeb3AuthCoreOptions } from "../core/IWeb3Auth";
 import { Web3AuthError } from "../errors";
-import { ProjectConfig } from "../interfaces";
-import { ProviderEvents, SafeEventEmitterProvider } from "../provider/IProvider";
+import type { LoginModeType, ProjectConfig } from "../interfaces";
+import type { ProviderEvents, SafeEventEmitterProvider } from "../provider/IProvider";
+import { WALLET_CONNECTOR_TYPE } from "../wallet";
 import { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_STATUS } from "./constants";
 export type UserInfo = AuthUserInfo;
 export { UX_MODE, UX_MODE_TYPE, WEB3AUTH_NETWORK, WEB3AUTH_NETWORK_TYPE };
@@ -45,12 +46,13 @@ export interface IBaseProvider<T> extends IProvider {
 export interface IConnector<T> extends SafeEventEmitter {
     connectorNamespace: ConnectorNamespaceType;
     type: CONNECTOR_CATEGORY_TYPE;
-    name: string;
+    name: WALLET_CONNECTOR_TYPE | string;
     status: CONNECTOR_STATUS_TYPE;
     provider: IProvider | null;
     connectorData?: unknown;
     connnected: boolean;
     isInjected?: boolean;
+    icon?: string;
     init(options?: ConnectorInitOptions): Promise<void>;
     disconnect(options?: {
         cleanup: boolean;
@@ -65,16 +67,21 @@ export interface IConnector<T> extends SafeEventEmitter {
         chainId: string;
     }): Promise<void>;
     authenticateUser(): Promise<UserAuthInfo>;
+    cleanup?(): Promise<void>;
 }
 export type ConnectorParams = {
     projectConfig?: ProjectConfig;
     coreOptions: IWeb3AuthCoreOptions;
 };
+export type BaseConnectorLoginParams = {
+    chainId: string;
+};
 export type ConnectorFn = (params: ConnectorParams) => IConnector<unknown>;
 export type CONNECTED_EVENT_DATA = {
-    connector: string;
+    connector: WALLET_CONNECTOR_TYPE;
     provider: IProvider;
     reconnected: boolean;
+    loginMode?: LoginModeType;
 };
 export interface IConnectorDataEvent {
     connectorName: string;
@@ -89,24 +96,26 @@ export type ConnectorEvents = {
         connector: string;
     }) => void;
     [CONNECTOR_EVENTS.ERRORED]: (error: Web3AuthError) => void;
+    [CONNECTOR_EVENTS.REHYDRATION_ERROR]: (error: Web3AuthError) => void;
     [CONNECTOR_EVENTS.CONNECTOR_DATA_UPDATED]: (data: IConnectorDataEvent) => void;
     [CONNECTOR_EVENTS.CACHE_CLEAR]: () => void;
     [CONNECTOR_EVENTS.CONNECTORS_UPDATED]: (data: {
         connectors: IConnector<unknown>[];
     }) => void;
+    [CONNECTOR_EVENTS.MFA_ENABLED]: (isMFAEnabled: boolean) => void;
 };
 export interface BaseConnectorConfig {
     label: string;
+    icon?: string;
     isInjected?: boolean;
+    chainNamespaces?: ChainNamespaceType[];
     showOnModal?: boolean;
-    showOnMobile?: boolean;
-    showOnDesktop?: boolean;
 }
 export type LoginMethodConfig = Partial<Record<AUTH_CONNECTION_TYPE, {
     /**
      * Display Name. If not provided, we use the default for auth app
      */
-    name: string;
+    name?: string;
     /**
      * Description for button. If provided, it renders as a full length button. else, icon button
      */
@@ -131,14 +140,6 @@ export type LoginMethodConfig = Partial<Record<AUTH_CONNECTION_TYPE, {
      * Whether to show the login button on modal or not
      */
     showOnModal?: boolean;
-    /**
-     * Whether to show the login button on desktop
-     */
-    showOnDesktop?: boolean;
-    /**
-     * Whether to show the login button on mobile
-     */
-    showOnMobile?: boolean;
     /**
      * Auth connection id of the provider.
      */
@@ -151,7 +152,23 @@ export type LoginMethodConfig = Partial<Record<AUTH_CONNECTION_TYPE, {
      * ExtraLoginOption params to be used for social login.
      */
     extraLoginOptions?: ExtraLoginOptions;
+    /**
+     * Auth connection type of the auth connector.
+     * Can be different from the original key.
+     *
+     * Example: This helps in customizing the google login button with auth0 custom connector.
+     */
+    authConnection?: AUTH_CONNECTION_TYPE;
+    /**
+     * Whether is it default connector.
+     *
+     * @internal
+     */
+    isDefault?: boolean;
 }>>;
 export type WalletConnectV2Data = {
     uri: string;
 };
+export type MetaMaskConnectorData = {
+    uri: string;
+};

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

@@ -0,0 +1,18 @@
+export declare const SMART_ACCOUNT_WALLET_SCOPE: {
+    readonly EMBEDDED: "embedded";
+    readonly ALL: "all";
+};
+export declare const MODAL_SIGN_IN_METHODS: {
+    readonly SOCIAL: "social";
+    readonly PASSWORDLESS: "passwordless";
+    readonly EXTERNAL_WALLETS: "externalWallets";
+};
+export declare const WIDGET_TYPE: {
+    readonly MODAL: "modal";
+    readonly EMBED: "embed";
+};
+export declare const WEB3AUTH_STATE_STORAGE_KEY = "Web3Auth-state";
+export declare const LOGIN_MODE: {
+    readonly MODAL: "modal";
+    readonly NO_MODAL: "no-modal";
+};

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

@@ -0,0 +1,10 @@
+import type { IWeb3AuthState } from "./interfaces";
+export declare const cookieStorage: (options?: {
+    expiry?: number;
+}) => {
+    getItem(key: string): string;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+};
+export declare function cookieToWeb3AuthState(cookie?: string | null): IWeb3AuthState;
+export declare function parseCookie(cookie: string, key: string): string;

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

@@ -1,10 +1,14 @@
 import { type AccountAbstractionMultiChainConfig } from "@toruslabs/ethereum-controllers";
-import { type BUILD_ENV_TYPE, SafeEventEmitter, UX_MODE_TYPE, type WhiteLabelData } from "@web3auth/auth";
+import { type BUILD_ENV_TYPE, type LoginParams, MfaSettings, SafeEventEmitter, UX_MODE_TYPE, type WhiteLabelData } from "@web3auth/auth";
 import { type WsEmbedParams } from "@web3auth/ws-embed";
-import { type CustomChainConfig } from "../chain/IChainInterface";
+import { type ChainNamespaceType, 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";
-import { type IPlugin, PluginFn } from "../plugin";
-import { type WALLET_CONNECTOR_TYPE } from "../wallet";
+import { type IPlugin, type PluginFn } from "../plugin";
+import { type WALLET_CONNECTOR_TYPE, WALLET_CONNECTORS } from "../wallet";
+export type AuthLoginParams = LoginParams & {
+    loginHint?: string;
+    idToken?: string;
+};
 export type WalletServicesConfig = Omit<WsEmbedParams, "buildEnv" | "enableLogging" | "chainId" | "chains" | "confirmationStrategy" | "accountAbstractionConfig"> & {
     /**
      * Determines how to show confirmation screens
@@ -53,7 +57,7 @@ export interface IWeb3AuthCoreOptions {
      *
      * @defaultValue "local"
      */
-    storageType?: "session" | "local";
+    storageType?: "session" | "local" | "cookies";
     /**
      * sessionTime (in seconds) for idToken issued by Web3Auth for server side verification.
      * @defaultValue 7 * 86400
@@ -62,15 +66,14 @@ export interface IWeb3AuthCoreOptions {
      */
     sessionTime?: number;
     /**
-     * Web3Auth Network to use for the session & the issued idToken
-     * @defaultValue sapphire_mainnet
+     * Web3Auth Network to use for the session.
      */
-    web3AuthNetwork?: WEB3AUTH_NETWORK_TYPE;
+    web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
     /**
      * Uses core-kit key with web3auth provider
      * @defaultValue false
      */
-    useCoreKitKey?: boolean;
+    useSFAKey?: boolean;
     /**
      * WhiteLabel options for web3auth
      */
@@ -104,20 +107,44 @@ export interface IWeb3AuthCoreOptions {
      * Private key provider for xrpl, mpc cases
      */
     privateKeyProvider?: IBaseProvider<string>;
+    /**
+     * Whether to enable SSR mode
+     *
+     * @defaultValue false
+     */
+    ssr?: boolean;
     /**
      * Build environment for Auth connector
      * @internal
      * @defaultValue BUILD_ENV.PRODUCTION
      */
     authBuildEnv?: BUILD_ENV_TYPE;
+    /**
+     * MFA settings for the auth connector
+     */
+    mfaSettings?: MfaSettings;
 }
+export type LoginParamMap = {
+    [WALLET_CONNECTORS.AUTH]: Partial<AuthLoginParams>;
+    [WALLET_CONNECTORS.METAMASK]: {
+        chainNamespace: ChainNamespaceType;
+    };
+    [WALLET_CONNECTORS.COINBASE]: {
+        chainNamespace: ChainNamespaceType;
+    };
+    [WALLET_CONNECTORS.WALLET_CONNECT_V2]: {
+        chainNamespace: ChainNamespaceType;
+    };
+};
 export interface IWeb3AuthCore extends SafeEventEmitter {
     readonly coreOptions: IWeb3AuthCoreOptions;
-    connectedConnectorName: string | null;
+    connectedConnectorName: WALLET_CONNECTOR_TYPE | null;
     currentChain: CustomChainConfig | undefined;
     status: CONNECTOR_STATUS_TYPE;
     provider: IProvider | null;
-    init(): Promise<void>;
+    init(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     getConnector(connectorName: WALLET_CONNECTOR_TYPE): IConnector<unknown> | null;
     getPlugin(pluginName: string): IPlugin | null;
     logout(options?: {
@@ -137,9 +164,10 @@ export interface IWeb3Auth extends IWeb3AuthCore {
      * Connect to a specific wallet connector
      * @param walletName - Key of the wallet connector to use.
      */
-    connectTo<T>(walletName: WALLET_CONNECTOR_TYPE, loginParams?: T): Promise<IProvider | null>;
+    connectTo<T extends WALLET_CONNECTOR_TYPE>(walletName: T, loginParams?: LoginParamMap[T]): Promise<IProvider | null>;
     enableMFA<T>(params: T): Promise<void>;
     manageMFA<T>(params: T): Promise<void>;
+    cleanup(): Promise<void>;
 }
 export type Web3AuthNoModalEvents = ConnectorEvents & {
     [CONNECTOR_EVENTS.READY]: () => void;

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

@@ -0,0 +1,3 @@
+type Reviver = (key: string, value: unknown) => unknown;
+export declare function deserialize<T>(value: string, reviver?: Reviver): T;
+export {};

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

@@ -8,7 +8,6 @@ export interface IWeb3AuthError extends CustomError {
 export type ErrorCodes = {
     [key: number]: string;
 };
-export declare function serializeError(args: unknown[]): [Error, unknown[]];
 export declare abstract class Web3AuthError extends CustomError implements IWeb3AuthError {
     code: number;
     message: string;
@@ -48,7 +47,7 @@ export declare class WalletLoginError extends Web3AuthError {
     static mfaEnabled(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static chainConfigNotAdded(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static unsupportedOperation(extraMessage?: string, cause?: unknown): IWeb3AuthError;
-    static coreKitKeyNotFound(extraMessage?: string, cause?: unknown): IWeb3AuthError;
+    static sfaKeyNotFound(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static userNotLoggedIn(extraMessage?: string, cause?: unknown): IWeb3AuthError;
 }
 export declare class WalletOperationsError extends Web3AuthError {

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

@@ -1,33 +1,13 @@
-import { BaseEmbedControllerState } from "@toruslabs/base-controllers";
-import type { AuthUserInfo, LoginParams } from "@web3auth/auth";
-import { CONNECTOR_STATUS_TYPE, IProvider, UserAuthInfo } from "../connector";
+import { CONNECTOR_STATUS_TYPE, IProvider } from "../connector";
 import { IPlugin } from "../plugin";
 export interface IBaseWeb3AuthHookContext {
     isInitialized: boolean;
     isInitializing: boolean;
     initError: unknown;
     isConnected: boolean;
-    isConnecting: boolean;
-    connectError: unknown;
-    provider: IProvider | null;
-    userInfo: Partial<AuthUserInfo> | null;
     isMFAEnabled: boolean;
+    provider: IProvider | null;
     status: CONNECTOR_STATUS_TYPE | null;
-    enableMFA(params?: LoginParams): Promise<void>;
-    manageMFA(params?: LoginParams): Promise<void>;
-    logout(params?: {
-        cleanup: boolean;
-    }): Promise<void>;
     getPlugin(pluginName: string): IPlugin | null;
-    authenticateUser(): Promise<UserAuthInfo>;
-    switchChain(params: {
-        chainId: string;
-    }): Promise<void>;
-}
-export interface IBaseWalletServicesHookContext {
-    isPluginConnected: boolean;
-    showWalletConnectScanner(showWalletConnectParams?: BaseEmbedControllerState["showWalletConnect"]): Promise<void>;
-    showSwap(showSwapParams?: BaseEmbedControllerState["showSwap"]): Promise<void>;
-    showCheckout(showCheckoutParams?: BaseEmbedControllerState["showCheckout"]): Promise<void>;
-    showWalletUI(showWalletUiParams?: BaseEmbedControllerState["showWalletUi"]): Promise<void>;
+    setIsMFAEnabled(isMFAEnabled: boolean): void;
 }

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

@@ -1,7 +1,8 @@
-export * from "./chain/config";
 export * from "./chain/IChainInterface";
 export * from "./composables";
 export * from "./connector";
+export * from "./constants";
+export { cookieToWeb3AuthState } from "./cookie";
 export * from "./core/IWeb3Auth";
 export * from "./errors";
 export * from "./hooks";

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

@@ -2,11 +2,18 @@ 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";
+import { LOGIN_MODE, MODAL_SIGN_IN_METHODS, SMART_ACCOUNT_WALLET_SCOPE, WIDGET_TYPE } from "./constants";
+import { WALLET_CONNECTOR_TYPE } from "./wallet";
 export interface WhitelistResponse {
     urls: string[];
     signed_urls: Record<string, string>;
 }
+export interface IWeb3AuthState {
+    cachedConnector: string | null;
+    connectedConnectorName: WALLET_CONNECTOR_TYPE | null;
+    currentChainId: string;
+    idToken: string | null;
+}
 export type ChainsConfig = CustomChainConfig[];
 export interface ExternalWalletsConfig {
     disableAllRecommendedWallets?: boolean;
@@ -41,15 +48,14 @@ export interface WalletUiConfig {
     portfolioWidgetPosition?: BUTTON_POSITION_TYPE;
     defaultPortfolio?: "token" | "nft";
 }
+export type ModalSignInMethodType = (typeof MODAL_SIGN_IN_METHODS)[keyof typeof MODAL_SIGN_IN_METHODS];
+export type WidgetType = (typeof WIDGET_TYPE)[keyof typeof WIDGET_TYPE];
 export interface LoginModalConfig {
-    widgetType?: "embed" | "modal";
+    widgetType?: WidgetType;
     logoAlignment?: "left" | "center";
     borderRadiusType?: "small" | "medium" | "large";
     buttonRadiusType?: "pill" | "rounded" | "square";
-    tncLink?: string;
-    privacyPolicy?: string;
-    enableMainSocialLoginButton?: boolean;
-    signInMethods?: ("social" | "passwordless" | "externalWallets")[];
+    signInMethods?: ModalSignInMethodType[];
     addPreviousLoginHint?: boolean;
     displayInstalledExternalWallets?: boolean;
     displayExternalWalletsCount?: boolean;
@@ -96,6 +102,7 @@ export interface WalletRegistryItem {
     }[];
     imgExtension?: string;
 }
+export type LoginModeType = (typeof LOGIN_MODE)[keyof typeof LOGIN_MODE];
 export type WalletRegistry = {
     others: Record<string, WalletRegistryItem>;
     default: Record<string, WalletRegistryItem>;

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

@@ -1,2 +1,3 @@
 import loglevel from "loglevel";
-export declare const log: loglevel.Logger;
+declare const log: loglevel.Logger;
+export { log };

package/dist/lib.cjs/types/base/plugin/IPlugin.d.ts

@@ -1,6 +1,6 @@
 import { type SafeEventEmitter, WhiteLabelData } from "@web3auth/auth";
 import { type IWeb3AuthCore } from "../core/IWeb3Auth";
-import { WALLET_CONNECTOR_TYPE } from "../wallet";
+import { type WALLET_CONNECTOR_TYPE } from "../wallet";
 export declare const PLUGIN_NAMESPACES: {
     readonly MULTICHAIN: "multichain";
     readonly EIP155: "eip155";

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

@@ -1,9 +1,21 @@
 import { cloneDeep } from "@toruslabs/base-controllers";
+import { BUILD_ENV_TYPE } from "@web3auth/auth";
+import { type Chain } from "viem";
+import { CustomChainConfig } from "./chain/IChainInterface";
 import { type WEB3AUTH_NETWORK_TYPE } from "./connector";
 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<ProjectConfig>;
+export declare const signerHost: (web3AuthNetwork?: WEB3AUTH_NETWORK_TYPE, authBuildEnv?: BUILD_ENV_TYPE) => string;
+export declare const fetchProjectConfig: ({ clientId, web3AuthNetwork, aaProvider, authBuildEnv, }: {
+    clientId: string;
+    web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
+    aaProvider?: string;
+    authBuildEnv?: BUILD_ENV_TYPE;
+}) => Promise<ProjectConfig>;
 export declare const fetchWalletRegistry: (url?: string) => Promise<WalletRegistry>;
 export declare const normalizeWalletName: (name: string) => string;
+export declare const fromWagmiChain: (chain: Chain) => CustomChainConfig;
+export declare function withAbort<T>(fn: () => Promise<T>, signal?: AbortSignal, onAbort?: () => void): Promise<T>;
+export declare const isBrowser: () => boolean;
+export declare const fromViemChain: (chain: Chain) => CustomChainConfig;
 export { cloneDeep };