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

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

@@ -1,3 +1,18 @@
+/*!
+   *  decimal.js v10.5.0
+   *  An arbitrary-precision Decimal type for JavaScript.
+   *  https://github.com/MikeMcl/decimal.js
+   *  Copyright (c) 2025 Michael Mclaughlin <M8ch88l@gmail.com>
+   *  MIT Licence
+   */
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
 /*!
  * The buffer module from node.js, for the browser.
  *
@@ -5,6 +20,45 @@
  * @license  MIT
  */
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
 /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * 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/adapters/auth-adapter/authAdapter.d.ts

@@ -0,0 +1,42 @@
+import { Auth, AuthOptions, LoginParams } from "@web3auth/auth";
+import { ADAPTER_CATEGORY_TYPE, ADAPTER_STATUS_TYPE, AdapterInitOptions, AdapterNamespaceType, BaseAdapter, BaseAdapterSettings, ChainNamespaceType, CustomChainConfig, IProvider, UserInfo } from "../../base";
+import type { AuthAdapterOptions, PrivateKeyProvider } from "./interface";
+export type AuthLoginParams = LoginParams & {
+    login_hint?: string;
+};
+export declare class AuthAdapter extends BaseAdapter<AuthLoginParams> {
+    readonly name: string;
+    readonly adapterNamespace: AdapterNamespaceType;
+    readonly type: ADAPTER_CATEGORY_TYPE;
+    authInstance: Auth | null;
+    status: ADAPTER_STATUS_TYPE;
+    currentChainNamespace: ChainNamespaceType;
+    privateKeyProvider: PrivateKeyProvider | null;
+    private authOptions;
+    private loginSettings;
+    constructor(params?: AuthAdapterOptions);
+    get chainConfigProxy(): CustomChainConfig | null;
+    get provider(): IProvider | null;
+    set provider(_: IProvider | null);
+    init(options: AdapterInitOptions): Promise<void>;
+    connect(params?: AuthLoginParams): 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>>;
+    setAdapterSettings(adapterSettings: Partial<AuthOptions & BaseAdapterSettings> & {
+        privateKeyProvider?: PrivateKeyProvider;
+    }): void;
+    addChain(chainConfig: CustomChainConfig, init?: boolean): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }, init?: boolean): Promise<void>;
+    private _getFinalPrivKey;
+    private _getFinalEd25519PrivKey;
+    private connectWithProvider;
+}

package/dist/types/adapters/auth-adapter/config.d.ts

@@ -0,0 +1,2 @@
+import { AuthAdapterOptions } from "./interface";
+export declare const getAuthDefaultOptions: () => AuthAdapterOptions;

package/dist/types/adapters/auth-adapter/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./authAdapter";
+export * from "./config";
+export * from "./interface";

package/dist/types/adapters/auth-adapter/interface.d.ts

@@ -0,0 +1,11 @@
+import { AuthOptions, BaseRedirectParams, LoginParams } from "@web3auth/auth";
+import { BaseAdapterSettings, IBaseProvider } from "../../base";
+export type LoginSettings = Partial<LoginParams> & Partial<BaseRedirectParams>;
+type MakeOptional<Type, Key extends keyof Type> = Omit<Type, Key> & Partial<Pick<Type, Key>>;
+export type PrivateKeyProvider = IBaseProvider<string>;
+export interface AuthAdapterOptions extends BaseAdapterSettings {
+    adapterSettings?: MakeOptional<AuthOptions, "clientId" | "network">;
+    loginSettings?: LoginSettings;
+    privateKeyProvider?: PrivateKeyProvider;
+}
+export { type AuthOptions, type AuthUserInfo, LOGIN_PROVIDER, type LoginConfig, type LoginParams } from "@web3auth/auth";

package/dist/types/adapters/base-evm-adapter/baseEvmAdapter.d.ts

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

package/dist/types/adapters/base-evm-adapter/index.d.ts

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

package/dist/types/adapters/base-solana-adapter/baseSolanaAdapter.d.ts

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

package/dist/types/adapters/base-solana-adapter/index.d.ts

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

package/dist/types/adapters/coinbase-adapter/coinbaseAdapter.d.ts

@@ -0,0 +1,33 @@
+import { AppMetadata, Preference } from "@coinbase/wallet-sdk";
+import { ADAPTER_CATEGORY_TYPE, ADAPTER_STATUS_TYPE, AdapterInitOptions, AdapterNamespaceType, BaseAdapterSettings, ChainNamespaceType, CustomChainConfig, IProvider, UserInfo } from "../../base";
+import { BaseEvmAdapter } from "../base-evm-adapter";
+export type CoinbaseWalletSDKOptions = Partial<AppMetadata & Preference>;
+export interface CoinbaseAdapterOptions extends BaseAdapterSettings {
+    adapterSettings?: CoinbaseWalletSDKOptions;
+}
+declare class CoinbaseAdapter extends BaseEvmAdapter<void> {
+    readonly adapterNamespace: AdapterNamespaceType;
+    readonly currentChainNamespace: ChainNamespaceType;
+    readonly type: ADAPTER_CATEGORY_TYPE;
+    readonly name: string;
+    status: ADAPTER_STATUS_TYPE;
+    private coinbaseProvider;
+    private coinbaseOptions;
+    constructor(adapterOptions?: CoinbaseAdapterOptions);
+    get provider(): IProvider | null;
+    set provider(_: IProvider | null);
+    setAdapterSettings(options: CoinbaseAdapterOptions): void;
+    init(options?: AdapterInitOptions): Promise<void>;
+    connect(): Promise<IProvider | null>;
+    disconnect(options?: {
+        cleanup: boolean;
+    }): Promise<void>;
+    getUserInfo(): Promise<Partial<UserInfo>>;
+    addChain(chainConfig: CustomChainConfig, init?: boolean): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }, init?: boolean): Promise<void>;
+    enableMFA(): Promise<void>;
+    manageMFA(): Promise<void>;
+}
+export { CoinbaseAdapter };

package/dist/types/adapters/coinbase-adapter/index.d.ts

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

package/dist/types/adapters/default-evm-adapter/index.d.ts

@@ -0,0 +1,6 @@
+import { IAdapter, IWeb3AuthCoreOptions } from "../../base";
+import { getEvmInjectedAdapters } from "./injectedAdapters";
+export declare const getEvmDefaultExternalAdapters: (params: {
+    options: IWeb3AuthCoreOptions;
+}) => IAdapter<unknown>[];
+export { getEvmInjectedAdapters };

package/dist/types/adapters/default-evm-adapter/injectedAdapters.d.ts

@@ -0,0 +1,4 @@
+import { IAdapter, IWeb3AuthCoreOptions } from "../../base";
+export declare const getEvmInjectedAdapters: (params: {
+    options: IWeb3AuthCoreOptions;
+}) => IAdapter<unknown>[];

package/dist/types/adapters/default-evm-adapter/injectedEvmAdapter.d.ts

@@ -0,0 +1,30 @@
+import { ADAPTER_CATEGORY_TYPE, ADAPTER_STATUS_TYPE, AdapterInitOptions, AdapterNamespaceType, BaseAdapterSettings, ChainNamespaceType, CustomChainConfig, IProvider, UserInfo } from "../../base";
+import { BaseEvmAdapter } from "../base-evm-adapter";
+declare class InjectedEvmAdapter extends BaseEvmAdapter<void> {
+    readonly adapterNamespace: AdapterNamespaceType;
+    readonly currentChainNamespace: ChainNamespaceType;
+    readonly type: ADAPTER_CATEGORY_TYPE;
+    readonly name: string;
+    readonly isInjected = true;
+    status: ADAPTER_STATUS_TYPE;
+    private injectedProvider;
+    constructor(options: BaseAdapterSettings & {
+        name: string;
+        provider: IProvider;
+    });
+    get provider(): IProvider | null;
+    set provider(_: IProvider | null);
+    init(options?: AdapterInitOptions): Promise<void>;
+    connect(): Promise<IProvider | null>;
+    disconnect(options?: {
+        cleanup: boolean;
+    }): Promise<void>;
+    getUserInfo(): Promise<Partial<UserInfo>>;
+    addChain(chainConfig: CustomChainConfig, init?: boolean): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }, init?: boolean): Promise<void>;
+    enableMFA(): Promise<void>;
+    manageMFA(): Promise<void>;
+}
+export { InjectedEvmAdapter };

package/dist/types/adapters/default-solana-adapter/index.d.ts

@@ -0,0 +1,6 @@
+import { IAdapter, IWeb3AuthCoreOptions } from "../../base";
+import { getSolanaInjectedAdapters } from "./injectedAdapters";
+export declare const getSolanaDefaultExternalAdapters: (params: {
+    options: IWeb3AuthCoreOptions;
+}) => IAdapter<unknown>[];
+export { getSolanaInjectedAdapters };

package/dist/types/adapters/default-solana-adapter/injectedAdapters.d.ts

@@ -0,0 +1,4 @@
+import { IAdapter, IWeb3AuthCoreOptions } from "../../base";
+export declare const getSolanaInjectedAdapters: (params: {
+    options: IWeb3AuthCoreOptions;
+}) => IAdapter<unknown>[];

package/dist/types/adapters/default-solana-adapter/utils.d.ts

@@ -0,0 +1,3 @@
+import { IdentifierString } from "@wallet-standard/base";
+import { CustomChainConfig } from "../../base";
+export declare const getSolanaChainByChainConfig: (chainConfig: CustomChainConfig) => IdentifierString;

package/dist/types/adapters/default-solana-adapter/walletStandardAdapter.d.ts

@@ -0,0 +1,31 @@
+import { Wallet } from "@wallet-standard/base";
+import { ADAPTER_CATEGORY_TYPE, ADAPTER_STATUS_TYPE, AdapterInitOptions, AdapterNamespaceType, BaseAdapterSettings, ChainNamespaceType, CustomChainConfig, IProvider, UserInfo } from "../../base";
+import { BaseSolanaAdapter } from "../base-solana-adapter";
+export declare class WalletStandardAdapter extends BaseSolanaAdapter<void> {
+    readonly name: string;
+    readonly adapterNamespace: AdapterNamespaceType;
+    readonly currentChainNamespace: ChainNamespaceType;
+    readonly type: ADAPTER_CATEGORY_TYPE;
+    readonly isInjected = true;
+    status: ADAPTER_STATUS_TYPE;
+    private wallet;
+    private injectedProvider;
+    constructor(options: BaseAdapterSettings & {
+        name: string;
+        wallet: Wallet;
+    });
+    get provider(): IProvider;
+    get isWalletConnected(): boolean;
+    init(options?: AdapterInitOptions): Promise<void>;
+    connect(): Promise<IProvider>;
+    disconnect(options?: {
+        cleanup: boolean;
+    }): Promise<void>;
+    getUserInfo(): Promise<Partial<UserInfo>>;
+    addChain(chainConfig: CustomChainConfig, init?: boolean): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }, init?: boolean): Promise<void>;
+    enableMFA(): Promise<void>;
+    manageMFA(): Promise<void>;
+}

package/dist/types/adapters/default-solana-adapter/walletStandardHandler.d.ts

@@ -0,0 +1,27 @@
+import { type SolanaSignAndSendTransactionFeature, type SolanaSignMessageFeature, type SolanaSignTransactionFeature } from "@solana/wallet-standard-features";
+import { PublicKey } from "@solana/web3.js";
+import { IdentifierString, type WalletWithFeatures } from "@wallet-standard/base";
+import { type StandardConnectFeature, type StandardDisconnectFeature, type StandardEventsFeature } from "@wallet-standard/features";
+import { SafeEventEmitter } from "@web3auth/auth";
+import BN from "bn.js";
+import { IWalletStandardProviderHandler, TransactionOrVersionedTransaction } from "../../providers/solana-provider";
+export type WalletStandard = WalletWithFeatures<StandardConnectFeature & StandardEventsFeature & StandardDisconnectFeature & SolanaSignAndSendTransactionFeature & SolanaSignMessageFeature & SolanaSignTransactionFeature>;
+export declare class WalletStandardProviderHandler extends SafeEventEmitter implements IWalletStandardProviderHandler {
+    private wallet;
+    private getCurrentChain;
+    constructor({ wallet, getCurrentChain }: {
+        wallet: WalletStandard;
+        getCurrentChain: () => IdentifierString;
+    });
+    get currentAccount(): import("@wallet-standard/base").WalletAccount;
+    get publicKey(): PublicKey;
+    signMessage(message: Uint8Array): Promise<{
+        signature: Uint8Array;
+        publicKey: BN;
+    }>;
+    signTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<T>;
+    signAllTransactions<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<T[]>;
+    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<{
+        signature: string;
+    }>;
+}

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

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

package/dist/types/adapters/wallet-connect-v2-adapter/WalletConnectV2Provider.d.ts

@@ -0,0 +1,36 @@
+import type { ISignClient } from "@walletconnect/types";
+import { CustomChainConfig } from "../../base";
+import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../providers/base-provider";
+export interface WalletConnectV2ProviderConfig extends BaseProviderConfig {
+    chainConfig: CustomChainConfig;
+}
+export interface WalletConnectV2ProviderState extends BaseProviderState {
+    accounts: string[];
+}
+export declare class WalletConnectV2Provider extends BaseProvider<BaseProviderConfig, WalletConnectV2ProviderState, ISignClient> {
+    private connector;
+    constructor({ config, state, connector }: {
+        config: WalletConnectV2ProviderConfig;
+        state?: BaseProviderState;
+        connector?: ISignClient;
+    });
+    static getProviderInstance: (params: {
+        connector: ISignClient;
+        chainConfig: CustomChainConfig;
+        skipLookupNetwork: boolean;
+    }) => Promise<WalletConnectV2Provider>;
+    enable(): Promise<string[]>;
+    setupProvider(connector: ISignClient): Promise<void>;
+    switchChain({ chainId }: {
+        chainId: string;
+    }): Promise<void>;
+    addChain(chainConfig: CustomChainConfig): Promise<void>;
+    protected lookupNetwork(_: ISignClient): Promise<string>;
+    private setupEngine;
+    private setupEthEngine;
+    private setupSolEngine;
+    private getEthChainSwitchMiddleware;
+    private connectedTopic;
+    private checkIfAccountAllowed;
+    private onConnectorStateUpdate;
+}

package/dist/types/adapters/wallet-connect-v2-adapter/config.d.ts

@@ -0,0 +1,35 @@
+import type { EngineTypes, ProposalTypes } from "@walletconnect/types";
+import { ChainNamespaceType } from "../../base";
+import { IAdapterSettings } from "./interface";
+export declare enum DEFAULT_EIP155_METHODS {
+    ETH_SEND_TRANSACTION = "eth_sendTransaction",
+    ETH_SIGN_TRANSACTION = "eth_signTransaction",
+    ETH_SIGN = "eth_sign",
+    PERSONAL_SIGN = "personal_sign",
+    ETH_SIGN_TYPED_DATA = "eth_signTypedData",
+    ETH_SIGN_TYPED_DATA_V3 = "eth_signTypedData_v3",
+    ETH_SIGN_TYPED_DATA_V4 = "eth_signTypedData_v4",
+    ADD_ETHEREUM_CHAIN = "wallet_addEthereumChain",
+    SWITCH_ETHEREUM_CHAIN = "wallet_switchEthereumChain"
+}
+export declare enum DEFAULT_SOLANA_METHODS {
+    SIGN_TRANSACTION = "solana_signTransaction",
+    SIGN_MESSAGE = "solana_signMessage"
+}
+export declare enum DEFAULT_EIP_155_EVENTS {
+    ETH_CHAIN_CHANGED = "chainChanged",
+    ETH_ACCOUNTS_CHANGED = "accountsChanged"
+}
+export declare enum DEFAULT_SOLANA_EVENTS {
+    SOL_CHAIN_CHANGED = "chainChanged",
+    SOL_ACCOUNTS_CHANGED = "accountsChanged"
+}
+export declare const SOLANA_CAIP_CHAIN_MAP: Record<string, string>;
+export declare const getNamespacesFromChains: (chains: string[]) => string[];
+export declare const getSupportedMethodsByNamespace: (namespace: string) => DEFAULT_EIP155_METHODS[] | DEFAULT_SOLANA_METHODS[];
+export declare const getSupportedEventsByNamespace: (namespace: string) => DEFAULT_EIP_155_EVENTS[] | DEFAULT_SOLANA_EVENTS[];
+export declare const getRequiredNamespaces: (chains: string[]) => ProposalTypes.RequiredNamespaces;
+export declare const getWalletConnectV2Settings: (namespace: ChainNamespaceType, chainIds: string[], projectID: string) => Promise<{
+    adapterSettings: IAdapterSettings;
+    loginSettings: EngineTypes.ConnectParams;
+}>;

package/dist/types/adapters/wallet-connect-v2-adapter/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./config";
+export * from "./interface";
+export * from "./walletConnectV2adapter";
+export * from "./WalletConnectV2Provider";

package/dist/types/adapters/wallet-connect-v2-adapter/interface.d.ts

@@ -0,0 +1,18 @@
+import type { EngineTypes, SignClientTypes } from "@walletconnect/types";
+import { BaseAdapterSettings } from "../../base";
+export interface OpenOptions {
+    uri: string;
+    chains?: string[];
+}
+export interface IQRCodeModal {
+    openModal: (options?: OpenOptions) => Promise<void>;
+    closeModal: () => void;
+}
+export interface IAdapterSettings {
+    walletConnectInitOptions?: SignClientTypes.Options;
+    qrcodeModal?: IQRCodeModal;
+}
+export interface WalletConnectV2AdapterOptions extends BaseAdapterSettings {
+    adapterSettings?: IAdapterSettings;
+    loginSettings?: EngineTypes.ConnectParams;
+}

package/dist/types/adapters/wallet-connect-v2-adapter/utils.d.ts

@@ -0,0 +1,3 @@
+import type { EngineTypes } from "@walletconnect/types";
+import type { ChainNamespaceType } from "../../base";
+export declare const isChainIdSupported: (chainNamespace: ChainNamespaceType, chainID: number, loginSettings: EngineTypes.ConnectParams | undefined) => boolean;

package/dist/types/adapters/wallet-connect-v2-adapter/walletConnectV2Utils.d.ts

@@ -0,0 +1,23 @@
+import type { ISignClient } from "@walletconnect/types";
+import type { AddEthereumChainParameter, IEthProviderHandlers } from "../../providers/ethereum-provider";
+import type { ISolanaProviderHandlers } from "../../providers/solana-provider";
+export declare function sendJrpcRequest<T, U>(signClient: ISignClient, chainId: string, method: string, params: U): Promise<T>;
+export declare function getAccounts(signClient: ISignClient): Promise<string[]>;
+export declare function getEthProviderHandlers({ connector, chainId }: {
+    connector: ISignClient;
+    chainId: number;
+}): IEthProviderHandlers;
+export declare function getSolProviderHandlers({ connector, chainId }: {
+    connector: ISignClient;
+    chainId: string;
+}): ISolanaProviderHandlers;
+export declare function switchChain({ connector, chainId, newChainId, }: {
+    connector: ISignClient;
+    chainId: number;
+    newChainId: string;
+}): Promise<void>;
+export declare function addChain({ connector, chainId, chainConfig, }: {
+    connector: ISignClient;
+    chainId: number;
+    chainConfig: AddEthereumChainParameter;
+}): Promise<void>;

package/dist/types/adapters/wallet-connect-v2-adapter/walletConnectV2adapter.d.ts

@@ -0,0 +1,42 @@
+import Client from "@walletconnect/sign-client";
+import { SessionTypes } from "@walletconnect/types";
+import { ADAPTER_CATEGORY_TYPE, ADAPTER_STATUS_TYPE, AdapterInitOptions, AdapterNamespaceType, BaseAdapter, ChainNamespaceType, CustomChainConfig, IProvider, UserAuthInfo, UserInfo, WalletConnectV2Data } from "../../base";
+import { WalletConnectV2AdapterOptions } from "./interface";
+declare class WalletConnectV2Adapter extends BaseAdapter<void> {
+    readonly name: string;
+    readonly adapterNamespace: AdapterNamespaceType;
+    readonly currentChainNamespace: ChainNamespaceType;
+    readonly type: ADAPTER_CATEGORY_TYPE;
+    adapterOptions: WalletConnectV2AdapterOptions;
+    status: ADAPTER_STATUS_TYPE;
+    adapterData: WalletConnectV2Data;
+    connector: Client | null;
+    activeSession: SessionTypes.Struct | null;
+    private wcProvider;
+    constructor(options?: WalletConnectV2AdapterOptions);
+    get connected(): boolean;
+    get provider(): IProvider | null;
+    set provider(_: IProvider | null);
+    init(options: AdapterInitOptions): Promise<void>;
+    connect(): Promise<IProvider | null>;
+    setAdapterSettings(adapterSettings: Partial<WalletConnectV2AdapterOptions>): void;
+    addChain(chainConfig: CustomChainConfig, init?: boolean): Promise<void>;
+    switchChain(params: {
+        chainId: string;
+    }, init?: boolean): Promise<void>;
+    getUserInfo(): Promise<Partial<UserInfo>>;
+    disconnect(options?: {
+        cleanup?: boolean;
+        sessionRemovedByWallet?: boolean;
+    }): Promise<void>;
+    authenticateUser(): Promise<UserAuthInfo>;
+    enableMFA(): Promise<void>;
+    manageMFA(): Promise<void>;
+    private cleanupPendingPairings;
+    private checkForPersistedSession;
+    private createNewSession;
+    private onConnectHandler;
+    private subscribeEvents;
+    private _getSignedMessage;
+}
+export { WalletConnectV2Adapter };

package/dist/types/base/adapter/baseAdapter.d.ts

@@ -0,0 +1,44 @@
+import { SafeEventEmitter, type WEB3AUTH_NETWORK_TYPE } from "@web3auth/auth";
+import { AdapterNamespaceType, ChainNamespaceType, CustomChainConfig } from "../chain/IChainInterface";
+import type { ADAPTER_CATEGORY_TYPE, ADAPTER_STATUS_TYPE, AdapterEvents, AdapterInitOptions, BaseAdapterSettings, IAdapter, IProvider, UserAuthInfo, UserInfo } from "./interfaces";
+export declare abstract class BaseAdapter<T> extends SafeEventEmitter<AdapterEvents> implements IAdapter<T> {
+    adapterData?: unknown;
+    sessionTime: number;
+    clientId: string;
+    web3AuthNetwork: WEB3AUTH_NETWORK_TYPE;
+    useCoreKitKey: boolean;
+    protected rehydrated: boolean;
+    protected chainConfig: CustomChainConfig | null;
+    protected knownChainConfigs: Record<CustomChainConfig["chainId"], CustomChainConfig>;
+    abstract adapterNamespace: AdapterNamespaceType;
+    abstract currentChainNamespace: ChainNamespaceType;
+    abstract type: ADAPTER_CATEGORY_TYPE;
+    abstract name: string;
+    abstract status: ADAPTER_STATUS_TYPE;
+    constructor(options?: BaseAdapterSettings);
+    get chainConfigProxy(): CustomChainConfig | null;
+    get connnected(): boolean;
+    abstract get provider(): IProvider | null;
+    setAdapterSettings(options: BaseAdapterSettings): void;
+    checkConnectionRequirements(): void;
+    checkInitializationRequirements(): void;
+    checkDisconnectionRequirements(): void;
+    checkAddChainRequirements(chainConfig: CustomChainConfig, init?: boolean): void;
+    checkSwitchChainRequirements({ chainId }: {
+        chainId: string;
+    }, init?: boolean): void;
+    updateAdapterData(data: unknown): void;
+    protected addChainConfig(chainConfig: CustomChainConfig): void;
+    protected getChainConfig(chainId: string): CustomChainConfig | null;
+    abstract init(options?: AdapterInitOptions): Promise<void>;
+    abstract connect(params?: T): 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 addChain(chainConfig: CustomChainConfig): Promise<void>;
+    abstract switchChain(params: {
+        chainId: string;
+    }): Promise<void>;
+}

package/dist/types/base/adapter/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const ADAPTER_STATUS: {
+    readonly NOT_READY: "not_ready";
+    readonly READY: "ready";
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+    readonly DISCONNECTED: "disconnected";
+    readonly ERRORED: "errored";
+};
+export declare const ADAPTER_EVENTS: {
+    readonly ADAPTER_DATA_UPDATED: "adapter_data_updated";
+    readonly CACHE_CLEAR: "cache_clear";
+    readonly NOT_READY: "not_ready";
+    readonly READY: "ready";
+    readonly CONNECTING: "connecting";
+    readonly CONNECTED: "connected";
+    readonly DISCONNECTED: "disconnected";
+    readonly ERRORED: "errored";
+};
+export declare const ADAPTER_CATEGORY: {
+    readonly EXTERNAL: "external";
+    readonly IN_APP: "in_app";
+};

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

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