@zkp2p/sdk 0.10.0-rc.6 → 0.10.0

package/dist/protocolViewerParsers-QMHI74AA.mjs

@@ -0,0 +1,5 @@
+export { enrichPvDepositView, enrichPvIntentView, parseDepositView, parseIntentView } from './chunk-JRLUSPR3.mjs';
+import './chunk-ZFBH4HD7.mjs';
+import './chunk-J5LGTIGS.mjs';
+//# sourceMappingURL=protocolViewerParsers-QMHI74AA.mjs.map
+//# sourceMappingURL=protocolViewerParsers-QMHI74AA.mjs.map

package/dist/{protocolViewerParsers-HMOHJWSP.mjs.map → protocolViewerParsers-QMHI74AA.mjs.map}

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

package/dist/react.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var react = require('react');
+var viem = require('viem');
 
 // src/react/hooks/useCreateDeposit.ts
 function useCreateDeposit({ client, onSuccess, onError }) {
@@ -105,74 +106,34 @@ function useSignalIntent({ client, onSuccess, onError }) {
     [signalIntent, prepareSignalIntent, isLoading, error, txHash, prepared]
   );
 }
-function useGetTakerStake({
-  client,
-  owner,
-  chainId,
-  autoFetch = true,
-  onSuccess,
-  onError
-}) {
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const [takerStake, setTakerStake] = react.useState(null);
-  const onSuccessRef = react.useRef(onSuccess);
-  const onErrorRef = react.useRef(onError);
-  react.useEffect(() => {
-    onSuccessRef.current = onSuccess;
-    onErrorRef.current = onError;
-  });
-  const requestSeqRef = react.useRef(0);
-  const getTakerStake = react.useCallback(
-    async (params) => {
-      if (!client) {
-        const err = new Error("Zkp2pClient is not initialized");
-        setError(err);
-        onErrorRef.current?.(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);
-        onErrorRef.current?.(err);
-        return null;
-      }
-      const requestId = ++requestSeqRef.current;
-      setIsLoading(true);
-      setError(null);
-      setTakerStake(null);
-      try {
-        const response = await client.getTakerStake(request);
-        if (requestId !== requestSeqRef.current) return null;
-        if (!response.success || !response.responseObject) {
-          throw new Error(response.message || "Taker stake request failed");
-        }
-        setTakerStake(response.responseObject);
-        onSuccessRef.current?.(response.responseObject);
-        return response;
-      } catch (err) {
-        if (requestId !== requestSeqRef.current) return null;
-        const e = err instanceof Error ? err : new Error(String(err));
-        setError(e);
-        onErrorRef.current?.(e);
-        return null;
-      } finally {
-        if (requestId === requestSeqRef.current) setIsLoading(false);
-      }
-    },
-    [client, owner, chainId]
-  );
-  react.useEffect(() => {
-    if (!autoFetch || !owner || !chainId) return;
-    void getTakerStake({ owner, chainId });
-  }, [autoFetch, owner, chainId, getTakerStake]);
-  return react.useMemo(
-    () => ({ getTakerStake, takerStake, isLoading, error }),
-    [getTakerStake, takerStake, isLoading, error]
-  );
+
+// src/takerTiers.ts
+var TAKER_TIER_SCHEDULE = [
+  { tier: "PLATINUM", perIntentCapUsd: 5e3, minVolumeUsd: 1e5, maxVolumeUsd: Infinity },
+  { tier: "PRO", perIntentCapUsd: 2500, minVolumeUsd: 5e4, maxVolumeUsd: 99999 },
+  { tier: "PLUS", perIntentCapUsd: 1e3, minVolumeUsd: 1e4, maxVolumeUsd: 49999 },
+  { tier: "PEER", perIntentCapUsd: 250, minVolumeUsd: 1e3, maxVolumeUsd: 9999 },
+  { tier: "PEASANT", perIntentCapUsd: 100, minVolumeUsd: 0, maxVolumeUsd: 999 }
+];
+var TAKER_TIER_ORDER = [
+  "PEASANT",
+  "PEER",
+  "PLUS",
+  "PRO",
+  "PLATINUM"
+];
+var TAKER_TIER_CAPS = Object.fromEntries(
+  TAKER_TIER_SCHEDULE.map((entry) => [entry.tier, entry.perIntentCapUsd])
+);
+function getNextTakerTier(currentTier) {
+  if (!currentTier) return null;
+  const index = TAKER_TIER_ORDER.indexOf(currentTier);
+  if (index === -1 || index >= TAKER_TIER_ORDER.length - 1) return null;
+  return TAKER_TIER_ORDER[index + 1];
 }
-function useGetTakerCapacity({
+
+// src/react/hooks/useGetTakerTier.ts
+function useGetTakerTier({
   client,
   owner,
   chainId,
@@ -182,63 +143,98 @@ function useGetTakerCapacity({
 }) {
   const [isLoading, setIsLoading] = react.useState(false);
   const [error, setError] = react.useState(null);
-  const [takerCapacity, setTakerCapacity] = react.useState(null);
-  const onSuccessRef = react.useRef(onSuccess);
-  const onErrorRef = react.useRef(onError);
-  react.useEffect(() => {
-    onSuccessRef.current = onSuccess;
-    onErrorRef.current = onError;
-  });
-  const requestSeqRef = react.useRef(0);
-  const getTakerCapacity = react.useCallback(
+  const [takerTier, setTakerTier] = react.useState(null);
+  const getTakerTier = react.useCallback(
     async (params) => {
       if (!client) {
         const err = new Error("Zkp2pClient is not initialized");
         setError(err);
-        onErrorRef.current?.(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);
-        onErrorRef.current?.(err);
+        onError?.(err);
         return null;
       }
-      const requestId = ++requestSeqRef.current;
       setIsLoading(true);
       setError(null);
-      setTakerCapacity(null);
+      setTakerTier(null);
       try {
-        const response = await client.getTakerCapacity(request);
-        if (requestId !== requestSeqRef.current) return null;
-        if (!response.success || !response.responseObject) {
-          throw new Error(response.message || "Taker capacity request failed");
-        }
-        setTakerCapacity(response.responseObject);
-        onSuccessRef.current?.(response.responseObject);
+        const response = await client.getTakerTier(request);
+        setTakerTier(response.responseObject);
+        onSuccess?.(response.responseObject);
         return response;
       } catch (err) {
-        if (requestId !== requestSeqRef.current) return null;
         const e = err instanceof Error ? err : new Error(String(err));
         setError(e);
-        onErrorRef.current?.(e);
+        onError?.(e);
         return null;
       } finally {
-        if (requestId === requestSeqRef.current) setIsLoading(false);
+        setIsLoading(false);
       }
     },
-    [client, owner, chainId]
+    [client, owner, chainId, onSuccess, onError]
   );
   react.useEffect(() => {
     if (!autoFetch || !owner || !chainId) return;
-    void getTakerCapacity({ owner, chainId });
-  }, [autoFetch, owner, chainId, getTakerCapacity]);
+    void getTakerTier({ owner, chainId });
+  }, [autoFetch, owner, chainId, getTakerTier]);
   return react.useMemo(
-    () => ({ getTakerCapacity, takerCapacity, isLoading, error }),
-    [getTakerCapacity, takerCapacity, isLoading, error]
+    () => ({ getTakerTier, takerTier, isLoading, error }),
+    [getTakerTier, takerTier, isLoading, error]
   );
 }
+function getNextTierCap(currentTier) {
+  const nextTier = getNextTakerTier(currentTier);
+  if (!nextTier) return null;
+  const nextCap = TAKER_TIER_CAPS[nextTier];
+  return nextCap != null ? `$${nextCap.toLocaleString()}` : null;
+}
+function formatCapFromBaseUnits(baseUnits) {
+  if (!baseUnits || baseUnits === "") return "$0";
+  const value = Number(viem.formatUnits(BigInt(baseUnits), 6));
+  return `$${value.toLocaleString()}`;
+}
+function getCapForDisplay(tier) {
+  const platformLimits = tier.platformLimits ?? [];
+  if (platformLimits.length === 0) {
+    return tier.perIntentCapBaseUnits ?? tier.maxOrderSize;
+  }
+  const bestCap = platformLimits.filter((limit) => !limit.isLocked && limit.effectiveCap && limit.effectiveCap !== "0").reduce((current, limit) => {
+    if (!current) return limit.effectiveCap;
+    return BigInt(limit.effectiveCap) > BigInt(current) ? limit.effectiveCap : current;
+  }, void 0);
+  return bestCap ?? "0";
+}
+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(getCapForDisplay(tier));
+  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);
@@ -1206,6 +1202,148 @@ function useSetVaultFee({ client, onSuccess, onError }) {
     [setVaultFee, prepareSetVaultFee, isLoading, error, txHash, prepared]
   );
 }
+
+// src/client/IntentGuardianOperations.ts
+var GUARDIAN_ERROR_CODES = {
+  ExtensionsDisabled: "EXTENSIONS_DISABLED",
+  ExtensionCostExceedsMax: "COST_EXCEEDS_MAX",
+  ExtensionFeeExceedsIntentAmount: "FEE_EXCEEDS_INTENT_AMOUNT",
+  IntentAlreadyExpired: "INTENT_ALREADY_EXPIRED",
+  EscrowNotWhitelisted: "ESCROW_NOT_WHITELISTED",
+  ZeroAddress: "ZERO_ADDRESS"
+};
+function classifyIntentGuardianError(error) {
+  const haystack = error instanceof Error ? `${error.name} ${error.message}` : typeof error === "string" ? error : "";
+  for (const [name, code] of Object.entries(GUARDIAN_ERROR_CODES)) {
+    if (haystack.includes(name)) return code;
+  }
+  return "UNKNOWN";
+}
+
+// src/react/hooks/useExtendIntentLifetime.ts
+function useExtendIntentLifetime({
+  client,
+  onSuccess,
+  onError
+}) {
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [errorCode, setErrorCode] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const [prepared, setPrepared] = react.useState(null);
+  const [policy, setPolicy] = react.useState(null);
+  const [quote, setQuote] = react.useState(null);
+  const fail = react.useCallback(
+    (err) => {
+      const e = err instanceof Error ? err : new Error(String(err));
+      const code = classifyIntentGuardianError(e);
+      setError(e);
+      setErrorCode(code);
+      onError?.(e, code);
+      return null;
+    },
+    [onError]
+  );
+  const requireClient = react.useCallback(() => {
+    if (!client) {
+      fail(new Error("Zkp2pClient is not initialized"));
+      return null;
+    }
+    return client;
+  }, [client, fail]);
+  const refreshPolicy = react.useCallback(async () => {
+    const c = requireClient();
+    if (!c) return null;
+    setIsLoading(true);
+    setError(null);
+    setErrorCode(null);
+    try {
+      const next = await c.getIntentGuardianPolicy();
+      setPolicy(next);
+      return next;
+    } catch (err) {
+      return fail(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [requireClient, fail]);
+  const refreshQuote = react.useCallback(
+    async (params) => {
+      setQuote(null);
+      const c = requireClient();
+      if (!c) return null;
+      setIsLoading(true);
+      setError(null);
+      setErrorCode(null);
+      try {
+        const next = await c.quoteIntentExtension(params);
+        setQuote(next);
+        return next;
+      } catch (err) {
+        return fail(err);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [requireClient, fail]
+  );
+  const extendIntentLifetime = react.useCallback(
+    async (params) => {
+      const c = requireClient();
+      if (!c) return null;
+      setIsLoading(true);
+      setError(null);
+      setErrorCode(null);
+      setTxHash(null);
+      try {
+        const hash = await c.extendIntentLifetime(params);
+        setTxHash(hash);
+        onSuccess?.(hash);
+        return hash;
+      } catch (err) {
+        return fail(err);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [requireClient, fail, onSuccess]
+  );
+  const prepareExtendIntentLifetime = react.useCallback(
+    async (params) => {
+      const c = requireClient();
+      if (!c) return null;
+      setIsLoading(true);
+      setError(null);
+      setErrorCode(null);
+      setPrepared(null);
+      try {
+        const tx = await c.extendIntentLifetime.prepare(params);
+        setPrepared(tx);
+        return tx;
+      } catch (err) {
+        return fail(err);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [requireClient, fail]
+  );
+  return {
+    extendIntentLifetime,
+    prepareExtendIntentLifetime,
+    refreshPolicy,
+    refreshQuote,
+    policy,
+    quote,
+    isLoading,
+    error,
+    errorCode,
+    txHash,
+    prepared,
+    /** False where no guardian is deployed; hide the extension action entirely. */
+    isAvailable: client?.hasIntentGuardian() ?? false
+  };
+}
 function useSetVaultMinRate({ client, onSuccess, onError }) {
   const [isLoading, setIsLoading] = react.useState(false);
   const [error, setError] = react.useState(null);
@@ -1584,6 +1722,8 @@ exports.asErrorMessage = asErrorMessage;
 exports.assertDelegationMethodSupport = assertDelegationMethodSupport;
 exports.classifyDelegationState = classifyDelegationState;
 exports.getDelegationRoute = getDelegationRoute;
+exports.getNextTierCap = getNextTierCap;
+exports.getTierDisplayInfo = getTierDisplayInfo;
 exports.isZeroRateManagerId = isZeroRateManagerId;
 exports.normalizeRateManagerId = normalizeRateManagerId;
 exports.normalizeRegistry = normalizeRegistry;
@@ -1593,9 +1733,9 @@ exports.useAddPaymentMethods = useAddPaymentMethods;
 exports.useCreateDeposit = useCreateDeposit;
 exports.useCreateVault = useCreateVault;
 exports.useDeactivateCurrency = useDeactivateCurrency;
+exports.useExtendIntentLifetime = useExtendIntentLifetime;
 exports.useFulfillIntent = useFulfillIntent;
-exports.useGetTakerCapacity = useGetTakerCapacity;
-exports.useGetTakerStake = useGetTakerStake;
+exports.useGetTakerTier = useGetTakerTier;
 exports.usePruneExpiredIntents = usePruneExpiredIntents;
 exports.useReleaseFundsToPayer = useReleaseFundsToPayer;
 exports.useRemoveCurrency = useRemoveCurrency;