@zkp2p/sdk 0.0.1

package/dist/react.cjs

@@ -0,0 +1,798 @@
+'use strict';
+
+var react = require('react');
+var viem = require('viem');
+
+// src/react/hooks/useCreateDeposit.ts
+function useCreateDeposit({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const [depositDetails, setDepositDetails] = react.useState(null);
+  const createDeposit = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      setDepositDetails(null);
+      try {
+        const result = await client.createDeposit(params);
+        setTxHash(result.hash);
+        setDepositDetails(result.depositDetails);
+        onSuccess?.(result);
+        return result;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ createDeposit, isLoading, error, txHash, depositDetails }), [createDeposit, isLoading, error, txHash, depositDetails]);
+}
+function useSignalIntent({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const signalIntent = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.signalIntent(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ signalIntent, isLoading, error, txHash }), [signalIntent, isLoading, error, txHash]);
+}
+function useGetTakerTier({
+  client,
+  owner,
+  chainId,
+  autoFetch = true,
+  onSuccess,
+  onError
+}) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [takerTier, setTakerTier] = react.useState(null);
+  const getTakerTier = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      const request = params ?? (owner && chainId ? { owner, chainId } : null);
+      if (!request) {
+        const err = new Error("Owner address and chainId are required");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTakerTier(null);
+      try {
+        const response = await client.getTakerTier(request);
+        setTakerTier(response.responseObject);
+        onSuccess?.(response.responseObject);
+        return response;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, owner, chainId, onSuccess, onError]
+  );
+  react.useEffect(() => {
+    if (!autoFetch || !owner || !chainId) return;
+    void getTakerTier({ owner, chainId });
+  }, [autoFetch, owner, chainId, getTakerTier]);
+  return react.useMemo(
+    () => ({ getTakerTier, takerTier, isLoading, error }),
+    [getTakerTier, takerTier, isLoading, error]
+  );
+}
+var TIER_CAPS = {
+  PEASANT: 100,
+  PEER: 500,
+  PLUS: 5e3,
+  PRO: 1e4,
+  PLATINUM: 25e3
+};
+function getNextTierCap(currentTier) {
+  if (!currentTier) return null;
+  const tierOrder = ["PEASANT", "PEER", "PLUS", "PRO", "PLATINUM"];
+  const currentIndex = tierOrder.indexOf(currentTier);
+  if (currentIndex === -1 || currentIndex >= tierOrder.length - 1) {
+    return null;
+  }
+  const nextTier = tierOrder[currentIndex + 1];
+  const nextCap = TIER_CAPS[nextTier];
+  return nextCap ? `$${nextCap.toLocaleString()}` : null;
+}
+function formatCapFromBaseUnits(baseUnits) {
+  if (!baseUnits || baseUnits === "") return "$0";
+  const value = Number(viem.formatUnits(BigInt(baseUnits), 6));
+  return `$${value.toLocaleString()}`;
+}
+function getTierDisplayInfo(tier) {
+  if (!tier) {
+    return {
+      tierLabel: "Loading...",
+      capDisplay: "...",
+      isNewUser: false,
+      showScore: false
+    };
+  }
+  const isNewUser = tier.source === "fallback";
+  const isZeroFulfills = tier.stats?.lifetimeFulfilledCount === 0;
+  const tierLabels = {
+    PEASANT: "Peer Peasant",
+    PEER: "Peer",
+    PLUS: "Peer Plus",
+    PRO: "Peer Pro",
+    PLATINUM: "Peer Platinum"
+  };
+  const capDisplay = formatCapFromBaseUnits(tier.perIntentCapBaseUnits);
+  return {
+    tierLabel: tierLabels[tier.tier] || tier.tier,
+    capDisplay,
+    isNewUser: isNewUser || isZeroFulfills,
+    showScore: !isNewUser && !!tier.stats && tier.stats.lockScoreDiluted !== "0"
+  };
+}
+function useFulfillIntent({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const fulfillIntent = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.fulfillIntent(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ fulfillIntent, isLoading, error, txHash }), [fulfillIntent, isLoading, error, txHash]);
+}
+function useReleaseFundsToPayer({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const releaseFundsToPayer = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.releaseFundsToPayer(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ releaseFundsToPayer, isLoading, error, txHash }), [releaseFundsToPayer, isLoading, error, txHash]);
+}
+function useSetAcceptingIntents({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const setAcceptingIntents = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.setAcceptingIntents(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ setAcceptingIntents, isLoading, error, txHash }), [setAcceptingIntents, isLoading, error, txHash]);
+}
+function useSetIntentRange({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const setIntentRange = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.setIntentRange(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ setIntentRange, isLoading, error, txHash }), [setIntentRange, isLoading, error, txHash]);
+}
+function useSetCurrencyMinRate({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const setCurrencyMinRate = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.setCurrencyMinRate(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ setCurrencyMinRate, isLoading, error, txHash }), [setCurrencyMinRate, isLoading, error, txHash]);
+}
+function useAddFunds({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const addFunds = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.addFunds(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ addFunds, isLoading, error, txHash }), [addFunds, isLoading, error, txHash]);
+}
+function useRemoveFunds({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const removeFunds = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.removeFunds(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ removeFunds, isLoading, error, txHash }), [removeFunds, isLoading, error, txHash]);
+}
+function useWithdrawDeposit({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const withdrawDeposit = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.withdrawDeposit(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ withdrawDeposit, isLoading, error, txHash }), [withdrawDeposit, isLoading, error, txHash]);
+}
+function useSetRetainOnEmpty({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const setRetainOnEmpty = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.setRetainOnEmpty(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ setRetainOnEmpty, isLoading, error, txHash }), [setRetainOnEmpty, isLoading, error, txHash]);
+}
+function useSetDelegate({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const setDelegate = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.setDelegate(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ setDelegate, isLoading, error, txHash }), [setDelegate, isLoading, error, txHash]);
+}
+function useRemoveDelegate({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const removeDelegate = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.removeDelegate(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ removeDelegate, isLoading, error, txHash }), [removeDelegate, isLoading, error, txHash]);
+}
+function useAddPaymentMethods({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const addPaymentMethods = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.addPaymentMethods(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ addPaymentMethods, isLoading, error, txHash }), [addPaymentMethods, isLoading, error, txHash]);
+}
+function useSetPaymentMethodActive({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const setPaymentMethodActive = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.setPaymentMethodActive(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ setPaymentMethodActive, isLoading, error, txHash }), [setPaymentMethodActive, isLoading, error, txHash]);
+}
+function useRemovePaymentMethod({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const removePaymentMethod = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.removePaymentMethod(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ removePaymentMethod, isLoading, error, txHash }), [removePaymentMethod, isLoading, error, txHash]);
+}
+function useAddCurrencies({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const addCurrencies = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.addCurrencies(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ addCurrencies, isLoading, error, txHash }), [addCurrencies, isLoading, error, txHash]);
+}
+function useDeactivateCurrency({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const deactivateCurrency = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.deactivateCurrency(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ deactivateCurrency, isLoading, error, txHash }), [deactivateCurrency, isLoading, error, txHash]);
+}
+function useRemoveCurrency({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const removeCurrency = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.removeCurrency(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ removeCurrency, isLoading, error, txHash }), [removeCurrency, isLoading, error, txHash]);
+}
+function usePruneExpiredIntents({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const pruneExpiredIntents = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setTxHash(null);
+      try {
+        const hash = await client.pruneExpiredIntents(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onSuccess, onError]
+  );
+  return react.useMemo(() => ({ pruneExpiredIntents, isLoading, error, txHash }), [pruneExpiredIntents, isLoading, error, txHash]);
+}
+
+exports.getNextTierCap = getNextTierCap;
+exports.getTierDisplayInfo = getTierDisplayInfo;
+exports.useAddCurrencies = useAddCurrencies;
+exports.useAddFunds = useAddFunds;
+exports.useAddPaymentMethods = useAddPaymentMethods;
+exports.useCreateDeposit = useCreateDeposit;
+exports.useDeactivateCurrency = useDeactivateCurrency;
+exports.useFulfillIntent = useFulfillIntent;
+exports.useGetTakerTier = useGetTakerTier;
+exports.usePruneExpiredIntents = usePruneExpiredIntents;
+exports.useReleaseFundsToPayer = useReleaseFundsToPayer;
+exports.useRemoveCurrency = useRemoveCurrency;
+exports.useRemoveDelegate = useRemoveDelegate;
+exports.useRemoveFunds = useRemoveFunds;
+exports.useRemovePaymentMethod = useRemovePaymentMethod;
+exports.useSetAcceptingIntents = useSetAcceptingIntents;
+exports.useSetCurrencyMinRate = useSetCurrencyMinRate;
+exports.useSetDelegate = useSetDelegate;
+exports.useSetIntentRange = useSetIntentRange;
+exports.useSetPaymentMethodActive = useSetPaymentMethodActive;
+exports.useSetRetainOnEmpty = useSetRetainOnEmpty;
+exports.useSignalIntent = useSignalIntent;
+exports.useWithdrawDeposit = useWithdrawDeposit;
+//# sourceMappingURL=react.cjs.map
+//# sourceMappingURL=react.cjs.map