@zkp2p/sdk 0.0.13 → 0.0.14-rc.2

package/dist/{paymentResolution-F4I7TTEW.mjs → paymentResolution-HBYLUETP.mjs}

@@ -1,4 +1,4 @@
-export { resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-2CLQDBR3.mjs';
+export { resolveFiatCurrencyBytes32, resolvePaymentMethodHash, resolvePaymentMethodHashFromCatalog, resolvePaymentMethodNameFromHash } from './chunk-RLCHSX5F.mjs';
 import './chunk-37HJPVJE.mjs';
-//# sourceMappingURL=paymentResolution-F4I7TTEW.mjs.map
-//# sourceMappingURL=paymentResolution-F4I7TTEW.mjs.map
+//# sourceMappingURL=paymentResolution-HBYLUETP.mjs.map
+//# sourceMappingURL=paymentResolution-HBYLUETP.mjs.map

package/dist/{paymentResolution-F4I7TTEW.mjs.map → paymentResolution-HBYLUETP.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"paymentResolution-F4I7TTEW.mjs"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"paymentResolution-HBYLUETP.mjs"}

package/dist/protocolViewerParsers-DDQ4TKNB.mjs

@@ -0,0 +1,6 @@
+export { enrichPvDepositView, enrichPvIntentView, parseDepositView, parseIntentView } from './chunk-DJ7FJLYA.mjs';
+import './chunk-RLCHSX5F.mjs';
+import './chunk-PQQWQF3C.mjs';
+import './chunk-37HJPVJE.mjs';
+//# sourceMappingURL=protocolViewerParsers-DDQ4TKNB.mjs.map
+//# sourceMappingURL=protocolViewerParsers-DDQ4TKNB.mjs.map

package/dist/{protocolViewerParsers-5WBXCEHR.mjs.map → protocolViewerParsers-DDQ4TKNB.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"protocolViewerParsers-5WBXCEHR.mjs"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"protocolViewerParsers-DDQ4TKNB.mjs"}

package/dist/react.cjs

@@ -599,6 +599,434 @@ function useRemoveDelegate({ client, onSuccess, onError }) {
   );
   return react.useMemo(() => ({ removeDelegate, isLoading, error, txHash }), [removeDelegate, isLoading, error, txHash]);
 }
+function useSetDepositRateManager({
+  client,
+  onSuccess,
+  onError
+}) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const [prepared, setPrepared] = react.useState(null);
+  const setDepositRateManager = 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.setDepositRateManager(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, onError, onSuccess]
+  );
+  const prepareSetDepositRateManager = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setPrepared(null);
+      try {
+        const tx = await client.setDepositRateManager.prepare(params);
+        setPrepared(tx);
+        return tx;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
+  return react.useMemo(
+    () => ({
+      setDepositRateManager,
+      prepareSetDepositRateManager,
+      isLoading,
+      error,
+      txHash,
+      prepared
+    }),
+    [setDepositRateManager, prepareSetDepositRateManager, isLoading, error, txHash, prepared]
+  );
+}
+function useClearDepositRateManager({
+  client,
+  onSuccess,
+  onError
+}) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const [prepared, setPrepared] = react.useState(null);
+  const clearDepositRateManager = 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.clearDepositRateManager(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, onError, onSuccess]
+  );
+  const prepareClearDepositRateManager = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setPrepared(null);
+      try {
+        const tx = await client.clearDepositRateManager.prepare(params);
+        setPrepared(tx);
+        return tx;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
+  return react.useMemo(
+    () => ({
+      clearDepositRateManager,
+      prepareClearDepositRateManager,
+      isLoading,
+      error,
+      txHash,
+      prepared
+    }),
+    [clearDepositRateManager, prepareClearDepositRateManager, isLoading, error, txHash, prepared]
+  );
+}
+function useCreateRateManager({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const [prepared, setPrepared] = react.useState(null);
+  const createRateManager = 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.createRateManager(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, onError, onSuccess]
+  );
+  const prepareCreateRateManager = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setPrepared(null);
+      try {
+        const tx = await client.createRateManager.prepare(params);
+        setPrepared(tx);
+        return tx;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
+  return react.useMemo(
+    () => ({
+      createRateManager,
+      prepareCreateRateManager,
+      isLoading,
+      error,
+      txHash,
+      prepared
+    }),
+    [createRateManager, prepareCreateRateManager, isLoading, error, txHash, prepared]
+  );
+}
+function useSetVaultFee({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const [prepared, setPrepared] = react.useState(null);
+  const setVaultFee = 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.setVaultFee(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, onError, onSuccess]
+  );
+  const prepareSetVaultFee = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setPrepared(null);
+      try {
+        const tx = await client.setVaultFee.prepare(params);
+        setPrepared(tx);
+        return tx;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
+  return react.useMemo(
+    () => ({
+      setVaultFee,
+      prepareSetVaultFee,
+      isLoading,
+      error,
+      txHash,
+      prepared
+    }),
+    [setVaultFee, prepareSetVaultFee, isLoading, error, txHash, prepared]
+  );
+}
+function useSetVaultMinRate({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const [prepared, setPrepared] = react.useState(null);
+  const setVaultMinRate = 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.setVaultMinRate(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, onError, onSuccess]
+  );
+  const prepareSetVaultMinRate = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setPrepared(null);
+      try {
+        const tx = await client.setVaultMinRate.prepare(params);
+        setPrepared(tx);
+        return tx;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
+  return react.useMemo(
+    () => ({
+      setVaultMinRate,
+      prepareSetVaultMinRate,
+      isLoading,
+      error,
+      txHash,
+      prepared
+    }),
+    [setVaultMinRate, prepareSetVaultMinRate, isLoading, error, txHash, prepared]
+  );
+}
+function useSetVaultConfig({ client, onSuccess, onError }) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const [prepared, setPrepared] = react.useState(null);
+  const setVaultConfig = 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.setVaultConfig(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, onError, onSuccess]
+  );
+  const prepareSetVaultConfig = react.useCallback(
+    async (params) => {
+      if (!client) {
+        const err = new Error("Zkp2pClient is not initialized");
+        setError(err);
+        onError?.(err);
+        return null;
+      }
+      setIsLoading(true);
+      setError(null);
+      setPrepared(null);
+      try {
+        const tx = await client.setVaultConfig.prepare(params);
+        setPrepared(tx);
+        return tx;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        onError?.(e);
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, onError]
+  );
+  return react.useMemo(
+    () => ({
+      setVaultConfig,
+      prepareSetVaultConfig,
+      isLoading,
+      error,
+      txHash,
+      prepared
+    }),
+    [setVaultConfig, prepareSetVaultConfig, isLoading, error, txHash, prepared]
+  );
+}
 function useAddPaymentMethods({ client, onSuccess, onError }) {
   const [isLoading, setIsLoading] = react.useState(false);
   const [error, setError] = react.useState(null);
@@ -836,7 +1264,9 @@ exports.getTierDisplayInfo = getTierDisplayInfo;
 exports.useAddCurrencies = useAddCurrencies;
 exports.useAddFunds = useAddFunds;
 exports.useAddPaymentMethods = useAddPaymentMethods;
+exports.useClearDepositRateManager = useClearDepositRateManager;
 exports.useCreateDeposit = useCreateDeposit;
+exports.useCreateRateManager = useCreateRateManager;
 exports.useDeactivateCurrency = useDeactivateCurrency;
 exports.useFulfillIntent = useFulfillIntent;
 exports.useGetTakerTier = useGetTakerTier;
@@ -849,9 +1279,13 @@ exports.useRemovePaymentMethod = useRemovePaymentMethod;
 exports.useSetAcceptingIntents = useSetAcceptingIntents;
 exports.useSetCurrencyMinRate = useSetCurrencyMinRate;
 exports.useSetDelegate = useSetDelegate;
+exports.useSetDepositRateManager = useSetDepositRateManager;
 exports.useSetIntentRange = useSetIntentRange;
 exports.useSetPaymentMethodActive = useSetPaymentMethodActive;
 exports.useSetRetainOnEmpty = useSetRetainOnEmpty;
+exports.useSetVaultConfig = useSetVaultConfig;
+exports.useSetVaultFee = useSetVaultFee;
+exports.useSetVaultMinRate = useSetVaultMinRate;
 exports.useSignalIntent = useSignalIntent;
 exports.useWithdrawDeposit = useWithdrawDeposit;
 //# sourceMappingURL=react.cjs.map