@web3auth/no-modal 10.14.1 → 11.0.0-beta.0

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

@@ -0,0 +1,75 @@
+'use strict';
+
+var vue = require('vue');
+require('@babel/runtime/helpers/objectSpread2');
+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');
+var connectorStatus = require('../base/connector/connectorStatus.js');
+require('../base/connector/constants.js');
+require('jwt-decode');
+require('../base/plugin/errors.js');
+var IPlugin = require('../base/plugin/IPlugin.js');
+
+function useWalletServicesInnerContextValue(web3AuthContext) {
+  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) {
+      const plugin = getPlugin(IPlugin.EVM_PLUGINS.WALLET_SERVICES);
+      walletServicesPlugin.value = plugin;
+      // When rehydrating, the connected listener may be registered after the connected event is emitted.
+      if (connectorStatus.CONNECTED_STATUSES.includes(plugin === null || plugin === void 0 ? void 0 : plugin.status)) ready.value = true;
+    }
+  });
+  vue.watch(walletServicesPlugin, (newWalletServicesPlugin, prevWalletServicesPlugin) => {
+    const connectedListener = () => {
+      ready.value = true;
+    };
+    const disconnectedListener = () => {
+      ready.value = false;
+    };
+    const connectingListener = () => {
+      connecting.value = true;
+    };
+    const previousPlugin = prevWalletServicesPlugin;
+    const currentPlugin = newWalletServicesPlugin;
+    if (previousPlugin && currentPlugin !== previousPlugin) {
+      previousPlugin.removeListener(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
+      previousPlugin.removeListener(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      previousPlugin.removeListener(IPlugin.PLUGIN_EVENTS.CONNECTING, connectingListener);
+    }
+    if (currentPlugin && currentPlugin !== previousPlugin) {
+      currentPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTED, connectedListener);
+      currentPlugin.on(IPlugin.PLUGIN_EVENTS.DISCONNECTED, disconnectedListener);
+      currentPlugin.on(IPlugin.PLUGIN_EVENTS.CONNECTING, connectingListener);
+    }
+  });
+  return {
+    plugin: walletServicesPlugin,
+    ready,
+    connecting
+  };
+}
+
+exports.useWalletServicesInnerContextValue = useWalletServicesInnerContextValue;

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

@@ -0,0 +1,217 @@
+'use strict';
+
+var vue = require('vue');
+var analytics = require('../base/analytics.js');
+require('@toruslabs/base-controllers');
+require('@babel/runtime/helpers/defineProperty');
+require('@toruslabs/session-manager');
+require('@web3auth/auth');
+var index = require('../base/errors/index.js');
+var loglevel = require('../base/loglevel.js');
+require('@toruslabs/constants');
+require('@toruslabs/http-helpers');
+var constants$1 = require('../base/constants.js');
+require('../base/wallet/index.js');
+require('../base/connector/connectorStatus.js');
+var constants = require('../base/connector/constants.js');
+require('jwt-decode');
+require('../base/plugin/errors.js');
+require('../base/plugin/IPlugin.js');
+
+function useWeb3AuthInnerContextValue({
+  Web3AuthConstructor,
+  watchSource,
+  getWeb3AuthOptions,
+  initialState,
+  createConnectionRef = () => vue.ref(null)
+}) {
+  const web3Auth = vue.shallowRef(null);
+  const connection = createConnectionRef();
+  const isMFAEnabled = vue.ref(false);
+  const status = vue.ref(null);
+  const chainId = vue.ref(null);
+  const chainNamespace = vue.ref(null);
+  const isInitializing = vue.ref(false);
+  const initError = vue.ref(null);
+  const isInitialized = vue.ref(false);
+  const isConnected = vue.ref(false);
+  const isAuthorized = vue.ref(false);
+  const getPlugin = name => {
+    if (!web3Auth.value) throw index.WalletInitializationError.notReady();
+    return web3Auth.value.getPlugin(name);
+  };
+  const setIsMFAEnabled = isMfaEnabled => {
+    isMFAEnabled.value = isMfaEnabled;
+  };
+  vue.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.ANALYTICS_INTEGRATION_TYPE.VUE_COMPOSABLES
+    });
+    web3Auth.value = web3AuthInstance;
+  }, {
+    immediate: true
+  });
+  vue.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) {
+        loglevel.log.error("Error initializing web3auth", error);
+        initError.value = error;
+      } finally {
+        isInitializing.value = false;
+      }
+    }
+  }, {
+    immediate: true
+  });
+  vue.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 === constants.CONNECTOR_STATUS.CONNECTED) {
+        var _web3Auth$value$curre, _web3Auth$value$curre2;
+        if (!isInitialized.value) isInitialized.value = true;
+        isConnected.value = true;
+        connection.value = newWeb3Auth.connection;
+        chainId.value = web3Auth.value.currentChainId;
+        chainNamespace.value = (_web3Auth$value$curre = (_web3Auth$value$curre2 = web3Auth.value.currentChain) === null || _web3Auth$value$curre2 === void 0 ? void 0 : _web3Auth$value$curre2.chainNamespace) !== null && _web3Auth$value$curre !== void 0 ? _web3Auth$value$curre : null;
+      }
+    };
+    const authorizedListener = () => {
+      status.value = web3Auth.value.status;
+      if (web3Auth.value.status === constants.CONNECTOR_STATUS.AUTHORIZED) {
+        isAuthorized.value = true;
+        isConnected.value = true;
+      }
+    };
+    const consentAcceptedListener = () => {
+      status.value = web3Auth.value.status;
+      if (web3Auth.value.status === constants.CONNECTOR_STATUS.CONNECTED || web3Auth.value.status === constants.CONNECTOR_STATUS.AUTHORIZED) {
+        var _web3Auth$value$curre3, _web3Auth$value$curre4;
+        if (!isInitialized.value) isInitialized.value = true;
+        isConnected.value = true;
+        connection.value = newWeb3Auth.connection;
+        chainId.value = web3Auth.value.currentChainId;
+        chainNamespace.value = (_web3Auth$value$curre3 = (_web3Auth$value$curre4 = web3Auth.value.currentChain) === null || _web3Auth$value$curre4 === void 0 ? void 0 : _web3Auth$value$curre4.chainNamespace) !== null && _web3Auth$value$curre3 !== void 0 ? _web3Auth$value$curre3 : null;
+        if (web3Auth.value.status === constants.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;
+    };
+    if (prevWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.READY, readyListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.ERRORED, errorListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+      prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      if (prevWeb3Auth.loginMode === constants$1.LOGIN_MODE.MODAL) {
+        prevWeb3Auth.removeListener(constants.CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+      }
+    }
+    if (newWeb3Auth && newWeb3Auth !== prevWeb3Auth) {
+      status.value = newWeb3Auth.status;
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.NOT_READY, notReadyListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.READY, readyListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.CONNECTED, connectedListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.AUTHORIZED, authorizedListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.DISCONNECTED, disconnectedListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.CONNECTING, connectingListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.ERRORED, errorListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.REHYDRATION_ERROR, errorListener);
+      newWeb3Auth.on(constants.CONNECTOR_EVENTS.MFA_ENABLED, mfaEnabledListener);
+      if (newWeb3Auth.loginMode === constants$1.LOGIN_MODE.MODAL) {
+        newWeb3Auth.on(constants.CONNECTOR_EVENTS.CONSENT_ACCEPTED, consentAcceptedListener);
+      }
+    }
+  }, {
+    immediate: true
+  });
+  vue.watch(connection, (newConnection, prevConnection) => {
+    var _prevConnection$ether, _newConnection$ethere;
+    const handleChainChange = newChainId => {
+      var _web3Auth$value$curre5, _web3Auth$value;
+      chainId.value = newChainId;
+      chainNamespace.value = (_web3Auth$value$curre5 = (_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$curre5 !== void 0 ? _web3Auth$value$curre5 : 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
+  };
+}
+
+exports.useWeb3AuthInnerContextValue = useWeb3AuthInnerContextValue;

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

@@ -11,15 +11,17 @@ require('@babel/runtime/helpers/defineProperty');
 require('@segment/analytics-next');
 var loglevel = require('../../base/loglevel.js');
 var baseControllers = require('@toruslabs/base-controllers');
+require('@toruslabs/session-manager');
 var index = 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');
 require('../../base/connector/constants.js');
 require('jwt-decode');
 require('../../base/plugin/errors.js');
 require('../../base/plugin/IPlugin.js');
-require('@toruslabs/constants');
-require('@toruslabs/http-helpers');
 var useWeb3Auth = require('../composables/useWeb3Auth.js');
 var useWeb3AuthDisconnect = require('../composables/useWeb3AuthDisconnect.js');
 var constants = require('./constants.js');
@@ -87,16 +89,16 @@ const Web3AuthWagmiProvider = vue.defineComponent({
   setup() {
     const {
       isConnected,
-      provider
+      connection
     } = useWeb3Auth.useWeb3Auth();
     const {
       disconnect
     } = useWeb3AuthDisconnect.useWeb3AuthDisconnect();
     const wagmiConfig = vue$1.useConfig();
     const {
-      reconnect
+      mutate: reconnect
     } = vue$1.useReconnect();
-    vue$1.useAccountEffect({
+    vue$1.useConnectionEffect({
       onDisconnect: async () => {
         loglevel.log.info("Disconnected from wagmi");
         if (isConnected.value) await disconnect();
@@ -108,9 +110,11 @@ const Web3AuthWagmiProvider = vue.defineComponent({
         }
       }
     });
-    vue.watch(isConnected, async newIsConnected => {
-      if (newIsConnected && provider.value) {
-        const connector = await setupConnector(provider.value, wagmiConfig);
+    vue.watch([isConnected, connection], async () => {
+      var _connection$value;
+      const newIsConnected = isConnected.value;
+      if (newIsConnected && (_connection$value = connection.value) !== null && _connection$value !== void 0 && _connection$value.ethereumProvider) {
+        const connector = await setupConnector(connection.value.ethereumProvider, wagmiConfig);
         if (!connector) {
           throw new Error("Failed to setup connector");
         }

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

@@ -0,0 +1,175 @@
+'use strict';
+
+var kit = require('@solana/kit');
+var metadataHelpers = require('@toruslabs/metadata-helpers');
+var wsEmbed = require('@web3auth/ws-embed');
+var evm = require('@x402/evm');
+var fetch$1 = require('@x402/fetch');
+var svm = require('@x402/svm');
+var viem = require('viem');
+require('../base/wallet/index.js');
+var interfaces = require('./interfaces.js');
+var solana = require('../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(interfaces.PAYMENT_REQUIRED_HEADER, metadataHelpers.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 _accounts$;
+  const accounts = await provider.request({
+    method: wsEmbed.EVM_METHOD_TYPES.GET_ACCOUNTS
+  });
+  return (_accounts$ = accounts === null || accounts === void 0 ? void 0 : accounts[0]) !== null && _accounts$ !== void 0 ? _accounts$ : null;
+}
+function createProviderBackedEvmSigner(provider, address) {
+  const walletClient = viem.createWalletClient({
+    account: address,
+    transport: viem.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(interfaces.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 = kit.getBase58Encoder();
+  const signerAddress = kit.address(walletAddress);
+  const clientSvmSigner = svm.toClientSvmSigner({
+    address: signerAddress,
+    signTransactions: async transactions => {
+      const signatureDictionaries = await Promise.all(transactions.map(async tx => {
+        const signatureBase58 = await solana.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 fetch$1.x402Client().register(SOLANA_CAIP2_WILDCARD, new svm.ExactSvmScheme(svmSigner, rpcUrl ? {
+    rpcUrl
+  } : undefined));
+  return fetch$1.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 = evm.toClientEvmSigner({
+    address,
+    signTypedData: async params => {
+      const {
+        domain,
+        types,
+        primaryType,
+        message
+      } = params;
+      return walletClient.signTypedData({
+        account: address,
+        domain,
+        types,
+        primaryType,
+        message
+      });
+    }
+  });
+  const client = new fetch$1.x402Client().register(EVM_CAIP2_WILDCARD, new evm.ExactEvmScheme(evmSigner));
+  return fetch$1.wrapFetchWithPayment(withX402BodyShim(fetch), client);
+}
+
+exports.PAYMENT_REQUIRED_HEADER = interfaces.PAYMENT_REQUIRED_HEADER;
+exports.EVM_CAIP2_WILDCARD = EVM_CAIP2_WILDCARD;
+exports.SOLANA_CAIP2_WILDCARD = SOLANA_CAIP2_WILDCARD;
+exports.createEvmX402Fetch = createEvmX402Fetch;
+exports.createProviderBackedEvmSigner = createProviderBackedEvmSigner;
+exports.createSolanaX402Fetch = createSolanaX402Fetch;
+exports.getEvmAddress = getEvmAddress;
+exports.withX402BodyShim = withX402BodyShim;

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

@@ -0,0 +1,5 @@
+'use strict';
+
+const PAYMENT_REQUIRED_HEADER = "PAYMENT-REQUIRED";
+
+exports.PAYMENT_REQUIRED_HEADER = PAYMENT_REQUIRED_HEADER;

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

@@ -0,0 +1,64 @@
+'use strict';
+
+var react = require('react');
+var baseControllers = require('@toruslabs/base-controllers');
+var useChain = require('../react/hooks/useChain.js');
+var useWeb3Auth = require('../react/hooks/useWeb3Auth.js');
+var index = require('./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.useChain();
+  const {
+    web3Auth,
+    isConnected,
+    connection
+  } = useWeb3Auth.useWeb3Auth();
+  // const { solanaWallet, accounts } = useSolanaWallet();
+  const fetchWithPayment = react.useCallback(async ({
+    url,
+    options
+  }) => {
+    if (!isConnected) throw new Error("Wallet not connected");
+    if (chainNamespace === baseControllers.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 index.createSolanaX402Fetch(solanaWallet, account.address)(url, options);
+    }
+    if (chainNamespace === baseControllers.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 index.getEvmAddress(provider);
+      if (!evmAddress) throw new Error("EVM address not available");
+      const signer = index.createProviderBackedEvmSigner(provider, evmAddress);
+      return index.createEvmX402Fetch(signer)(url, options);
+    }
+    throw new Error("Unsupported chain namespace");
+  }, [web3Auth, isConnected, chainNamespace, address, connection]);
+  return {
+    fetchWithPayment
+  };
+};
+
+exports.createEvmX402Fetch = index.createEvmX402Fetch;
+exports.createProviderBackedEvmSigner = index.createProviderBackedEvmSigner;
+exports.createSolanaX402Fetch = index.createSolanaX402Fetch;
+exports.getEvmAddress = index.getEvmAddress;
+exports.useX402Fetch = useX402Fetch;

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

@@ -0,0 +1,58 @@
+'use strict';
+
+var vue = require('vue');
+var baseControllers = require('@toruslabs/base-controllers');
+var useWeb3Auth = require('../vue/composables/useWeb3Auth.js');
+var index = require('./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.useWeb3Auth();
+  const fetchWithPayment = async ({
+    url,
+    options
+  }) => {
+    if (!isConnected.value) throw new Error("Wallet not connected");
+    if (chainNamespace.value === baseControllers.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 index.createSolanaX402Fetch(solanaWallet, account.address)(url, options);
+    }
+    if (chainNamespace.value === baseControllers.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 = vue.toValue(address)) !== null && _toValue !== void 0 ? _toValue : await index.getEvmAddress(provider);
+      if (!evmAddress) throw new Error("EVM address not available");
+      const signer = index.createProviderBackedEvmSigner(provider, evmAddress);
+      return index.createEvmX402Fetch(signer)(url, options);
+    }
+    throw new Error("Unsupported chain namespace");
+  };
+  return {
+    fetchWithPayment
+  };
+};
+
+exports.createEvmX402Fetch = index.createEvmX402Fetch;
+exports.createSolanaX402Fetch = index.createSolanaX402Fetch;
+exports.useX402Fetch = useX402Fetch;