@provex/react 1.11.0 → 2.0.0

package/dist/wagmi.cjs

@@ -11,15 +11,15 @@ var currencies = require('@provex/utils/currencies');
 var tokens = require('@provex/utils/tokens');
 var units = require('@provex/utils/units');
 var conversionRates = require('@provex/utils/conversionRates');
-var reputation = require('@provex/utils/reputation');
 var contracts = require('@provex/utils/contracts');
 var proving = require('@provex/proving');
+var chain = require('@provex/utils/chain');
 var utils = require('@provex/utils');
 var deposit = require('@provex/utils/deposit');
 var fees = require('@provex/utils/fees');
 var abis = require('@provex/abis');
-var chain = require('@provex/utils/chain');
 var chains = require('viem/chains');
+var reputation = require('@provex/utils/reputation');
 var extensionReact = require('@provex/extension-react');
 
 // src/wagmi/useWagmiWallet.ts
@@ -80,6 +80,15 @@ function createApiClient(apiUrl) {
     })
   };
 }
+
+// src/lib/clock.ts
+var systemClock = Object.freeze({
+  now: () => Date.now(),
+  setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
+  clearTimeout: (handle) => globalThis.clearTimeout(handle),
+  setInterval: (callback, intervalMs) => globalThis.setInterval(callback, intervalMs),
+  clearInterval: (handle) => globalThis.clearInterval(handle)
+});
 var ProvexContext = react.createContext(null);
 var defaultQueryClient = new reactQuery.QueryClient({
   defaultOptions: {
@@ -96,22 +105,23 @@ function ProvexProvider({
   publicClient: publicClient2,
   publicClients,
   wallet,
+  clock = systemClock,
   children
 }) {
   const resolvedQueryClient = queryClient ?? defaultQueryClient;
   const contextValue = react.useMemo(() => {
     const apiClient = createApiClient(config.apiUrl);
     const chainId = config.chain.id;
-    const base2 = publicClients ?? {};
-    const resolved = { ...base2 };
+    const base = publicClients ?? {};
+    const resolved = { ...base };
     if (publicClient2 && !resolved[chainId]) {
       resolved[chainId] = publicClient2;
     }
     if (!resolved[chainId]) {
       resolved[chainId] = viem.createPublicClient({ chain: config.chain, transport: viem.http() });
     }
-    return { config, indexer, apiClient, publicClients: resolved, wallet };
-  }, [config, indexer, publicClient2, publicClients, wallet]);
+    return { config, indexer, apiClient, publicClients: resolved, wallet, clock };
+  }, [config, indexer, publicClient2, publicClients, wallet, clock]);
   return /* @__PURE__ */ jsxRuntime.jsx(ProvexContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: resolvedQueryClient, children }) });
 }
 function useProvex() {
@@ -130,6 +140,9 @@ function useOptionalProvexPublicClient(chainId) {
   const target = chainId ?? ctx.config.chain.id;
   return ctx.publicClients[target];
 }
+function useClock() {
+  return useOptionalProvex()?.clock ?? systemClock;
+}
 function WagmiProvexProvider(props) {
   const publicClients = useWagmiPublicClients();
   const wallet = useWagmiWallet() ?? void 0;
@@ -267,25 +280,29 @@ var getTransactionGasInputs = async (chainId) => {
 // src/lib/updates.ts
 var POLL_INTERVAL_MS = 1e3;
 var SLOW_SYNC_THRESHOLD_MS = 15e3;
+var sleep = (clock, delayMs) => new Promise((resolve) => {
+  clock.setTimeout(resolve, delayMs);
+});
 var checkTransactionIndexed = async ({
   queryTransaction,
   hash,
   onSuccess,
   onSlowSync,
-  slowSyncThresholdMs = SLOW_SYNC_THRESHOLD_MS
+  slowSyncThresholdMs = SLOW_SYNC_THRESHOLD_MS,
+  clock = systemClock
 }) => {
-  const startTime = Date.now();
+  const startTime = clock.now();
   let slowSyncFired = false;
   while (true) {
     const result = await queryTransaction(hash);
     if (result) {
       break;
     }
-    if (!slowSyncFired && onSlowSync && Date.now() - startTime > slowSyncThresholdMs) {
+    if (!slowSyncFired && onSlowSync && clock.now() - startTime > slowSyncThresholdMs) {
       slowSyncFired = true;
       onSlowSync();
     }
-    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    await sleep(clock, POLL_INTERVAL_MS);
   }
   onSuccess?.();
 };
@@ -630,7 +647,7 @@ var ProveXClient = class {
    * Handles all encoding internally:
    * 1. Registers payee details with the API (so buyers can discover them)
    * 2. Hashes provider keys and currency codes to bytes32
-   * 3. Expands sub-providers (e.g., 'zelle' → zelle-chase, zelle-bofa, zelle-citi)
+   * 3. Collapses bank-level keys to their rail (e.g., 'zelle-chase' → 'zelle'); Zelle is one rail
    * 4. Encodes gating service witness signers
    * 5. Submits the on-chain transaction
    *
@@ -920,43 +937,6 @@ var ProveXClient = class {
     });
     return res.responseObject ?? null;
   }
-  /**
-   * Submit zkTLS proofs and get a signed attestation for fulfillIntent.
-   * This is the proof verification step — after the buyer makes payment and
-   * generates proofs via the browser extension.
-   */
-  async getAttestation(params) {
-    const endpoint = `/api/v0/attestation/verify/${params.platform}/${params.actionType}`;
-    const proof = params.proofs.length === 1 ? params.proofs[0] : params.proofs;
-    const res = await fetch(`${this.apiUrl}${endpoint}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        proofType: "reclaim",
-        proof: JSON.stringify(proof),
-        chainId: params.chainId,
-        verifyingContract: params.verifyingContract,
-        intent: params.intent
-      })
-    });
-    if (!res.ok) {
-      let errorMessage = `Attestation error: ${res.status}`;
-      try {
-        const errorJson = await res.json();
-        if (errorJson.details?.message) errorMessage = errorJson.details.message;
-        else if (errorJson.message) errorMessage = errorJson.message;
-        else if (errorJson.error) errorMessage = errorJson.error;
-      } catch {
-      }
-      return {
-        success: false,
-        message: errorMessage,
-        statusCode: res.status,
-        responseObject: {}
-      };
-    }
-    return await res.json();
-  }
   /** Make a POST request to the API. */
   async apiPost(path, body) {
     const res = await fetch(`${this.apiUrl}${path}`, {
@@ -1056,6 +1036,11 @@ function createProveXClient(config) {
 }
 
 // src/hooks/useSignalIntent.ts
+var DEFAULT_SIGNAL_INTENT_MESSAGES = {
+  clientOrDepositUnavailable: "Client or deposit not available",
+  noEscrowAddress: "No escrow address found",
+  success: "Intent signaled successfully"
+};
 var ERROR_PATTERNS = [
   { pattern: /user rejected|user denied|rejected the request|user cancelled|user canceled/i, message: "Transaction was cancelled." },
   { pattern: /InsufficientDepositLiquidity|0xc3df48f3/i, message: "This deposit no longer has enough available liquidity. Please try a smaller amount or a different deposit." },
@@ -1070,28 +1055,48 @@ function getUserFriendlyErrorMessage(error) {
   }
   return "Something went wrong. Please try again.";
 }
+function isClientRejection(error) {
+  return error instanceof ProveXError && error.isRejection;
+}
+var LOADING_STATUSES = /* @__PURE__ */ new Set([
+  "loading_payee",
+  "loading_intent",
+  "prompt_wallet_confirm",
+  "writing_intent"
+]);
 function useSignalIntent({
   wallet,
+  chainId,
+  indexer,
+  apiUrl,
   onSuccess,
   onFailure,
   deposit,
-  refetchDeposits
+  refetchDeposits,
+  beginTransaction,
+  isRejection = isClientRejection,
+  formatError = getUserFriendlyErrorMessage,
+  messages
 }) {
   const provex = useOptionalProvex();
   const [status, setStatus] = react.useState("input");
   const [message, setMessage] = react.useState(null);
+  const copy = { ...DEFAULT_SIGNAL_INTENT_MESSAGES, ...messages };
+  const chain$1 = (chainId === void 0 ? void 0 : chain.chainIdToChain.get(chainId)) ?? provex?.config.chain;
+  const resolvedIndexer = indexer ?? provex?.indexer;
+  const resolvedApiUrl = apiUrl ?? provex?.config.apiUrl;
+  const escrow = deposit?.escrow ?? void 0;
   const client = react.useMemo(() => {
-    if (!provex) return null;
+    if (!chain$1 || !wallet || !resolvedIndexer || resolvedApiUrl === void 0) return null;
     return createProveXClient({
-      chain: provex.config.chain,
-      apiUrl: provex.config.apiUrl,
+      chain: chain$1,
       wallet,
-      indexer: provex.indexer
+      indexer: resolvedIndexer,
+      apiUrl: resolvedApiUrl,
+      escrowAddress: escrow
     });
-  }, [provex, wallet]);
-  const isLoading = react.useMemo(() => {
-    return status === "loading_payee" || status === "loading_intent" || status === "prompt_wallet_confirm" || status === "writing_intent";
-  }, [status]);
+  }, [chain$1, wallet, resolvedIndexer, resolvedApiUrl, escrow]);
+  const isLoading = LOADING_STATUSES.has(status);
   const startOrder = react.useCallback(async ({
     paymentMethod,
     depositId,
@@ -1103,42 +1108,48 @@ function useSignalIntent({
   }) => {
     if (!client || !deposit) {
       setStatus("error");
-      setMessage("Client or deposit not available");
+      setMessage(copy.clientOrDepositUnavailable);
       return;
     }
-    const escrow = deposit.escrow;
-    if (!escrow) {
+    const depositEscrow = deposit.escrow;
+    if (!depositEscrow) {
       setStatus("error");
-      setMessage("No escrow address found");
+      setMessage(copy.noEscrowAddress);
       return;
     }
+    const transaction = beginTransaction ? await beginTransaction() : void 0;
+    if (transaction === null) return;
     setStatus("loading_intent");
     try {
       const result = await client.signalIntent({
-        deposit: { escrow, localId: deposit.localId ?? depositId },
+        deposit: { escrow: depositEscrow, localId: deposit.localId ?? depositId },
         paymentMethod,
         tokenAmount,
         toAddress,
         fiatCurrencyCode,
         conversionRate,
-        subProvider
+        subProvider,
+        onAwaitingSignature: () => transaction?.awaitingSignature(),
+        onTransactionHash: (hash) => transaction?.attach(hash)
       });
       setStatus("success");
-      setMessage("Intent signaled successfully");
+      setMessage(copy.success);
       onSuccess(result.intentHash);
     } catch (error) {
-      if (error instanceof ProveXError && error.isRejection) {
+      if (isRejection(error)) {
+        transaction?.failed(error);
         setStatus("input");
         setMessage(null);
         return;
       }
       console.error("Failed to signal intent", error);
+      transaction?.failed(error);
       setStatus("error");
-      setMessage(getUserFriendlyErrorMessage(error));
+      setMessage(formatError(error));
       refetchDeposits?.();
       onFailure?.();
     }
-  }, [client, deposit, onSuccess, onFailure, refetchDeposits]);
+  }, [client, deposit, beginTransaction, isRejection, formatError, onSuccess, onFailure, refetchDeposits, copy.clientOrDepositUnavailable, copy.noEscrowAddress, copy.success]);
   return {
     startOrder,
     status,
@@ -1146,93 +1157,167 @@ function useSignalIntent({
     isLoading
   };
 }
-function useReputation({
-  address,
-  chainId
+function filteringTierFor(options) {
+  if (options.vipStatus === "unknown") return null;
+  if (options.vipStatus === "vip") return payment.tiers.PRESIDENT;
+  return options.tier;
+}
+
+// src/hooks/useUserReputation.ts
+function computeUserReputation({
+  stats,
+  pulseTimestamp,
+  now = () => /* @__PURE__ */ new Date()
 }) {
-  const { indexer } = useProvex();
-  const queryClient = reactQuery.useQueryClient();
-  const isBase = chainId === chains.base.id;
-  const reputationQuery = reactQuery.useQuery({
-    queryKey: ["provex", "reputation", address, isBase ? chains.base.id : "all"],
+  if (!stats) return reputation.DEFAULT_REPUTATION;
+  const makerVolume = stats.fulfilledMakerVolume ?? 0n;
+  const makerCount = stats.fulfilledMakerCount ?? 0;
+  const combinedVolume = stats.fulfilledVolume + makerVolume;
+  const combinedFulfilledCount = stats.fulfilledCount + makerCount;
+  let tier = reputation.getTierFromVolume(combinedVolume);
+  const lockScore = stats.lateCancellations * 50;
+  const dilutedLockScore = combinedFulfilledCount > 0 ? lockScore / (1 + combinedFulfilledCount * 0.1) : lockScore;
+  let tierPenalty = 0;
+  if (dilutedLockScore >= 1e3) tierPenalty = 4;
+  else if (dilutedLockScore >= 500) tierPenalty = 3;
+  else if (dilutedLockScore >= 200) tierPenalty = 2;
+  else if (dilutedLockScore >= 50) tierPenalty = 1;
+  if (tierPenalty > 0) {
+    const currentTierIndex = reputation.TIER_ORDER.indexOf(tier);
+    const newTierIndex = Math.max(0, currentTierIndex - tierPenalty);
+    tier = reputation.TIER_ORDER[newTierIndex] ?? "peasant";
+  }
+  const cooldownHours = reputation.TAKER_TIERS[tier].cooldownHours;
+  let cooldownEndsAt = null;
+  let isOnCooldown = false;
+  if (cooldownHours > 0 && pulseTimestamp !== null && pulseTimestamp !== void 0) {
+    const lastSignaledTime = Number(pulseTimestamp) * 1e3;
+    const cooldownMs = cooldownHours * 60 * 60 * 1e3;
+    cooldownEndsAt = new Date(lastSignaledTime + cooldownMs);
+    isOnCooldown = cooldownEndsAt > now();
+  }
+  return {
+    tier,
+    fulfilledVolume: combinedVolume,
+    lockScore: dilutedLockScore,
+    cooldownEndsAt,
+    isOnCooldown
+  };
+}
+var useIndexerReputationSource = ({ address }) => {
+  const provex = useOptionalProvex();
+  if (!provex) {
+    throw new Error("useUserReputation needs a <ProvexProvider> or a `source` option");
+  }
+  const { indexer } = provex;
+  const query = reactQuery.useQuery({
+    queryKey: ["provex", "reputation", address, chains.pulsechain.id],
     queryFn: async () => {
       if (!address) return null;
-      return indexer.getUserReputation({
-        address,
-        chainId: isBase ? chains.base.id : void 0
-      });
+      const data = await indexer.getUserReputation({ address, chainId: chains.pulsechain.id });
+      return {
+        fulfilledVolume: data.fulfilledVolume,
+        fulfilledCount: data.fulfilledCount,
+        lateCancellations: data.lateCancellations,
+        lastSignaledAt: data.lastSignaledAt[chains.pulsechain.id] ?? null
+      };
     },
     enabled: !!address,
     staleTime: 6e4,
     refetchInterval: 12e4
   });
+  const refetch = react.useCallback(() => query.refetch(), [query]);
+  const row = query.data ?? null;
+  return {
+    stats: row,
+    lastSignaledTimestamp: row ? row.lastSignaledAt : null,
+    isLoading: query.isLoading,
+    error: query.error,
+    refetch
+  };
+};
+function useUserReputation({
+  address,
+  source = useIndexerReputationSource,
+  vipStatus = "normal",
+  disabled
+}) {
+  const provex = useOptionalProvex();
+  const isDisabled = disabled ?? provex?.config.reputationDisabled ?? false;
+  const { stats, lastSignaledTimestamp, isLoading: sourceLoading, error, refetch: refetchSource } = source({ address });
+  const canBypassCooldown = vipStatus === "vip";
   const reputation$1 = react.useMemo(() => {
-    const data = reputationQuery.data;
-    if (!data) return reputation.DEFAULT_REPUTATION;
-    let tier = reputation.getTierFromVolume(data.fulfilledVolume);
-    const lockScore = data.lateCancellations * 50;
-    const dilutedLockScore = data.fulfilledCount > 0 ? lockScore / (1 + data.fulfilledCount * 0.1) : lockScore;
-    let tierPenalty = 0;
-    if (dilutedLockScore >= 1e3) tierPenalty = 4;
-    else if (dilutedLockScore >= 500) tierPenalty = 3;
-    else if (dilutedLockScore >= 200) tierPenalty = 2;
-    else if (dilutedLockScore >= 50) tierPenalty = 1;
-    if (tierPenalty > 0) {
-      const currentTierIndex = reputation.TIER_ORDER.indexOf(tier);
-      const newTierIndex = Math.max(0, currentTierIndex - tierPenalty);
-      tier = reputation.TIER_ORDER[newTierIndex] ?? "peasant";
-    }
-    const cooldownHours = reputation.TAKER_TIERS[tier].cooldownHours;
-    let cooldownEndsAt = null;
-    let isOnCooldown = false;
-    const baseTimestamp = data.lastSignaledAt[chains.base.id] ?? null;
-    const pulseTimestamp = data.lastSignaledAt[369] ?? null;
-    const candidateTimestamps = isBase ? [baseTimestamp] : [baseTimestamp, pulseTimestamp];
-    const lastSignaledTimestamp = candidateTimestamps.filter((ts) => ts !== null).sort((a, b) => Number(b) - Number(a))[0] ?? null;
-    if (cooldownHours > 0 && lastSignaledTimestamp) {
-      const lastSignaledTime = Number(lastSignaledTimestamp) * 1e3;
-      const cooldownMs = cooldownHours * 60 * 60 * 1e3;
-      cooldownEndsAt = new Date(lastSignaledTime + cooldownMs);
-      isOnCooldown = cooldownEndsAt > /* @__PURE__ */ new Date();
-    }
-    return {
-      tier,
-      fulfilledVolume: data.fulfilledVolume,
-      lockScore: dilutedLockScore,
-      cooldownEndsAt,
-      isOnCooldown
-    };
-  }, [reputationQuery.data, isBase]);
-  const hasLoadedData = reputationQuery.data !== void 0;
-  const isLoading = reputationQuery.isLoading && !hasLoadedData;
-  const refetch = react.useCallback(() => {
-    queryClient.invalidateQueries({
-      queryKey: ["provex", "reputation", address]
-    });
-  }, [queryClient, address]);
+    if (isDisabled) return reputation.DEFAULT_REPUTATION;
+    const computed = computeUserReputation({ stats, pulseTimestamp: lastSignaledTimestamp });
+    if (!canBypassCooldown) return computed;
+    return { ...computed, tier: payment.tiers.PRESIDENT, isOnCooldown: false, cooldownEndsAt: null };
+  }, [stats, lastSignaledTimestamp, canBypassCooldown, isDisabled]);
+  const hasLoadedData = stats !== null;
+  const isLoading = sourceLoading && !hasLoadedData;
+  const refetch = react.useCallback(async () => {
+    await refetchSource();
+  }, [refetchSource]);
+  const lastSignaledIntentMs = react.useMemo(
+    () => lastSignaledTimestamp === null || lastSignaledTimestamp === void 0 ? null : Number(lastSignaledTimestamp) * 1e3,
+    [lastSignaledTimestamp]
+  );
+  const filteringTier = isDisabled ? null : filteringTierFor({ vipStatus, tier: reputation$1.tier });
   return {
     reputation: reputation$1,
+    lastSignaledIntentMs,
+    vipStatus,
+    filteringTier,
     isLoading,
-    error: reputationQuery.error,
+    error,
     refetch
   };
 }
+var NO_LIMITS = {
+  hasLimits: false,
+  noCooldownProviders: [],
+  selectedProviderCooldownHours: 0,
+  cooldownRemaining: null,
+  isOnCooldown: false,
+  effectiveCap: null,
+  amountExceedsCap: false,
+  capExceededMessage: null,
+  tierName: null,
+  tierBaseCapUsd: null,
+  capMultiplier: null,
+  effectiveCapUsd: null,
+  providerName: null
+};
+var COOLDOWN_TICK_MS = 6e4;
 function useReputationLimits({
   chainId,
   selectedPaymentMethod,
   tier,
   decimals,
+  orderTokenAmount,
   amountInInt,
-  cooldownEndsAt
+  cooldownEndsAt,
+  disabled,
+  clock
 }) {
-  const hasLimits = true;
+  const provex = useOptionalProvex();
+  const providerClock = useClock();
+  const activeClock = clock ?? providerClock;
+  const isDisabled = disabled ?? provex?.config.reputationDisabled ?? false;
+  const hasLimits = !isDisabled;
+  const orderAmount = orderTokenAmount ?? amountInInt ?? null;
+  const [tick, setTick] = react.useState(0);
+  react.useEffect(() => {
+    if (!hasLimits || !cooldownEndsAt) return;
+    const id = activeClock.setInterval(() => setTick((count) => count + 1), COOLDOWN_TICK_MS);
+    return () => activeClock.clearInterval(id);
+  }, [hasLimits, cooldownEndsAt, activeClock]);
   const { cooldownRemaining, isOnCooldown } = react.useMemo(() => {
-    const providerCooldownHours = reputation.getCooldownHours({ tier, providerKey: selectedPaymentMethod }) ;
+    const providerCooldownHours = hasLimits ? reputation.getCooldownHours({ tier, providerKey: selectedPaymentMethod }) : 0;
     const providerHasCooldown = providerCooldownHours > 0;
     if (!cooldownEndsAt || !providerHasCooldown) {
       return { cooldownRemaining: null, isOnCooldown: false };
     }
-    const remainingMs = cooldownEndsAt.getTime() - Date.now();
+    const remainingMs = cooldownEndsAt.getTime() - activeClock.now();
     if (remainingMs <= 0) {
       return { cooldownRemaining: null, isOnCooldown: false };
     }
@@ -1240,8 +1325,9 @@ function useReputationLimits({
     const minutes = Math.floor(remainingMs % (1e3 * 60 * 60) / (1e3 * 60));
     const formatted = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
     return { cooldownRemaining: formatted, isOnCooldown: true };
-  }, [cooldownEndsAt, hasLimits, tier, selectedPaymentMethod]);
+  }, [cooldownEndsAt, hasLimits, tier, selectedPaymentMethod, tick, activeClock]);
   const noCooldownProviders = react.useMemo(() => {
+    if (!hasLimits) return [];
     const available = payment.verifiablePaymentMethods(chainId);
     return available.filter((key) => {
       if (key === selectedPaymentMethod) return false;
@@ -1251,22 +1337,43 @@ function useReputationLimits({
     });
   }, [hasLimits, chainId, selectedPaymentMethod, tier]);
   const selectedProviderCooldownHours = react.useMemo(() => {
+    if (!hasLimits) return 0;
     return reputation.getCooldownHours({ tier, providerKey: selectedPaymentMethod });
   }, [hasLimits, tier, selectedPaymentMethod]);
   const effectiveCap = react.useMemo(() => {
+    if (!hasLimits) return null;
     return reputation.getEffectiveCap({ tier, providerKey: selectedPaymentMethod, decimals });
   }, [hasLimits, tier, selectedPaymentMethod, decimals]);
   const amountExceedsCap = react.useMemo(
-    () => reputation.isOverOrderCap({ orderTokenAmount: amountInInt ?? null, cap: effectiveCap }),
-    [effectiveCap, amountInInt]
+    () => reputation.isOverOrderCap({ orderTokenAmount: orderAmount, cap: effectiveCap }),
+    [effectiveCap, orderAmount]
   );
-  const capExceededMessage = react.useMemo(() => {
-    if (!amountExceedsCap || effectiveCap === null) return null;
+  const tierName = react.useMemo(
+    () => hasLimits ? reputation.TAKER_TIERS[tier].name : null,
+    [hasLimits, tier]
+  );
+  const providerName = react.useMemo(
+    () => hasLimits ? payment.providerConfigs(chainId)[selectedPaymentMethod]?.name ?? selectedPaymentMethod : null,
+    [hasLimits, chainId, selectedPaymentMethod]
+  );
+  const tierBaseCapUsd = react.useMemo(
+    () => hasLimits && effectiveCap !== null && effectiveCap !== reputation.UNLIMITED_CAP_BASE_UNITS ? reputation.TAKER_TIERS[tier].baseCap : null,
+    [hasLimits, tier, effectiveCap]
+  );
+  const capMultiplier = react.useMemo(
+    () => hasLimits && effectiveCap !== null && effectiveCap !== reputation.UNLIMITED_CAP_BASE_UNITS ? payment.getPlatformRisk(chainId, selectedPaymentMethod).capMultiplier ?? 1 : null,
+    [hasLimits, chainId, selectedPaymentMethod, effectiveCap]
+  );
+  const effectiveCapUsd = react.useMemo(() => {
+    if (!hasLimits || effectiveCap === null) return null;
     if (effectiveCap === reputation.UNLIMITED_CAP_BASE_UNITS) return null;
-    const capUsd = reputation.getEffectiveCapDisplayUsd(effectiveCap, decimals) ?? 0;
-    const providerName = payment.providerConfigs(chainId)[selectedPaymentMethod]?.name ?? selectedPaymentMethod;
-    return `Amount exceeds your $${capUsd.toLocaleString()} limit for ${providerName}`;
-  }, [amountExceedsCap, effectiveCap, chainId, selectedPaymentMethod, decimals]);
+    return reputation.getEffectiveCapDisplayUsd(effectiveCap, decimals) ?? null;
+  }, [hasLimits, effectiveCap, decimals]);
+  const capExceededMessage = react.useMemo(() => {
+    if (!amountExceedsCap || effectiveCapUsd === null || providerName === null) return null;
+    return `Amount exceeds your $${effectiveCapUsd.toLocaleString()} limit for ${providerName}`;
+  }, [amountExceedsCap, effectiveCapUsd, providerName]);
+  if (!hasLimits) return NO_LIMITS;
   return {
     hasLimits,
     noCooldownProviders,
@@ -1275,7 +1382,12 @@ function useReputationLimits({
     isOnCooldown,
     effectiveCap,
     amountExceedsCap,
-    capExceededMessage
+    capExceededMessage,
+    tierName,
+    tierBaseCapUsd,
+    capMultiplier,
+    effectiveCapUsd,
+    providerName
   };
 }
 function usePayeeDetails({
@@ -1312,7 +1424,8 @@ function usePayeeDetails({
   }, [indexedIntent]);
   const expiryTime = indexedIntent?.expiryTime ?? null;
   const depositQuery = reactQuery.useQuery({
-    queryKey: ["provex", "deposit", indexedIntent?.escrow, indexedIntent?.depositLocalId, chainId],
+    // Query keys are hashed with JSON.stringify, which throws on bigint.
+    queryKey: ["provex", "deposit", indexedIntent?.escrow, indexedIntent?.depositLocalId.toString(), chainId],
     queryFn: () => indexer.getDepositWithVerifiers({
       escrow: indexedIntent.escrow,
       localId: indexedIntent.depositLocalId,
@@ -1660,36 +1773,100 @@ function useNullifierRegistry({
     checkNullifierUsed
   };
 }
-function useProvexProving(deps) {
+function encodeOrchestratorFulfill(attestation, verificationData, intentHash) {
+  const args = [
+    {
+      paymentProof: utils.encodeV3PaymentProof(attestation),
+      intentHash,
+      verificationData,
+      postIntentHookData: "0x"
+    }
+  ];
+  return {
+    args,
+    calldata: viem.encodeFunctionData({ abi: abis.OrchestratorAbi, functionName: "fulfillIntent", args }),
+    abi: abis.OrchestratorAbi
+  };
+}
+function createWalletProvingClient(options) {
   const {
-    proveXClient,
+    orchestratorAddress,
+    chainId,
+    writeContract,
+    publicClient: publicClient2,
     checkNullifierUsed,
+    getGasInputs,
+    encodeFulfill = encodeOrchestratorFulfill,
+    onPrefill
+  } = options;
+  return {
+    chainId,
+    async fulfillIntent(params) {
+      const context = { chainId, request: void 0 };
+      const gasInputs = await getGasInputs();
+      const { args, calldata, abi } = encodeFulfill(
+        params.attestation,
+        params.verificationData,
+        params.intentHash
+      );
+      params.onAwaitingSignature?.(context);
+      const hash = await writeContract({
+        address: orchestratorAddress,
+        abi,
+        functionName: "fulfillIntent",
+        args,
+        chainId,
+        ...gasInputs
+      });
+      onPrefill?.(
+        {
+          to: orchestratorAddress,
+          data: calldata,
+          value: 0n,
+          originalTip: gasInputs.maxPriorityFeePerGas
+        },
+        gasInputs,
+        hash
+      );
+      params.onTransactionHash?.({ ...context, hash });
+      const receipt = publicClient2 ? await publicClient2.waitForTransactionReceipt({ hash }) : void 0;
+      return { hash, receipt };
+    },
+    async checkNullifierUsed({ nullifier }) {
+      return checkNullifierUsed(nullifier);
+    }
+  };
+}
+
+// src/hooks/useProvingFlow.ts
+function useProvingFlow(options) {
+  const {
+    rail,
     request,
     paymentMethodId,
     captureAdapter,
     attestationBaseUrl,
+    attestationServiceUrl,
     onAwaitingSignature,
     onTransactionHash,
     onComplete
-  } = deps;
-  const client = react.useMemo(
-    () => ({
-      // Pin the rail to the intent's chain. request.chainId is the single chain
-      // that drives both useNullifierRegistry (the read backing checkNullifierUsed)
-      // and ProveXClient.fulfillIntent here, so useProving's chain-pin assertion
-      // is a tautology in correct wiring and a tripwire if they ever diverge.
-      chainId: request.chainId,
-      fulfillIntent: proveXClient.fulfillIntent,
-      checkNullifierUsed: ({ nullifier }) => checkNullifierUsed(nullifier)
-    }),
-    [proveXClient, checkNullifierUsed, request.chainId]
-  );
+  } = options;
+  const chainId = options.chainId ?? request.chainId;
+  const client = react.useMemo(() => {
+    if (rail.kind === "wallet") return createWalletProvingClient({ ...rail, chainId });
+    return {
+      chainId,
+      fulfillIntent: rail.fulfillIntent,
+      checkNullifierUsed: ({ nullifier }) => rail.checkNullifierUsed(nullifier)
+    };
+  }, [rail, chainId]);
   const resolvedCaptureAdapter = react.useMemo(
     () => captureAdapter ?? extensionReact.createExtensionEnclaveAdapter({
       getPeer: () => window.peer,
-      attestationBaseUrl
+      attestationBaseUrl,
+      ...attestationServiceUrl ? { attestationServiceUrl } : {}
     }),
-    [captureAdapter, attestationBaseUrl]
+    [captureAdapter, attestationBaseUrl, attestationServiceUrl]
   );
   const manualSelect = proving.useManualTransactionSelect();
   const { state, authenticate, fulfill, retryVerification, retrySubmission } = proving.useProving({
@@ -1705,6 +1882,17 @@ function useProvexProving(deps) {
   return { state, authenticate, fulfill, retryVerification, retrySubmission, manualSelect };
 }
 
+// src/hooks/useProvexProving.ts
+function useProvexProving(deps) {
+  const { proveXClient, checkNullifierUsed, ...flowOptions } = deps;
+  const { fulfillIntent } = proveXClient;
+  const rail = react.useMemo(
+    () => ({ kind: "client", fulfillIntent, checkNullifierUsed }),
+    [fulfillIntent, checkNullifierUsed]
+  );
+  return useProvingFlow({ rail, ...flowOptions });
+}
+
 // src/useProvexBuy.ts
 function parseAmountSafe(value, decimals) {
   if (!value || value === "." || value === "0.") return null;
@@ -1746,10 +1934,8 @@ function useProvexBuy({
     paymentMethod: activePaymentMethod,
     currency
   });
-  const { reputation: reputation$1 } = useReputation({
-    address: wallet.address,
-    chainId
-  });
+  const { reputation } = useUserReputation({
+    address: wallet.address});
   const amountBigInt = react.useMemo(
     () => parseAmountSafe(amount, currency.decimals),
     [amount, currency.decimals]
@@ -1785,12 +1971,11 @@ function useProvexBuy({
   refetchAllRef.current = payeeResult.refetchAll;
   react.useEffect(() => {
     if (phase !== "committed") return;
-    if (!intentHash) return;
     const interval = setInterval(() => {
       refetchAllRef.current();
     }, 5e3);
     return () => clearInterval(interval);
-  }, [phase, intentHash]);
+  }, [phase]);
   react.useEffect(() => {
     if (!payeeResult.isPruned) return;
     if (phase === "browse") return;
@@ -1830,6 +2015,7 @@ function useProvexBuy({
       payeeDetailsHash,
       token,
       intent: {
+        owner: intent.owner,
         amount: intent.amount,
         timestamp: intent.timestamp,
         paymentMethod: intent.paymentMethod,
@@ -1848,6 +2034,7 @@ function useProvexBuy({
       token: token ?? { decimals: 18 },
       intent: {
         intentHash: intentHash ?? "0x",
+        owner: "0x",
         amount: "0",
         timestampMs: "0",
         paymentMethod: "0x",
@@ -1909,10 +2096,10 @@ function useProvexBuy({
   const limits = useReputationLimits({
     chainId,
     selectedPaymentMethod: activePaymentMethod,
-    tier: reputation$1.tier,
+    tier: reputation.tier,
     decimals: tokenDecimals,
-    amountInInt: tokenAmount,
-    cooldownEndsAt: reputation$1.cooldownEndsAt
+    orderTokenAmount: tokenAmount,
+    cooldownEndsAt: reputation.cooldownEndsAt
   });
   const rateDisplay = react.useMemo(() => {
     if (!bestRate || !token) return null;
@@ -1998,7 +2185,7 @@ function useProvexBuy({
     tokenAmountDisplay,
     token,
     currency,
-    reputation: reputation$1 ?? reputation.DEFAULT_REPUTATION,
+    reputation,
     limits,
     feePercentage: feeInfo?.percentage ?? null,
     payeeDetails: payeeResult.payeeDetails,