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

package/dist/{types/base/adapter → lib.cjs/types/base/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 { 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 { 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,74 +34,75 @@ 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;
     showOnMobile?: boolean;
     showOnDesktop?: boolean;
 }
-export type LoginMethodConfig = Record<string, {
+export type LoginMethodConfig = Partial<Record<AUTH_CONNECTION_TYPE, {
     /**
      * Display Name. If not provided, we use the default for auth app
      */
@@ -137,7 +139,15 @@ export type LoginMethodConfig = Record<string, {
      * Whether to show the login button on mobile
      */
     showOnMobile?: boolean;
-}>;
+    /**
+     * Auth connection id of the provider.
+     */
+    authConnectionId?: string;
+    /**
+     * Grouped auth connection id of the provider.
+     */
+    groupedAuthConnectionId?: string;
+}>>;
 export type WalletConnectV2Data = {
     uri: string;
 };

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

@@ -0,0 +1,142 @@
+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" | "chainId" | "chains" | "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.
+     * You can obtain your client id from the web3auth developer dashboard.
+     * You can set any random string for this on localhost.
+     */
+    clientId: string;
+    /**
+     * multiple chain configurations,
+     * only provided chains will be used
+     */
+    chains?: CustomChainConfig[];
+    /**
+     * default chain Id to use
+     */
+    defaultChainId?: string;
+    /**
+     * setting to true will enable logs
+     *
+     * @defaultValue false
+     */
+    enableLogging?: boolean;
+    /**
+     * setting to "local" will persist social login session across browser tabs.
+     *
+     * @defaultValue "local"
+     */
+    storageType?: "session" | "local";
+    /**
+     * sessionTime (in seconds) for idToken issued by Web3Auth for server side verification.
+     * @defaultValue 7 * 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 sapphire_mainnet
+     */
+    web3AuthNetwork?: WEB3AUTH_NETWORK_TYPE;
+    /**
+     * Uses core-kit key with web3auth provider
+     * @defaultValue false
+     */
+    useCoreKitKey?: boolean;
+    /**
+     * WhiteLabel options for web3auth
+     */
+    uiConfig?: UIConfig;
+    /**
+     * Account abstraction config for your chain namespace
+     */
+    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;
+    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>;
+    switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+}
+export interface IWeb3Auth extends IWeb3AuthCore {
+    connected: boolean;
+    cachedConnector: string | null;
+    getConnector(connectorName: WALLET_CONNECTOR_TYPE): IConnector<unknown> | null;
+    /**
+     * 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>;
+    enableMFA<T>(params: T): Promise<void>;
+    manageMFA<T>(params: T): Promise<void>;
+}
+export type Web3AuthNoModalEvents = ConnectorEvents & {
+    [CONNECTOR_EVENTS.READY]: () => void;
+    MODAL_VISIBILITY: (visibility: boolean) => void;
+};
+export type Web3AuthNoModalOptions = IWeb3AuthCoreOptions;

package/dist/{types → lib.cjs/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 → lib.cjs/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 → lib.cjs/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 → lib.cjs/types}/base/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { WhiteLabelData } from "@web3auth/auth";
+import { AuthConnectionConfig, WhiteLabelData } from "@web3auth/auth";
 import { ChainNamespaceType } from "./chain/IChainInterface";
 export interface WhitelistResponse {
     urls: string[];
@@ -11,6 +11,7 @@ export interface PROJECT_CONFIG_RESPONSE {
     wallet_connect_project_id?: string;
     whitelist?: WhitelistResponse;
     key_export_enabled?: boolean;
+    auth_connection_config?: AuthConnectionConfig;
 }
 export interface WalletRegistryItem {
     name: string;

package/dist/{types → 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_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 → lib.cjs/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 → lib.cjs/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/lib.cjs/types/base/wallet/index.d.ts

@@ -0,0 +1,29 @@
+export declare const MULTI_CHAIN_CONNECTORS: {
+    AUTH: string;
+    WALLET_CONNECT_V2: string;
+    SFA: string;
+};
+export declare const SOLANA_CONNECTORS: {
+    AUTH: string;
+    WALLET_CONNECT_V2: string;
+    SFA: string;
+};
+export declare const EVM_CONNECTORS: {
+    AUTH: string;
+    WALLET_CONNECT_V2: string;
+    SFA: string;
+    COINBASE: string;
+};
+export declare const WALLET_CONNECTORS: {
+    AUTH: string;
+    WALLET_CONNECT_V2: string;
+    SFA: string;
+    COINBASE: 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];
+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/lib.cjs/types/connectors/auth-connector/authConnector.d.ts

@@ -0,0 +1,49 @@
+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;
+    private authConnectionConfig;
+    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;
+    private connectWithSocialLogin;
+    private connectWithJwtLogin;
+    private getOAuthProviderConfig;
+}
+export declare const authConnector: (params?: Omit<AuthConnectorOptions, "coreOptions" | "authConnectionConfig">) => ConnectorFn;
+export type AuthConnectorType = AuthConnector;
+export {};

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

@@ -0,0 +1,2 @@
+import { AuthConnectionConfig, BUILD_ENV_TYPE, WEB3AUTH_NETWORK_TYPE } from "@web3auth/auth";
+export declare const getAuthConnectionConfig: (environment: BUILD_ENV_TYPE, network: WEB3AUTH_NETWORK_TYPE) => AuthConnectionConfig;

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

@@ -0,0 +1,18 @@
+import { BUILD_ENV_TYPE } from "@web3auth/auth";
+import { LogLevelDesc } from "loglevel";
+export declare const PASSWORDLESS_SERVER_API_URL = "https://api.web3auth.io/passwordless-service";
+export declare const PASSWORDLESS_SERVER_SOCKET_URL = "https://api-passwordless.web3auth.io";
+export declare const DEVELOP_PASSWORDLESS_SERVER_API_URL = "https://api-develop.web3auth.io/passwordless-service";
+export declare const DEVELOP_PASSWORDLESS_SERVER_SOCKET_URL = "https://api-develop-passwordless.web3auth.io";
+export declare const AUTH_SERVER_URL = "https://api.web3auth.io/auth-service";
+export declare const DEVELOP_AUTH_SERVER_URL = "https://api-develop.web3auth.io/auth-service";
+export interface ConfigBuild {
+    apiHost: string;
+    passwordlessBackendHost: string;
+    passwordlessHost: string;
+    sentrySampleRate: string;
+    sentryTransactionSampleRate: string;
+    supportsVersioning: boolean;
+    logLevel: LogLevelDesc;
+}
+export declare const configBuild: Record<BUILD_ENV_TYPE, ConfigBuild>;

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

@@ -0,0 +1,60 @@
+import { WEB3AUTH_NETWORK_TYPE } from "@web3auth/auth";
+export interface ConfigEnv {
+    googleClientId: string;
+    appleClientId: string;
+    discordClientId: string;
+    facebookClientId: string;
+    githubClientId: string;
+    kakaoClientId: string;
+    lineClientId: string;
+    linkedinClientId: string;
+    redditClientId: string;
+    twitchClientId: string;
+    twitterClientId: string;
+    weiboClientId: string;
+    wechatClientId: string;
+    hostedEmailPasswordlessClientId: string;
+    hostedSmsPasswordlessClientId: string;
+    hostedFarcasterClientId?: string;
+    passkeysClientId: string;
+    authenticatorClientId: string;
+    googleVerifier: string;
+    appleVerifier: string;
+    discordVerifier: string;
+    facebookVerifier: string;
+    githubVerifier: string;
+    kakaoVerifier: string;
+    lineVerifier: string;
+    linkedinVerifier: string;
+    redditVerifier: string;
+    twitchVerifier: string;
+    twitterVerifier: string;
+    weiboVerifier: string;
+    wechatVerifier: string;
+    hostedEmailPasswordlessVerifier: string;
+    hostedSmsPasswordlessVerifier: string;
+    passkeysVerifier: string;
+    authenticatorVerifier: string;
+    hostedFarcasterVerifier?: string;
+    walletGoogleVerifier?: string;
+    walletAppleVerifier?: string;
+    walletDiscordVerifier?: string;
+    walletFacebookVerifier?: string;
+    walletGithubVerifier?: string;
+    walletKakaoVerifier?: string;
+    walletLineVerifier?: string;
+    walletLinkedinVerifier?: string;
+    walletRedditVerifier?: string;
+    walletTwitchVerifier?: string;
+    walletTwitterVerifier?: string;
+    walletWeiboVerifier?: string;
+    walletWechatVerifier?: string;
+    walletHostedEmailPasswordlessVerifier?: string;
+    walletHostedSmsPasswordlessVerifier?: string;
+    loginDomain: string;
+    farcasterLoginDomain?: string;
+    verifierSubIdentifier: string;
+    signerHost: string;
+    metadataHost: string;
+}
+export declare const configEnv: Record<WEB3AUTH_NETWORK_TYPE, ConfigEnv>;

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

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

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

@@ -0,0 +1,15 @@
+import { AuthConnectionConfig, 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>;
+export type PrivateKeyProvider = IBaseProvider<string>;
+export type WalletServicesSettings = Omit<WsEmbedParams, "chains" | "chainId"> & {
+    modalZIndex?: number;
+};
+export interface AuthConnectorOptions extends BaseConnectorSettings {
+    connectorSettings?: Omit<AuthOptions, "clientId" | "network" | "authConnectionConfig">;
+    loginSettings?: LoginSettings;
+    walletServicesSettings?: WalletServicesSettings;
+    authConnectionConfig?: AuthConnectionConfig;
+}
+export { AUTH_CONNECTION, type AUTH_CONNECTION_TYPE, type AuthConnectionConfig, type AuthOptions, type AuthUserInfo, type LoginParams, } from "@web3auth/auth";

package/dist/lib.cjs/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/lib.cjs/types/connectors/base-evm-connector/index.d.ts

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

package/dist/lib.cjs/types/connectors/base-solana-connector/baseSolanaConnector.d.ts

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

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

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

package/dist/lib.cjs/types/connectors/coinbase-connector/coinbaseConnector.d.ts

@@ -0,0 +1,7 @@
+import { AppMetadata, Preference } from "@coinbase/wallet-sdk";
+import { BaseConnectorSettings, ConnectorFn } from "../../base";
+export type CoinbaseWalletSDKOptions = Partial<AppMetadata & Preference>;
+export interface CoinbaseConnectorOptions extends BaseConnectorSettings {
+    connectorSettings?: CoinbaseWalletSDKOptions;
+}
+export declare const coinbaseConnector: (params?: CoinbaseWalletSDKOptions) => ConnectorFn;

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

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

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

@@ -0,0 +1,7 @@
+export * from "./auth-connector";
+export * from "./base-evm-connector";
+export * from "./base-solana-connector";
+export * from "./coinbase-connector";
+export * from "./injected-evm-connector";
+export * from "./injected-solana-connector";
+export * from "./wallet-connect-v2-connector";

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

@@ -0,0 +1,2 @@
+export { injectedEvmConnector } from "./injectedEvmConnector";
+export { createStore as createMipd } from "mipd";