@chipi-stack/chipi-react 13.13.0 → 14.1.0

package/dist/hooks.js

@@ -7,6 +7,7 @@ var chipiPasskey = require('@chipi-stack/chipi-passkey');
 require('react/jsx-runtime');
 var shared = require('@chipi-stack/shared');
 var types = require('@chipi-stack/types');
+var core = require('@chipi-stack/core');
 
 // src/hooks/useCreateWallet.ts
 var ChipiContext = react.createContext(null);
@@ -40,6 +41,9 @@ function useCreateWallet() {
           throw new Error("Failed to create passkey for wallet");
         }
       }
+      if (!encryptKey) {
+        throw new Error("encryptKey is required when usePasskey is false");
+      }
       return chipiSDK.createWallet({
         params: {
           ...input.params,
@@ -66,8 +70,7 @@ function useGetWallet(input) {
   const query = reactQuery.useQuery({
     queryKey: ["wallet", input?.params?.externalUserId],
     queryFn: async () => {
-      if (!input || !input.params || !input.getBearerToken)
-        throw new Error("Input is required");
+      if (!input || !input.params || !input.getBearerToken) throw new Error("Input is required");
       const bearerToken = await input.getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
       return chipiSDK.getWallet(input.params, bearerToken);
@@ -109,22 +112,16 @@ function useGetWallet(input) {
 function useChipiWallet(config) {
   const { chipiSDK } = useChipiContext();
   const queryClient = reactQuery.useQueryClient();
-  const {
-    externalUserId,
-    getBearerToken,
-    defaultToken = "USDC",
-    enabled = true
-  } = config;
-  const isEnabled = Boolean(
-    enabled && externalUserId && externalUserId.trim() !== ""
-  );
+  const { externalUserId, getBearerToken, defaultToken = "USDC", enabled = true } = config;
+  const trimmedUserId = externalUserId?.trim() || null;
+  const isEnabled = Boolean(enabled && trimmedUserId);
   const walletQuery = reactQuery.useQuery({
-    queryKey: ["chipi-wallet", externalUserId],
+    queryKey: ["chipi-wallet", trimmedUserId],
     queryFn: async () => {
-      if (!externalUserId) return null;
+      if (!trimmedUserId) return null;
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
-      return chipiSDK.getWallet({ externalUserId }, bearerToken);
+      return chipiSDK.getWallet({ externalUserId: trimmedUserId }, bearerToken);
     },
     enabled: isEnabled,
     retry: (failureCount, error) => {
@@ -150,7 +147,7 @@ function useChipiWallet(config) {
         bearerToken
       );
     },
-    enabled: Boolean(walletPublicKey),
+    enabled: Boolean(isEnabled && walletPublicKey),
     retry: (failureCount, error) => {
       if (error instanceof shared.ChipiApiError || error?.status) {
         return false;
@@ -160,14 +157,14 @@ function useChipiWallet(config) {
   });
   const createWalletMutation = reactQuery.useMutation({
     mutationFn: async ({ encryptKey, walletType = "CHIPI" }) => {
-      if (!externalUserId) throw new Error("External user ID is required");
+      if (!trimmedUserId) throw new Error("External user ID is required");
       const bearerToken = await getBearerToken();
       if (!bearerToken) throw new Error("Bearer token is required");
       return chipiSDK.createWallet({
         params: {
           chain: types.Chain.STARKNET,
           encryptKey,
-          externalUserId,
+          externalUserId: trimmedUserId,
           walletType
         },
         bearerToken
@@ -175,7 +172,7 @@ function useChipiWallet(config) {
     },
     onSuccess: () => {
       queryClient.invalidateQueries({
-        queryKey: ["chipi-wallet", externalUserId]
+        queryKey: ["chipi-wallet", trimmedUserId]
       });
     }
   });
@@ -250,14 +247,10 @@ function useChipiSession(config) {
     defaultMaxCalls = 1e3,
     autoCheckStatus = true
   } = config;
-  const [localSession, setLocalSession] = react.useState(
-    storedSession ?? null
-  );
+  const [localSession, setLocalSession] = react.useState(storedSession ?? null);
   const [error, setError] = react.useState(null);
   react.useEffect(() => {
-    if (storedSession) {
-      setLocalSession(storedSession);
-    }
+    setLocalSession(storedSession ?? null);
   }, [storedSession]);
   const supportsSession = react.useMemo(() => {
     if (!wallet) return false;
@@ -293,27 +286,32 @@ function useChipiSession(config) {
   const hasActiveSession = sessionState === "active";
   const isSessionExpired = sessionState === "expired";
   const remainingCalls = sessionStatusQuery.data?.remainingCalls;
-  const createSessionMutation = reactQuery.useMutation({
-    mutationFn: async (params = {}) => {
-      if (!encryptKey) throw new Error("Encryption key (PIN) is required");
-      if (!supportsSession) throw new Error("Wallet does not support sessions. Only CHIPI wallets support session keys.");
-      const sessionData = chipiSDK.sessions.createSessionKey({
-        encryptKey,
-        durationSeconds: params.durationSeconds ?? defaultDurationSeconds
-      });
-      return sessionData;
-    },
-    onSuccess: async (sessionData) => {
-      setLocalSession(sessionData);
-      setError(null);
-      if (onSessionCreated) {
-        await onSessionCreated(sessionData);
+  const createSessionMutation = reactQuery.useMutation(
+    {
+      mutationFn: async (params = {}) => {
+        if (!encryptKey) throw new Error("Encryption key (PIN) is required");
+        if (!supportsSession)
+          throw new Error(
+            "Wallet does not support sessions. Only CHIPI wallets support session keys."
+          );
+        const sessionData = chipiSDK.sessions.createSessionKey({
+          encryptKey,
+          durationSeconds: params.durationSeconds ?? defaultDurationSeconds
+        });
+        return sessionData;
+      },
+      onSuccess: async (sessionData) => {
+        setLocalSession(sessionData);
+        setError(null);
+        if (onSessionCreated) {
+          await onSessionCreated(sessionData);
+        }
+      },
+      onError: (err) => {
+        setError(err);
       }
-    },
-    onError: (err) => {
-      setError(err);
     }
-  });
+  );
   const registerSessionMutation = reactQuery.useMutation({
     mutationFn: async (sessionConfig = {}) => {
       if (!wallet) throw new Error("Wallet is required");
@@ -474,22 +472,19 @@ function useMigrateWalletToPasskey() {
     mutationFn: async (input) => {
       const { wallet, oldEncryptKey, externalUserId, bearerToken } = input;
       try {
-        const passkeyResult = await chipiPasskey.createWalletPasskey(
-          externalUserId,
-          externalUserId
-          // Using externalUserId as userName
-        );
         let decryptedPrivateKey;
         try {
-          decryptedPrivateKey = backend.decryptPrivateKey(
-            wallet.encryptedPrivateKey,
-            oldEncryptKey
-          );
-        } catch (error) {
+          decryptedPrivateKey = backend.decryptPrivateKey(wallet.encryptedPrivateKey, oldEncryptKey);
+        } catch {
           throw new Error(
             "Failed to decrypt wallet with provided encryptKey. Please verify your PIN/password is correct."
           );
         }
+        const passkeyResult = await chipiPasskey.createWalletPasskey(
+          externalUserId,
+          externalUserId
+          // Using externalUserId as userName
+        );
         const newEncryptedPrivateKey = backend.encryptPrivateKey(
           decryptedPrivateKey,
           passkeyResult.encryptKey
@@ -549,44 +544,49 @@ function useUpdateWalletEncryption() {
 }
 function useTransfer() {
   const { chipiSDK, passkeyAdapter } = useChipiContext();
-  const mutation = reactQuery.useMutation(
-    {
-      mutationFn: async (input) => {
-        let encryptKey = input.params.encryptKey;
-        if (input.params.usePasskey) {
-          if (!input.params.externalUserId) {
-            throw new Error(
-              "externalUserId is required when usePasskey is true"
-            );
+  const mutation = reactQuery.useMutation({
+    mutationFn: async (input) => {
+      let encryptKey = input.params.encryptKey;
+      if (input.params.usePasskey) {
+        if (!input.params.externalUserId) {
+          throw new Error("externalUserId is required when usePasskey is true");
+        }
+        try {
+          const key = await passkeyAdapter.getWalletEncryptKey({
+            externalUserId: input.params.externalUserId
+          });
+          if (!key) {
+            throw new Error("Passkey authentication was cancelled");
+          }
+          encryptKey = key;
+        } catch (error) {
+          if (error instanceof DOMException && error.name === "NotAllowedError") {
+            throw new Error("Passkey authentication was cancelled by the user");
           }
-          try {
-            const key = await passkeyAdapter.getWalletEncryptKey({
-              externalUserId: input.params.externalUserId
-            });
-            if (!key) {
-              throw new Error("Passkey authentication was cancelled");
-            }
-            encryptKey = key;
-          } catch (error) {
-            if (error instanceof Error) {
-              throw new Error(
-                `Passkey authentication failed: ${error.message}`
-              );
-            }
-            throw new Error("Failed to authenticate with passkey");
+          if (error instanceof Error) {
+            throw error;
           }
+          throw new Error("Failed to authenticate with passkey");
         }
-        return chipiSDK.transfer({
-          params: {
-            ...input.params,
-            amount: String(input.params.amount),
-            encryptKey
-          },
-          bearerToken: input.bearerToken
-        });
       }
+      if (!encryptKey) {
+        throw new Error("encryptKey is required when usePasskey is false");
+      }
+      const {
+        usePasskey: _usePasskey,
+        externalUserId: _externalUserId,
+        ...transferParams
+      } = input.params;
+      return chipiSDK.transfer({
+        params: {
+          ...transferParams,
+          amount: String(transferParams.amount),
+          encryptKey
+        },
+        bearerToken: input.bearerToken
+      });
     }
-  );
+  });
   return {
     transfer: mutation.mutate,
     transferAsync: mutation.mutateAsync,
@@ -622,10 +622,20 @@ function useApprove() {
           throw new Error("Failed to authenticate with passkey");
         }
       }
+      if (!encryptKey) {
+        throw new Error(
+          "encryptKey is required when usePasskey is false. Provide a PIN or enable usePasskey."
+        );
+      }
+      const {
+        usePasskey: _usePasskey,
+        externalUserId: _externalUserId,
+        ...approveParams
+      } = params.params;
       return chipiSDK.approve({
         params: {
-          ...params.params,
-          amount: String(params.params.amount),
+          ...approveParams,
+          amount: String(approveParams.amount),
           encryptKey
         },
         bearerToken: params.bearerToken
@@ -675,9 +685,8 @@ function useGetTransactionList(input) {
   });
   const fetchTransactionList = async (newInput) => {
     return queryClient.fetchQuery({
-      queryKey: buildQueryKey(newInput?.query),
+      queryKey: buildQueryKey(newInput.query),
       queryFn: async () => {
-        if (!newInput?.getBearerToken) throw new Error("getBearerToken is required");
         const bearerToken = await newInput.getBearerToken();
         if (!bearerToken) throw new Error("Bearer token is required");
         return chipiSDK.getTransactionList(newInput.query, bearerToken);
@@ -695,6 +704,104 @@ function useGetTransactionList(input) {
     fetchTransactionList
   };
 }
+function useGetTransaction(input) {
+  const { chipiSDK } = useChipiContext();
+  const queryClient = reactQuery.useQueryClient();
+  const buildQueryKey = (hashOrId) => ["transaction", hashOrId ?? null];
+  const query = reactQuery.useQuery({
+    queryKey: buildQueryKey(input?.hashOrId),
+    queryFn: async () => {
+      if (!input?.hashOrId) throw new Error("hashOrId is required");
+      if (!input?.getBearerToken) throw new Error("getBearerToken is required");
+      const bearerToken = await input.getBearerToken();
+      if (!bearerToken) throw new Error("Bearer token is required");
+      return chipiSDK.getTransaction(input.hashOrId, bearerToken);
+    },
+    enabled: Boolean(input?.hashOrId && input?.getBearerToken),
+    retry: (failureCount, error) => {
+      if (error instanceof shared.ChipiApiError || error?.status) {
+        return false;
+      }
+      return failureCount < 3;
+    },
+    ...input?.queryOptions
+  });
+  const fetchTransaction = async (newInput) => {
+    return queryClient.fetchQuery({
+      queryKey: buildQueryKey(newInput.hashOrId),
+      queryFn: async () => {
+        const bearerToken = await newInput.getBearerToken();
+        if (!bearerToken) throw new Error("Bearer token is required");
+        return chipiSDK.getTransaction(newInput.hashOrId, bearerToken);
+      },
+      retry: (failureCount, error) => {
+        if (error instanceof shared.ChipiApiError || error?.status) {
+          return false;
+        }
+        return failureCount < 3;
+      }
+    });
+  };
+  return {
+    ...query,
+    fetchTransaction
+  };
+}
+var TERMINAL_STATUSES = [
+  types.OnChainTxStatus.ACCEPTED_ON_L1,
+  types.OnChainTxStatus.REJECTED,
+  types.OnChainTxStatus.REVERTED
+];
+function useGetTransactionStatus(input) {
+  const { chipiSDK } = useChipiContext();
+  const queryClient = reactQuery.useQueryClient();
+  const buildQueryKey = (hash) => ["transaction-status", hash ?? null];
+  const query = reactQuery.useQuery({
+    queryKey: buildQueryKey(input?.hash),
+    queryFn: async () => {
+      if (!input?.hash) throw new Error("hash is required");
+      if (!input?.getBearerToken) throw new Error("getBearerToken is required");
+      const bearerToken = await input.getBearerToken();
+      if (!bearerToken) throw new Error("Bearer token is required");
+      return chipiSDK.getTransactionStatus(input.hash, bearerToken);
+    },
+    enabled: Boolean(input?.hash && input?.getBearerToken),
+    refetchInterval: (query2) => {
+      const status = query2.state.data?.status;
+      if (status && TERMINAL_STATUSES.includes(status)) {
+        return false;
+      }
+      return input?.refetchInterval ?? 3e3;
+    },
+    retry: (failureCount, error) => {
+      if (error instanceof shared.ChipiApiError || error?.status) {
+        return false;
+      }
+      return failureCount < 3;
+    },
+    ...input?.queryOptions
+  });
+  const fetchTransactionStatus = async (newInput) => {
+    return queryClient.fetchQuery({
+      queryKey: buildQueryKey(newInput.hash),
+      queryFn: async () => {
+        const bearerToken = await newInput.getBearerToken();
+        if (!bearerToken) throw new Error("Bearer token is required");
+        return chipiSDK.getTransactionStatus(newInput.hash, bearerToken);
+      },
+      retry: (failureCount, error) => {
+        if (error instanceof shared.ChipiApiError || error?.status) {
+          return false;
+        }
+        return failureCount < 3;
+      }
+    });
+  };
+  return {
+    ...query,
+    fetchTransactionStatus
+  };
+}
 function usePurchaseSku() {
   const { chipiSDK } = useChipiContext();
   const mutation = reactQuery.useMutation({
@@ -734,8 +841,7 @@ function useGetSkuPurchase(input) {
       queryKey: ["sku-purchase", newInput?.id],
       queryFn: async () => {
         if (!newInput?.id) throw new Error("id is required");
-        if (!newInput?.getBearerToken)
-          throw new Error("getBearerToken is required");
+        if (!newInput?.getBearerToken) throw new Error("getBearerToken is required");
         const bearerToken = await newInput.getBearerToken();
         if (!bearerToken) throw new Error("Bearer token is required");
         return chipiSDK.getSkuPurchase(newInput.id, bearerToken);
@@ -809,9 +915,7 @@ function useGetSku(input) {
       if (!bearerToken) throw new Error("Bearer token is required");
       return chipiSDK.getSku(input.id, bearerToken);
     },
-    enabled: Boolean(
-      input?.id && input?.getBearerToken && input.id.trim() !== ""
-    ),
+    enabled: Boolean(input?.id && input?.getBearerToken && input.id.trim() !== ""),
     retry: (failureCount, error) => {
       if (error instanceof shared.ChipiApiError || error?.status) {
         return false;
@@ -824,14 +928,13 @@ function useGetSku(input) {
     return queryClient.fetchQuery({
       queryKey: ["sku", input2?.id],
       queryFn: async () => {
-        if (!input2?.getBearerToken)
-          throw new Error("getBearerToken is required");
+        if (!input2?.getBearerToken) throw new Error("getBearerToken is required");
         const bearerToken = await input2.getBearerToken();
         if (!bearerToken) throw new Error("Bearer token is required");
         return chipiSDK.getSku(input2.id, bearerToken);
       },
       retry: (failureCount, error) => {
-        if (error instanceof shared.ChipiApiError || error?.code) {
+        if (error instanceof shared.ChipiApiError || error?.status) {
           return false;
         }
         return failureCount < 3;
@@ -850,9 +953,7 @@ function useCallAnyContract() {
       let encryptKey = params.params.encryptKey;
       if (params.params.usePasskey) {
         if (!params.params.externalUserId) {
-          throw new Error(
-            "externalUserId is required when usePasskey is true"
-          );
+          throw new Error("externalUserId is required when usePasskey is true");
         }
         try {
           const key = await passkeyAdapter.getWalletEncryptKey({
@@ -863,17 +964,26 @@ function useCallAnyContract() {
           }
           encryptKey = key;
         } catch (error) {
+          if (error instanceof DOMException && error.name === "NotAllowedError") {
+            throw new Error("Passkey authentication was cancelled by the user");
+          }
           if (error instanceof Error) {
-            throw new Error(
-              `Passkey authentication failed: ${error.message}`
-            );
+            throw error;
           }
           throw new Error("Failed to authenticate with passkey");
         }
       }
+      if (!encryptKey) {
+        throw new Error("encryptKey is required when usePasskey is false");
+      }
+      const {
+        usePasskey: _usePasskey,
+        externalUserId: _externalUserId,
+        ...contractParams
+      } = params.params;
       return chipiSDK.callAnyContract({
         params: {
-          ...params.params,
+          ...contractParams,
           encryptKey
         },
         bearerToken: params.bearerToken
@@ -941,7 +1051,8 @@ function useGetTokenBalance(input) {
     return queryClient.fetchQuery({
       queryKey: buildQueryKey(newInput?.params),
       queryFn: async () => {
-        if (!newInput || !newInput.getBearerToken || !newInput.params) throw new Error("Input is required");
+        if (!newInput || !newInput.getBearerToken || !newInput.params)
+          throw new Error("Input is required");
         const bearerToken = await newInput.getBearerToken();
         if (!bearerToken) throw new Error("Bearer token is required");
         return chipiSDK.getTokenBalance(newInput.params, bearerToken);
@@ -978,10 +1089,7 @@ function useCreateSessionKey() {
 function useAddSessionKeyToContract() {
   const { chipiSDK } = useChipiContext();
   const mutation = reactQuery.useMutation({
-    mutationFn: (input) => chipiSDK.sessions.addSessionKeyToContract(
-      input.params,
-      input.bearerToken
-    )
+    mutationFn: (input) => chipiSDK.sessions.addSessionKeyToContract(input.params, input.bearerToken)
   });
   return {
     addSessionKeyToContract: mutation.mutate,
@@ -1013,11 +1121,7 @@ function useRevokeSessionKey() {
 function useGetSessionData(params, options) {
   const { chipiSDK } = useChipiContext();
   const query = reactQuery.useQuery({
-    queryKey: [
-      "sessionData",
-      params?.walletAddress,
-      params?.sessionPublicKey
-    ],
+    queryKey: ["sessionData", params?.walletAddress, params?.sessionPublicKey],
     queryFn: () => {
       if (!params) {
         throw new Error("Session data params are required");
@@ -1054,6 +1158,240 @@ function useExecuteWithSession() {
     reset: mutation.reset
   };
 }
+function useX402Payment(config) {
+  const { chipiSDK } = useChipiContext();
+  const {
+    wallet,
+    encryptKey,
+    getBearerToken: getBearerTokenFn,
+    bearerToken: staticBearerToken,
+    maxPaymentAmount: maxPaymentAmountProp,
+    maxAmount,
+    allowedRecipients,
+    session,
+    onPaymentComplete
+  } = config;
+  const maxPaymentAmount = maxPaymentAmountProp ?? maxAmount;
+  const getBearerToken = react.useMemo(
+    () => getBearerTokenFn ?? (staticBearerToken ? () => Promise.resolve(staticBearerToken) : () => Promise.resolve(void 0)),
+    [getBearerTokenFn, staticBearerToken]
+  );
+  const [lastTxHash, setLastTxHash] = react.useState(null);
+  const [lastAmount, setLastAmount] = react.useState(null);
+  const [lastPayment, setLastPayment] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const paymentCountRef = react.useRef(0);
+  const [paymentCount, setPaymentCount] = react.useState(0);
+  const totalSpentRef = react.useRef(0n);
+  const [totalSpent, setTotalSpent] = react.useState("0.000000");
+  const parsePaymentRequired = react.useCallback((response) => {
+    const headerValue = response.headers.get("payment-required");
+    if (!headerValue) {
+      throw new Error(
+        "Server returned 402 but no PAYMENT-REQUIRED header. The server may not support x402 or is misconfigured."
+      );
+    }
+    try {
+      return JSON.parse(headerValue);
+    } catch {
+      throw new Error("Malformed PAYMENT-REQUIRED header: invalid JSON");
+    }
+  }, []);
+  const validateRequirement = react.useCallback(
+    (requirement) => {
+      if (requirement.scheme !== "exact") {
+        throw new Error(
+          `Unsupported payment scheme: "${requirement.scheme}". Only "exact" is supported.`
+        );
+      }
+      if (requirement.network !== "starknet-mainnet") {
+        throw new Error(
+          `Unsupported network: "${requirement.network}". Only "starknet-mainnet" is supported.`
+        );
+      }
+      const USDC_MAINNET = "0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb";
+      const normalizeAddr = (a) => a.toLowerCase().replace(/^0x0+/, "0x");
+      if (normalizeAddr(requirement.asset) !== normalizeAddr(USDC_MAINNET)) {
+        throw new Error(`Unsupported asset: ${requirement.asset}. Only USDC is supported.`);
+      }
+      if (!requirement.payTo) {
+        throw new Error("Invalid payment requirement: missing payTo address");
+      }
+      const timeoutSeconds = Number(requirement.maxTimeoutSeconds);
+      if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
+        throw new Error("Invalid payment requirement: maxTimeoutSeconds must be a positive number");
+      }
+      let requiredAmount;
+      try {
+        requiredAmount = BigInt(requirement.maxAmountRequired);
+      } catch {
+        throw new Error("Invalid payment requirement: maxAmountRequired must be an integer string");
+      }
+      if (requiredAmount <= 0n) {
+        throw new Error("Invalid payment requirement: maxAmountRequired must be > 0");
+      }
+      if (maxPaymentAmount) {
+        const trimmed = maxPaymentAmount.trim();
+        if (!/^\d+(\.\d{1,6})?$/.test(trimmed)) {
+          throw new Error(`Invalid maxPaymentAmount format: "${maxPaymentAmount}"`);
+        }
+        const [whole, frac = ""] = trimmed.split(".");
+        const fracPadded = (frac + "000000").slice(0, 6);
+        const maxBaseUnits = BigInt((whole || "0") + fracPadded);
+        if (requiredAmount > maxBaseUnits) {
+          const requiredHuman = (Number(requiredAmount) / 1e6).toFixed(6);
+          throw new Error(
+            `Payment amount ${requiredHuman} USDC exceeds maximum allowed ${maxPaymentAmount} USDC`
+          );
+        }
+      }
+      if (allowedRecipients && allowedRecipients.length > 0) {
+        const normalize = (a) => a.toLowerCase().replace(/^0x0+/, "0x");
+        const normalized = normalize(requirement.payTo);
+        const isAllowed = allowedRecipients.some((addr) => normalize(addr) === normalized);
+        if (!isAllowed) {
+          throw new Error(`Recipient ${requirement.payTo} is not in the allowed recipients list`);
+        }
+      }
+    },
+    [maxPaymentAmount, allowedRecipients]
+  );
+  const signPayment = react.useCallback(
+    async (requirement) => {
+      if (!wallet) {
+        throw new Error("Wallet is required for x402 payments");
+      }
+      if (!encryptKey) {
+        throw new Error("Encryption key (PIN) is required for x402 payments");
+      }
+      validateRequirement(requirement);
+      const nonce = crypto.randomUUID();
+      const validUntil = Math.floor(Date.now() / 1e3) + requirement.maxTimeoutSeconds;
+      if (session) {
+        const bearerToken = await getBearerToken();
+        if (!bearerToken) throw new Error("Bearer token is required");
+        const txHash = await chipiSDK.executeTransactionWithSession({
+          params: {
+            encryptKey,
+            wallet,
+            session,
+            calls: [
+              {
+                contractAddress: requirement.asset,
+                entrypoint: "transfer",
+                calldata: [requirement.payTo, requirement.maxAmountRequired, "0x0"]
+              }
+            ]
+          },
+          bearerToken
+        });
+        return {
+          x402Version: 1,
+          scheme: "exact",
+          network: "starknet-mainnet",
+          payload: {
+            signature: { r: txHash, s: "session" },
+            fromAddress: wallet.publicKey,
+            toAddress: requirement.payTo,
+            amount: requirement.maxAmountRequired,
+            asset: requirement.asset,
+            validUntil,
+            nonce
+          }
+        };
+      }
+      const typedData = core.buildX402TypedData({
+        from_address: wallet.publicKey,
+        to_address: requirement.payTo,
+        amount: requirement.maxAmountRequired,
+        asset: requirement.asset,
+        valid_until: String(validUntil),
+        nonce
+      });
+      const signature = await chipiSDK.signTypedData({
+        params: {
+          encryptKey,
+          wallet,
+          typedData
+        }
+      });
+      return {
+        x402Version: 1,
+        scheme: "exact",
+        network: "starknet-mainnet",
+        payload: {
+          signature,
+          fromAddress: wallet.publicKey,
+          toAddress: requirement.payTo,
+          amount: requirement.maxAmountRequired,
+          asset: requirement.asset,
+          validUntil,
+          nonce
+        }
+      };
+    },
+    [wallet, encryptKey, session, getBearerToken, chipiSDK, validateRequirement]
+  );
+  const paymentMutation = reactQuery.useMutation(
+    {
+      mutationFn: async ({ url, init }) => {
+        const response = await globalThis.fetch(url, init);
+        if (response.status !== 402) {
+          return response;
+        }
+        const requirement = parsePaymentRequired(response);
+        const payment = await signPayment(requirement);
+        const humanAmount = (Number(BigInt(requirement.maxAmountRequired)) / 1e6).toFixed(6);
+        const isSessionPayment = payment.payload.signature.s === "session";
+        const txHash = isSessionPayment ? payment.payload.signature.r : null;
+        setLastAmount(humanAmount);
+        setLastTxHash(txHash);
+        setLastPayment({ txHash, amount: humanAmount, timestamp: Date.now() });
+        totalSpentRef.current += BigInt(requirement.maxAmountRequired);
+        setTotalSpent((Number(totalSpentRef.current) / 1e6).toFixed(6));
+        paymentCountRef.current += 1;
+        setPaymentCount(paymentCountRef.current);
+        const headers = new Headers(init?.headers);
+        headers.set("X-PAYMENT", JSON.stringify(payment));
+        const paidResponse = await globalThis.fetch(url, { ...init, headers });
+        if (paidResponse.status === 402) {
+          throw new Error(
+            "Server returned 402 after payment was submitted. Payment may have failed verification."
+          );
+        }
+        if (onPaymentComplete) {
+          void Promise.resolve(onPaymentComplete(txHash ?? "", humanAmount)).catch(() => {
+          });
+        }
+        return paidResponse;
+      },
+      onError: (err) => {
+        setError(err);
+      },
+      onSuccess: () => {
+        setError(null);
+      }
+    }
+  );
+  const x402Fetch = react.useCallback(
+    async (url, init) => {
+      return paymentMutation.mutateAsync({ url, init });
+    },
+    [paymentMutation]
+  );
+  return {
+    x402Fetch,
+    payFetch: x402Fetch,
+    signPayment,
+    isPaying: paymentMutation.isPending,
+    lastTxHash,
+    lastAmount,
+    lastPayment,
+    totalSpent,
+    error: error || paymentMutation.error || null,
+    paymentCount
+  };
+}
 
 exports.useAddSessionKeyToContract = useAddSessionKeyToContract;
 exports.useApprove = useApprove;
@@ -1068,7 +1406,9 @@ exports.useGetSku = useGetSku;
 exports.useGetSkuList = useGetSkuList;
 exports.useGetSkuPurchase = useGetSkuPurchase;
 exports.useGetTokenBalance = useGetTokenBalance;
+exports.useGetTransaction = useGetTransaction;
 exports.useGetTransactionList = useGetTransactionList;
+exports.useGetTransactionStatus = useGetTransactionStatus;
 exports.useGetWallet = useGetWallet;
 exports.useMigrateWalletToPasskey = useMigrateWalletToPasskey;
 exports.usePurchaseSku = usePurchaseSku;
@@ -1076,5 +1416,6 @@ exports.useRecordSendTransaction = useRecordSendTransaction;
 exports.useRevokeSessionKey = useRevokeSessionKey;
 exports.useTransfer = useTransfer;
 exports.useUpdateWalletEncryption = useUpdateWalletEncryption;
+exports.useX402Payment = useX402Payment;
 //# sourceMappingURL=hooks.js.map
 //# sourceMappingURL=hooks.js.map