@chipi-stack/chipi-react 14.0.0 → 14.1.1

package/dist/hooks.mjs

@@ -1,10 +1,11 @@
 import { useMutation, useQueryClient, useQuery } from '@tanstack/react-query';
-import { createContext, useMemo, useCallback, useState, useEffect, useContext } from 'react';
+import { createContext, useMemo, useCallback, useState, useEffect, useRef, useContext } from 'react';
 import { decryptPrivateKey, encryptPrivateKey } from '@chipi-stack/backend';
 import { createWalletPasskey } from '@chipi-stack/chipi-passkey';
 import 'react/jsx-runtime';
 import { ChipiApiError } from '@chipi-stack/shared';
-import { Chain, ChainToken } from '@chipi-stack/types';
+import { OnChainTxStatus, Chain, ChainToken } from '@chipi-stack/types';
+import { buildX402TypedData } from '@chipi-stack/core';
 
 // src/hooks/useCreateWallet.ts
 var ChipiContext = createContext(null);
@@ -701,6 +702,104 @@ function useGetTransactionList(input) {
     fetchTransactionList
   };
 }
+function useGetTransaction(input) {
+  const { chipiSDK } = useChipiContext();
+  const queryClient = useQueryClient();
+  const buildQueryKey = (hashOrId) => ["transaction", hashOrId ?? null];
+  const query = 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 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 ChipiApiError || error?.status) {
+          return false;
+        }
+        return failureCount < 3;
+      }
+    });
+  };
+  return {
+    ...query,
+    fetchTransaction
+  };
+}
+var TERMINAL_STATUSES = [
+  OnChainTxStatus.ACCEPTED_ON_L1,
+  OnChainTxStatus.REJECTED,
+  OnChainTxStatus.REVERTED
+];
+function useGetTransactionStatus(input) {
+  const { chipiSDK } = useChipiContext();
+  const queryClient = useQueryClient();
+  const buildQueryKey = (hash) => ["transaction-status", hash ?? null];
+  const query = 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 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 ChipiApiError || error?.status) {
+          return false;
+        }
+        return failureCount < 3;
+      }
+    });
+  };
+  return {
+    ...query,
+    fetchTransactionStatus
+  };
+}
 function usePurchaseSku() {
   const { chipiSDK } = useChipiContext();
   const mutation = useMutation({
@@ -1057,7 +1156,241 @@ 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 = useMemo(
+    () => getBearerTokenFn ?? (staticBearerToken ? () => Promise.resolve(staticBearerToken) : () => Promise.resolve(void 0)),
+    [getBearerTokenFn, staticBearerToken]
+  );
+  const [lastTxHash, setLastTxHash] = useState(null);
+  const [lastAmount, setLastAmount] = useState(null);
+  const [lastPayment, setLastPayment] = useState(null);
+  const [error, setError] = useState(null);
+  const paymentCountRef = useRef(0);
+  const [paymentCount, setPaymentCount] = useState(0);
+  const totalSpentRef = useRef(0n);
+  const [totalSpent, setTotalSpent] = useState("0.000000");
+  const parsePaymentRequired = 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 = 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 = 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 = 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 = 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 = 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
+  };
+}
 
-export { useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuPurchase, useGetTokenBalance, useGetTransactionList, useGetWallet, useMigrateWalletToPasskey, usePurchaseSku, useRecordSendTransaction, useRevokeSessionKey, useTransfer, useUpdateWalletEncryption };
+export { useAddSessionKeyToContract, useApprove, useCallAnyContract, useChipiSession, useChipiWallet, useCreateSessionKey, useCreateWallet, useExecuteWithSession, useGetSessionData, useGetSku, useGetSkuList, useGetSkuPurchase, useGetTokenBalance, useGetTransaction, useGetTransactionList, useGetTransactionStatus, useGetWallet, useMigrateWalletToPasskey, usePurchaseSku, useRecordSendTransaction, useRevokeSessionKey, useTransfer, useUpdateWalletEncryption, useX402Payment };
 //# sourceMappingURL=hooks.mjs.map
 //# sourceMappingURL=hooks.mjs.map