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

package/dist/noModal.umd.min.js.LICENSE.txt

@@ -53,12 +53,3 @@ PERFORMANCE OF THIS SOFTWARE.
  * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
  * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
  */
-
-/**
- * [js-sha3]{@link https://github.com/emn178/js-sha3}
- *
- * @version 0.8.0
- * @author Chen, Yi-Cyuan [emn178@gmail.com]
- * @copyright Chen, Yi-Cyuan 2015-2018
- * @license MIT
- */

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

@@ -6,14 +6,14 @@ export declare const CHAIN_NAMESPACES: {
     readonly OTHER: "other";
 };
 export type ChainNamespaceType = (typeof CHAIN_NAMESPACES)[keyof typeof CHAIN_NAMESPACES];
-export declare const ADAPTER_NAMESPACES: {
+export declare const CONNECTOR_NAMESPACES: {
     readonly EIP155: "eip155";
     readonly SOLANA: "solana";
     readonly CASPER: "casper";
     readonly XRPL: "xrpl";
     readonly MULTICHAIN: "multichain";
 };
-export type AdapterNamespaceType = (typeof ADAPTER_NAMESPACES)[keyof typeof ADAPTER_NAMESPACES];
+export type ConnectorNamespaceType = (typeof CONNECTOR_NAMESPACES)[keyof typeof CONNECTOR_NAMESPACES];
 export type CustomChainConfig = {
     chainNamespace: ChainNamespaceType;
     /**

package/dist/types/base/chain/config.d.ts

@@ -1,5 +1,5 @@
 import { ChainNamespaceType, CustomChainConfig } from "./IChainInterface";
-export declare const getEvmChainConfig: (chainId: number) => CustomChainConfig | null;
+export declare const getEvmChainConfig: (chainId: number, web3AuthClientId?: string) => CustomChainConfig | null;
 export declare const getSolanaChainConfig: (chainId: number) => CustomChainConfig | null;
 export declare const getXrplChainConfig: (chainId: number) => CustomChainConfig | null;
-export declare const getChainConfig: (chainNamespace: ChainNamespaceType, chainId?: number | string) => CustomChainConfig | null;
+export declare const getChainConfig: (chainNamespace: ChainNamespaceType, chainId?: number | string, web3AuthClientId?: string) => CustomChainConfig | null;

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

@@ -0,0 +1,37 @@
+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";
+export declare abstract class BaseConnector<T> extends SafeEventEmitter<ConnectorEvents> implements IConnector<T> {
+    connectorData?: unknown;
+    isInjected?: boolean;
+    coreOptions: BaseConnectorSettings["coreOptions"];
+    protected rehydrated: boolean;
+    abstract connectorNamespace: ConnectorNamespaceType;
+    abstract type: CONNECTOR_CATEGORY_TYPE;
+    abstract name: string;
+    abstract status: CONNECTOR_STATUS_TYPE;
+    constructor(options: BaseConnectorSettings);
+    get connnected(): boolean;
+    abstract get provider(): IProvider | null;
+    checkConnectionRequirements(): void;
+    checkInitializationRequirements({ chainConfig }: {
+        chainConfig?: CustomChainConfig;
+    }): void;
+    checkDisconnectionRequirements(): void;
+    checkSwitchChainRequirements(params: {
+        chainId: string;
+    }, init?: boolean): void;
+    updateConnectorData(data: unknown): void;
+    abstract init(options?: ConnectorInitOptions): Promise<void>;
+    abstract connect(params: T & {
+        chainId: string;
+    }): Promise<IProvider | null>;
+    abstract disconnect(): Promise<void>;
+    abstract getUserInfo(): Promise<Partial<UserInfo>>;
+    abstract enableMFA(params?: T): Promise<void>;
+    abstract manageMFA(params?: T): Promise<void>;
+    abstract authenticateUser(): Promise<UserAuthInfo>;
+    abstract switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+}

package/dist/types/base/{adapter → connector}/constants.d.ts

@@ -1,22 +1,25 @@
-export declare const ADAPTER_STATUS: {
+export declare const CONNECTOR_STATUS: {
     readonly NOT_READY: "not_ready";
     readonly READY: "ready";
     readonly CONNECTING: "connecting";
     readonly CONNECTED: "connected";
+    readonly DISCONNECTING: "disconnecting";
     readonly DISCONNECTED: "disconnected";
     readonly ERRORED: "errored";
 };
-export declare const ADAPTER_EVENTS: {
-    readonly ADAPTER_DATA_UPDATED: "adapter_data_updated";
+export declare const CONNECTOR_EVENTS: {
+    readonly CONNECTOR_DATA_UPDATED: "connector_data_updated";
     readonly CACHE_CLEAR: "cache_clear";
+    readonly CONNECTORS_UPDATED: "connectors_updated";
     readonly NOT_READY: "not_ready";
     readonly READY: "ready";
     readonly CONNECTING: "connecting";
     readonly CONNECTED: "connected";
+    readonly DISCONNECTING: "disconnecting";
     readonly DISCONNECTED: "disconnected";
     readonly ERRORED: "errored";
 };
-export declare const ADAPTER_CATEGORY: {
+export declare const CONNECTOR_CATEGORY: {
     readonly EXTERNAL: "external";
     readonly IN_APP: "in_app";
 };

package/dist/types/base/{adapter → connector}/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./baseAdapter";
+export * from "./baseConnector";
 export * from "./constants";
 export * from "./interfaces";
 export * from "./utils";

package/dist/types/base/{adapter → connector}/interfaces.d.ts

@@ -1,28 +1,29 @@
-import { ChainNamespaceType } from "@toruslabs/base-controllers";
 import { AuthUserInfo, JRPCRequest, JRPCResponse, Maybe, RequestArguments, SafeEventEmitter, SendCallBack, UX_MODE, type UX_MODE_TYPE, WEB3AUTH_NETWORK, type WEB3AUTH_NETWORK_TYPE } from "@web3auth/auth";
-import { AdapterNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
+import { ConnectorNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
+import { IWeb3AuthCoreOptions } from "../core/IWeb3Auth";
 import { Web3AuthError } from "../errors";
+import { PROJECT_CONFIG_RESPONSE } from "../interfaces";
 import { ProviderEvents, SafeEventEmitterProvider } from "../provider/IProvider";
-import { ADAPTER_CATEGORY, ADAPTER_EVENTS, ADAPTER_STATUS } from "./constants";
+import { CONNECTOR_CATEGORY, CONNECTOR_EVENTS, CONNECTOR_STATUS } from "./constants";
 export type UserInfo = AuthUserInfo;
 export { UX_MODE, UX_MODE_TYPE, WEB3AUTH_NETWORK, WEB3AUTH_NETWORK_TYPE };
-export type ADAPTER_CATEGORY_TYPE = (typeof ADAPTER_CATEGORY)[keyof typeof ADAPTER_CATEGORY];
-export interface AdapterInitOptions {
+export type CONNECTOR_CATEGORY_TYPE = (typeof CONNECTOR_CATEGORY)[keyof typeof CONNECTOR_CATEGORY];
+export interface ConnectorInitOptions {
     /**
-     * Whether to auto connect to the adapter based on redirect mode or saved adapters
+     * Whether to auto connect to the connector based on redirect mode or saved connectors
      */
     autoConnect?: boolean;
+    /**
+     * The chainId to connect to
+     */
+    chainId: string;
 }
-export type ADAPTER_STATUS_TYPE = (typeof ADAPTER_STATUS)[keyof typeof ADAPTER_STATUS];
+export type CONNECTOR_STATUS_TYPE = (typeof CONNECTOR_STATUS)[keyof typeof CONNECTOR_STATUS];
 export type UserAuthInfo = {
     idToken: string;
 };
-export interface BaseAdapterSettings {
-    clientId?: string;
-    sessionTime?: number;
-    chainConfig?: CustomChainConfig;
-    web3AuthNetwork?: WEB3AUTH_NETWORK_TYPE;
-    useCoreKitKey?: boolean;
+export interface BaseConnectorSettings {
+    coreOptions: IWeb3AuthCoreOptions;
 }
 export interface IProvider extends SafeEventEmitter<ProviderEvents> {
     get chainId(): string;
@@ -33,67 +34,68 @@ export interface IProvider extends SafeEventEmitter<ProviderEvents> {
 }
 export interface IBaseProvider<T> extends IProvider {
     provider: SafeEventEmitterProvider | null;
-    currentChainConfig: CustomChainConfig;
-    setupProvider(provider: T): Promise<void>;
-    addChain(chainConfig: CustomChainConfig): void;
+    currentChain: CustomChainConfig;
+    setupProvider(provider: T, chainId: string): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
     updateProviderEngineProxy(provider: SafeEventEmitterProvider): void;
     setKeyExportFlag(flag: boolean): void;
 }
-export interface IAdapter<T> extends SafeEventEmitter {
-    adapterNamespace: AdapterNamespaceType;
-    currentChainNamespace: ChainNamespaceType;
-    chainConfigProxy: CustomChainConfig | null;
-    type: ADAPTER_CATEGORY_TYPE;
+export interface IConnector<T> extends SafeEventEmitter {
+    connectorNamespace: ConnectorNamespaceType;
+    type: CONNECTOR_CATEGORY_TYPE;
     name: string;
-    sessionTime: number;
-    web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
-    useCoreKitKey: boolean | undefined;
-    clientId: string;
-    status: ADAPTER_STATUS_TYPE;
+    status: CONNECTOR_STATUS_TYPE;
     provider: IProvider | null;
-    adapterData?: unknown;
+    connectorData?: unknown;
     connnected: boolean;
     isInjected?: boolean;
-    addChain(chainConfig: CustomChainConfig): Promise<void>;
-    init(options?: AdapterInitOptions): Promise<void>;
+    init(options?: ConnectorInitOptions): Promise<void>;
     disconnect(options?: {
         cleanup: boolean;
     }): Promise<void>;
-    connect(params?: T): Promise<IProvider | null>;
+    connect(params: T & {
+        chainId: string;
+    }): Promise<IProvider | null>;
     getUserInfo(): Promise<Partial<UserInfo>>;
     enableMFA(params?: T): Promise<void>;
     manageMFA(params?: T): Promise<void>;
-    setAdapterSettings(adapterSettings: BaseAdapterSettings): void;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
     authenticateUser(): Promise<UserAuthInfo>;
 }
+export type ConnectorParams = {
+    projectConfig?: PROJECT_CONFIG_RESPONSE;
+    coreOptions: IWeb3AuthCoreOptions;
+};
+export type ConnectorFn = (params: ConnectorParams) => IConnector<unknown>;
 export type CONNECTED_EVENT_DATA = {
-    adapter: string;
+    connector: string;
     provider: IProvider;
     reconnected: boolean;
 };
-export interface IAdapterDataEvent {
-    adapterName: string;
+export interface IConnectorDataEvent {
+    connectorName: string;
     data: unknown;
 }
-export type AdapterEvents = {
-    [ADAPTER_EVENTS.NOT_READY]: () => void;
-    [ADAPTER_EVENTS.READY]: (adapter: string) => void;
-    [ADAPTER_EVENTS.CONNECTED]: (data: CONNECTED_EVENT_DATA) => void;
-    [ADAPTER_EVENTS.DISCONNECTED]: () => void;
-    [ADAPTER_EVENTS.CONNECTING]: (data: {
-        adapter: string;
+export type ConnectorEvents = {
+    [CONNECTOR_EVENTS.NOT_READY]: () => void;
+    [CONNECTOR_EVENTS.READY]: (connector: string) => void;
+    [CONNECTOR_EVENTS.CONNECTED]: (data: CONNECTED_EVENT_DATA) => void;
+    [CONNECTOR_EVENTS.DISCONNECTED]: () => void;
+    [CONNECTOR_EVENTS.CONNECTING]: (data: {
+        connector: string;
+    }) => void;
+    [CONNECTOR_EVENTS.ERRORED]: (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;
-    [ADAPTER_EVENTS.ERRORED]: (error: Web3AuthError) => void;
-    [ADAPTER_EVENTS.ADAPTER_DATA_UPDATED]: (data: IAdapterDataEvent) => void;
-    [ADAPTER_EVENTS.CACHE_CLEAR]: () => void;
 };
-export interface BaseAdapterConfig {
+export interface BaseConnectorConfig {
     label: string;
     isInjected?: boolean;
     showOnModal?: boolean;

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

@@ -1,8 +1,31 @@
-import { SafeEventEmitter, WhiteLabelData } from "@web3auth/auth";
-import { ADAPTER_EVENTS, ADAPTER_STATUS_TYPE, AdapterEvents, IAdapter, IBaseProvider, IProvider, UserAuthInfo, UserInfo, WEB3AUTH_NETWORK_TYPE } from "../adapter";
-import { CustomChainConfig } from "../chain/IChainInterface";
-import { type IPlugin } from "../plugin";
-import { WALLET_ADAPTER_TYPE } from "../wallet";
+import { type AccountAbstractionConfig } from "@toruslabs/ethereum-controllers";
+import { 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";
+import { type IPlugin, PluginFn } from "../plugin";
+import { type WALLET_CONNECTOR_TYPE } from "../wallet";
+export type WalletServicesConfig = Omit<WsEmbedParams, "buildEnv" | "enableLogging" | "chainConfig" | "confirmationStrategy" | "accountAbstractionConfig"> & {
+    /**
+     * Determines how to show confirmation screens
+     * @defaultValue default
+     *
+     * default & auto-approve
+     * - use auto-approve as default
+     * - if wallet connect request use modal
+     *
+     * modal
+     * - use modal always
+     */
+    confirmationStrategy?: Exclude<WsEmbedParams["confirmationStrategy"], "popup">;
+    modalZIndex?: number;
+};
+export interface UIConfig extends WhiteLabelData {
+    /**
+     * UX Mode for the auth connector
+     */
+    uxMode?: UX_MODE_TYPE;
+}
 export interface IWeb3AuthCoreOptions {
     /**
      * Client id for web3auth.
@@ -11,11 +34,14 @@ export interface IWeb3AuthCoreOptions {
      */
     clientId: string;
     /**
-     * custom chain configuration for chainNamespace
-     *
-     * @defaultValue mainnet config of provided chainNamespace
+     * multiple chain configurations,
+     * only provided chains will be used
+     */
+    chains?: CustomChainConfig[];
+    /**
+     * default chain Id to use
      */
-    chainConfig?: CustomChainConfig;
+    defaultChainId?: string;
     /**
      * setting to true will enable logs
      *
@@ -27,17 +53,17 @@ export interface IWeb3AuthCoreOptions {
      *
      * @defaultValue "local"
      */
-    storageKey?: "session" | "local";
+    storageType?: "session" | "local";
     /**
      * sessionTime (in seconds) for idToken issued by Web3Auth for server side verification.
-     * @defaultValue 86400
+     * @defaultValue 7 * 86400
      *
-     * Note: max value can be 7 days (86400 * 7) and min can be  1 day (86400)
+     * Note: max value can be 30 days (86400 * 30) and min can be  1 sec (1)
      */
     sessionTime?: number;
     /**
      * Web3Auth Network to use for the session & the issued idToken
-     * @defaultValue mainnet
+     * @defaultValue sapphire_mainnet
      */
     web3AuthNetwork?: WEB3AUTH_NETWORK_TYPE;
     /**
@@ -48,54 +74,69 @@ export interface IWeb3AuthCoreOptions {
     /**
      * WhiteLabel options for web3auth
      */
-    uiConfig?: WhiteLabelData;
-    /**
-     * Private key provider for your chain namespace
-     */
-    privateKeyProvider?: IBaseProvider<string>;
+    uiConfig?: UIConfig;
     /**
-     * Account abstraction provider for your chain namespace
+     * Account abstraction config for your chain namespace
      */
-    accountAbstractionProvider?: IBaseProvider<IProvider>;
+    accountAbstractionConfig?: AccountAbstractionConfig;
     /**
      * Whether to use AA with external wallet
      */
     useAAWithExternalWallet?: boolean;
+    /**
+     * Connectors to use
+     */
+    connectors?: ConnectorFn[];
+    /**
+     * Plugins to use
+     */
+    plugins?: PluginFn[];
+    /**
+     * Whether to enable multi injected provider discovery
+     * @defaultValue true
+     */
+    multiInjectedProviderDiscovery?: boolean;
+    /**
+     * Wallet services config
+     */
+    walletServicesConfig?: WalletServicesConfig;
+    /**
+     * Private key provider for xrpl, mpc cases
+     */
+    privateKeyProvider?: IBaseProvider<string>;
 }
 export interface IWeb3AuthCore extends SafeEventEmitter {
     readonly coreOptions: IWeb3AuthCoreOptions;
-    connectedAdapterName: string | null;
-    status: ADAPTER_STATUS_TYPE;
+    connectedConnectorName: string | null;
+    currentChain: CustomChainConfig;
+    status: CONNECTOR_STATUS_TYPE;
     provider: IProvider | null;
     init(): Promise<void>;
+    getConnector(connectorName: WALLET_CONNECTOR_TYPE): IConnector<unknown> | null;
+    getPlugin(pluginName: string): IPlugin | null;
     logout(options?: {
         cleanup: boolean;
     }): Promise<void>;
     getUserInfo(): Promise<Partial<UserInfo>>;
     authenticateUser(): Promise<UserAuthInfo>;
-    addChain(chainConfig: CustomChainConfig): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
-    addPlugin(plugin: IPlugin): void;
-    getPlugin(pluginName: string): IPlugin | null;
 }
 export interface IWeb3Auth extends IWeb3AuthCore {
     connected: boolean;
-    cachedAdapter: string | null;
-    walletAdapters: Record<string, IAdapter<unknown>>;
-    getAdapter(adapterName: WALLET_ADAPTER_TYPE): IAdapter<unknown> | null;
-    configureAdapter(adapter: IAdapter<unknown>): IWeb3Auth;
+    cachedConnector: string | null;
+    getConnector(connectorName: WALLET_CONNECTOR_TYPE): IConnector<unknown> | null;
     /**
-     * Connect to a specific wallet adapter
-     * @param walletName - Key of the walletAdapter to use.
+     * Connect to a specific wallet connector
+     * @param walletName - Key of the wallet connector to use.
      */
-    connectTo<T>(walletName: WALLET_ADAPTER_TYPE, loginParams?: T): Promise<IProvider | null>;
+    connectTo<T>(walletName: WALLET_CONNECTOR_TYPE, loginParams?: T): Promise<IProvider | null>;
     enableMFA<T>(params: T): Promise<void>;
     manageMFA<T>(params: T): Promise<void>;
 }
-export type Web3AuthNoModalEvents = AdapterEvents & {
-    [ADAPTER_EVENTS.READY]: () => void;
+export type Web3AuthNoModalEvents = ConnectorEvents & {
+    [CONNECTOR_EVENTS.READY]: () => void;
     MODAL_VISIBILITY: (visibility: boolean) => void;
 };
 export type Web3AuthNoModalOptions = IWeb3AuthCoreOptions;

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

@@ -27,7 +27,7 @@ export declare class WalletInitializationError extends Web3AuthError {
     static windowBlocked(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static windowClosed(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static incompatibleChainNameSpace(extraMessage?: string, cause?: unknown): IWeb3AuthError;
-    static duplicateAdapterError(extraMessage?: string, cause?: unknown): IWeb3AuthError;
+    static duplicateConnectorError(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static invalidProviderConfigError(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static providerNotReadyError(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static rpcConnectionError(extraMessage?: string, cause?: unknown): IWeb3AuthError;

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

@@ -1,7 +1,6 @@
 import { BaseEmbedControllerState } from "@toruslabs/base-controllers";
 import type { AuthUserInfo, LoginParams } from "@web3auth/auth";
-import { ADAPTER_STATUS_TYPE, IProvider, UserAuthInfo } from "../adapter";
-import { CustomChainConfig } from "../chain/IChainInterface";
+import { CONNECTOR_STATUS_TYPE, IProvider, UserAuthInfo } from "../connector";
 import { IPlugin } from "../plugin";
 export interface IBaseWeb3AuthHookContext {
     isInitialized: boolean;
@@ -13,17 +12,14 @@ export interface IBaseWeb3AuthHookContext {
     provider: IProvider | null;
     userInfo: Partial<AuthUserInfo> | null;
     isMFAEnabled: boolean;
-    status: ADAPTER_STATUS_TYPE | null;
+    status: CONNECTOR_STATUS_TYPE | null;
     enableMFA(params?: LoginParams): Promise<void>;
     manageMFA(params?: LoginParams): Promise<void>;
     logout(params?: {
         cleanup: boolean;
     }): Promise<void>;
-    addAndSwitchChain(chainConfig: CustomChainConfig): Promise<void>;
-    addPlugin(plugin: IPlugin): void;
     getPlugin(pluginName: string): IPlugin | null;
     authenticateUser(): Promise<UserAuthInfo>;
-    addChain(chainConfig: CustomChainConfig): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;

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

@@ -1,7 +1,7 @@
-export * from "./adapter";
 export * from "./chain/config";
 export * from "./chain/IChainInterface";
 export * from "./composables";
+export * from "./connector";
 export * from "./core/IWeb3Auth";
 export * from "./errors";
 export * from "./hooks";

package/dist/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_ADAPTER_TYPE } from "../wallet";
+import { WALLET_CONNECTOR_TYPE } from "../wallet";
 export declare const PLUGIN_NAMESPACES: {
     readonly MULTICHAIN: "multichain";
     readonly EIP155: "eip155";
@@ -37,17 +37,14 @@ export declare const WALLET_PLUGINS: {
     readonly WALLET_SERVICES: "wallet-services";
     readonly NFT_CHECKOUT: "nft-checkout";
 };
-export interface PluginConnectParams {
-    sessionId: string;
-    sessionNamespace?: string;
-}
 export interface IPlugin extends SafeEventEmitter {
     name: string;
     status: PLUGIN_STATUS_TYPE;
-    SUPPORTED_ADAPTERS: WALLET_ADAPTER_TYPE[];
+    SUPPORTED_CONNECTORS: WALLET_CONNECTOR_TYPE[];
     pluginNamespace: PluginNamespace;
     initWithWeb3Auth(web3auth: IWeb3AuthCore, whiteLabel?: WhiteLabelData): Promise<void>;
-    connect(params?: PluginConnectParams): Promise<void>;
+    connect(): Promise<void>;
     disconnect(): Promise<void>;
     cleanup(): Promise<void>;
 }
+export type PluginFn = () => IPlugin;

package/dist/types/base/plugin/errors.d.ts

@@ -4,7 +4,7 @@ export declare class WalletServicesPluginError extends Web3AuthError {
     constructor(code: number, message?: string, cause?: unknown);
     static fromCode(code: number, extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static notInitialized(extraMessage?: string, cause?: unknown): IWeb3AuthError;
-    static unsupportedAdapter(extraMessage?: string, cause?: unknown): IWeb3AuthError;
+    static unsupportedConnector(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static providerRequired(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static web3authRequired(extraMessage?: string, cause?: unknown): IWeb3AuthError;
     static web3AuthNotConnected(extraMessage?: string, cause?: unknown): IWeb3AuthError;

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

@@ -1,5 +1,5 @@
 import { cloneDeep } from "@toruslabs/base-controllers";
-import { type WEB3AUTH_NETWORK_TYPE } from "./adapter";
+import { type WEB3AUTH_NETWORK_TYPE } from "./connector";
 import type { PROJECT_CONFIG_RESPONSE, WalletRegistry } from "./interfaces";
 export declare const isHexStrict: (hex: string) => boolean;
 export declare const signerHost: (web3AuthNetwork?: WEB3AUTH_NETWORK_TYPE) => string;

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

@@ -1,33 +1,29 @@
-export declare const MULTI_CHAIN_ADAPTERS: {
+export declare const MULTI_CHAIN_CONNECTORS: {
     AUTH: string;
     WALLET_CONNECT_V2: string;
     SFA: string;
 };
-export declare const SOLANA_ADAPTERS: {
+export declare const SOLANA_CONNECTORS: {
     AUTH: string;
     WALLET_CONNECT_V2: string;
     SFA: string;
-    TORUS_SOLANA: string;
 };
-export declare const EVM_ADAPTERS: {
+export declare const EVM_CONNECTORS: {
     AUTH: string;
     WALLET_CONNECT_V2: string;
     SFA: string;
-    TORUS_EVM: string;
     COINBASE: string;
 };
-export declare const WALLET_ADAPTERS: {
+export declare const WALLET_CONNECTORS: {
     AUTH: string;
     WALLET_CONNECT_V2: string;
     SFA: string;
-    TORUS_SOLANA: string;
-    TORUS_EVM: string;
     COINBASE: string;
 };
-export type WALLET_ADAPTER_TYPE = (typeof WALLET_ADAPTERS)[keyof typeof WALLET_ADAPTERS];
-export type SOLANA_ADAPTER_TYPE = (typeof SOLANA_ADAPTERS)[keyof typeof SOLANA_ADAPTERS];
-export type EVM_ADAPTER_TYPE = (typeof EVM_ADAPTERS)[keyof typeof EVM_ADAPTERS];
-export type MULTI_CHAIN_ADAPTER_TYPE = (typeof MULTI_CHAIN_ADAPTERS)[keyof typeof MULTI_CHAIN_ADAPTERS];
-export declare const ADAPTER_NAMES: {
+export type WALLET_CONNECTOR_TYPE = (typeof WALLET_CONNECTORS)[keyof typeof WALLET_CONNECTORS];
+export type SOLANA_CONNECTOR_TYPE = (typeof SOLANA_CONNECTORS)[keyof typeof SOLANA_CONNECTORS];
+export type EVM_CONNECTOR_TYPE = (typeof EVM_CONNECTORS)[keyof typeof EVM_CONNECTORS];
+export type MULTI_CHAIN_CONNECTOR_TYPE = (typeof MULTI_CHAIN_CONNECTORS)[keyof typeof MULTI_CHAIN_CONNECTORS];
+export declare const CONNECTOR_NAMES: {
     [x: string]: string;
 };

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

@@ -0,0 +1,45 @@
+import { Auth, 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";
+export type AuthLoginParams = LoginParams & {
+    login_hint?: string;
+};
+declare class AuthConnector extends BaseConnector<AuthLoginParams> {
+    readonly name: string;
+    readonly connectorNamespace: ConnectorNamespaceType;
+    readonly type: CONNECTOR_CATEGORY_TYPE;
+    authInstance: Auth | null;
+    status: CONNECTOR_STATUS_TYPE;
+    privateKeyProvider: PrivateKeyProvider | null;
+    private authOptions;
+    private loginSettings;
+    private wsSettings;
+    private wsEmbedInstance;
+    constructor(params: AuthConnectorOptions);
+    get provider(): IProvider | null;
+    get wsEmbed(): WsEmbed;
+    set provider(_: IProvider | null);
+    init(options: ConnectorInitOptions): Promise<void>;
+    connect(params: Partial<AuthLoginParams> & {
+        chainId: string;
+    }): Promise<IProvider | null>;
+    enableMFA(params?: AuthLoginParams): Promise<void>;
+    manageMFA(params?: AuthLoginParams): Promise<void>;
+    disconnect(options?: {
+        cleanup: boolean;
+    }): Promise<void>;
+    authenticateUser(): Promise<{
+        idToken: string;
+    }>;
+    getUserInfo(): Promise<Partial<UserInfo>>;
+    switchChain(params: {
+        chainId: string;
+    }, init?: boolean): Promise<void>;
+    private getChain;
+    private _getFinalPrivKey;
+    private connectWithProvider;
+}
+export declare const authConnector: (params?: Omit<AuthConnectorOptions, "coreOptions">) => ConnectorFn;
+export type AuthConnectorType = AuthConnector;
+export {};

package/dist/types/connectors/auth-connector/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./authConnector";
+export * from "./interface";

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

@@ -0,0 +1,14 @@
+import { type AuthOptions, type BaseRedirectParams, type LoginParams } from "@web3auth/auth";
+import { type WsEmbedParams } from "@web3auth/ws-embed";
+import { type BaseConnectorSettings, type IBaseProvider } from "../../base";
+export type LoginSettings = Partial<LoginParams> & Partial<BaseRedirectParams>;
+export type PrivateKeyProvider = IBaseProvider<string>;
+export type WalletServicesSettings = WsEmbedParams & {
+    modalZIndex?: number;
+};
+export interface AuthConnectorOptions extends BaseConnectorSettings {
+    connectorSettings?: Omit<AuthOptions, "clientId" | "network">;
+    loginSettings?: LoginSettings;
+    walletServicesSettings?: WalletServicesSettings;
+}
+export { type AuthOptions, type AuthUserInfo, LOGIN_PROVIDER, type LoginConfig, type LoginParams } from "@web3auth/auth";

package/dist/types/connectors/base-evm-connector/baseEvmConnector.d.ts

@@ -0,0 +1,7 @@
+import { BaseConnector, ConnectorInitOptions, UserAuthInfo } from "../../base";
+export declare abstract class BaseEvmConnector<T> extends BaseConnector<T> {
+    init(_?: ConnectorInitOptions): Promise<void>;
+    authenticateUser(): Promise<UserAuthInfo>;
+    disconnectSession(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/types/connectors/base-evm-connector/index.d.ts

@@ -0,0 +1 @@
+export * from "./baseEvmConnector";