@web3auth/no-modal 10.16.0 → 11.0.0-beta.1

package/dist/lib.cjs/types/react/solana/provider.d.ts

@@ -0,0 +1,26 @@
+import type { SolanaClient } from "@solana/client";
+import { SolanaProvider as SolanaProviderBase } from "@solana/react-hooks";
+import type { ComponentProps } from "react";
+import { PropsWithChildren } from "react";
+type SolanaProviderProps = Omit<ComponentProps<typeof SolanaProviderBase>, "client" | "config">;
+export declare function SolanaProvider({ children, ...props }: PropsWithChildren<SolanaProviderProps>): import("react").FunctionComponentElement<Readonly<{
+    children: import("react").ReactNode;
+    client?: SolanaClient;
+    config?: import("@solana/client").SolanaClientConfig | import("@solana/client").CreateDefaultClientOptions;
+    query?: Readonly<{
+        config?: import("swr").SWRConfiguration;
+        resetOnClusterChange?: boolean;
+        suspense?: boolean;
+        disabled?: boolean;
+    }> | false;
+    walletPersistence?: Readonly<{
+        autoConnect?: boolean;
+        storage?: Readonly<{
+            getItem(key: string): string | null;
+            removeItem(key: string): void;
+            setItem(key: string, value: string): void;
+        }> | null;
+        storageKey?: string;
+    }> | false;
+}>>;
+export {};

package/dist/lib.cjs/types/vue/composables/index.d.ts

@@ -1,13 +1,15 @@
+export * from "./useAuthTokenInfo";
 export * from "./useChain";
 export * from "./useCheckout";
 export * from "./useEnableMFA";
 export * from "./useFunding";
-export * from "./useIdentityToken";
+export { useInjectedWeb3AuthInnerContext } from "./useInjectedWeb3AuthInnerContext";
 export * from "./useManageMFA";
 export * from "./useReceive";
 export * from "./useSwap";
 export * from "./useSwitchChain";
 export * from "./useWalletConnectScanner";
+export * from "./useWallets";
 export * from "./useWalletServicesPlugin";
 export * from "./useWalletUI";
 export * from "./useWeb3Auth";

package/dist/lib.cjs/types/vue/composables/{useIdentityToken.d.ts → useAuthTokenInfo.d.ts}

@@ -1,9 +1,9 @@
 import { Ref } from "vue";
 import { Web3AuthError } from "../../base";
-export interface IUseIdentityToken {
+export interface IUseAuthTokenInfo {
     loading: Ref<boolean>;
     error: Ref<Web3AuthError | null>;
     token: Ref<string | null>;
-    getIdentityToken: () => Promise<string | null>;
+    getAuthTokenInfo: () => Promise<string | null>;
 }
-export declare const useIdentityToken: () => IUseIdentityToken;
+export declare const useAuthTokenInfo: () => IUseAuthTokenInfo;

package/dist/lib.cjs/types/vue/composables/useInjectedWeb3AuthInnerContext.d.ts

@@ -0,0 +1 @@
+export declare function useInjectedWeb3AuthInnerContext<TContext>(): TContext;

package/dist/lib.cjs/types/vue/composables/useWallets.d.ts

@@ -0,0 +1,9 @@
+import { Ref } from "vue";
+import { type ConnectedAccountsWithProviders, Web3AuthError } from "../../base";
+export interface IUseWallets {
+    loading: Ref<boolean>;
+    error: Ref<Web3AuthError | null>;
+    wallets: Ref<ConnectedAccountsWithProviders[]>;
+    syncWallets(): Promise<void>;
+}
+export declare const useWallets: () => IUseWallets;

package/dist/lib.cjs/types/vue/composables/useWeb3Auth.d.ts

@@ -1,3 +1,2 @@
 import { IWeb3AuthInnerContext } from "../interfaces";
-export type IWeb3AuthNoModalContext = Omit<IWeb3AuthInnerContext, "isMFAEnabled" | "setIsMFAEnabled">;
-export declare const useWeb3Auth: () => IWeb3AuthNoModalContext;
+export declare const useWeb3Auth: () => IWeb3AuthInnerContext;

package/dist/lib.cjs/types/vue/composables/useWeb3AuthConnect.d.ts

@@ -1,10 +1,10 @@
 import { Ref } from "vue";
-import { IProvider, LoginParamMap, WALLET_CONNECTOR_TYPE, Web3AuthError } from "../../base";
+import { Connection, LoginParamMap, WALLET_CONNECTOR_TYPE, Web3AuthError } from "../../base";
 export interface IUseWeb3AuthConnect {
     isConnected: Ref<boolean>;
     loading: Ref<boolean>;
     error: Ref<Web3AuthError | null>;
     connectorName: Ref<WALLET_CONNECTOR_TYPE | null>;
-    connect: <T extends WALLET_CONNECTOR_TYPE>(connectorType: T, loginParams?: LoginParamMap[T]) => Promise<IProvider | null>;
+    connect: <T extends WALLET_CONNECTOR_TYPE>(connectorType: T, loginParams?: LoginParamMap[T]) => Promise<Connection | null>;
 }
 export declare const useWeb3AuthConnect: () => IUseWeb3AuthConnect;

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

@@ -1,4 +1,6 @@
 export * from "./composables";
 export * from "./context";
 export * from "./interfaces";
+export { useWalletServicesInnerContextValue } from "./useWalletServicesInnerContextValue";
+export { useWeb3AuthInnerContextValue } from "./useWeb3AuthInnerContextValue";
 export * from "./Web3AuthProvider";

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

@@ -1,5 +1,5 @@
 import { Ref, ShallowRef } from "vue";
-import type { ChainNamespaceType, CONNECTOR_STATUS_TYPE, IPlugin, IProvider, IWeb3AuthCoreOptions } from "../base";
+import type { ChainNamespaceType, Connection, CONNECTOR_STATUS_TYPE, IPlugin, IWeb3AuthCoreOptions } from "../base";
 import type { Web3AuthNoModal } from "../noModal";
 import { WalletServicesPluginType } from "../plugins/wallet-services-plugin";
 export type Web3AuthContextConfig = {
@@ -11,7 +11,7 @@ export interface Web3AuthProviderProps {
 interface IBaseWeb3AuthComposableContext {
     isConnected: Ref<boolean>;
     isAuthorized: Ref<boolean>;
-    provider: Ref<IProvider | null>;
+    connection: Ref<Connection | null>;
     isInitializing: Ref<boolean>;
     initError: Ref<Error | null>;
     isInitialized: Ref<boolean>;

package/dist/lib.cjs/types/vue/solana/composables/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./useSignAndSendTransaction";
 export * from "./useSignMessage";
 export * from "./useSignTransaction";
+export * from "./useSolanaClient";
 export * from "./useSolanaWallet";

package/dist/lib.cjs/types/vue/solana/composables/useSignAndSendTransaction.d.ts

@@ -1,10 +1,15 @@
+import type { Transaction } from "@solana/kit";
 import { Ref } from "vue";
 import { type Web3AuthError } from "../../../base/errors";
-import type { TransactionOrVersionedTransaction } from "../../../providers/solana-provider";
 export type IUseSignAndSendTransaction = {
     loading: Ref<boolean>;
     error: Ref<Web3AuthError | null>;
     data: Ref<string | null>;
-    signAndSendTransaction: (transaction: TransactionOrVersionedTransaction) => Promise<string>;
+    /**
+     * Signs and sends a transaction to the network
+     * @param transaction - Compiled transaction from \@solana/kit
+     * @returns The signature of the transaction encoded in base58
+     */
+    signAndSendTransaction: (transaction: Transaction) => Promise<string>;
 };
 export declare const useSignAndSendTransaction: () => IUseSignAndSendTransaction;

package/dist/lib.cjs/types/vue/solana/composables/useSignTransaction.d.ts

@@ -1,10 +1,15 @@
+import type { Transaction } from "@solana/kit";
 import { Ref } from "vue";
-import { type Web3AuthError } from "../../../base/errors";
-import { TransactionOrVersionedTransaction } from "../../../providers/solana-provider";
+import { type Web3AuthError } from "../../../base";
 export type IUseSignTransaction = {
     loading: Ref<boolean>;
     error: Ref<Web3AuthError | null>;
     data: Ref<string | null>;
-    signTransaction: (transaction: TransactionOrVersionedTransaction) => Promise<string>;
+    /**
+     * Signs a transaction and returns the base64-encoded wire transaction.
+     * @param transaction - Compiled transaction from \@solana/kit
+     * @returns The signed transaction encoded as a base64 wire transaction
+     */
+    signTransaction: (transaction: Transaction) => Promise<string>;
 };
 export declare const useSignTransaction: () => IUseSignTransaction;

package/dist/lib.cjs/types/vue/solana/composables/useSolanaClient.d.ts

@@ -0,0 +1,7 @@
+import { SolanaClient } from "@solana/client";
+import { Ref } from "vue";
+/**
+ * Injects the Solana Framework Kit client when inside SolanaProvider and Web3Auth is connected on Solana.
+ * Otherwise returns null.
+ */
+export declare function useSolanaClient(): Ref<SolanaClient | null>;

package/dist/lib.cjs/types/vue/solana/composables/useSolanaWallet.d.ts

@@ -1,9 +1,22 @@
-import { Connection } from "@solana/web3.js";
+import { type Rpc, type SolanaRpcApi } from "@solana/kit";
+import type { Wallet } from "@wallet-standard/base";
 import { Ref, ShallowRef } from "vue";
-import { SolanaWallet } from "../../../providers/solana-provider/solanaWallet";
 export type IUseSolanaWallet = {
     accounts: Ref<string[] | null>;
-    solanaWallet: ShallowRef<SolanaWallet | null>;
-    connection: ShallowRef<Connection | null>;
+    solanaWallet: ShallowRef<Wallet | null>;
+    /**
+     * Solana RPC client for making RPC calls.
+     * @example
+     * ```typescript
+     * const { value: balance } = await rpc.value.getBalance(address("...")).send();
+     * const { value: latestBlockhash } = await rpc.value.getLatestBlockhash().send();
+     * ```
+     */
+    rpc: ShallowRef<Rpc<SolanaRpcApi> | null>;
+    /**
+     * Returns the Solana ed25519 private key. Only works with the Auth connector.
+     * @throws Error if connected via a non-Auth connector or if the provider is unavailable.
+     */
+    getPrivateKey: () => Promise<string>;
 };
 export declare const useSolanaWallet: () => IUseSolanaWallet;

package/dist/lib.cjs/types/vue/solana/constants.d.ts

@@ -0,0 +1,3 @@
+import type { SolanaClient } from "@solana/client";
+import type { InjectionKey, Ref } from "vue";
+export declare const SOLANA_CLIENT_KEY: InjectionKey<Ref<SolanaClient | null>>;

package/dist/lib.cjs/types/vue/solana/index.d.ts

@@ -1 +1,3 @@
 export * from "./composables";
+export * from "./constants";
+export * from "./provider";

package/dist/lib.cjs/types/vue/solana/provider.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Syncs Web3Auth Solana connection with Framework Kit client.
+ * When user is connected via Web3Auth and current chain is Solana, creates a Framework Kit client
+ * with Web3Auth as the wallet connector and connects it (same pattern as Wagmi provider).
+ */
+export declare const SolanaProvider: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/lib.cjs/types/vue/useWalletServicesInnerContextValue.d.ts

@@ -0,0 +1,13 @@
+import { type Ref, type ShallowRef } from "vue";
+type IWeb3AuthContextForWalletServices = {
+    getPlugin: (pluginName: string) => unknown;
+    isInitialized: Ref<boolean>;
+    isConnected: Ref<boolean>;
+};
+export type IWalletServicesInnerContextValue<TWalletServicesPlugin> = {
+    plugin: ShallowRef<TWalletServicesPlugin | null>;
+    ready: Ref<boolean>;
+    connecting: Ref<boolean>;
+};
+export declare function useWalletServicesInnerContextValue<TWalletServicesPlugin>(web3AuthContext: IWeb3AuthContextForWalletServices): IWalletServicesInnerContextValue<TWalletServicesPlugin>;
+export {};

package/dist/lib.cjs/types/vue/useWeb3AuthInnerContextValue.d.ts

@@ -0,0 +1,26 @@
+import { type Ref, type ShallowRef } from "vue";
+import { type ChainNamespaceType, type Connection, type CONNECTOR_STATUS_TYPE, type IWeb3Auth, IWeb3AuthState } from "../base";
+export type IWeb3AuthInnerContextValue<TWeb3Auth extends IWeb3Auth> = {
+    web3Auth: ShallowRef<TWeb3Auth | null>;
+    isConnected: Ref<boolean>;
+    isAuthorized: Ref<boolean>;
+    connection: Ref<Connection | null>;
+    isInitializing: Ref<boolean>;
+    initError: Ref<Error | null>;
+    isInitialized: Ref<boolean>;
+    status: Ref<CONNECTOR_STATUS_TYPE | null>;
+    isMFAEnabled: Ref<boolean>;
+    chainId: Ref<string | null>;
+    chainNamespace: Ref<ChainNamespaceType | null>;
+    getPlugin: TWeb3Auth["getPlugin"];
+    setIsMFAEnabled: (isMfaEnabled: boolean) => void;
+};
+type UseWeb3AuthInnerContextValueOptions<TWeb3Auth extends IWeb3Auth, TWatchSource, TWeb3AuthOptions> = {
+    Web3AuthConstructor: new (options: TWeb3AuthOptions, initialState?: Partial<IWeb3AuthState>) => TWeb3Auth;
+    watchSource: () => TWatchSource;
+    getWeb3AuthOptions: (source: TWatchSource) => TWeb3AuthOptions;
+    createConnectionRef?: () => Ref<Connection | null>;
+    initialState?: Partial<IWeb3AuthState>;
+};
+export declare function useWeb3AuthInnerContextValue<TWeb3Auth extends IWeb3Auth, TWatchSource, TWeb3AuthOptions>({ Web3AuthConstructor, watchSource, getWeb3AuthOptions, initialState, createConnectionRef, }: UseWeb3AuthInnerContextValueOptions<TWeb3Auth, TWatchSource, TWeb3AuthOptions>): IWeb3AuthInnerContextValue<TWeb3Auth>;
+export {};

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

@@ -0,0 +1,43 @@
+import { Wallet } from "@wallet-standard/base";
+import { Address, type WalletClient } from "viem";
+import { IProvider } from "../base/connector";
+export * from "./interfaces";
+export declare const EVM_CAIP2_WILDCARD = "eip155:*";
+export declare const SOLANA_CAIP2_WILDCARD = "solana:*";
+export declare function getEvmAddress(provider: IProvider): Promise<Address | null>;
+export declare function createProviderBackedEvmSigner(provider: IProvider, address: Address): WalletClient;
+/**
+ * Wraps a fetch function so that 402 responses whose v2 payment requirements
+ * arrive in the response body (instead of the PAYMENT-REQUIRED header) are
+ * normalised: the body JSON is base64-encoded and promoted into the
+ * PAYMENT-REQUIRED header so that the \@x402/fetch client library can process it.
+ *
+ * The \@x402/fetch library's body fallback only accepts x402Version === 1;
+ * this shim bridges the gap for servers that send v2 data in the body.
+ *
+ * @param baseFetch - The underlying fetch implementation to wrap
+ * @returns A fetch-compatible function with the shim applied
+ */
+export declare function withX402BodyShim(baseFetch: typeof fetch): typeof fetch;
+/**
+ * Creates a payment-aware fetch function for a connected Solana wallet.
+ * Registers the exact SVM payment scheme and applies the body-shim so that
+ * servers returning v2 payment requirements in the response body are handled
+ * transparently.
+ *
+ * @param wallet - Connected Solana wallet (must have an account)
+ * @param walletAddress - The wallet's public key as a base58 address string
+ * @param rpcUrl - Optional custom Solana RPC URL (defaults to public cluster endpoints)
+ * @returns A fetch-compatible function that handles x402 payment flows
+ */
+export declare function createSolanaX402Fetch(wallet: Wallet, walletAddress: string, rpcUrl?: string): typeof fetch;
+/**
+ * Creates a payment-aware fetch function for an EVM typed-data signer.
+ * Registers the exact EVM payment scheme and applies the body-shim so that
+ * servers returning v2 payment requirements in the response body are handled
+ * transparently.
+ *
+ * @param signer - Minimal signer with an address and EIP-712 signTypedData implementation
+ * @returns A fetch-compatible function that handles x402 payment flows
+ */
+export declare function createEvmX402Fetch(walletClient: WalletClient): typeof fetch;

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

@@ -0,0 +1,11 @@
+export declare const PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
+export interface IUseX402FetchParams {
+    /** The URL to send the payment-gated request to. */
+    url: string;
+    /** Optional fetch init options (method, headers, body, etc.). */
+    options?: RequestInit;
+}
+export interface IUseX402FetchReturnValues {
+    /** Trigger the payment-gated fetch. Resolves with the raw `Response` — callers are responsible for reading and parsing the body. */
+    fetchWithPayment: (params: IUseX402FetchParams) => Promise<Response>;
+}

package/dist/lib.cjs/types/x402/react.d.ts

@@ -0,0 +1,17 @@
+import type { Address } from "viem";
+import { createEvmX402Fetch, createProviderBackedEvmSigner, createSolanaX402Fetch, getEvmAddress } from "./index";
+import type { IUseX402FetchParams, IUseX402FetchReturnValues } from "./interfaces";
+export { createEvmX402Fetch, createProviderBackedEvmSigner, createSolanaX402Fetch, getEvmAddress };
+export type { IUseX402FetchParams, IUseX402FetchReturnValues };
+/**
+ * Web3Auth-integrated x402 fetch hook.
+ *
+ * Automatically selects the correct payment path based on the currently connected
+ * chain namespace:
+ *  - **Solana** - uses `createSolanaX402Fetch` backed by the web3auth Solana wallet.
+ *  - **EVM** - uses `createEvmX402Fetch` backed by the web3auth EIP-1193 provider.
+ *
+ * Callers do not need to pass a signer manually; it is sourced internally.
+ * When `address` is provided, it takes precedence over the provider's active account.
+ */
+export declare const useX402Fetch: (address?: Address) => IUseX402FetchReturnValues;

package/dist/lib.cjs/types/x402/vue.d.ts

@@ -0,0 +1,18 @@
+import type { Address } from "viem";
+import { type MaybeRefOrGetter } from "vue";
+import { createEvmX402Fetch, createSolanaX402Fetch } from "./index";
+import type { IUseX402FetchParams, IUseX402FetchReturnValues } from "./interfaces";
+export { createEvmX402Fetch, createSolanaX402Fetch };
+export type { IUseX402FetchParams, IUseX402FetchReturnValues };
+/**
+ * Web3Auth-integrated x402 fetch composable.
+ *
+ * Automatically selects the correct payment path based on the currently connected
+ * chain namespace:
+ *  - **Solana** - uses `createSolanaX402Fetch` backed by the web3auth Solana wallet.
+ *  - **EVM** - uses `createEvmX402Fetch` backed by the web3auth EIP-1193 provider.
+ *
+ * Callers do not need to pass a signer manually; it is sourced internally.
+ * When `address` is provided, it takes precedence over the provider's active account.
+ */
+export declare const useX402Fetch: (address?: MaybeRefOrGetter<Address | undefined>) => IUseX402FetchReturnValues;

package/dist/lib.cjs/vue/WalletServicesInnerProvider.js

@@ -6,74 +6,29 @@ require('@babel/runtime/helpers/defineProperty');
 require('@segment/analytics-next');
 require('../base/loglevel.js');
 require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
 require('@web3auth/auth');
 require('../base/errors/index.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+require('../base/constants.js');
 require('../base/wallet/index.js');
 require('../base/connector/connectorStatus.js');
-var constants = require('../base/connector/constants.js');
+require('../base/connector/constants.js');
 require('jwt-decode');
 var errors = require('../base/plugin/errors.js');
-var IPlugin = require('../base/plugin/IPlugin.js');
-require('@toruslabs/constants');
-require('@toruslabs/http-helpers');
+require('../base/plugin/IPlugin.js');
 var useWeb3AuthInner = require('./composables/useWeb3AuthInner.js');
 var WalletServicesContext = require('./context/WalletServicesContext.js');
+var useWalletServicesInnerContextValue = require('./useWalletServicesInnerContextValue.js');
 
 const WalletServicesInnerProvider = vue.defineComponent({
   name: "WalletServicesInnerProvider",
   setup() {
     const web3AuthContext = useWeb3AuthInner.useWeb3AuthInner();
     if (!web3AuthContext) throw errors.WalletServicesPluginError.fromCode(1000, "`WalletServicesProvider` must be wrapped by `Web3AuthProvider`");
-    const {
-      getPlugin,
-      isInitialized,
-      isConnected
-    } = web3AuthContext;
-    const walletServicesPlugin = vue.shallowRef(null);
-    const ready = vue.ref(false);
-    const connecting = vue.ref(false);
-    vue.watch(isInitialized, newIsInitialized => {
-      if (newIsInitialized) {
-        const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
-        walletServicesPlugin.value = plugin;
-      }
-    });
-    vue.watch(isConnected, newIsConnected => {
-      if (newIsConnected) {
-        var _walletServicesPlugin;
-        const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
-        walletServicesPlugin.value = plugin;
-        // when rehydrating, the connectedListener may be registered after the connected event is emitted, we need to check the status here
-        if (((_walletServicesPlugin = walletServicesPlugin.value) === null || _walletServicesPlugin === void 0 ? void 0 : _walletServicesPlugin.status) === constants.CONNECTOR_STATUS.CONNECTED) ready.value = true;
-      }
-    });
-    vue.watch(walletServicesPlugin, (newWalletServicesPlugin, prevWalletServicesPlugin) => {
-      const connectedListener = () => {
-        ready.value = true;
-      };
-      const disconnectedListener = () => {
-        ready.value = false;
-      };
-      const connectingListener = () => {
-        connecting.value = true;
-      };
-      // unregister previous listeners
-      if (prevWalletServicesPlugin && newWalletServicesPlugin !== prevWalletServicesPlugin) {
-        prevWalletServicesPlugin.removeListener(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
-        prevWalletServicesPlugin.removeListener(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
-        prevWalletServicesPlugin.removeListener(IPlugin.PLUGIN_EVENTS.CONNECTING, connectingListener);
-      }
-      if (newWalletServicesPlugin && newWalletServicesPlugin !== prevWalletServicesPlugin) {
-        newWalletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
-        newWalletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
-        newWalletServicesPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTING, connectingListener);
-      }
-    });
-    vue.provide(WalletServicesContext.WalletServicesContextKey, {
-      plugin: walletServicesPlugin,
-      ready,
-      connecting
-    });
+    const value = useWalletServicesInnerContextValue.useWalletServicesInnerContextValue(web3AuthContext);
+    vue.provide(WalletServicesContext.WalletServicesContextKey, value);
   },
   render() {
     var _this$$slots$default;