@zkp2p/cash 0.1.3 → 0.1.4

package/dist/react.js

@@ -1,4 +1,4 @@
-import { isCashError, CASH_ORDER_POLL_INTERVAL_MS } from './chunk-FKVPZVFH.js';
+import { isCashError, CASH_ORDER_POLL_INTERVAL_MS } from './chunk-P3KYZ2FX.js';
 import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
 
 function useEstimate({
@@ -13,14 +13,32 @@ function useEstimate({
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState(null);
   const mountedRef = useRef(true);
+  const latestRequestRef = useRef(0);
   const timerRef = useRef(null);
+  const estimateIdentityRef = useRef(null);
+  const loadingIdentityRef = useRef(null);
+  const errorIdentityRef = useRef(null);
   const refresh = useCallback(async () => {
+    const requestId = ++latestRequestRef.current;
+    const isCurrent = () => mountedRef.current && requestId === latestRequestRef.current;
     if (!client || !currency || !amount || amount <= 0n) {
-      if (mountedRef.current) setEstimate(null);
+      if (isCurrent()) {
+        estimateIdentityRef.current = null;
+        loadingIdentityRef.current = null;
+        errorIdentityRef.current = null;
+        setEstimate(null);
+        setIsLoading(false);
+        setError(null);
+      }
       return;
     }
-    setIsLoading(true);
-    setError(null);
+    const identity = { client, amount, currency, platform, source };
+    if (isCurrent()) {
+      loadingIdentityRef.current = identity;
+      errorIdentityRef.current = null;
+      setIsLoading(true);
+      setError(null);
+    }
     try {
       const result = await client.estimate({
         amount,
@@ -28,17 +46,31 @@ function useEstimate({
         ...platform ? { platform } : {},
         ...source ? { source } : {}
       });
-      if (mountedRef.current) setEstimate(result);
+      if (isCurrent()) {
+        estimateIdentityRef.current = identity;
+        setEstimate(result);
+      }
     } catch (err) {
       const e = err instanceof Error ? err : new Error(String(err));
-      if (mountedRef.current) {
+      if (isCurrent()) {
+        estimateIdentityRef.current = null;
+        errorIdentityRef.current = identity;
         setEstimate(null);
         setError(e);
       }
     } finally {
-      if (mountedRef.current) setIsLoading(false);
+      if (isCurrent()) setIsLoading(false);
     }
   }, [client, currency, amount, platform, source]);
+  useEffect(() => {
+    latestRequestRef.current += 1;
+    estimateIdentityRef.current = null;
+    loadingIdentityRef.current = null;
+    errorIdentityRef.current = null;
+    setEstimate(null);
+    setIsLoading(false);
+    setError(null);
+  }, [client, amount, currency, platform, source]);
   useEffect(() => {
     mountedRef.current = true;
     void refresh();
@@ -47,10 +79,38 @@ function useEstimate({
     }
     return () => {
       mountedRef.current = false;
+      latestRequestRef.current += 1;
       if (timerRef.current) clearInterval(timerRef.current);
     };
   }, [refresh, refreshIntervalMs]);
-  return { estimate, isLoading, error, refresh };
+  const matchesCurrentIdentity = (identity) => identity?.client === client && identity.amount === amount && identity.currency === currency && identity.platform === platform && identity.source === source;
+  return {
+    estimate: matchesCurrentIdentity(estimateIdentityRef.current) ? estimate : null,
+    isLoading: matchesCurrentIdentity(loadingIdentityRef.current) ? isLoading : false,
+    error: matchesCurrentIdentity(errorIdentityRef.current) ? error : null,
+    refresh
+  };
+}
+function useMountedRef() {
+  const mounted = useRef(true);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  return mounted;
+}
+
+// src/react/useCashout.ts
+function matchesIdentity(identity, client, signer, sourceSigner) {
+  return identity?.client === client && identity.signer === signer && identity.sourceSigner === sourceSigner;
+}
+function notifyObserver(observer, value) {
+  try {
+    observer?.(value);
+  } catch {
+  }
 }
 function useCashout({
   client,
@@ -61,16 +121,35 @@ function useCashout({
   onError
 }) {
   const [pending, setPending] = useState(null);
+  const pendingRef = useRef(null);
   const [result, setResult] = useState(null);
   const [error, setError] = useState(null);
+  const resultIdentityRef = useRef(null);
+  const errorIdentityRef = useRef(null);
+  const mounted = useMountedRef();
+  useEffect(() => {
+    pendingRef.current = null;
+    resultIdentityRef.current = null;
+    errorIdentityRef.current = null;
+    setPending(null);
+    setResult(null);
+    setError(null);
+  }, [client, signer, sourceSigner]);
   const cashout = useCallback(
     async (input) => {
+      const identity = { client, signer, sourceSigner };
       if (!client || !signer) {
         const err = new Error("Cash client or signer is not ready");
-        setError(err);
-        onError?.(err);
+        if (mounted.current) {
+          errorIdentityRef.current = identity;
+          setError(err);
+        }
+        notifyObserver(onError, err);
         return null;
       }
+      if (matchesIdentity(pendingRef.current, client, signer, sourceSigner)) return null;
+      const active = { ...identity, kind: "cashout" };
+      pendingRef.current = active;
       setPending("cashout");
       setError(null);
       setResult(null);
@@ -80,28 +159,44 @@ function useCashout({
           ...sourceSigner ? { sourceSigner } : {},
           ...onSourceProgress ? { onSourceProgress } : {}
         });
-        setResult(cashoutResult);
-        onCashout?.(cashoutResult);
+        if (mounted.current && pendingRef.current === active) {
+          resultIdentityRef.current = identity;
+          setResult(cashoutResult);
+        }
+        notifyObserver(onCashout, cashoutResult);
         return cashoutResult;
       } catch (err) {
         const e = err instanceof Error ? err : new Error(String(err));
-        setError(e);
-        onError?.(e);
+        if (mounted.current && pendingRef.current === active) {
+          errorIdentityRef.current = identity;
+          setError(e);
+        }
+        notifyObserver(onError, e);
         return null;
       } finally {
-        setPending(null);
+        if (mounted.current && pendingRef.current === active) {
+          pendingRef.current = null;
+          setPending(null);
+        }
       }
     },
     [client, signer, sourceSigner, onSourceProgress, onCashout, onError]
   );
   const withdraw = useCallback(
     async (depositId, amount) => {
+      const identity = { client, signer, sourceSigner };
       if (!client || !signer) {
         const err = new Error("Cash client or signer is not ready");
-        setError(err);
-        onError?.(err);
+        if (mounted.current) {
+          errorIdentityRef.current = identity;
+          setError(err);
+        }
+        notifyObserver(onError, err);
         return null;
       }
+      if (matchesIdentity(pendingRef.current, client, signer, sourceSigner)) return null;
+      const active = { ...identity, kind: "withdraw" };
+      pendingRef.current = active;
       setPending("withdraw");
       setError(null);
       try {
@@ -111,41 +206,70 @@ function useCashout({
         });
       } catch (err) {
         const e = err instanceof Error ? err : new Error(String(err));
-        setError(e);
-        onError?.(e);
+        if (mounted.current && pendingRef.current === active) {
+          errorIdentityRef.current = identity;
+          setError(e);
+        }
+        notifyObserver(onError, e);
         return null;
       } finally {
-        setPending(null);
+        if (mounted.current && pendingRef.current === active) {
+          pendingRef.current = null;
+          setPending(null);
+        }
       }
     },
-    [client, signer, onError]
+    [client, signer, sourceSigner, onError]
   );
   const topUp = useCallback(
     async (depositId, amount) => {
+      const identity = { client, signer, sourceSigner };
       if (!client || !signer) {
         const err = new Error("Cash client or signer is not ready");
-        setError(err);
-        onError?.(err);
+        if (mounted.current) {
+          errorIdentityRef.current = identity;
+          setError(err);
+        }
+        notifyObserver(onError, err);
         return null;
       }
+      if (matchesIdentity(pendingRef.current, client, signer, sourceSigner)) return null;
+      const active = { ...identity, kind: "topUp" };
+      pendingRef.current = active;
       setPending("topUp");
       setError(null);
       try {
         return await client.topUp(depositId, amount, { signer });
       } catch (err) {
         const e = err instanceof Error ? err : new Error(String(err));
-        setError(e);
-        onError?.(e);
+        if (mounted.current && pendingRef.current === active) {
+          errorIdentityRef.current = identity;
+          setError(e);
+        }
+        notifyObserver(onError, e);
         return null;
       } finally {
-        setPending(null);
+        if (mounted.current && pendingRef.current === active) {
+          pendingRef.current = null;
+          setPending(null);
+        }
       }
     },
-    [client, signer, onError]
+    [client, signer, sourceSigner, onError]
   );
+  const visiblePending = matchesIdentity(pendingRef.current, client, signer, sourceSigner) ? pending : null;
+  const visibleResult = matchesIdentity(resultIdentityRef.current, client, signer, sourceSigner) ? result : null;
+  const visibleError = matchesIdentity(errorIdentityRef.current, client, signer, sourceSigner) ? error : null;
   return useMemo(
-    () => ({ cashout, topUp, withdraw, pending, result, error }),
-    [cashout, topUp, withdraw, pending, result, error]
+    () => ({
+      cashout,
+      topUp,
+      withdraw,
+      pending: visiblePending,
+      result: visibleResult,
+      error: visibleError
+    }),
+    [cashout, topUp, withdraw, visiblePending, visibleResult, visibleError]
   );
 }
 function usePoll(enabled, intervalMs, tick) {
@@ -166,16 +290,6 @@ function usePoll(enabled, intervalMs, tick) {
     };
   }, [enabled, intervalMs, tick]);
 }
-function useMountedRef() {
-  const mounted = useRef(true);
-  useEffect(() => {
-    mounted.current = true;
-    return () => {
-      mounted.current = false;
-    };
-  }, []);
-  return mounted;
-}
 
 // src/react/useOrder.ts
 function useOrder({
@@ -188,27 +302,52 @@ function useOrder({
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState(null);
   const mounted = useMountedRef();
+  const latestRequest = useRef(0);
+  const orderIdentity = useRef(null);
+  const loadingIdentity = useRef(null);
+  const errorIdentity = useRef(null);
+  useEffect(() => {
+    latestRequest.current += 1;
+    orderIdentity.current = null;
+    loadingIdentity.current = null;
+    errorIdentity.current = null;
+    setOrder(null);
+    setIsLoading(false);
+    setError(null);
+  }, [client, depositId]);
   const fetchOrder = useCallback(
     async (isActive = () => true) => {
       if (!client || !depositId) return null;
-      setIsLoading(true);
-      setError(null);
+      const requestId = ++latestRequest.current;
+      const identity = { client, depositId };
+      const isCurrent = () => mounted.current && isActive() && requestId === latestRequest.current;
+      if (isCurrent()) {
+        loadingIdentity.current = identity;
+        errorIdentity.current = null;
+        setIsLoading(true);
+        setError(null);
+      }
       try {
         const derived = await client.order(depositId);
-        if (isActive()) setOrder(derived);
+        if (!isCurrent()) return null;
+        orderIdentity.current = identity;
+        setOrder(derived);
         return derived;
       } catch (err) {
         if (isCashError(err) && err.code === "ORDER_NOT_FOUND") {
           return null;
         }
         const e = err instanceof Error ? err : new Error(String(err));
-        if (isActive()) setError(e);
+        if (isCurrent()) {
+          errorIdentity.current = identity;
+          setError(e);
+        }
         return null;
       } finally {
-        if (isActive()) setIsLoading(false);
+        if (isCurrent()) setIsLoading(false);
       }
     },
-    [client, depositId]
+    [client, depositId, mounted]
   );
   usePoll(
     Boolean(client && depositId && !paused),
@@ -222,7 +361,13 @@ function useOrder({
     )
   );
   const refresh = useCallback(() => fetchOrder(() => mounted.current), [fetchOrder, mounted]);
-  return { order, isLoading, error, refresh };
+  const matchesCurrentIdentity = (identity) => identity?.client === client && identity.depositId === depositId;
+  return {
+    order: matchesCurrentIdentity(orderIdentity.current) ? order : null,
+    isLoading: matchesCurrentIdentity(loadingIdentity.current) ? isLoading : false,
+    error: matchesCurrentIdentity(errorIdentity.current) ? error : null,
+    refresh
+  };
 }
 function useOrders({
   client,
@@ -235,42 +380,74 @@ function useOrders({
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState(null);
   const mounted = useMountedRef();
+  const latestRequest = useRef(0);
+  const ordersIdentity = useRef(null);
+  const loadingIdentity = useRef(null);
+  const errorIdentity = useRef(null);
+  useEffect(() => {
+    latestRequest.current += 1;
+    ordersIdentity.current = null;
+    loadingIdentity.current = null;
+    errorIdentity.current = null;
+    setOrders([]);
+    setIsLoading(false);
+    setError(null);
+  }, [client, owner, limit]);
   const fetchOrders = useCallback(
     async (isActive = () => true) => {
       if (!client || !owner) return [];
-      setIsLoading(true);
-      setError(null);
+      const requestId = ++latestRequest.current;
+      const identity = { client, owner, limit };
+      const isCurrent = () => mounted.current && isActive() && requestId === latestRequest.current;
+      if (isCurrent()) {
+        loadingIdentity.current = identity;
+        errorIdentity.current = null;
+        setIsLoading(true);
+        setError(null);
+      }
       try {
         const derived = await client.orders(owner, { limit });
-        if (isActive()) setOrders(derived);
+        if (!isCurrent()) return [];
+        ordersIdentity.current = identity;
+        setOrders(derived);
         return derived;
       } catch (err) {
         const e = err instanceof Error ? err : new Error(String(err));
-        if (isActive()) setError(e);
+        if (isCurrent()) {
+          errorIdentity.current = identity;
+          setError(e);
+        }
         return [];
       } finally {
-        if (isActive()) setIsLoading(false);
+        if (isCurrent()) setIsLoading(false);
       }
     },
-    [client, owner, limit]
+    [client, owner, limit, mounted]
   );
   usePoll(
     Boolean(client && owner && !paused),
     pollIntervalMs,
     useCallback(
       async (isActive) => {
-        const result = await fetchOrders(isActive);
-        return result.some((o) => o.isInFlight);
+        await fetchOrders(isActive);
+        return true;
       },
       [fetchOrders]
     )
   );
   const refresh = useCallback(() => fetchOrders(() => mounted.current), [fetchOrders, mounted]);
-  const inFlightCount = orders.filter((o) => o.isInFlight).length;
-  const totalCashedOut = orders.reduce((sum, o) => sum + o.filledAmount, 0n);
-  return { orders, inFlightCount, totalCashedOut, isLoading, error, refresh };
+  const matchesCurrentIdentity = (identity) => identity?.client === client && identity.owner === owner && identity.limit === limit;
+  const visibleOrders = matchesCurrentIdentity(ordersIdentity.current) ? orders : [];
+  const inFlightCount = visibleOrders.filter((o) => o.isInFlight).length;
+  const totalCashedOut = visibleOrders.reduce((sum, o) => sum + o.filledAmount, 0n);
+  return {
+    orders: visibleOrders,
+    inFlightCount,
+    totalCashedOut,
+    isLoading: matchesCurrentIdentity(loadingIdentity.current) ? isLoading : false,
+    error: matchesCurrentIdentity(errorIdentity.current) ? error : null,
+    refresh
+  };
 }
 
 export { useCashout, useEstimate, useOrder, useOrders };
-//# sourceMappingURL=react.js.map
-//# sourceMappingURL=react.js.map

package/dist/tools.cjs

@@ -1,16 +1,30 @@
 'use strict';
 
+// package.json
+var package_default = {
+  version: "0.1.4"};
+
 // src/tools/index.ts
 var bigintString = {
   type: "string",
-  pattern: "^[0-9]+$",
+  pattern: "^0*[1-9][0-9]*$",
   description: "Base units as a decimal string. For the default path this is USDC 6 decimals; with source it is source-token base units."
 };
 var depositId = {
   type: "string",
+  pattern: "^0x[0-9a-fA-F]{40}_[0-9]+$",
   description: "Composite deposit id (escrow_onchainId) returned by cash_cashout - the resume key"
 };
-var cashTools = [
+var address = {
+  type: "string",
+  pattern: "^0x[0-9a-fA-F]{40}$"
+};
+var chainId = {
+  type: "integer",
+  minimum: 1,
+  maximum: Number.MAX_SAFE_INTEGER
+};
+var builtInCashTools = [
   {
     name: "cash_capabilities",
     description: "Discover what Peer Cash can do: payout platforms, oracle-priced currencies per platform, Base USDC destination, default Base USDC source, payee handle hints, and amount bounds. Set includeRelaySources=true to fetch live Relay-supported EVM source chains/tokens through the Relay SDK.",
@@ -27,23 +41,23 @@ var cashTools = [
   },
   {
     name: "cash_source_quote",
-    description: "Quote any Relay-supported EVM source asset into Base USDC through @relayprotocol/relay-sdk. Use this before cash_cashout when the user starts with an asset other than Base USDC.",
+    description: "Quote any Relay-supported EVM source asset into Base USDC through @relayprotocol/relay-sdk. A custody-capable host must submit the returned route, poll cash_source_status to success, then call Base-USDC cash_cashout with the guaranteed output amount. Never submit the route twice.",
     inputSchema: {
       type: "object",
       properties: {
-        user: { type: "string", description: "Source wallet submitting the Relay transaction." },
+        user: { ...address, description: "Source wallet submitting the Relay transaction." },
         amount: bigintString,
         source: {
           type: "object",
           properties: {
-            chainId: { type: "number", description: "Relay-supported EVM source chain id." },
-            currency: { type: "string", description: "Source token/native address." }
+            chainId: { ...chainId, description: "Relay-supported EVM source chain id." },
+            currency: { ...address, description: "Source token/native address." }
           },
           required: ["chainId", "currency"],
           additionalProperties: false
         },
         recipient: {
-          type: "string",
+          ...address,
           description: "Base recipient for Relay-delivered USDC. Defaults to user."
         },
         tradeType: {
@@ -75,14 +89,14 @@ var cashTools = [
           type: "object",
           description: "Optional Relay EVM source asset. Omit for the Base USDC default path.",
           properties: {
-            chainId: { type: "number", description: "Relay-supported EVM source chain id." },
-            currency: { type: "string", description: "Source token/native address." },
+            chainId: { ...chainId, description: "Relay-supported EVM source chain id." },
+            currency: { ...address, description: "Source token/native address." },
             user: {
-              type: "string",
+              ...address,
               description: "Source wallet submitting the Relay transaction."
             },
             recipient: {
-              type: "string",
+              ...address,
               description: "Base recipient for Relay-delivered USDC. Defaults to user."
             },
             tradeType: {
@@ -100,29 +114,11 @@ var cashTools = [
   },
   {
     name: "cash_cashout",
-    description: "Start a cash-out. Default path: Base USDC amount and tool hosts can return UNSIGNED transactions plus same-index steps [approve, createDeposit]. With source: signer-backed clients first execute a Relay SDK EVM route into Base USDC, then register the payee and create the protocol-held cash-out order. Non-Base source chains need a source-chain signer. Custody-separated hosts should use cash_source_quote/cash_source_status first, then Base USDC cash_cashout.",
+    description: "Start a Base-USDC cash-out using the custody-separated prepare path. Returns UNSIGNED transactions plus same-index steps [approve, createDeposit]; signing and ordered submission stay host-side. For another source asset, complete cash_source_quote and cash_source_status first, then pass the guaranteed Base USDC output amount here.",
     inputSchema: {
       type: "object",
       properties: {
         amount: bigintString,
-        source: {
-          type: "object",
-          description: "Optional Relay EVM source asset. Omit for the Base USDC default path.",
-          properties: {
-            chainId: { type: "number", description: "Relay-supported EVM source chain id." },
-            currency: { type: "string", description: "Source token/native address." },
-            recipient: {
-              type: "string",
-              description: "Base recipient for Relay-delivered USDC. Defaults to signer."
-            },
-            tradeType: {
-              type: "string",
-              enum: ["EXACT_INPUT", "EXACT_OUTPUT", "EXPECTED_OUTPUT"]
-            }
-          },
-          required: ["chainId", "currency"],
-          additionalProperties: false
-        },
         receive: {
           type: "object",
           description: "Where the fiat should arrive",
@@ -169,12 +165,17 @@ var cashTools = [
     inputSchema: {
       type: "object",
       properties: {
-        owner: { type: "string", description: "The maker wallet address (0x...)" },
+        owner: { ...address, description: "The maker wallet address (0x...)" },
         inFlight: {
           type: "boolean",
           description: "Only awaiting-buyer / matched / delivering orders"
         },
-        limit: { type: "number", description: "Max deposits to scan (default 100)" }
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 1e3,
+          description: "Max deposits to scan (default 100)"
+        }
       },
       required: ["owner"],
       additionalProperties: false
@@ -186,7 +187,7 @@ var cashTools = [
     inputSchema: {
       type: "object",
       properties: {
-        address: { type: "string", description: "The buyer (taker) wallet address (0x...)" }
+        address: { ...address, description: "The buyer (taker) wallet address (0x...)" }
       },
       required: ["address"],
       additionalProperties: false
@@ -231,14 +232,13 @@ var cashTools = [
     }
   }
 ];
+var cashTools = [...builtInCashTools];
 var cashToolManifest = {
   name: "@zkp2p/cash",
-  version: "0.1.2",
+  version: package_default.version,
   description: "Peer Cash - offramp-only: route any Relay-supported EVM source asset to Base USDC, then cash out to fiat at the live oracle market rate (0% spread). Mutating protocol tools return unsigned transactions plus step labels with ERC-8021 peer-cash attribution.",
   tools: cashTools
 };
 
 exports.cashToolManifest = cashToolManifest;
 exports.cashTools = cashTools;
-//# sourceMappingURL=tools.cjs.map
-//# sourceMappingURL=tools.cjs.map