@zkp2p/cash 0.1.2 → 0.1.4

package/dist/react.cjs

@@ -15,14 +15,32 @@ function useEstimate({
   const [isLoading, setIsLoading] = react.useState(false);
   const [error, setError] = react.useState(null);
   const mountedRef = react.useRef(true);
+  const latestRequestRef = react.useRef(0);
   const timerRef = react.useRef(null);
+  const estimateIdentityRef = react.useRef(null);
+  const loadingIdentityRef = react.useRef(null);
+  const errorIdentityRef = react.useRef(null);
   const refresh = react.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,
@@ -30,17 +48,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]);
+  react.useEffect(() => {
+    latestRequestRef.current += 1;
+    estimateIdentityRef.current = null;
+    loadingIdentityRef.current = null;
+    errorIdentityRef.current = null;
+    setEstimate(null);
+    setIsLoading(false);
+    setError(null);
+  }, [client, amount, currency, platform, source]);
   react.useEffect(() => {
     mountedRef.current = true;
     void refresh();
@@ -49,10 +81,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 = react.useRef(true);
+  react.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,
@@ -63,16 +123,35 @@ function useCashout({
   onError
 }) {
   const [pending, setPending] = react.useState(null);
+  const pendingRef = react.useRef(null);
   const [result, setResult] = react.useState(null);
   const [error, setError] = react.useState(null);
+  const resultIdentityRef = react.useRef(null);
+  const errorIdentityRef = react.useRef(null);
+  const mounted = useMountedRef();
+  react.useEffect(() => {
+    pendingRef.current = null;
+    resultIdentityRef.current = null;
+    errorIdentityRef.current = null;
+    setPending(null);
+    setResult(null);
+    setError(null);
+  }, [client, signer, sourceSigner]);
   const cashout = react.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);
@@ -82,28 +161,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 = react.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 {
@@ -113,41 +208,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 = react.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 react.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]
   );
 }
 
@@ -159,12 +283,14 @@ var CashError = class extends Error {
   code;
   retryable;
   remediation;
+  recovery;
   constructor(shape, options) {
     super(shape.message, options);
     this.name = "CashError";
     this.code = shape.code;
     this.retryable = shape.retryable;
     this.remediation = shape.remediation;
+    if (shape.recovery) this.recovery = shape.recovery;
   }
   /** Serializable view (for tool results and logs). */
   toJSON() {
@@ -172,7 +298,8 @@ var CashError = class extends Error {
       code: this.code,
       message: this.message,
       retryable: this.retryable,
-      remediation: this.remediation
+      remediation: this.remediation,
+      ...this.recovery ? { recovery: this.recovery } : {}
     };
   }
 };
@@ -197,16 +324,6 @@ function usePoll(enabled, intervalMs, tick) {
     };
   }, [enabled, intervalMs, tick]);
 }
-function useMountedRef() {
-  const mounted = react.useRef(true);
-  react.useEffect(() => {
-    mounted.current = true;
-    return () => {
-      mounted.current = false;
-    };
-  }, []);
-  return mounted;
-}
 
 // src/react/useOrder.ts
 function useOrder({
@@ -219,27 +336,52 @@ function useOrder({
   const [isLoading, setIsLoading] = react.useState(false);
   const [error, setError] = react.useState(null);
   const mounted = useMountedRef();
+  const latestRequest = react.useRef(0);
+  const orderIdentity = react.useRef(null);
+  const loadingIdentity = react.useRef(null);
+  const errorIdentity = react.useRef(null);
+  react.useEffect(() => {
+    latestRequest.current += 1;
+    orderIdentity.current = null;
+    loadingIdentity.current = null;
+    errorIdentity.current = null;
+    setOrder(null);
+    setIsLoading(false);
+    setError(null);
+  }, [client, depositId]);
   const fetchOrder = react.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),
@@ -253,7 +395,13 @@ function useOrder({
     )
   );
   const refresh = react.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,
@@ -266,45 +414,77 @@ function useOrders({
   const [isLoading, setIsLoading] = react.useState(false);
   const [error, setError] = react.useState(null);
   const mounted = useMountedRef();
+  const latestRequest = react.useRef(0);
+  const ordersIdentity = react.useRef(null);
+  const loadingIdentity = react.useRef(null);
+  const errorIdentity = react.useRef(null);
+  react.useEffect(() => {
+    latestRequest.current += 1;
+    ordersIdentity.current = null;
+    loadingIdentity.current = null;
+    errorIdentity.current = null;
+    setOrders([]);
+    setIsLoading(false);
+    setError(null);
+  }, [client, owner, limit]);
   const fetchOrders = react.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,
     react.useCallback(
       async (isActive) => {
-        const result = await fetchOrders(isActive);
-        return result.some((o) => o.isInFlight);
+        await fetchOrders(isActive);
+        return true;
       },
       [fetchOrders]
     )
   );
   const refresh = react.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
+  };
 }
 
 exports.useCashout = useCashout;
 exports.useEstimate = useEstimate;
 exports.useOrder = useOrder;
 exports.useOrders = useOrders;
-//# sourceMappingURL=react.cjs.map
-//# sourceMappingURL=react.cjs.map

package/dist/react.d.cts

@@ -1,5 +1,5 @@
 import { CurrencyType } from '@zkp2p/sdk';
-import { n as CashClient, E as EstimateInput, i as CashEstimate, z as CashoutOptions, h as CashoutResult, y as CashoutInput, T as TopUpResult, W as WithdrawResult, e as CashOrder } from './createCashClient-iHuGgjH_.cjs';
+import { q as CashClient, E as EstimateInput, i as CashEstimate, B as CashoutOptions, h as CashoutResult, A as CashoutInput, T as TopUpResult, W as WithdrawResult, e as CashOrder } from './createCashClient-BbkfxILl.cjs';
 import { WalletClient } from 'viem';
 import '@relayprotocol/relay-sdk';
 
@@ -27,6 +27,7 @@ declare function useEstimate({ client, amount, currency, platform, source, refre
     refresh: () => Promise<void>;
 };
 
+type PendingMutation = 'cashout' | 'withdraw' | 'topUp';
 interface UseCashoutOptions {
     client: CashClient | null;
     /** A viem WalletClient with an account, on Base. */
@@ -49,7 +50,7 @@ declare function useCashout({ client, signer, sourceSigner, onSourceProgress, on
     cashout: (input: CashoutInput) => Promise<CashoutResult | null>;
     topUp: (depositId: string, amount: bigint) => Promise<TopUpResult | null>;
     withdraw: (depositId: string, amount?: bigint) => Promise<WithdrawResult | null>;
-    pending: "withdraw" | "cashout" | "topUp" | null;
+    pending: PendingMutation | null;
     result: CashoutResult | null;
     error: Error | null;
 };
@@ -84,14 +85,15 @@ interface UseOrdersOptions {
     owner: string | null | undefined;
     /** Max deposits to scan. */
     limit?: number;
-    /** Poll cadence (ms) while any order is in flight. */
+    /** Poll cadence (ms) while the feed is enabled. */
     pollIntervalMs?: number;
     paused?: boolean;
 }
 /**
  * List the user's cash-out orders (the Transactions-feed pattern). Reads
  * deposits by depositor and derives real amounts + states from the indexer
- * aggregates. Polls while any order is in flight.
+ * aggregates. Polls while enabled so an empty or terminal feed can still
+ * discover a newly indexed cash-out without a remount.
  */
 declare function useOrders({ client, owner, limit, pollIntervalMs, paused, }: UseOrdersOptions): {
     orders: CashOrder[];

package/dist/react.d.ts

@@ -1,5 +1,5 @@
 import { CurrencyType } from '@zkp2p/sdk';
-import { n as CashClient, E as EstimateInput, i as CashEstimate, z as CashoutOptions, h as CashoutResult, y as CashoutInput, T as TopUpResult, W as WithdrawResult, e as CashOrder } from './createCashClient-iHuGgjH_.js';
+import { q as CashClient, E as EstimateInput, i as CashEstimate, B as CashoutOptions, h as CashoutResult, A as CashoutInput, T as TopUpResult, W as WithdrawResult, e as CashOrder } from './createCashClient-BbkfxILl.js';
 import { WalletClient } from 'viem';
 import '@relayprotocol/relay-sdk';
 
@@ -27,6 +27,7 @@ declare function useEstimate({ client, amount, currency, platform, source, refre
     refresh: () => Promise<void>;
 };
 
+type PendingMutation = 'cashout' | 'withdraw' | 'topUp';
 interface UseCashoutOptions {
     client: CashClient | null;
     /** A viem WalletClient with an account, on Base. */
@@ -49,7 +50,7 @@ declare function useCashout({ client, signer, sourceSigner, onSourceProgress, on
     cashout: (input: CashoutInput) => Promise<CashoutResult | null>;
     topUp: (depositId: string, amount: bigint) => Promise<TopUpResult | null>;
     withdraw: (depositId: string, amount?: bigint) => Promise<WithdrawResult | null>;
-    pending: "withdraw" | "cashout" | "topUp" | null;
+    pending: PendingMutation | null;
     result: CashoutResult | null;
     error: Error | null;
 };
@@ -84,14 +85,15 @@ interface UseOrdersOptions {
     owner: string | null | undefined;
     /** Max deposits to scan. */
     limit?: number;
-    /** Poll cadence (ms) while any order is in flight. */
+    /** Poll cadence (ms) while the feed is enabled. */
     pollIntervalMs?: number;
     paused?: boolean;
 }
 /**
  * List the user's cash-out orders (the Transactions-feed pattern). Reads
  * deposits by depositor and derives real amounts + states from the indexer
- * aggregates. Polls while any order is in flight.
+ * aggregates. Polls while enabled so an empty or terminal feed can still
+ * discover a newly indexed cash-out without a remount.
  */
 declare function useOrders({ client, owner, limit, pollIntervalMs, paused, }: UseOrdersOptions): {
     orders: CashOrder[];