@zkp2p/sdk 0.0.1

package/dist/react.mjs

@@ -0,0 +1,774 @@
+import { useState, useCallback, useMemo, useEffect } from 'react';
+import { formatUnits } from 'viem';
+
+// src/react/hooks/useCreateDeposit.ts
+function useCreateDeposit({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const [depositDetails, setDepositDetails] = useState(null);
+  const createDeposit = 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 useMemo(() => ({ createDeposit, isLoading, error, txHash, depositDetails }), [createDeposit, isLoading, error, txHash, depositDetails]);
+}
+function useSignalIntent({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const signalIntent = 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 useMemo(() => ({ signalIntent, isLoading, error, txHash }), [signalIntent, isLoading, error, txHash]);
+}
+function useGetTakerTier({
+  client,
+  owner,
+  chainId,
+  autoFetch = true,
+  onSuccess,
+  onError
+}) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [takerTier, setTakerTier] = useState(null);
+  const getTakerTier = 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]
+  );
+  useEffect(() => {
+    if (!autoFetch || !owner || !chainId) return;
+    void getTakerTier({ owner, chainId });
+  }, [autoFetch, owner, chainId, getTakerTier]);
+  return 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(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] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const fulfillIntent = 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 useMemo(() => ({ fulfillIntent, isLoading, error, txHash }), [fulfillIntent, isLoading, error, txHash]);
+}
+function useReleaseFundsToPayer({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const releaseFundsToPayer = 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 useMemo(() => ({ releaseFundsToPayer, isLoading, error, txHash }), [releaseFundsToPayer, isLoading, error, txHash]);
+}
+function useSetAcceptingIntents({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const setAcceptingIntents = 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 useMemo(() => ({ setAcceptingIntents, isLoading, error, txHash }), [setAcceptingIntents, isLoading, error, txHash]);
+}
+function useSetIntentRange({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const setIntentRange = 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 useMemo(() => ({ setIntentRange, isLoading, error, txHash }), [setIntentRange, isLoading, error, txHash]);
+}
+function useSetCurrencyMinRate({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const setCurrencyMinRate = 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 useMemo(() => ({ setCurrencyMinRate, isLoading, error, txHash }), [setCurrencyMinRate, isLoading, error, txHash]);
+}
+function useAddFunds({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const addFunds = 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 useMemo(() => ({ addFunds, isLoading, error, txHash }), [addFunds, isLoading, error, txHash]);
+}
+function useRemoveFunds({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const removeFunds = 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 useMemo(() => ({ removeFunds, isLoading, error, txHash }), [removeFunds, isLoading, error, txHash]);
+}
+function useWithdrawDeposit({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const withdrawDeposit = 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 useMemo(() => ({ withdrawDeposit, isLoading, error, txHash }), [withdrawDeposit, isLoading, error, txHash]);
+}
+function useSetRetainOnEmpty({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const setRetainOnEmpty = 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 useMemo(() => ({ setRetainOnEmpty, isLoading, error, txHash }), [setRetainOnEmpty, isLoading, error, txHash]);
+}
+function useSetDelegate({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const setDelegate = 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 useMemo(() => ({ setDelegate, isLoading, error, txHash }), [setDelegate, isLoading, error, txHash]);
+}
+function useRemoveDelegate({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const removeDelegate = 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 useMemo(() => ({ removeDelegate, isLoading, error, txHash }), [removeDelegate, isLoading, error, txHash]);
+}
+function useAddPaymentMethods({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const addPaymentMethods = 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 useMemo(() => ({ addPaymentMethods, isLoading, error, txHash }), [addPaymentMethods, isLoading, error, txHash]);
+}
+function useSetPaymentMethodActive({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const setPaymentMethodActive = 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 useMemo(() => ({ setPaymentMethodActive, isLoading, error, txHash }), [setPaymentMethodActive, isLoading, error, txHash]);
+}
+function useRemovePaymentMethod({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const removePaymentMethod = 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 useMemo(() => ({ removePaymentMethod, isLoading, error, txHash }), [removePaymentMethod, isLoading, error, txHash]);
+}
+function useAddCurrencies({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const addCurrencies = 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 useMemo(() => ({ addCurrencies, isLoading, error, txHash }), [addCurrencies, isLoading, error, txHash]);
+}
+function useDeactivateCurrency({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const deactivateCurrency = 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 useMemo(() => ({ deactivateCurrency, isLoading, error, txHash }), [deactivateCurrency, isLoading, error, txHash]);
+}
+function useRemoveCurrency({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const removeCurrency = 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 useMemo(() => ({ removeCurrency, isLoading, error, txHash }), [removeCurrency, isLoading, error, txHash]);
+}
+function usePruneExpiredIntents({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [txHash, setTxHash] = useState(null);
+  const pruneExpiredIntents = 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 useMemo(() => ({ pruneExpiredIntents, isLoading, error, txHash }), [pruneExpiredIntents, isLoading, error, txHash]);
+}
+
+export { getNextTierCap, getTierDisplayInfo, useAddCurrencies, useAddFunds, useAddPaymentMethods, useCreateDeposit, useDeactivateCurrency, useFulfillIntent, useGetTakerTier, usePruneExpiredIntents, useReleaseFundsToPayer, useRemoveCurrency, useRemoveDelegate, useRemoveFunds, useRemovePaymentMethod, useSetAcceptingIntents, useSetCurrencyMinRate, useSetDelegate, useSetIntentRange, useSetPaymentMethodActive, useSetRetainOnEmpty, useSignalIntent, useWithdrawDeposit };
+//# sourceMappingURL=react.mjs.map
+//# sourceMappingURL=react.mjs.map