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

package/dist/lib.esm/vue/useWeb3AuthInnerContextValue.js

@@ -0,0 +1,213 @@
+import { shallowRef, ref, watch } from 'vue';
+import { ANALYTICS_INTEGRATION_TYPE } from '../base/analytics.js';
+import { log } from '../base/loglevel.js';
+import { LOGIN_MODE } from '../base/constants.js';
+import { WalletInitializationError } from '../base/errors/index.js';
+import { CONNECTOR_EVENTS, CONNECTOR_STATUS } from '../base/connector/constants.js';
+
+function useWeb3AuthInnerContextValue({
+  Web3AuthConstructor,
+  watchSource,
+  getWeb3AuthOptions,
+  initialState,
+  createConnectionRef = () => ref(null)
+}) {
+  const web3Auth = shallowRef(null);
+  const connection = createConnectionRef();
+  const isMFAEnabled = ref(false);
+  const status = ref(null);
+  const chainId = ref(null);
+  const chainNamespace = ref(null);
+  const isInitializing = ref(false);
+  const initError = ref(null);
+  const isInitialized = ref(false);
+  const isConnected = ref(false);
+  const isAuthorized = ref(false);
+  const getPlugin = name => {
+    if (!web3Auth.value) throw WalletInitializationError.notReady();
+    return web3Auth.value.getPlugin(name);
+  };
+  const setIsMFAEnabled = isMfaEnabled => {
+    isMFAEnabled.value = isMfaEnabled;
+  };
+  watch(watchSource, (newSource, _, onInvalidate) => {
+    const resetHookState = () => {
+      connection.value = null;
+      isMFAEnabled.value = false;
+      isConnected.value = false;
+      isAuthorized.value = false;
+      status.value = null;
+      chainId.value = null;
+      chainNamespace.value = null;
+    };
+    onInvalidate(() => {
+      if (web3Auth.value) {
+        web3Auth.value.cleanup();
+      }
+    });
+    resetHookState();
+    const web3AuthInstance = new Web3AuthConstructor(getWeb3AuthOptions(newSource), initialState);
+    web3AuthInstance.setAnalyticsProperties({
+      integration_type: ANALYTICS_INTEGRATION_TYPE.VUE_COMPOSABLES
+    });
+    web3Auth.value = web3AuthInstance;
+  }, {
+    immediate: true
+  });
+  watch(web3Auth, async (newWeb3Auth, _, onInvalidate) => {
+    const controller = new AbortController();
+    onInvalidate(() => {
+      controller.abort();
+    });
+    if (newWeb3Auth) {
+      try {
+        initError.value = null;
+        isInitializing.value = true;
+        await newWeb3Auth.init({
+          signal: controller.signal
+        });
+      } catch (error) {
+        log.error("Error initializing web3auth", error);
+        initError.value = error;
+      } finally {
+        isInitializing.value = false;
+      }
+    }
+  }, {
+    immediate: true
+  });
+  watch(web3Auth, (newWeb3Auth, prevWeb3Auth) => {
+    const notReadyListener = () => {
+      status.value = web3Auth.value.status;
+    };
+    const readyListener = () => {
+      status.value = web3Auth.value.status;
+      isInitialized.value = true;
+    };
+    const connectedListener = data => {
+      if (data.pendingUserConsent) return;
+      status.value = web3Auth.value.status;
+      // We do this because of rehydration issues. status connected is fired first but web3auth sdk is not ready yet.
+      if (web3Auth.value.status === CONNECTOR_STATUS.CONNECTED) {
+        var _currentChain$chainNa, _currentChain;
+        if (!isInitialized.value) isInitialized.value = true;
+        isConnected.value = true;
+        connection.value = web3Auth.value.connection;
+        chainId.value = web3Auth.value.currentChainId;
+        chainNamespace.value = (_currentChain$chainNa = (_currentChain = web3Auth.value.currentChain) === null || _currentChain === void 0 ? void 0 : _currentChain.chainNamespace) !== null && _currentChain$chainNa !== void 0 ? _currentChain$chainNa : null;
+      }
+    };
+    const authorizedListener = () => {
+      status.value = web3Auth.value.status;
+      if (web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
+        isAuthorized.value = true;
+        isConnected.value = true;
+      }
+    };
+    const consentAcceptedListener = () => {
+      status.value = web3Auth.value.status;
+      if (web3Auth.value.status === CONNECTOR_STATUS.CONNECTED || web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
+        var _currentChain$chainNa2, _currentChain2;
+        if (!isInitialized.value) isInitialized.value = true;
+        isConnected.value = true;
+        connection.value = web3Auth.value.connection;
+        chainId.value = web3Auth.value.currentChainId;
+        chainNamespace.value = (_currentChain$chainNa2 = (_currentChain2 = web3Auth.value.currentChain) === null || _currentChain2 === void 0 ? void 0 : _currentChain2.chainNamespace) !== null && _currentChain$chainNa2 !== void 0 ? _currentChain$chainNa2 : null;
+        if (web3Auth.value.status === CONNECTOR_STATUS.AUTHORIZED) {
+          isAuthorized.value = true;
+        }
+      }
+    };
+    const disconnectedListener = () => {
+      status.value = web3Auth.value.status;
+      isConnected.value = false;
+      connection.value = null;
+      isMFAEnabled.value = false;
+      isAuthorized.value = false;
+    };
+    const connectingListener = () => {
+      status.value = web3Auth.value.status;
+    };
+    const errorListener = () => {
+      status.value = web3Auth.value.status;
+    };
+    const mfaEnabledListener = () => {
+      isMFAEnabled.value = true;
+    };
+    const connectionUpdatedListener = () => {
+      var _currentChain$chainNa3, _currentChain3;
+      status.value = web3Auth.value.status;
+      connection.value = web3Auth.value.connection;
+      chainId.value = web3Auth.value.currentChainId;
+      chainNamespace.value = (_currentChain$chainNa3 = (_currentChain3 = web3Auth.value.currentChain) === null || _currentChain3 === void 0 ? void 0 : _currentChain3.chainNamespace) !== null && _currentChain$chainNa3 !== void 0 ? _currentChain$chainNa3 : null;
+    };
+    if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.READY, readyListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.ERRORED, errorListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
+      if (prevWeb3Auth.loginMode === LOGIN_MODE.MODAL) {
+        prevWeb3Auth.removeListener(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+      }
+    }
+    if (newWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
+      status.value = newWeb3Auth.status;
+      newWeb3Auth.on(CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.READY, readyListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.ERRORED, errorListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      newWeb3Auth.on(CONNECTOR_EVENTS.CONNECTION_UPDATED, connectionUpdatedListener);
+      if (newWeb3Auth.loginMode === LOGIN_MODE.MODAL) {
+        newWeb3Auth.on(CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+      }
+    }
+  }, {
+    immediate: true
+  });
+  watch(connection, (newConnection, prevConnection) => {
+    var _prevConnection$ether, _newConnection$ethere;
+    const handleChainChange = newChainId => {
+      var _web3Auth$value$curre, _web3Auth$value;
+      chainId.value = newChainId;
+      chainNamespace.value = (_web3Auth$value$curre = (_web3Auth$value = web3Auth.value) === null || _web3Auth$value === void 0 || (_web3Auth$value = _web3Auth$value.currentChain) === null || _web3Auth$value === void 0 ? void 0 : _web3Auth$value.chainNamespace) !== null && _web3Auth$value$curre !== void 0 ? _web3Auth$value$curre : null;
+    };
+    const prevProvider = (_prevConnection$ether = prevConnection === null || prevConnection === void 0 ? void 0 : prevConnection.ethereumProvider) !== null && _prevConnection$ether !== void 0 ? _prevConnection$ether : null;
+    const newProvider = (_newConnection$ethere = newConnection === null || newConnection === void 0 ? void 0 : newConnection.ethereumProvider) !== null && _newConnection$ethere !== void 0 ? _newConnection$ethere : null;
+    if (prevProvider && newProvider !== prevProvider) {
+      prevProvider.removeListener("chainChanged", handleChainChange);
+    }
+    if (newProvider && newProvider !== prevProvider) {
+      newProvider.on("chainChanged", handleChainChange);
+    }
+  }, {
+    immediate: true
+  });
+  return {
+    web3Auth,
+    isConnected,
+    isAuthorized,
+    connection,
+    isInitializing,
+    initError,
+    isInitialized,
+    status,
+    isMFAEnabled,
+    chainId,
+    chainNamespace,
+    getPlugin,
+    setIsMFAEnabled
+  };
+}
+
+export { useWeb3AuthInnerContextValue };

package/dist/lib.esm/vue/wagmi/provider.js

@@ -1,14 +1,14 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { hydrate } from '@wagmi/core';
-import { configKey, createConfig, useConfig, useReconnect, useAccountEffect } from '@wagmi/vue';
+import { configKey, createConfig, useConfig, useReconnect, useConnectionEffect } from '@wagmi/vue';
 import { injected } from '@wagmi/vue/connectors';
 import { randomId } from '@web3auth/auth';
 import { defineChain, webSocket, http, fallback } from 'viem';
 import { defineComponent, h, shallowRef, ref, watch, provide } from 'vue';
 import { log } from '../../base/loglevel.js';
 import { defaultWagmiConfig } from './constants.js';
-import { useWeb3AuthDisconnect } from '../composables/useWeb3AuthDisconnect.js';
 import { useWeb3Auth } from '../composables/useWeb3Auth.js';
+import { useWeb3AuthDisconnect } from '../composables/useWeb3AuthDisconnect.js';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
 import { WalletInitializationError } from '../../base/errors/index.js';
 
@@ -78,16 +78,17 @@ const Web3AuthWagmiProvider = defineComponent({
   setup() {
     const {
       isConnected,
-      provider
+      connection
     } = useWeb3Auth();
     const {
       disconnect
     } = useWeb3AuthDisconnect();
     const wagmiConfig = useConfig();
     const {
-      reconnect
+      mutate: reconnect
     } = useReconnect();
-    useAccountEffect({
+    const lastSyncedWeb3AuthConnection = shallowRef(null);
+    useConnectionEffect({
       onDisconnect: async () => {
         log.info("Disconnected from wagmi");
         if (isConnected.value) await disconnect();
@@ -99,15 +100,28 @@ const Web3AuthWagmiProvider = defineComponent({
         }
       }
     });
-    watch(isConnected, async newIsConnected => {
-      if (newIsConnected && provider.value) {
-        const connector = await setupConnector(provider.value, wagmiConfig);
-        if (!connector) {
-          throw new Error("Failed to setup connector");
+    watch([isConnected, connection], async () => {
+      var _newConnection$ethere;
+      const newIsConnected = isConnected.value;
+      const newConnection = connection.value;
+      const newEth = (_newConnection$ethere = newConnection === null || newConnection === void 0 ? void 0 : newConnection.ethereumProvider) !== null && _newConnection$ethere !== void 0 ? _newConnection$ethere : null;
+      if (newIsConnected && newConnection && newEth) {
+        // Linked-account switches can reuse or replace the underlying wallet provider,
+        // so key wagmi resyncs off the Web3Auth connection object instead of provider identity.
+        if (lastSyncedWeb3AuthConnection.value !== newConnection) {
+          if (getWeb3authConnector(wagmiConfig)) {
+            resetConnectorState(wagmiConfig);
+          }
+          lastSyncedWeb3AuthConnection.value = newConnection;
+          const connector = await setupConnector(newEth, wagmiConfig);
+          if (!connector) {
+            throw new Error("Failed to setup connector");
+          }
+          await connectWeb3AuthWithWagmi(connector, wagmiConfig);
+          reconnect();
         }
-        await connectWeb3AuthWithWagmi(connector, wagmiConfig);
-        reconnect();
       } else if (!newIsConnected) {
+        lastSyncedWeb3AuthConnection.value = null;
         if (wagmiConfig.state.status === "connected") {
           await disconnectWeb3AuthFromWagmi(wagmiConfig);
         }

package/dist/lib.esm/x402/index.js

@@ -0,0 +1,170 @@
+import { getBase58Encoder, address } from '@solana/kit';
+import { encodeBase64Url } from '@toruslabs/metadata-helpers';
+import { EVM_METHOD_TYPES } from '@web3auth/ws-embed';
+import { toClientEvmSigner, ExactEvmScheme } from '@x402/evm';
+import { x402Client, wrapFetchWithPayment } from '@x402/fetch';
+import { ExactSvmScheme, toClientSvmSigner } from '@x402/svm';
+import { createWalletClient, custom } from 'viem';
+import { PAYMENT_REQUIRED_HEADER } from './interfaces.js';
+import { walletSignTransaction } from '../base/wallet/solana.js';
+
+const EVM_CAIP2_WILDCARD = "eip155:*";
+const SOLANA_CAIP2_WILDCARD = "solana:*";
+
+/**
+ * For 402 responses that carry v2 payment requirements in the JSON body instead
+ * of the PAYMENT-REQUIRED header, reads the body, promotes the data into the
+ * header, and reconstructs the response so downstream code can consume it normally.
+ *
+ * Returns the original response unchanged when the body is not JSON, is malformed,
+ * or does not carry an x402Version \>= 2 payload.
+ */
+async function normalizePaymentRequiredResponse(response) {
+  var _response$headers$get;
+  const contentType = (_response$headers$get = response.headers.get("Content-Type")) !== null && _response$headers$get !== void 0 ? _response$headers$get : "";
+  let body;
+  if (contentType.includes("application/json")) {
+    body = await response.json();
+  } else {
+    const data = await response.text();
+    body = JSON.parse(data);
+  }
+  try {
+    if (body.x402Version && body.x402Version >= 2) {
+      const newHeaders = new Headers(response.headers);
+      const jsonData = JSON.stringify(body);
+      newHeaders.set(PAYMENT_REQUIRED_HEADER, encodeBase64Url(jsonData));
+      return new Response(jsonData, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: newHeaders
+      });
+    }
+  } catch {
+    // Malformed JSON - fall through and return response with the already-consumed body
+  }
+  return new Response(JSON.stringify(body), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+async function getEvmAddress(provider) {
+  var _ref;
+  const accounts = await provider.request({
+    method: EVM_METHOD_TYPES.GET_ACCOUNTS
+  });
+  return (_ref = accounts === null || accounts === void 0 ? void 0 : accounts[0]) !== null && _ref !== void 0 ? _ref : null;
+}
+function createProviderBackedEvmSigner(provider, address) {
+  const walletClient = createWalletClient({
+    account: address,
+    transport: custom(provider)
+  });
+  return 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
+ */
+function withX402BodyShim(baseFetch) {
+  return async (input, init) => {
+    const response = await baseFetch(input, init);
+    if (response.status === 402 && !response.headers.get(PAYMENT_REQUIRED_HEADER)) {
+      return normalizePaymentRequiredResponse(response);
+    }
+    return response;
+  };
+}
+
+/**
+ * Builds a `@x402/svm`-compatible `TransactionPartialSigner` from a web3auth
+ * Solana provider.
+ *
+ * The web3auth `signTransaction` call returns the signer's Ed25519 signature
+ * encoded in base58 (64 bytes). We decode it back to bytes and slot it into
+ * the signature dictionary that `@solana/kit`'s partial-signing helpers expect.
+ */
+function createSvmSigner(wallet, walletAddress) {
+  const base58Encoder = getBase58Encoder();
+  const signerAddress = address(walletAddress);
+  const clientSvmSigner = toClientSvmSigner({
+    address: signerAddress,
+    signTransactions: async transactions => {
+      const signatureDictionaries = await Promise.all(transactions.map(async tx => {
+        const signatureBase58 = await walletSignTransaction(wallet, tx);
+        return {
+          [signerAddress]: base58Encoder.encode(signatureBase58)
+        };
+      }));
+      return signatureDictionaries;
+    }
+  });
+  return clientSvmSigner;
+}
+
+/**
+ * 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
+ */
+function createSolanaX402Fetch(wallet, walletAddress, rpcUrl) {
+  if (!walletAddress) throw new Error("Wallet address is unavailable.");
+  const svmSigner = createSvmSigner(wallet, walletAddress);
+  const client = new x402Client().register(SOLANA_CAIP2_WILDCARD, new ExactSvmScheme(svmSigner, rpcUrl ? {
+    rpcUrl
+  } : undefined));
+  return wrapFetchWithPayment(withX402BodyShim(fetch), client);
+}
+
+/**
+ * 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
+ */
+function createEvmX402Fetch(walletClient) {
+  var _walletClient$account;
+  const address = (_walletClient$account = walletClient.account) === null || _walletClient$account === void 0 ? void 0 : _walletClient$account.address;
+  if (!address) throw new Error("Wallet account is unavailable.");
+  const evmSigner = toClientEvmSigner({
+    address,
+    signTypedData: async params => {
+      const {
+        domain,
+        types,
+        primaryType,
+        message
+      } = params;
+      return walletClient.signTypedData({
+        account: address,
+        domain,
+        types,
+        primaryType,
+        message
+      });
+    }
+  });
+  const client = new x402Client().register(EVM_CAIP2_WILDCARD, new ExactEvmScheme(evmSigner));
+  return wrapFetchWithPayment(withX402BodyShim(fetch), client);
+}
+
+export { EVM_CAIP2_WILDCARD, PAYMENT_REQUIRED_HEADER, SOLANA_CAIP2_WILDCARD, createEvmX402Fetch, createProviderBackedEvmSigner, createSolanaX402Fetch, getEvmAddress, withX402BodyShim };

package/dist/lib.esm/x402/interfaces.js

@@ -0,0 +1,3 @@
+const PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
+
+export { PAYMENT_REQUIRED_HEADER };

package/dist/lib.esm/x402/react.js

@@ -0,0 +1,59 @@
+import { useCallback } from 'react';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { useChain } from '../react/hooks/useChain.js';
+import { useWeb3Auth } from '../react/hooks/useWeb3Auth.js';
+import { createSolanaX402Fetch, getEvmAddress, createProviderBackedEvmSigner, createEvmX402Fetch } from './index.js';
+
+/**
+ * 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.
+ */
+const useX402Fetch = address => {
+  const {
+    chainNamespace
+  } = useChain();
+  const {
+    web3Auth,
+    isConnected,
+    connection
+  } = useWeb3Auth();
+  // const { solanaWallet, accounts } = useSolanaWallet();
+
+  const fetchWithPayment = useCallback(async ({
+    url,
+    options
+  }) => {
+    if (!isConnected) throw new Error("Wallet not connected");
+    if (chainNamespace === CHAIN_NAMESPACES.SOLANA) {
+      var _solanaWallet$account;
+      const {
+        solanaWallet
+      } = connection;
+      if (!solanaWallet || !((_solanaWallet$account = solanaWallet.accounts) !== null && _solanaWallet$account !== void 0 && _solanaWallet$account[0])) throw new Error("Solana wallet not available");
+      const account = solanaWallet.accounts[0];
+      if (!account) throw new Error("Solana account not available");
+      return createSolanaX402Fetch(solanaWallet, account.address)(url, options);
+    }
+    if (chainNamespace === CHAIN_NAMESPACES.EIP155) {
+      const provider = connection === null || connection === void 0 ? void 0 : connection.ethereumProvider;
+      if (!provider) throw new Error("EVM provider not available");
+      const evmAddress = address !== null && address !== void 0 ? address : await getEvmAddress(provider);
+      if (!evmAddress) throw new Error("EVM address not available");
+      const signer = createProviderBackedEvmSigner(provider, evmAddress);
+      return createEvmX402Fetch(signer)(url, options);
+    }
+    throw new Error("Unsupported chain namespace");
+  }, [web3Auth, isConnected, chainNamespace, address, connection]);
+  return {
+    fetchWithPayment
+  };
+};
+
+export { createEvmX402Fetch, createProviderBackedEvmSigner, createSolanaX402Fetch, getEvmAddress, useX402Fetch };

package/dist/lib.esm/x402/vue.js

@@ -0,0 +1,54 @@
+import { toValue } from 'vue';
+import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
+import { useWeb3Auth } from '../vue/composables/useWeb3Auth.js';
+import { createSolanaX402Fetch, getEvmAddress, createProviderBackedEvmSigner, createEvmX402Fetch } from './index.js';
+
+/**
+ * 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.
+ */
+const useX402Fetch = address => {
+  const {
+    isConnected,
+    chainNamespace,
+    connection
+  } = useWeb3Auth();
+  const fetchWithPayment = async ({
+    url,
+    options
+  }) => {
+    if (!isConnected.value) throw new Error("Wallet not connected");
+    if (chainNamespace.value === CHAIN_NAMESPACES.SOLANA) {
+      var _solanaWallet$account;
+      const {
+        solanaWallet
+      } = connection.value;
+      if (!solanaWallet || !((_solanaWallet$account = solanaWallet.accounts) !== null && _solanaWallet$account !== void 0 && _solanaWallet$account[0])) throw new Error("Solana wallet not available");
+      const account = solanaWallet.accounts[0];
+      if (!account) throw new Error("Solana account not available");
+      return createSolanaX402Fetch(solanaWallet, account.address)(url, options);
+    }
+    if (chainNamespace.value === CHAIN_NAMESPACES.EIP155) {
+      var _connection$value, _toValue;
+      const provider = (_connection$value = connection.value) === null || _connection$value === void 0 ? void 0 : _connection$value.ethereumProvider;
+      if (!provider) throw new Error("EVM provider not available");
+      const evmAddress = (_toValue = toValue(address)) !== null && _toValue !== void 0 ? _toValue : await getEvmAddress(provider);
+      if (!evmAddress) throw new Error("EVM address not available");
+      const signer = createProviderBackedEvmSigner(provider, evmAddress);
+      return createEvmX402Fetch(signer)(url, options);
+    }
+    throw new Error("Unsupported chain namespace");
+  };
+  return {
+    fetchWithPayment
+  };
+};
+
+export { createEvmX402Fetch, createSolanaX402Fetch, useX402Fetch };