@provex/react 1.2.3

package/dist/index.cjs

@@ -0,0 +1,2756 @@
+'use strict';
+
+var react = require('react');
+var reactQuery = require('@tanstack/react-query');
+var jsxRuntime = require('react/jsx-runtime');
+var payment = require('@provex/utils/payment');
+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 viem = require('viem');
+var fees = require('@provex/utils/fees');
+var abis = require('@provex/abis');
+var chain = require('@provex/utils/chain');
+var chains = require('viem/chains');
+var wagmi = require('wagmi');
+var ids = require('@provex/utils/ids');
+
+// src/ProvexProvider.tsx
+
+// src/lib/api.ts
+function createApiClient(apiUrl) {
+  async function request(path, options) {
+    const url = `${apiUrl}${path}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`API request failed: ${response.status} ${response.statusText} (${url})`);
+    }
+    return response.json();
+  }
+  return {
+    get: (path, options) => request(path, { ...options, method: "GET" }),
+    post: (path, body, options) => request(path, {
+      ...options,
+      method: "POST",
+      body: JSON.stringify(body)
+    })
+  };
+}
+var ProvexContext = react.createContext(null);
+var defaultQueryClient = new reactQuery.QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 3e4,
+      refetchOnWindowFocus: false
+    }
+  }
+});
+function ProvexProvider({
+  config,
+  indexer,
+  queryClient,
+  children
+}) {
+  const resolvedQueryClient = queryClient ?? defaultQueryClient;
+  const contextValue = react.useMemo(() => {
+    const apiClient = createApiClient(config.apiUrl);
+    return { config, indexer, apiClient };
+  }, [config.apiUrl, config.chain, indexer]);
+  return /* @__PURE__ */ jsxRuntime.jsx(ProvexContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: resolvedQueryClient, children }) });
+}
+function useProvex() {
+  const context = react.useContext(ProvexContext);
+  if (!context) {
+    throw new Error("useProvex must be used within a <ProvexProvider>");
+  }
+  return context;
+}
+function useOptionalProvex() {
+  return react.useContext(ProvexContext);
+}
+var DEFAULT_REFETCH_INTERVAL_MS = 5e3;
+function getRate({
+  deposit,
+  paymentMethod,
+  currency
+}) {
+  if (!deposit) return 0n;
+  const paymentConfig = payment.providerConfigs(deposit.chainId)[paymentMethod];
+  const candidateKeys = [
+    paymentMethod,
+    ...Array.from(paymentConfig?.subProviders ?? []).map((sp) => sp.key)
+  ];
+  let minRate = null;
+  for (const key of candidateKeys) {
+    const contractId = payment.providerKeyToContractId(key).toLowerCase();
+    const value = deposit.conversionRates.get(contractId)?.get(currency.contractId.toLowerCase());
+    if (value) {
+      if (minRate === null || value < minRate) {
+        minRate = value;
+      }
+    }
+  }
+  return minRate ?? 0n;
+}
+function toDepositInfo(deposit) {
+  return {
+    escrow: deposit.escrow,
+    localId: deposit.localId,
+    chainId: deposit.chainId,
+    participantAddress: deposit.participantAddress,
+    token: deposit.token,
+    remaining: deposit.remaining,
+    deposited: deposit.deposited,
+    minAmount: deposit.minAmount,
+    maxAmount: deposit.maxAmount,
+    status: deposit.status,
+    acceptingIntents: deposit.acceptingIntents,
+    availableFunds: deposit.availableFunds,
+    conversionRates: deposit.conversionRates,
+    verifierPaymentMethodIds: deposit.paymentMethodIds
+  };
+}
+function useDeposits(options) {
+  const {
+    token,
+    currency = currencies.SUPPORTED_CURRENCIES.USD,
+    paymentMethod,
+    refetchIntervalMs = DEFAULT_REFETCH_INTERVAL_MS
+  } = options;
+  const { indexer } = useProvex();
+  const queryClient = reactQuery.useQueryClient();
+  const paymentMethodIds = react.useMemo(() => {
+    const paymentConfig = payment.providerConfigs(token.chainId)[paymentMethod];
+    return /* @__PURE__ */ new Set([
+      payment.providerKeyToContractId(paymentMethod).toLowerCase(),
+      ...paymentConfig.v2Verifiers.map((v) => v.toLowerCase()),
+      ...Array.from(paymentConfig.subProviders).flatMap((subProvider) => [
+        payment.providerKeyToContractId(subProvider.key).toLowerCase(),
+        ...subProvider.v2Verifiers(token.chainId).map((v) => v.toLowerCase())
+      ])
+    ]);
+  }, [token.chainId, paymentMethod]);
+  const depositsQuery = reactQuery.useQuery({
+    queryKey: ["provex", "deposits", token.address, token.chainId, currency.contractId, paymentMethod],
+    queryFn: async () => {
+      const result = await indexer.getMatchableDeposits({
+        chainId: token.chainId,
+        token: token.address,
+        currencyId: currency.contractId
+      });
+      return result.items.filter((d) => {
+        for (const id of d.paymentMethodIds) {
+          if (paymentMethodIds.has(id)) return true;
+        }
+        return false;
+      }).map(toDepositInfo);
+    },
+    staleTime: refetchIntervalMs,
+    refetchInterval: refetchIntervalMs
+  });
+  const deposits = react.useMemo(() => depositsQuery.data ?? [], [depositsQuery.data]);
+  const canAcceptAmount = react.useCallback((deposit, amount) => {
+    return amount <= deposit.availableFunds && amount >= deposit.minAmount && amount <= deposit.maxAmount;
+  }, []);
+  const filterDepositsByAmount = react.useCallback((amountInInt) => {
+    if (!amountInInt || !currency) return [];
+    const matchable = [];
+    for (const deposit of deposits) {
+      const rate = getRate({ deposit, paymentMethod, currency });
+      if (rate === 0n) continue;
+      const amountToken = conversionRates.convertCurrencyToTokenOutput({
+        token,
+        currency,
+        currencyAmountInt: amountInInt,
+        rate
+      });
+      if (canAcceptAmount(deposit, amountToken)) {
+        matchable.push({ deposit, rate });
+      }
+    }
+    return matchable.sort((a, b) => {
+      if (a.rate < b.rate) return -1;
+      if (a.rate > b.rate) return 1;
+      if (a.deposit.localId < b.deposit.localId) return -1;
+      if (a.deposit.localId > b.deposit.localId) return 1;
+      return 0;
+    }).map((m) => m.deposit);
+  }, [deposits, currency, paymentMethod, token, canAcceptAmount]);
+  const refetch = react.useCallback(() => {
+    queryClient.invalidateQueries({
+      queryKey: ["provex", "deposits", token.address, token.chainId, currency.contractId, paymentMethod]
+    });
+  }, [queryClient, token.address, token.chainId, currency.contractId, paymentMethod]);
+  return {
+    deposits,
+    isLoading: depositsQuery.isLoading,
+    isUpdating: depositsQuery.isFetching && !depositsQuery.isLoading,
+    error: depositsQuery.error,
+    refetch,
+    filterDepositsByAmount,
+    getMatchableDeposits: (amountInInt) => {
+      if (typeof amountInInt === "string") {
+        amountInInt = units.parseUnits(amountInInt, { decimals: currency?.decimals || 2 });
+      }
+      if (!amountInInt) return [];
+      return filterDepositsByAmount(amountInInt);
+    }
+  };
+}
+var getTransactionGasInputs = async (chainId) => {
+  const chain$1 = chain.chainIdToChain.get(chainId);
+  if (!chain$1) {
+    throw new Error(`Unsupported chainId: ${chainId}`);
+  }
+  const block = await tokens.publicClient(chain$1).getBlock({
+    blockTag: "latest"
+  });
+  if (!block.baseFeePerGas) {
+    throw new Error(`No baseFeePerGas available for chainId: ${chainId}`);
+  }
+  return {
+    maxFeePerGas: block.baseFeePerGas * 2n,
+    maxPriorityFeePerGas: block.baseFeePerGas / 5n
+  };
+};
+
+// src/lib/updates.ts
+var POLL_INTERVAL_MS = 1e3;
+var SLOW_SYNC_THRESHOLD_MS = 15e3;
+var checkMutation = async ({
+  queryDeposit,
+  depositIdHex,
+  status,
+  onSuccess,
+  onSlowSync,
+  slowSyncThresholdMs = SLOW_SYNC_THRESHOLD_MS
+}) => {
+  const startTime = Date.now();
+  let slowSyncFired = false;
+  while (true) {
+    const result = await queryDeposit(depositIdHex);
+    if (result?.status === status) {
+      break;
+    }
+    if (!slowSyncFired && onSlowSync && Date.now() - startTime > slowSyncThresholdMs) {
+      slowSyncFired = true;
+      onSlowSync();
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  setTimeout(() => {
+    onSuccess?.();
+  }, POLL_INTERVAL_MS);
+};
+var checkTransactionIndexed = async ({
+  queryTransaction,
+  hash,
+  onSuccess,
+  onSlowSync,
+  slowSyncThresholdMs = SLOW_SYNC_THRESHOLD_MS
+}) => {
+  const startTime = Date.now();
+  let slowSyncFired = false;
+  while (true) {
+    const result = await queryTransaction(hash);
+    if (result) {
+      break;
+    }
+    if (!slowSyncFired && onSlowSync && Date.now() - startTime > slowSyncThresholdMs) {
+      slowSyncFired = true;
+      onSlowSync();
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+  }
+  onSuccess?.();
+};
+
+// src/lib/errors.ts
+var ERROR_PATTERNS = [
+  // Wallet / signer rejections
+  { pattern: /user rejected|user denied|rejected the request|user cancelled|user canceled/i, message: "Transaction was cancelled." },
+  // On-chain reverts — specific errors first (first match wins)
+  { pattern: /InsufficientDepositLiquidity|0xc3df48f3/i, message: "This deposit no longer has enough available liquidity. Please try a smaller amount or a different deposit." },
+  { pattern: /execution reverted/i, message: "Transaction failed on-chain. The order may no longer be available." },
+  // Gas / balance issues
+  { pattern: /insufficient funds/i, message: "Insufficient funds for gas fees." },
+  { pattern: /gas required exceeds/i, message: "Transaction requires more gas than allowed." },
+  // Transaction replacement / nonce issues
+  { pattern: /could not replace existing tx|replacement transaction underpriced|nonce too low/i, message: "A previous transaction is still pending. Please wait for it to confirm or speed it up in your wallet." },
+  // Deposit state errors
+  { pattern: /DepositNotAcceptingIntents|0x67688c1a/i, message: "This deposit is currently paused. Please try a different deposit." },
+  // Network / RPC errors
+  { pattern: /could not detect network|network changed/i, message: "Network connection issue. Please check your wallet network." },
+  { pattern: /disconnected|not connected/i, message: "Wallet disconnected. Please reconnect and try again." },
+  { pattern: /timeout|etimedout/i, message: "Request timed out. Please try again." },
+  { pattern: /fetch failed|econnrefused|enotfound/i, message: "Unable to reach the server. Please check your connection." },
+  // Rate limiting / service unavailable
+  { pattern: /429|too many requests/i, message: "Too many requests. Please wait a moment and try again." },
+  { pattern: /503|service unavailable/i, message: "Service temporarily unavailable. Please try again shortly." },
+  // Nullifier / double-spend (keep the original — it's already user-friendly)
+  { pattern: /nullifier has already been used/i, message: "This payment has already been verified and cannot be used again." },
+  { pattern: /already been verified/i, message: "This payment has already been verified and cannot be used again." }
+];
+function getUserFriendlyErrorMessage(error) {
+  const raw = extractErrorString(error);
+  for (const { pattern, message } of ERROR_PATTERNS) {
+    if (pattern.test(raw)) {
+      return message;
+    }
+  }
+  return "Something went wrong. Please try again.";
+}
+function isUserRejectionError(error) {
+  const raw = extractErrorString(error);
+  return /user rejected|user denied|rejected the request|user cancelled|user canceled/i.test(raw);
+}
+function extractErrorString(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+// src/client/types.ts
+var PROVEX_DEFAULTS = {
+  8453: { apiUrl: "https://app.provex.com", indexerUrl: "https://indexer.provex.com" },
+  369: { apiUrl: "https://app.provex.com", indexerUrl: "https://indexer.provex.com" }
+};
+var ProveXError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "ProveXError";
+    this.code = code;
+    this.cause = cause;
+  }
+  /** Check if this error was caused by the user rejecting in their wallet. */
+  get isRejection() {
+    return this.code === "WALLET_REJECTED";
+  }
+};
+
+// src/client/ProveXClient.ts
+var ProveXClient = class {
+  /** The viem Chain object — carries RPC URLs, chain ID, and metadata. */
+  chain;
+  /** Numeric chain ID (derived from chain.id). */
+  chainId;
+  wallet;
+  indexer;
+  escrowOverride;
+  onTransactionHash;
+  apiUrl;
+  onSlowSync;
+  /** Lazily-created public client for RPC calls. */
+  _publicClient = null;
+  /** Cached orchestrator address (lazy-loaded). */
+  cachedOrchestratorAddress = null;
+  constructor(config) {
+    this.chain = config.chain;
+    this.chainId = config.chain.id;
+    const defaults = PROVEX_DEFAULTS[this.chainId];
+    this.wallet = config.wallet;
+    this.indexer = config.indexer;
+    this.escrowOverride = config.escrowAddress;
+    this.onTransactionHash = config.onTransactionHash;
+    this.onSlowSync = config.onSlowSync;
+    this.apiUrl = config.apiUrl ?? defaults?.apiUrl ?? "https://app.provex.com";
+    this.createDepositRaw = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "createDeposit",
+      argsMapper: (params) => [params]
+    });
+    this.addFunds = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "addFunds",
+      argsMapper: (params) => [params.depositId, params.amount]
+    });
+    this.removeFunds = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "removeFunds",
+      argsMapper: (params) => [params.depositId, params.amount]
+    });
+    this.withdrawDeposit = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "withdrawDeposit",
+      argsMapper: (params) => [params.depositId]
+    });
+    this.pruneExpiredIntents = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "pruneExpiredIntents",
+      argsMapper: (params) => [params.depositId]
+    });
+    this.setAcceptingIntents = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "setAcceptingIntents",
+      argsMapper: (params) => [params.depositId, params.accepting]
+    });
+    this.setRetainOnEmpty = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "setRetainOnEmpty",
+      argsMapper: (params) => [params.depositId, params.retain]
+    });
+    this.setIntentRange = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "setIntentRange",
+      argsMapper: (params) => [params.depositId, { min: params.min, max: params.max }]
+    });
+    this.setPaymentMethodActive = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "setPaymentMethodActive",
+      argsMapper: (params) => [params.depositId, params.paymentMethod, params.active]
+    });
+    this.setCurrencyMinRate = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "setCurrencyMinRate",
+      argsMapper: (params) => [params.depositId, params.paymentMethod, params.currency, params.rate]
+    });
+    this.addCurrencies = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "addCurrencies",
+      argsMapper: (params) => [params.depositId, params.paymentMethod, params.currencies]
+    });
+    this.deactivateCurrency = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "deactivateCurrency",
+      argsMapper: (params) => [params.depositId, params.paymentMethod, params.currencyCode]
+    });
+    this.addPaymentMethods = this.buildWritableMethod({
+      abi: abis.V3EscrowAbi,
+      contractResolver: () => this.getEscrowAddress(),
+      functionName: "addPaymentMethods",
+      argsMapper: (params) => [params.depositId, params.paymentMethods, params.paymentMethodData, params.currencies]
+    });
+    this.cancelIntent = this.buildWritableMethod({
+      abi: abis.OrchestratorAbi,
+      contractResolver: () => this.getOrchestratorAddress(),
+      functionName: "cancelIntent",
+      argsMapper: (params) => [params.intentHash]
+    });
+    this.releaseFundsToPayer = this.buildWritableMethod({
+      abi: abis.OrchestratorAbi,
+      contractResolver: () => this.getOrchestratorAddress(),
+      functionName: "releaseFundsToPayer",
+      argsMapper: (params) => [params.intentHash]
+    });
+    this.approve = this.buildWritableMethod({
+      abi: [{ name: "approve", type: "function", stateMutability: "nonpayable", inputs: [{ name: "spender", type: "address" }, { name: "amount", type: "uint256" }], outputs: [{ name: "", type: "bool" }] }],
+      contractResolver: (_params) => _params.token,
+      functionName: "approve",
+      argsMapper: (params) => [params.spender, params.amount ?? BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")]
+    });
+  }
+  // ─── Address Resolution ──────────────────────────────────────────────────
+  /** Get the V3 escrow address for this client's chain. */
+  getEscrowAddress() {
+    if (this.escrowOverride) return this.escrowOverride;
+    const addr = contracts.getLatestContract(this.chainId, "escrow", "v3");
+    if (!addr) throw new ProveXError("VALIDATION_ERROR", `No V3 escrow found for chain ${this.chainId}`);
+    return addr;
+  }
+  /** Get the orchestrator address (cached after first read). */
+  async getOrchestratorAddress() {
+    if (this.cachedOrchestratorAddress) return this.cachedOrchestratorAddress;
+    const escrow = this.getEscrowAddress();
+    const result = await this.readContract({
+      address: escrow,
+      abi: abis.V3EscrowAbi,
+      functionName: "orchestrator"
+    });
+    this.cachedOrchestratorAddress = result;
+    return this.cachedOrchestratorAddress;
+  }
+  // ─── Indexer Reads ───────────────────────────────────────────────────────
+  requireIndexer() {
+    if (!this.indexer) throw new ProveXError("INDEXER_NOT_CONFIGURED", "No IndexerAdapter provided. Pass `indexer` to createProveXClient().");
+    return this.indexer;
+  }
+  async getMatchableDeposits(params) {
+    return this.requireIndexer().getMatchableDeposits({ ...params, chainId: this.chainId });
+  }
+  async getDepositWithVerifiers(params) {
+    return this.requireIndexer().getDepositWithVerifiers({ ...params, chainId: this.chainId });
+  }
+  async getIntent(intentHash) {
+    return this.requireIndexer().getIntent({ intentHash, chainId: this.chainId });
+  }
+  async getPayeeDetailsHash(params) {
+    return this.requireIndexer().getPayeeDetailsHash({ ...params, chainId: this.chainId });
+  }
+  async getUserReputation(address) {
+    return this.requireIndexer().getUserReputation({ address, chainId: this.chainId });
+  }
+  // ─── On-Chain Reads ──────────────────────────────────────────────────────
+  async getProtocolFees() {
+    const orchestrator = await this.getOrchestratorAddress();
+    const [feeRaw, feeRecipient] = await Promise.all([
+      this.readContract({ address: orchestrator, abi: abis.OrchestratorAbi, functionName: "protocolFee" }),
+      this.readContract({ address: orchestrator, abi: abis.OrchestratorAbi, functionName: "protocolFeeRecipient" })
+    ]);
+    return {
+      feeRaw,
+      feeInfo: fees.normalizeFeePrecision(feeRaw),
+      feeRecipient
+    };
+  }
+  async getDeposit(depositId) {
+    return this.readContract({
+      address: this.getEscrowAddress(),
+      abi: abis.V3EscrowAbi,
+      functionName: "getDeposit",
+      args: [depositId]
+    });
+  }
+  async getAccountDeposits(account) {
+    return this.readContract({
+      address: this.getEscrowAddress(),
+      abi: abis.V3EscrowAbi,
+      functionName: "getAccountDeposits",
+      args: [account]
+    });
+  }
+  async getDepositCounter() {
+    return this.readContract({
+      address: this.getEscrowAddress(),
+      abi: abis.V3EscrowAbi,
+      functionName: "depositCounter"
+    });
+  }
+  async getAllowance(params) {
+    return this.readContract({
+      address: params.token,
+      abi: [{ name: "allowance", type: "function", stateMutability: "view", inputs: [{ name: "owner", type: "address" }, { name: "spender", type: "address" }], outputs: [{ name: "", type: "uint256" }] }],
+      functionName: "allowance",
+      args: [params.owner, params.spender]
+    });
+  }
+  async checkNullifierUsed(params) {
+    try {
+      const orchestrator = await this.getOrchestratorAddress();
+      const verifierRegistry = await this.readContract({ address: orchestrator, abi: abis.OrchestratorAbi, functionName: "paymentVerifierRegistry" });
+      const verifier = await this.readContract({ address: verifierRegistry, abi: abis.PaymentVerifierRegistryAbi, functionName: "getVerifier", args: [params.paymentMethodId] });
+      const nullifierRegistry = await this.readContract({ address: verifier, abi: abis.UnifiedPaymentVerifierAbi, functionName: "nullifierRegistry" });
+      return await this.readContract({ address: nullifierRegistry, abi: abis.NullifierRegistryAbi, functionName: "isNullified", args: [params.nullifier] });
+    } catch {
+      return null;
+    }
+  }
+  // ─── Escrow Writes ───────────────────────────────────────────────────────
+  /** Low-level deposit creation — pass pre-hashed contract params directly. */
+  createDepositRaw;
+  addFunds;
+  removeFunds;
+  withdrawDeposit;
+  pruneExpiredIntents;
+  setAcceptingIntents;
+  setRetainOnEmpty;
+  setIntentRange;
+  setPaymentMethodActive;
+  setCurrencyMinRate;
+  addCurrencies;
+  deactivateCurrency;
+  addPaymentMethods;
+  /**
+   * Create a deposit with human-readable params.
+   *
+   * 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)
+   * 4. Encodes gating service witness signers
+   * 5. Submits the on-chain transaction
+   *
+   * @example
+   * ```ts
+   * await client.createDeposit({
+   *   token: USDC_ADDRESS,
+   *   amount: 1000_000000n,
+   *   intentRange: { min: 10_000000n, max: 500_000000n },
+   *   paymentMethods: [
+   *     { provider: 'venmo', payeeId: '@myvenmo', currencies: [{ code: 'USD', minRate: 0n }] },
+   *   ],
+   *   retainOnEmpty: true,
+   * })
+   * ```
+   */
+  async createDeposit(params) {
+    await Promise.all(
+      params.paymentMethods.map(
+        (pm) => this.registerMaker({
+          providerKey: pm.provider,
+          providerId: pm.payeeId,
+          telegramHandle: params.telegramHandle
+        }).catch((err) => {
+          console.warn(`[ProveXClient] Failed to register maker for ${pm.provider}:`, err);
+        })
+      )
+    );
+    const rawParams = this.buildCreateDepositRawParams(params);
+    return this.createDepositRaw(rawParams);
+  }
+  /**
+   * Prepare an unsigned createDeposit transaction (no API call, no wallet).
+   *
+   * Use this for smart accounts, multisig, gasless relayers, or offline signing.
+   * Maker registration is NOT performed — call `registerMaker()` separately
+   * if you need buyers to discover the payee.
+   */
+  async prepareCreateDeposit(params) {
+    return this.createDepositRaw.prepare(this.buildCreateDepositRawParams(params));
+  }
+  /**
+   * Convert human-readable deposit params to raw contract params.
+   * Handles provider expansion, hashing, gating service encoding, and defaults.
+   */
+  buildCreateDepositRawParams(params) {
+    const expanded = [];
+    const configs = payment.providerConfigs(this.chainId);
+    for (const pm of params.paymentMethods) {
+      const hash = payment.computePayeeDetailsHash(pm.payeeId);
+      const config = configs[pm.provider];
+      if (config?.subProviders && config.subProviders.size > 0) {
+        for (const sub of config.subProviders) {
+          expanded.push({
+            providerKey: sub.key,
+            payeeDetailsHash: hash,
+            currencies: pm.currencies,
+            intentGatingService: pm.intentGatingService,
+            data: pm.data
+          });
+        }
+      } else {
+        expanded.push({
+          providerKey: pm.provider,
+          payeeDetailsHash: hash,
+          currencies: pm.currencies,
+          intentGatingService: pm.intentGatingService,
+          data: pm.data
+        });
+      }
+    }
+    const defaultGatingData = viem.encodeAbiParameters(
+      viem.parseAbiParameters(["address[]"]),
+      [[contracts.reclaimSigners.peerWitnessSigner, contracts.reclaimSigners.reclaimWitnessSigner]]
+    );
+    const defaultGatingService = contracts.getLatestContract(this.chainId, "gatingService", "v3") ?? viem.zeroAddress;
+    return {
+      token: params.token,
+      amount: params.amount,
+      intentAmountRange: {
+        min: params.intentRange?.min ?? 1000000n,
+        max: params.intentRange?.max ?? params.amount
+      },
+      paymentMethods: expanded.map((p) => payment.providerKeyToContractId(p.providerKey)),
+      paymentMethodData: expanded.map((p) => ({
+        intentGatingService: p.intentGatingService ?? defaultGatingService,
+        payeeDetails: p.payeeDetailsHash,
+        data: p.data ?? defaultGatingData
+      })),
+      currencies: expanded.map(
+        (p) => p.currencies.map((c) => ({
+          code: currencies.tickerToContractId(c.code),
+          minConversionRate: c.minRate
+        }))
+      ),
+      delegate: params.delegate ?? viem.zeroAddress,
+      intentGuardian: params.intentGuardian ?? viem.zeroAddress,
+      retainOnEmpty: params.retainOnEmpty ?? false
+    };
+  }
+  // ─── Orchestrator Writes ─────────────────────────────────────────────────
+  cancelIntent;
+  releaseFundsToPayer;
+  /**
+   * Signal an intent to buy tokens from a deposit (buyer side).
+   *
+   * Handles the full multi-step flow:
+   * 1. Fetches payee details hash from the indexer
+   * 2. Requests a gating service signature from the API
+   * 3. Simulates the transaction
+   * 4. Submits to Orchestrator.signalIntent()
+   * 5. Parses the IntentSignaled event to extract the intent hash
+   *
+   * @returns Transaction result with the on-chain intent hash.
+   * @throws {ProveXError} VALIDATION_ERROR if payee details or gating signature missing.
+   * @throws {ProveXError} API_ERROR if gating service rejects the intent.
+   * @throws {ProveXError} WALLET_REJECTED if user cancels in wallet.
+   *
+   * @example
+   * ```ts
+   * const { hash, intentHash } = await client.signalIntent({
+   *   deposit: { escrow: '0x...', localId: 1n },
+   *   paymentMethod: providerKeyToContractId('venmo'),
+   *   tokenAmount: 100_000000n,
+   *   toAddress: wallet.address,
+   *   fiatCurrencyCode: tickerToContractId('USD'),
+   *   conversionRate: 1_000000000000000000n,
+   * })
+   * ```
+   */
+  async signalIntent(params) {
+    const wallet = this.requireWallet();
+    const orchestrator = await this.getOrchestratorAddress();
+    const indexer = this.requireIndexer();
+    const payeeDetailsHash = await indexer.getPayeeDetailsHash({
+      escrow: params.deposit.escrow,
+      localId: params.deposit.localId,
+      chainId: this.chainId,
+      paymentMethodId: params.paymentMethod
+    });
+    if (!payeeDetailsHash) {
+      throw new ProveXError("VALIDATION_ERROR", "No payee details found for this deposit and payment method.");
+    }
+    const gatingResponse = await this.requestGatingSignature({
+      processorName: params.subProvider ?? "",
+      depositId: params.deposit.localId.toString(),
+      amount: params.tokenAmount.toString(),
+      payeeDetails: payeeDetailsHash,
+      toAddress: params.toAddress,
+      paymentMethod: params.paymentMethod,
+      fiatCurrency: params.fiatCurrencyCode,
+      conversionRate: params.conversionRate.toString(),
+      chainId: this.chainId.toString(),
+      orchestratorAddress: orchestrator,
+      escrowAddress: params.deposit.escrow
+    });
+    const rawParams = {
+      escrow: params.deposit.escrow,
+      depositId: params.deposit.localId,
+      amount: params.tokenAmount,
+      to: params.toAddress,
+      paymentMethod: params.paymentMethod,
+      fiatCurrency: params.fiatCurrencyCode,
+      conversionRate: params.conversionRate,
+      referrer: viem.zeroAddress,
+      referrerFee: 0n,
+      gatingServiceSignature: gatingResponse.signature,
+      signatureExpiration: gatingResponse.expiration,
+      postIntentHook: viem.zeroAddress,
+      data: "0x"
+    };
+    const publicClient2 = this.getPublicClient();
+    try {
+      await publicClient2.simulateContract({
+        address: orchestrator,
+        abi: abis.OrchestratorAbi,
+        functionName: "signalIntent",
+        args: [rawParams],
+        account: params.toAddress
+      });
+    } catch (simError) {
+      throw new ProveXError("CONTRACT_ERROR", simError.message ?? "Signal intent simulation failed", simError);
+    }
+    const gasInputs = await getTransactionGasInputs(this.chainId);
+    const txData = viem.encodeFunctionData({
+      abi: abis.OrchestratorAbi,
+      functionName: "signalIntent",
+      args: [rawParams]
+    });
+    let txHash;
+    try {
+      txHash = await wallet.sendTransaction({
+        to: orchestrator,
+        data: txData,
+        chainId: this.chainId,
+        ...gasInputs
+      });
+    } catch (err) {
+      if (isUserRejectionError(err)) {
+        throw new ProveXError("WALLET_REJECTED", "Transaction was rejected in wallet.", err);
+      }
+      throw new ProveXError("CONTRACT_ERROR", err.message ?? "Transaction failed", err);
+    }
+    this.onTransactionHash?.(txHash);
+    const receipt = await publicClient2.waitForTransactionReceipt({ hash: txHash });
+    let intentHash = null;
+    for (const log of receipt.logs) {
+      try {
+        const decoded = viem.decodeEventLog({
+          abi: abis.OrchestratorAbi,
+          data: log.data,
+          topics: log.topics
+        });
+        if (decoded.eventName === "IntentSignaled") {
+          intentHash = decoded.args.intentHash;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!intentHash) {
+      throw new ProveXError("CONTRACT_ERROR", "Transaction succeeded but IntentSignaled event not found in receipt.");
+    }
+    if (this.indexer) {
+      await checkTransactionIndexed({
+        queryTransaction: this.indexer.getTransactionByHash,
+        hash: txHash,
+        onSlowSync: this.onSlowSync
+      });
+    }
+    return { hash: txHash, receipt, intentHash };
+  }
+  /**
+   * Request a gating service signature for intent signaling.
+   * The gating service validates the intent and returns a signature
+   * the Orchestrator contract verifies on-chain.
+   */
+  async requestGatingSignature(params) {
+    const res = await this.apiPost("/api/v0/attestation/verify/intent", params);
+    if (!res.success) {
+      throw new ProveXError("API_ERROR", res.message ?? "Gating service rejected the intent.");
+    }
+    const signature = res.responseObject.intentData?.gatingServiceSignature ?? res.responseObject.signedIntent;
+    if (!signature) {
+      throw new ProveXError("API_ERROR", "No signature received from gating service.");
+    }
+    const expiration = res.responseObject.signatureExpiration ? BigInt(res.responseObject.signatureExpiration) : BigInt(Math.floor(Date.now() / 1e3) + 3600);
+    return { signature, expiration };
+  }
+  // ─── ERC20 ───────────────────────────────────────────────────────────────
+  approve;
+  // ─── API Methods (Maker Registration, Attestation) ──────────────────────
+  /** Get payee details for a provider and user ID. */
+  async getPayeeInfo(params) {
+    try {
+      const res = await fetch(`${this.apiUrl}/api/v0/makers/${params.provider}/${params.userId}`);
+      if (!res.ok) return null;
+      const json = await res.json();
+      return json.responseObject ?? null;
+    } catch {
+      return null;
+    }
+  }
+  /** Validate a maker's payment identity before registration. */
+  async validateMaker(params) {
+    const res = await this.apiPost("/api/v0/makers/validate", {
+      processorName: params.providerKey,
+      depositData: {
+        [params.providerKey]: params.providerId,
+        telegramUsername: params.telegramHandle ?? ""
+      }
+    });
+    return res.responseObject ?? false;
+  }
+  /** Register a maker's payment identity (e.g., Venmo username). Required before creating deposits. */
+  async registerMaker(params) {
+    const res = await this.apiPost("/api/v0/makers/create", {
+      processorName: params.providerKey,
+      depositData: {
+        [params.providerKey]: params.providerId,
+        telegramUsername: params.telegramHandle ?? ""
+      }
+    });
+    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.message) errorMessage = errorJson.message;
+      } 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}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new ProveXError("API_ERROR", `API request failed: ${res.status}`);
+    }
+    return await res.json();
+  }
+  // ─── Indexer Sync ────────────────────────────────────────────────────────
+  async waitForTransactionIndexed(hash) {
+    const indexer = this.requireIndexer();
+    await checkTransactionIndexed({
+      queryTransaction: indexer.getTransactionByHash,
+      hash,
+      onSlowSync: this.onSlowSync
+    });
+  }
+  // ─── Internal Helpers ────────────────────────────────────────────────────
+  /** Get or create a viem PublicClient for this chain. Cached after first use. */
+  getPublicClient() {
+    if (!this._publicClient) {
+      this._publicClient = viem.createPublicClient({ chain: this.chain, transport: viem.http() });
+    }
+    return this._publicClient;
+  }
+  /** Read from a contract using wallet adapter or public RPC. */
+  async readContract(params) {
+    if (this.wallet?.readContract) {
+      return this.wallet.readContract({ ...params, chainId: this.chainId });
+    }
+    return this.getPublicClient().readContract(params);
+  }
+  /** Require a connected wallet, or throw. */
+  requireWallet() {
+    if (!this.wallet) throw new ProveXError("WALLET_NOT_CONNECTED", "No wallet adapter provided. Pass `wallet` to createProveXClient().");
+    if (!this.wallet.address) throw new ProveXError("WALLET_NOT_CONNECTED", "Wallet is not connected.");
+    return this.wallet;
+  }
+  /**
+   * Build a WritableMethod from an ABI definition.
+   * The returned function supports both execute (full lifecycle) and .prepare() (unsigned tx).
+   */
+  buildWritableMethod({
+    abi,
+    contractResolver,
+    functionName,
+    argsMapper
+  }) {
+    const prepare = async (params) => {
+      const to = await contractResolver(params);
+      const args = argsMapper(params);
+      const data = viem.encodeFunctionData({
+        abi,
+        functionName,
+        args
+      });
+      return { to, data, value: 0n, chainId: this.chainId };
+    };
+    const execute = async (params) => {
+      const wallet = this.requireWallet();
+      const prepared = await prepare(params);
+      const gasInputs = await getTransactionGasInputs(this.chainId);
+      let hash;
+      try {
+        hash = await wallet.sendTransaction({ ...prepared, ...gasInputs });
+      } catch (err) {
+        if (isUserRejectionError(err)) {
+          throw new ProveXError("WALLET_REJECTED", "Transaction was rejected in wallet.", err);
+        }
+        throw new ProveXError("CONTRACT_ERROR", err.message ?? "Transaction failed", err);
+      }
+      this.onTransactionHash?.(hash);
+      const receipt = await this.getPublicClient().waitForTransactionReceipt({ hash });
+      if (this.indexer) {
+        await checkTransactionIndexed({
+          queryTransaction: this.indexer.getTransactionByHash,
+          hash,
+          onSlowSync: this.onSlowSync
+        });
+      }
+      return { hash, receipt };
+    };
+    execute.prepare = prepare;
+    return execute;
+  }
+};
+function createProveXClient(config) {
+  return new ProveXClient(config);
+}
+
+// src/hooks/useSignalIntent.ts
+var ERROR_PATTERNS2 = [
+  { 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." },
+  { pattern: /execution reverted/i, message: "Transaction failed on-chain. The order may no longer be available." },
+  { pattern: /insufficient funds/i, message: "Insufficient funds for gas fees." },
+  { pattern: /timeout|etimedout/i, message: "Request timed out. Please try again." }
+];
+function getUserFriendlyErrorMessage2(error) {
+  const raw = error instanceof Error ? error.message : String(error);
+  for (const { pattern, message } of ERROR_PATTERNS2) {
+    if (pattern.test(raw)) return message;
+  }
+  return "Something went wrong. Please try again.";
+}
+function useSignalIntent({
+  wallet,
+  onSuccess,
+  onFailure,
+  deposit,
+  refetchDeposits
+}) {
+  const provex = useOptionalProvex();
+  const [status, setStatus] = react.useState("input");
+  const [message, setMessage] = react.useState(null);
+  const client = react.useMemo(() => {
+    if (!provex) return null;
+    return createProveXClient({
+      chain: provex.config.chain,
+      apiUrl: provex.config.apiUrl,
+      wallet,
+      indexer: provex.indexer
+    });
+  }, [provex, wallet]);
+  const isLoading = react.useMemo(() => {
+    return status === "loading_payee" || status === "loading_intent" || status === "prompt_wallet_confirm" || status === "writing_intent";
+  }, [status]);
+  const startOrder = react.useCallback(async ({
+    paymentMethod,
+    depositId,
+    tokenAmount,
+    toAddress,
+    fiatCurrencyCode,
+    conversionRate,
+    subProvider
+  }) => {
+    if (!client || !deposit) {
+      setStatus("error");
+      setMessage("Client or deposit not available");
+      return;
+    }
+    const escrow = deposit.escrow;
+    if (!escrow) {
+      setStatus("error");
+      setMessage("No escrow address found");
+      return;
+    }
+    setStatus("loading_intent");
+    try {
+      const result = await client.signalIntent({
+        deposit: { escrow, localId: deposit.localId ?? depositId },
+        paymentMethod,
+        tokenAmount,
+        toAddress,
+        fiatCurrencyCode,
+        conversionRate,
+        subProvider
+      });
+      setStatus("success");
+      setMessage("Intent signaled successfully");
+      onSuccess(result.intentHash);
+    } catch (error) {
+      if (error instanceof ProveXError && error.isRejection) {
+        setStatus("input");
+        setMessage(null);
+        return;
+      }
+      console.error("Failed to signal intent", error);
+      setStatus("error");
+      setMessage(getUserFriendlyErrorMessage2(error));
+      refetchDeposits?.();
+      onFailure?.();
+    }
+  }, [client, deposit, onSuccess, onFailure, refetchDeposits]);
+  return {
+    startOrder,
+    status,
+    message,
+    isLoading
+  };
+}
+function useReputation({
+  address,
+  chainId
+}) {
+  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"],
+    queryFn: async () => {
+      if (!address) return null;
+      return indexer.getUserReputation({
+        address,
+        chainId: isBase ? chains.base.id : void 0
+      });
+    },
+    enabled: !!address,
+    staleTime: 6e4,
+    refetchInterval: 12e4
+  });
+  const reputation$1 = react.useMemo(() => {
+    const data = reputationQuery.data;
+    if (!data) return reputation.DEFAULT_REPUTATION;
+    let tier = reputation.getTierFromVolume(data.fulfilledVolumeUsdc);
+    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,
+      fulfilledVolumeUsdc: data.fulfilledVolumeUsdc,
+      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]);
+  return {
+    reputation: reputation$1,
+    isLoading,
+    error: reputationQuery.error,
+    refetch
+  };
+}
+function getTierDisplayInfo(tier) {
+  const config = reputation.TAKER_TIERS[tier];
+  const colors = {
+    [payment.tiers.PEASANT]: "gray",
+    [payment.tiers.NEUTRAL]: "blue",
+    [payment.tiers.PLUS]: "green",
+    [payment.tiers.PRO]: "purple",
+    [payment.tiers.PLATINUM]: "yellow",
+    [payment.tiers.PRESIDENT]: "cyan"
+  };
+  return {
+    name: config.name,
+    baseCap: config.baseCap,
+    cooldownHours: config.cooldownHours,
+    color: colors[tier],
+    volumeRangeDisplay: reputation.getVolumeRangeDisplay(tier)
+  };
+}
+function useReputationLimits({
+  chainId,
+  selectedPaymentMethod,
+  tier,
+  amountInInt,
+  cooldownEndsAt
+}) {
+  const hasLimits = true;
+  const { cooldownRemaining, isOnCooldown } = react.useMemo(() => {
+    const providerCooldownHours = reputation.getCooldownHours({ tier, providerKey: selectedPaymentMethod }) ;
+    const providerHasCooldown = providerCooldownHours > 0;
+    if (!cooldownEndsAt || !providerHasCooldown) {
+      return { cooldownRemaining: null, isOnCooldown: false };
+    }
+    const remainingMs = cooldownEndsAt.getTime() - Date.now();
+    if (remainingMs <= 0) {
+      return { cooldownRemaining: null, isOnCooldown: false };
+    }
+    const hours = Math.floor(remainingMs / (1e3 * 60 * 60));
+    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]);
+  const noCooldownProviders = react.useMemo(() => {
+    const available = payment.verifiablePaymentMethods(chainId);
+    return available.filter((key) => {
+      if (key === selectedPaymentMethod) return false;
+      const platformRisk = payment.getPlatformRisk(chainId, key);
+      if (!platformRisk.hasCooldown) return false;
+      return reputation.getCooldownHours({ tier, providerKey: key }) === 0;
+    });
+  }, [hasLimits, chainId, selectedPaymentMethod, tier]);
+  const selectedProviderCooldownHours = react.useMemo(() => {
+    return reputation.getCooldownHours({ tier, providerKey: selectedPaymentMethod });
+  }, [hasLimits, tier, selectedPaymentMethod]);
+  const effectiveCap = react.useMemo(() => {
+    return reputation.getEffectiveCap({ tier, providerKey: selectedPaymentMethod });
+  }, [hasLimits, tier, selectedPaymentMethod]);
+  const amountExceedsCap = react.useMemo(() => {
+    if (effectiveCap === null) return false;
+    if (!amountInInt) return false;
+    const amountUsd = Number(amountInInt) / 1e6;
+    return amountUsd > effectiveCap;
+  }, [effectiveCap, amountInInt]);
+  const capExceededMessage = react.useMemo(() => {
+    if (!amountExceedsCap || effectiveCap === null) return null;
+    const providerName = payment.providerConfigs(chainId)[selectedPaymentMethod]?.name ?? selectedPaymentMethod;
+    return `Amount exceeds your $${effectiveCap.toLocaleString()} limit for ${providerName}`;
+  }, [amountExceedsCap, effectiveCap, chainId, selectedPaymentMethod]);
+  return {
+    hasLimits,
+    noCooldownProviders,
+    selectedProviderCooldownHours,
+    cooldownRemaining,
+    isOnCooldown,
+    effectiveCap,
+    amountExceedsCap,
+    capExceededMessage
+  };
+}
+var intentStatuses = {
+  pending: "pending",
+  signalled: "signalled",
+  fulfilled: "fulfilled",
+  pruned: "pruned"
+};
+function usePayeeDetails({
+  intentHash,
+  chainId
+}) {
+  const { indexer, apiClient } = useProvex();
+  const queryClient = reactQuery.useQueryClient();
+  const intentQuery = reactQuery.useQuery({
+    queryKey: ["provex", "intent", intentHash, chainId],
+    queryFn: () => indexer.getIntent({ intentHash, chainId }),
+    enabled: !!intentHash,
+    staleTime: Infinity,
+    refetchInterval: false
+  });
+  const indexedIntent = intentQuery.data ?? null;
+  const intentStatus = react.useMemo(() => {
+    if (!indexedIntent) return null;
+    return indexedIntent.status;
+  }, [indexedIntent]);
+  const intent = react.useMemo(() => {
+    if (!indexedIntent) return null;
+    return {
+      owner: indexedIntent.ownerAddress,
+      to: indexedIntent.toAddress,
+      escrow: indexedIntent.escrow,
+      depositId: indexedIntent.depositLocalId,
+      amount: indexedIntent.amount,
+      timestamp: indexedIntent.timestamp,
+      paymentMethod: indexedIntent.paymentMethodId,
+      fiatCurrency: indexedIntent.fiatCurrency,
+      conversionRate: indexedIntent.conversionRate
+    };
+  }, [indexedIntent]);
+  const expiryTime = indexedIntent?.expiryTime ?? null;
+  const depositQuery = reactQuery.useQuery({
+    queryKey: ["provex", "deposit", indexedIntent?.escrow, indexedIntent?.depositLocalId, chainId],
+    queryFn: () => indexer.getDepositWithVerifiers({
+      escrow: indexedIntent.escrow,
+      localId: indexedIntent.depositLocalId,
+      chainId
+    }),
+    enabled: !!indexedIntent,
+    staleTime: Infinity
+  });
+  const deposit = depositQuery.data ?? null;
+  const providerKey = react.useMemo(() => {
+    if (!deposit || !indexedIntent) return null;
+    return payment.verifierGetsKey(deposit.chainId, indexedIntent.paymentMethodId);
+  }, [deposit, indexedIntent]);
+  const userId = react.useMemo(() => {
+    if (!deposit || !providerKey) return null;
+    const verifier = deposit.verifiers.find(
+      (v) => payment.verifierGetsKey(deposit.chainId, v.paymentMethodId) === providerKey
+    );
+    return verifier?.payeeDetailsHash ?? null;
+  }, [deposit, providerKey]);
+  const apiProviderKey = react.useMemo(() => {
+    if (!providerKey) return null;
+    if (payment.isSubProviderKey(providerKey)) {
+      return payment.getParentProviderKey(providerKey);
+    }
+    return providerKey;
+  }, [providerKey]);
+  const payeeDetailsQuery = reactQuery.useQuery({
+    queryKey: ["provex", "payeeDetails", apiProviderKey, userId],
+    queryFn: async () => {
+      if (!userId || !apiProviderKey) return null;
+      try {
+        const response = await apiClient.get(
+          `/api/v1/makers/${apiProviderKey}/${userId}`
+        );
+        return response.responseObject ?? null;
+      } catch {
+        return null;
+      }
+    },
+    enabled: !!userId && !!apiProviderKey,
+    staleTime: Infinity,
+    retry: false
+  });
+  const payeeDetails = payeeDetailsQuery.data ?? null;
+  const isFetching = intentQuery.isFetching || depositQuery.isFetching;
+  const refetch = react.useCallback(() => {
+    queryClient.invalidateQueries({ queryKey: ["provex", "intent", intentHash] });
+  }, [queryClient, intentHash]);
+  const refetchAll = react.useCallback(async () => {
+    const [intentResult] = await Promise.all([
+      intentQuery.refetch(),
+      depositQuery.refetch(),
+      payeeDetailsQuery.refetch()
+    ]);
+    const updated = intentResult.data;
+    if (!updated) return null;
+    return updated.status;
+  }, [intentQuery, depositQuery, payeeDetailsQuery]);
+  return react.useMemo(() => ({
+    intentStatus,
+    isFetching,
+    isValid: !!intent,
+    intent,
+    providerKey,
+    userId,
+    payeeDetails,
+    deposit,
+    expiryTime,
+    isV2Intent: false,
+    // Adapter only returns V3 intents
+    isPruned: indexedIntent?.status === "pruned",
+    prunedAt: indexedIntent?.prunedAt ?? null,
+    isFulfilled: indexedIntent?.status === "fulfilled",
+    refetch,
+    refetchAll
+  }), [
+    intentStatus,
+    isFetching,
+    intent,
+    providerKey,
+    userId,
+    payeeDetails,
+    deposit,
+    expiryTime,
+    indexedIntent,
+    refetch,
+    refetchAll
+  ]);
+}
+var FEE_CACHE_STALE_TIME = 60 * 60 * 1e3;
+function useProtocolFees({
+  chainId,
+  escrowAddress,
+  enabled = true
+}) {
+  const {
+    data: orchestratorAddress,
+    isLoading: isLoadingOrchestrator,
+    isError: isErrorOrchestrator,
+    error: errorOrchestrator,
+    refetch: refetchOrchestrator
+  } = wagmi.useReadContract({
+    address: escrowAddress,
+    abi: abis.V3EscrowAbi,
+    functionName: "orchestrator",
+    chainId,
+    query: {
+      enabled,
+      staleTime: FEE_CACHE_STALE_TIME,
+      gcTime: FEE_CACHE_STALE_TIME
+    }
+  });
+  const {
+    data: feeData,
+    isLoading: isLoadingFees,
+    isError: isErrorFees,
+    error: errorFees,
+    refetch: refetchFees
+  } = wagmi.useReadContracts({
+    contracts: [
+      {
+        address: orchestratorAddress,
+        abi: abis.OrchestratorAbi,
+        functionName: "protocolFee",
+        chainId
+      },
+      {
+        address: orchestratorAddress,
+        abi: abis.OrchestratorAbi,
+        functionName: "protocolFeeRecipient",
+        chainId
+      }
+    ],
+    query: {
+      enabled: enabled && !!orchestratorAddress,
+      staleTime: FEE_CACHE_STALE_TIME,
+      gcTime: FEE_CACHE_STALE_TIME
+    }
+  });
+  const protocolFeeRaw = feeData?.[0]?.result;
+  const protocolFeeRecipient = feeData?.[1]?.result;
+  const feeInfo = react.useMemo(() => {
+    if (protocolFeeRaw === void 0) return void 0;
+    return fees.normalizeFeePrecision(protocolFeeRaw);
+  }, [protocolFeeRaw]);
+  const isFeeQueryPending = !!orchestratorAddress && protocolFeeRaw === void 0 && !isErrorFees;
+  const isLoading = isLoadingOrchestrator || isLoadingFees || isFeeQueryPending;
+  const isError = isErrorOrchestrator || isErrorFees;
+  const error = errorOrchestrator || errorFees || null;
+  const refetch = () => {
+    refetchOrchestrator();
+    refetchFees();
+  };
+  return {
+    protocolFeeRaw,
+    feeInfo,
+    protocolFeeRecipient,
+    orchestratorAddress,
+    isLoading,
+    isError,
+    error,
+    refetch
+  };
+}
+function useProtocolFeePercentage(params) {
+  const { feeInfo } = useProtocolFees(params);
+  return feeInfo?.percentage;
+}
+
+// src/useProvexBuy.ts
+function parseAmountSafe(value, decimals) {
+  if (!value || value === "." || value === "0.") return null;
+  try {
+    const parsed = units.parseUnits(value, { decimals });
+    return parsed > 0n ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function useProvexBuy({
+  wallet,
+  onIntentSignaled,
+  onComplete,
+  paymentMethods: allowedPaymentMethods
+}) {
+  const { config } = useProvex();
+  const [phase, setPhase] = react.useState("browse");
+  const [amount, setAmountRaw] = react.useState("");
+  const [selectedPaymentMethod, setSelectedPaymentMethod] = react.useState("");
+  const [selectedDeposit, setSelectedDeposit] = react.useState(null);
+  const [intentHash, setIntentHash] = react.useState(null);
+  const [errorMessage, setErrorMessage] = react.useState(null);
+  const chainId = config.chain?.id ?? config.chainId;
+  const token = react.useMemo(() => tokens.getDefaultToken(chainId), [chainId]);
+  const currency = currencies.SUPPORTED_CURRENCIES.USD;
+  const availablePaymentMethods = react.useMemo(() => {
+    const all = payment.verifiablePaymentMethods(chainId);
+    if (!allowedPaymentMethods || allowedPaymentMethods.length === 0) return all;
+    return all.filter((pm) => allowedPaymentMethods.includes(pm));
+  }, [chainId, allowedPaymentMethods]);
+  const activePaymentMethod = react.useMemo(() => {
+    if (selectedPaymentMethod) return selectedPaymentMethod;
+    return availablePaymentMethods[0] ?? null;
+  }, [selectedPaymentMethod, availablePaymentMethods]);
+  const depositsResult = useDeposits({
+    token,
+    paymentMethod: activePaymentMethod,
+    currency
+  });
+  const { reputation: reputation$1 } = useReputation({
+    address: wallet.address,
+    chainId
+  });
+  const amountBigInt = react.useMemo(
+    () => parseAmountSafe(amount, currency.decimals),
+    [amount, currency.decimals]
+  );
+  const limits = useReputationLimits({
+    chainId,
+    selectedPaymentMethod: activePaymentMethod,
+    tier: reputation$1.tier,
+    amountInInt: amountBigInt,
+    cooldownEndsAt: reputation$1.cooldownEndsAt
+  });
+  const signalIntent = useSignalIntent({
+    wallet,
+    chainId,
+    deposit: selectedDeposit,
+    onSuccess: (hash) => {
+      setIntentHash(hash);
+      setPhase("committed");
+      onIntentSignaled?.(hash, chainId);
+    },
+    onFailure: () => {
+      setErrorMessage("Order failed. Please try again.");
+    },
+    refetchDeposits: depositsResult.refetch
+  });
+  const escrowAddress = react.useMemo(
+    () => contracts.getLatestContract(chainId, "escrow"),
+    [chainId]
+  );
+  const { feeInfo } = useProtocolFees({
+    chainId,
+    escrowAddress: escrowAddress ?? "0x",
+    enabled: !!escrowAddress
+  });
+  const payeeResult = usePayeeDetails({
+    intentHash,
+    chainId
+  });
+  const refetchAllRef = react.useRef(payeeResult.refetchAll);
+  refetchAllRef.current = payeeResult.refetchAll;
+  react.useEffect(() => {
+    if (phase !== "committed" && phase !== "proving") return;
+    if (!intentHash) return;
+    const interval = setInterval(() => {
+      refetchAllRef.current();
+    }, 5e3);
+    return () => clearInterval(interval);
+  }, [phase, intentHash]);
+  react.useEffect(() => {
+    if (!payeeResult.isFulfilled) return;
+    if (phase === "complete") return;
+    setPhase("complete");
+    if (intentHash) onComplete?.(intentHash, chainId);
+  }, [payeeResult.isFulfilled, phase, intentHash, chainId, onComplete]);
+  react.useEffect(() => {
+    if (!payeeResult.isPruned) return;
+    if (phase === "browse") return;
+    setErrorMessage("Order expired. Please try again.");
+    setPhase("browse");
+  }, [payeeResult.isPruned, phase]);
+  const intentExpiryTime = react.useMemo(() => {
+    if (!payeeResult.expiryTime) return null;
+    return new Date(Number(payeeResult.expiryTime) * 1e3);
+  }, [payeeResult.expiryTime]);
+  const matchableDeposits = react.useMemo(() => {
+    if (!amountBigInt) return [];
+    return depositsResult.getMatchableDeposits(amountBigInt);
+  }, [amountBigInt, depositsResult]);
+  const bestDeposit = matchableDeposits[0] ?? null;
+  const bestRate = react.useMemo(() => {
+    if (!bestDeposit || !activePaymentMethod) return null;
+    const r = getRate({ deposit: bestDeposit, paymentMethod: activePaymentMethod, currency });
+    return r === 0n ? null : r;
+  }, [bestDeposit, activePaymentMethod, currency]);
+  const tokenAmount = react.useMemo(() => {
+    if (!amountBigInt || !bestRate || !token) return null;
+    return conversionRates.convertCurrencyToTokenOutput({
+      token,
+      currency,
+      currencyAmountInt: amountBigInt,
+      rate: bestRate
+    });
+  }, [amountBigInt, bestRate, token, currency]);
+  const rateDisplay = react.useMemo(() => {
+    if (!bestRate || !token) return null;
+    const rateFloat = Number(bestRate) / 1e18;
+    return `1 ${token.symbol} = ${currency.symbol}${rateFloat.toFixed(currency.decimals)}`;
+  }, [bestRate, token, currency]);
+  const tokenAmountDisplay = react.useMemo(() => {
+    if (!tokenAmount || !token) return null;
+    return units.formatUnits(tokenAmount, { decimals: token.decimals });
+  }, [tokenAmount, token]);
+  const canSubmit = react.useMemo(() => {
+    if (!wallet.address) return false;
+    if (!activePaymentMethod) return false;
+    if (!amountBigInt || amountBigInt <= 0n) return false;
+    if (!bestDeposit) return false;
+    if (limits.isOnCooldown) return false;
+    if (limits.amountExceedsCap) return false;
+    if (signalIntent.isLoading) return false;
+    return true;
+  }, [wallet.address, activePaymentMethod, amountBigInt, bestDeposit, limits, signalIntent.isLoading]);
+  const validationMessage = react.useMemo(() => {
+    if (!wallet.address) return "Connect your wallet to continue";
+    if (!activePaymentMethod) return "Select a payment method";
+    if (!amount) return null;
+    if (!amountBigInt || amountBigInt <= 0n) return "Enter a valid amount";
+    if (limits.isOnCooldown && limits.cooldownRemaining) {
+      return `Cooldown active: ${limits.cooldownRemaining} remaining`;
+    }
+    if (limits.capExceededMessage) return limits.capExceededMessage;
+    if (depositsResult.isLoading) return "Loading available orders...";
+    if (!bestDeposit && amount) return "No orders available for this amount";
+    return null;
+  }, [wallet.address, activePaymentMethod, amount, amountBigInt, limits, depositsResult.isLoading, bestDeposit]);
+  const setAmount = react.useCallback((value) => {
+    if (value === "" || /^\d*\.?\d*$/.test(value)) {
+      setAmountRaw(value);
+      setErrorMessage(null);
+    }
+  }, []);
+  const selectDeposit = react.useCallback((deposit) => {
+    setSelectedDeposit(deposit);
+  }, []);
+  const submitOrder = react.useCallback(async () => {
+    if (!canSubmit || !bestDeposit || !tokenAmount || !activePaymentMethod || !wallet.address) return;
+    setSelectedDeposit(bestDeposit);
+    setErrorMessage(null);
+    const paymentMethodContractId = payment.providerKeyToContractId(activePaymentMethod);
+    await signalIntent.startOrder({
+      paymentMethod: paymentMethodContractId,
+      depositId: bestDeposit.localId,
+      tokenAmount,
+      toAddress: wallet.address,
+      fiatCurrencyCode: currency.contractId,
+      conversionRate: bestRate
+    });
+  }, [canSubmit, bestDeposit, tokenAmount, activePaymentMethod, wallet.address, signalIntent, currency.contractId, bestRate]);
+  const confirmPayment = react.useCallback(() => {
+    setPhase("proving");
+  }, []);
+  const reset = react.useCallback(() => {
+    setPhase("browse");
+    setAmountRaw("");
+    setSelectedPaymentMethod("");
+    setSelectedDeposit(null);
+    setIntentHash(null);
+    setErrorMessage(null);
+  }, []);
+  return {
+    phase,
+    amount,
+    setAmount,
+    selectedPaymentMethod,
+    setSelectedPaymentMethod,
+    availablePaymentMethods,
+    deposits: depositsResult.deposits,
+    selectedDeposit,
+    selectDeposit,
+    isLoadingDeposits: depositsResult.isLoading,
+    rate: bestRate,
+    rateDisplay,
+    tokenAmount,
+    tokenAmountDisplay,
+    token,
+    currency,
+    reputation: reputation$1 ?? reputation.DEFAULT_REPUTATION,
+    limits,
+    feePercentage: feeInfo?.percentage ?? null,
+    payeeDetails: payeeResult.payeeDetails,
+    payeeName: payeeResult.payeeDetails?.name ?? null,
+    payeeId: payeeResult.payeeDetails?.payeeId ?? null,
+    isPayeeLoading: payeeResult.isFetching,
+    intentExpiryTime,
+    isIntentExpired: payeeResult.isPruned,
+    indexedIntentStatus: payeeResult.intentStatus,
+    canSubmit,
+    validationMessage,
+    submitOrder,
+    confirmPayment,
+    reset,
+    intentHash,
+    intentStatus: signalIntent.status,
+    intentError: errorMessage ?? signalIntent.message,
+    isSubmitting: signalIntent.isLoading,
+    chainId
+  };
+}
+var ProvexBuyContext = react.createContext(null);
+function useProvexBuyContext() {
+  const ctx = react.useContext(ProvexBuyContext);
+  if (!ctx) {
+    throw new Error(
+      "useProvexBuyContext must be used within a <ProvexBuyProvider>. Wrap your component tree with <ProvexBuyProvider> or use useProvexBuy() directly."
+    );
+  }
+  return ctx;
+}
+function ProvexBuyProvider({
+  children,
+  ...options
+}) {
+  const buy = useProvexBuy(options);
+  return /* @__PURE__ */ jsxRuntime.jsx(ProvexBuyContext.Provider, { value: buy, children });
+}
+var STATUS_MESSAGES = {
+  input: "",
+  loading_payee: "Loading payment details...",
+  loading_intent: "Requesting signature...",
+  loading_orchestrator: "Loading orchestrator...",
+  prompt_wallet_confirm: "Confirm in your wallet...",
+  writing_intent: "Submitting transaction...",
+  success: "Order placed successfully!",
+  error: "Something went wrong."
+};
+function BrowsePhase({
+  className,
+  style,
+  render
+}) {
+  const ctx = useProvexBuyContext();
+  if (ctx.phase !== "browse") return null;
+  const state = {
+    amount: ctx.amount,
+    setAmount: ctx.setAmount,
+    selectedPaymentMethod: ctx.selectedPaymentMethod,
+    setSelectedPaymentMethod: ctx.setSelectedPaymentMethod,
+    availablePaymentMethods: ctx.availablePaymentMethods,
+    chainId: ctx.chainId,
+    rateDisplay: ctx.rateDisplay,
+    tokenAmountDisplay: ctx.tokenAmountDisplay,
+    token: ctx.token,
+    currency: ctx.currency,
+    canSubmit: ctx.canSubmit,
+    isSubmitting: ctx.isSubmitting,
+    validationMessage: ctx.validationMessage,
+    intentError: ctx.intentError,
+    intentStatus: ctx.intentStatus,
+    isLoadingDeposits: ctx.isLoadingDeposits,
+    deposits: ctx.deposits,
+    submitOrder: ctx.submitOrder
+  };
+  if (render) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: render(state) });
+  const tokenSymbol = ctx.token?.symbol ?? "USDC";
+  const matchCount = ctx.deposits.length;
+  const statusMessage = STATUS_MESSAGES[ctx.intentStatus] ?? "";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-provex-phase": "browse",
+      "data-provex-section": "browse",
+      className,
+      style,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-field": "payment-method", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("label", { "data-provex-label": "payment-method", htmlFor: "provex-payment-method", children: "Payment Method" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "select",
+            {
+              "data-provex-select": "payment-method",
+              id: "provex-payment-method",
+              value: ctx.selectedPaymentMethod || (ctx.availablePaymentMethods[0] ?? ""),
+              onChange: (e) => ctx.setSelectedPaymentMethod(e.target.value),
+              children: ctx.availablePaymentMethods.map((pm) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: pm, children: payment.getPaymentMethodName(ctx.chainId, pm) }, pm))
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-field": "amount", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("label", { "data-provex-label": "amount", htmlFor: "provex-amount", children: [
+            "Amount (",
+            ctx.currency?.ticker ?? "USD",
+            ")"
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-input-group": "amount", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-input-prefix": "", children: ctx.currency?.symbol ?? "$" }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                "data-provex-input": "amount",
+                id: "provex-amount",
+                type: "text",
+                inputMode: "decimal",
+                placeholder: "0.00",
+                value: ctx.amount,
+                onChange: (e) => ctx.setAmount(e.target.value),
+                autoComplete: "off"
+              }
+            )
+          ] })
+        ] }),
+        ctx.rateDisplay && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-info": "rate", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "rate", children: "Rate" }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-value": "rate", children: ctx.rateDisplay })
+        ] }),
+        ctx.tokenAmountDisplay && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-info": "receive", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "receive", children: "You receive" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-provex-value": "receive", children: [
+            ctx.tokenAmountDisplay,
+            " ",
+            tokenSymbol
+          ] })
+        ] }),
+        ctx.isLoadingDeposits && ctx.amount && /* @__PURE__ */ jsxRuntime.jsx("div", { "data-provex-info": "loading", children: /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-status": "loading", children: "Searching for orders..." }) }),
+        !ctx.isLoadingDeposits && ctx.amount && matchCount > 0 && /* @__PURE__ */ jsxRuntime.jsx("div", { "data-provex-info": "match-count", children: /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-provex-value": "match-count", children: [
+          matchCount,
+          " order",
+          matchCount !== 1 ? "s" : "",
+          " available"
+        ] }) }),
+        ctx.validationMessage && /* @__PURE__ */ jsxRuntime.jsx("p", { "data-provex-message": "validation", children: ctx.validationMessage }),
+        ctx.intentError && /* @__PURE__ */ jsxRuntime.jsx("p", { "data-provex-message": "error", children: ctx.intentError }),
+        ctx.isSubmitting && statusMessage && /* @__PURE__ */ jsxRuntime.jsx("p", { "data-provex-message": "status", children: statusMessage }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            "data-provex-button": "buy",
+            type: "button",
+            disabled: !ctx.canSubmit,
+            onClick: ctx.submitOrder,
+            children: ctx.isSubmitting ? "Processing..." : "Buy"
+          }
+        )
+      ]
+    }
+  );
+}
+function CommittedPhase({
+  className,
+  style,
+  render
+}) {
+  const ctx = useProvexBuyContext();
+  if (ctx.phase !== "committed") return null;
+  const state = {
+    intentHash: ctx.intentHash,
+    amount: ctx.amount,
+    currency: ctx.currency,
+    selectedPaymentMethod: ctx.selectedPaymentMethod,
+    chainId: ctx.chainId,
+    tokenAmountDisplay: ctx.tokenAmountDisplay,
+    token: ctx.token,
+    confirmPayment: ctx.confirmPayment,
+    payeeDetails: ctx.payeeDetails,
+    payeeName: ctx.payeeName,
+    payeeId: ctx.payeeId,
+    isPayeeLoading: ctx.isPayeeLoading,
+    intentExpiryTime: ctx.intentExpiryTime
+  };
+  if (render) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: render(state) });
+  const tokenSymbol = ctx.token?.symbol ?? "USDC";
+  const paymentName = ctx.selectedPaymentMethod ? payment.getPaymentMethodName(ctx.chainId, ctx.selectedPaymentMethod) : "Unknown";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-provex-phase": "committed",
+      "data-provex-section": "committed",
+      className,
+      style,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-info": "order-summary", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("p", { "data-provex-heading": "committed", children: "Order Placed" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-detail": "amount", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "amount", children: "Amount" }),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-provex-value": "amount", children: [
+              ctx.currency?.symbol,
+              ctx.amount
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-detail": "receive", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "receive", children: "You receive" }),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-provex-value": "receive", children: [
+              ctx.tokenAmountDisplay,
+              " ",
+              tokenSymbol
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-detail": "payment-method", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "payment-method", children: "Pay via" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-value": "payment-method", children: paymentName })
+          ] }),
+          ctx.intentHash && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-detail": "intent-hash", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "intent-hash", children: "Order ID" }),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-provex-value": "intent-hash", title: ctx.intentHash, children: [
+              ctx.intentHash.slice(0, 10),
+              "...",
+              ctx.intentHash.slice(-8)
+            ] })
+          ] })
+        ] }),
+        ctx.isPayeeLoading && /* @__PURE__ */ jsxRuntime.jsx("div", { "data-provex-info": "payee-loading", children: /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-status": "loading", children: "Loading seller details..." }) }),
+        !ctx.isPayeeLoading && ctx.payeeId && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-info": "payee", children: [
+          ctx.payeeName && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-detail": "payee-name", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "payee-name", children: "Seller" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-value": "payee-name", children: ctx.payeeName })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-detail": "payee-id", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "payee-id", children: "Send to" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-value": "payee-id", children: ctx.payeeId })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { "data-provex-info": "instructions", children: /* @__PURE__ */ jsxRuntime.jsxs("p", { "data-provex-text": "instructions", children: [
+          "Send ",
+          ctx.currency?.symbol,
+          ctx.amount,
+          " via ",
+          paymentName,
+          " to the seller, then verify your payment to release the ",
+          tokenSymbol,
+          "."
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            "data-provex-button": "prove",
+            type: "button",
+            disabled: ctx.isPayeeLoading,
+            onClick: ctx.confirmPayment,
+            children: "I have paid"
+          }
+        )
+      ]
+    }
+  );
+}
+function ProvingPhase({
+  className,
+  style,
+  render
+}) {
+  const ctx = useProvexBuyContext();
+  if (ctx.phase !== "proving") return null;
+  const state = {
+    intentHash: ctx.intentHash,
+    intentExpiryTime: ctx.intentExpiryTime,
+    isIntentExpired: ctx.isIntentExpired,
+    indexedIntentStatus: ctx.indexedIntentStatus
+  };
+  if (render) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: render(state) });
+  const statusText = ctx.indexedIntentStatus === "fulfilled" ? "Payment verified!" : "Generating zero-knowledge proof of your payment...";
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-provex-phase": "proving",
+      "data-provex-section": "proving",
+      className,
+      style,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { "data-provex-heading": "proving", children: "Verifying Payment" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { "data-provex-text": "proving", children: statusText }),
+        ctx.intentHash && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-detail": "intent-hash", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "intent-hash", children: "Order ID" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-provex-value": "intent-hash", title: ctx.intentHash, children: [
+            ctx.intentHash.slice(0, 10),
+            "...",
+            ctx.intentHash.slice(-8)
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { "data-provex-info": "status", children: /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-status": ctx.indexedIntentStatus ?? "proving", children: ctx.indexedIntentStatus === "fulfilled" ? "Complete" : "Processing..." }) })
+      ]
+    }
+  );
+}
+function CompletePhase({
+  className,
+  style,
+  render
+}) {
+  const ctx = useProvexBuyContext();
+  if (ctx.phase !== "complete") return null;
+  const state = {
+    intentHash: ctx.intentHash,
+    chainId: ctx.chainId,
+    reset: ctx.reset
+  };
+  if (render) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: render(state) });
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-provex-phase": "complete",
+      "data-provex-section": "complete",
+      className,
+      style,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { "data-provex-heading": "complete", children: "Purchase Complete" }),
+        /* @__PURE__ */ jsxRuntime.jsx("p", { "data-provex-text": "complete", children: "Your tokens have been released to your wallet." }),
+        ctx.intentHash && /* @__PURE__ */ jsxRuntime.jsxs("div", { "data-provex-detail": "intent-hash", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { "data-provex-label": "intent-hash", children: "Order ID" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { "data-provex-value": "intent-hash", title: ctx.intentHash, children: [
+            ctx.intentHash.slice(0, 10),
+            "...",
+            ctx.intentHash.slice(-8)
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            "data-provex-button": "buy-more",
+            type: "button",
+            onClick: ctx.reset,
+            children: "Buy More"
+          }
+        )
+      ]
+    }
+  );
+}
+function applyTheme(baseStyle, theme) {
+  if (!theme) return baseStyle;
+  const vars = {};
+  const themeEntries = [
+    ["accent", theme.accent],
+    ["background", theme.background],
+    ["backgroundCard", theme.backgroundCard],
+    ["text", theme.text],
+    ["textMuted", theme.textMuted],
+    ["border", theme.border],
+    ["error", theme.error],
+    ["radius", theme.radius],
+    ["font", theme.font]
+  ];
+  for (const [key, value] of themeEntries) {
+    if (value === void 0) continue;
+    const kebab = key.replace(/[A-Z]/g, (ch) => `-${ch.toLowerCase()}`);
+    vars[`--provex-${kebab}`] = value;
+  }
+  if (Object.keys(vars).length === 0) return baseStyle;
+  return { ...baseStyle, ...vars };
+}
+function ProvexBuy({
+  wallet,
+  onIntentSignaled,
+  onComplete,
+  paymentMethods,
+  className,
+  style,
+  theme
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ProvexBuyProvider,
+    {
+      wallet,
+      onIntentSignaled,
+      onComplete,
+      paymentMethods,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        ProvexBuyRoot,
+        {
+          className,
+          style: applyTheme(style, theme)
+        }
+      )
+    }
+  );
+}
+function ProvexBuyRoot({
+  className,
+  style
+}) {
+  const { phase } = useProvexBuyContext();
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className,
+      style,
+      "data-provex-root": "",
+      "data-provex-phase": phase,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(BrowsePhase, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(CommittedPhase, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(ProvingPhase, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(CompletePhase, {})
+      ]
+    }
+  );
+}
+function useWagmiWallet() {
+  const { address } = wagmi.useAccount();
+  const { data: walletClient } = wagmi.useWalletClient();
+  return react.useMemo(() => {
+    if (!walletClient || !address) return null;
+    return {
+      address,
+      async sendTransaction(tx) {
+        return walletClient.sendTransaction({
+          to: tx.to,
+          data: tx.data,
+          value: tx.value ?? 0n,
+          chain: walletClient.chain,
+          maxFeePerGas: tx.maxFeePerGas,
+          maxPriorityFeePerGas: tx.maxPriorityFeePerGas
+        });
+      }
+    };
+  }, [walletClient, address]);
+}
+var DISCONNECTED_WALLET = {
+  address: void 0,
+  sendTransaction: () => Promise.reject(new Error("Wallet not connected"))
+};
+function ProvexBuyWagmi({
+  onIntentSignaled,
+  onComplete,
+  paymentMethods,
+  className,
+  style,
+  theme
+}) {
+  const wallet = useWagmiWallet() ?? DISCONNECTED_WALLET;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ProvexBuy,
+    {
+      wallet,
+      onIntentSignaled,
+      onComplete,
+      paymentMethods,
+      className,
+      style,
+      theme
+    }
+  );
+}
+function useNullifierRegistry({
+  escrowAddress,
+  paymentMethodId,
+  chainId
+}) {
+  const publicClient2 = wagmi.usePublicClient({ chainId });
+  const { data: orchestratorAddress, isLoading: isLoadingOrchestrator } = wagmi.useReadContract({
+    address: escrowAddress,
+    abi: abis.V3EscrowAbi,
+    functionName: "orchestrator",
+    chainId,
+    query: {
+      enabled: !!escrowAddress
+    }
+  });
+  const { data: paymentVerifierRegistryAddress, isLoading: isLoadingRegistry } = wagmi.useReadContract({
+    address: orchestratorAddress,
+    abi: abis.OrchestratorAbi,
+    functionName: "paymentVerifierRegistry",
+    chainId,
+    query: {
+      enabled: !!orchestratorAddress
+    }
+  });
+  const { data: verifierAddress, isLoading: isLoadingVerifier } = wagmi.useReadContract({
+    address: paymentVerifierRegistryAddress,
+    abi: abis.PaymentVerifierRegistryAbi,
+    functionName: "getVerifier",
+    args: paymentMethodId ? [paymentMethodId] : void 0,
+    chainId,
+    query: {
+      enabled: !!paymentVerifierRegistryAddress && !!paymentMethodId
+    }
+  });
+  const { data: nullifierRegistryAddress, isLoading: isLoadingNullifierRegistry } = wagmi.useReadContract({
+    address: verifierAddress,
+    abi: abis.UnifiedPaymentVerifierAbi,
+    functionName: "nullifierRegistry",
+    chainId,
+    query: {
+      enabled: !!verifierAddress
+    }
+  });
+  const isLoading = isLoadingOrchestrator || isLoadingRegistry || isLoadingVerifier || isLoadingNullifierRegistry;
+  const checkNullifierUsed = react.useCallback(
+    async (nullifier) => {
+      if (!nullifierRegistryAddress || !publicClient2) {
+        return null;
+      }
+      try {
+        const isUsed = await publicClient2.readContract({
+          address: nullifierRegistryAddress,
+          abi: abis.NullifierRegistryAbi,
+          functionName: "isNullified",
+          args: [nullifier]
+        });
+        return isUsed;
+      } catch (error) {
+        console.error("[useNullifierRegistry] Failed to check nullifier:", error);
+        return null;
+      }
+    },
+    [nullifierRegistryAddress, publicClient2]
+  );
+  return {
+    orchestratorAddress,
+    paymentVerifierRegistryAddress,
+    verifierAddress,
+    nullifierRegistryAddress,
+    isLoading,
+    checkNullifierUsed
+  };
+}
+var useAllowance = ({
+  token,
+  spender,
+  account,
+  balance,
+  defaultAllowance = "max",
+  onSuccess,
+  onError,
+  onSettled
+}) => {
+  const targetAllowance = react.useMemo(() => {
+    if (defaultAllowance === "balance" && balance) {
+      return balance;
+    }
+    return viem.maxUint256;
+  }, [defaultAllowance, balance]);
+  const { chain: currentChain } = wagmi.useConnection();
+  const { mutateAsync: switchChainAsync } = wagmi.useSwitchChain();
+  const publicClient2 = wagmi.usePublicClient({ chainId: token.chainId });
+  const queryEnabled = !!publicClient2 && !!account && !!spender && !!token.address;
+  const { data, isLoading, error, refetch } = reactQuery.useQuery({
+    queryKey: ["allowance", token.address, spender, account, token.chainId],
+    queryFn: async () => {
+      const result = await publicClient2.readContract({
+        abi: viem.erc20Abi,
+        address: token.address,
+        functionName: "allowance",
+        args: [account, spender]
+      });
+      return result;
+    },
+    enabled: queryEnabled
+  });
+  const [approvalPhase, setApprovalPhase] = react.useState("idle");
+  const { mutateAsync } = wagmi.useWriteContract();
+  const isWritingApproval = approvalPhase !== "idle";
+  const approvalLoadingText = approvalPhase === "confirming" ? "Confirming..." : `Approve ${token.symbol}`;
+  return {
+    allowance: data ?? null,
+    isLoading,
+    isWritingApproval,
+    /** Loading text for the approval button */
+    approvalLoadingText,
+    error,
+    writeApproval: async () => {
+      if (!account || !spender || !token.address || !publicClient2) {
+        return;
+      }
+      setApprovalPhase("submitting");
+      try {
+        if (currentChain?.id !== token.chainId) {
+          await switchChainAsync({ chainId: token.chainId });
+        }
+        const gasInputs = await getTransactionGasInputs(token.chainId);
+        const hash = await mutateAsync({
+          chainId: token.chainId,
+          address: token.address,
+          abi: viem.erc20Abi,
+          functionName: "approve",
+          ...gasInputs,
+          args: [spender, targetAllowance]
+        });
+        setApprovalPhase("confirming");
+        await publicClient2.waitForTransactionReceipt({ hash });
+        await refetch();
+        onSuccess?.(hash);
+      } catch (err) {
+        onError?.(err);
+      } finally {
+        setApprovalPhase("idle");
+        onSettled?.();
+      }
+    }
+  };
+};
+var useCancelIntent = ({
+  onSuccess,
+  onMutate,
+  onError,
+  onSettled,
+  chainId,
+  escrowAddress: providedEscrowAddress,
+  version: explicitVersion
+}) => {
+  const provex = useOptionalProvex();
+  const wallet = useWagmiWallet();
+  const [status, setStatus] = react.useState("idle");
+  const [errorMessage, setErrorMessage] = react.useState(null);
+  const isLoading = react.useMemo(() => status === "prompt_wallet_confirm" || status === "writing_tx", [status]);
+  const version = react.useMemo(() => {
+    if (explicitVersion) return explicitVersion;
+    if (providedEscrowAddress) {
+      const detected = contracts.getEscrowVersion(providedEscrowAddress);
+      if (detected) return detected;
+    }
+    return "v3";
+  }, [explicitVersion, providedEscrowAddress]);
+  const escrowAddress = react.useMemo(() => {
+    if (providedEscrowAddress) return providedEscrowAddress;
+    if (!chainId) return null;
+    return contracts.getLatestContract(chainId, "escrow", version);
+  }, [providedEscrowAddress, chainId, version]);
+  const client = react.useMemo(() => {
+    if (!provex || !chainId || version !== "v3") return null;
+    return createProveXClient({
+      chain: provex.config.chain,
+      apiUrl: provex.config.apiUrl,
+      wallet: wallet ?? void 0,
+      indexer: provex.indexer,
+      escrowAddress: escrowAddress ?? void 0
+    });
+  }, [provex, chainId, version, wallet, escrowAddress]);
+  const { mutateAsync: writeContractAsync } = wagmi.useWriteContract();
+  const publicClient2 = wagmi.usePublicClient();
+  const cancelIntent = react.useCallback(async (intentHash) => {
+    if (!intentHash || !chainId) return;
+    setStatus("prompt_wallet_confirm");
+    setErrorMessage(null);
+    onMutate?.();
+    try {
+      if (version === "v3" && client) {
+        await client.cancelIntent({ intentHash });
+      } else {
+        if (!escrowAddress) throw new Error("Missing escrow address");
+        const gasInputs = await getTransactionGasInputs(chainId);
+        const hash = await writeContractAsync({
+          address: escrowAddress,
+          abi: abis.V2EscrowAbi,
+          functionName: "cancelIntent",
+          args: [intentHash],
+          ...gasInputs
+        });
+        if (publicClient2) await publicClient2.waitForTransactionReceipt({ hash });
+        if (provex?.indexer) {
+          await checkTransactionIndexed({ queryTransaction: provex.indexer.getTransactionByHash, hash });
+        }
+      }
+      setStatus("success");
+      onSuccess?.();
+    } catch (error) {
+      const isRejection = error instanceof ProveXError && error.isRejection || isUserRejectionError(error);
+      if (isRejection) {
+        setStatus("idle");
+      } else {
+        setStatus("error");
+        setErrorMessage(getUserFriendlyErrorMessage(error));
+      }
+      onError?.(error);
+    } finally {
+      onSettled?.();
+    }
+  }, [chainId, escrowAddress, version, client, publicClient2, writeContractAsync, provex, onSuccess, onMutate, onError, onSettled]);
+  return {
+    cancelIntent,
+    status,
+    isLoading,
+    version,
+    errorMessage
+  };
+};
+var useReleaseFundsToPayer = ({
+  onSuccess,
+  onSettled,
+  chainId,
+  escrowAddress: providedEscrowAddress,
+  version: explicitVersion
+}) => {
+  const provex = useOptionalProvex();
+  const wallet = useWagmiWallet();
+  const [status, setStatus] = react.useState("idle");
+  const [errorMessage, setErrorMessage] = react.useState(null);
+  const isLoading = react.useMemo(
+    () => status === "prompt_wallet_confirm" || status === "writing_tx",
+    [status]
+  );
+  const version = react.useMemo(() => {
+    if (explicitVersion) return explicitVersion;
+    if (providedEscrowAddress) {
+      const detected = contracts.getEscrowVersion(providedEscrowAddress);
+      if (detected) return detected;
+    }
+    return "v3";
+  }, [explicitVersion, providedEscrowAddress]);
+  const escrowAddress = react.useMemo(() => {
+    if (providedEscrowAddress) return providedEscrowAddress;
+    if (!chainId) return null;
+    return contracts.getLatestContract(chainId, "escrow", version);
+  }, [providedEscrowAddress, chainId, version]);
+  const client = react.useMemo(() => {
+    if (!provex || !chainId || version !== "v3") return null;
+    return createProveXClient({
+      chain: provex.config.chain,
+      apiUrl: provex.config.apiUrl,
+      wallet: wallet ?? void 0,
+      indexer: provex.indexer,
+      escrowAddress: escrowAddress ?? void 0
+    });
+  }, [provex, chainId, version, wallet, escrowAddress]);
+  const { mutateAsync: writeContractAsync } = wagmi.useWriteContract();
+  const publicClient2 = wagmi.usePublicClient();
+  const releaseFundsToPayer = react.useCallback(async (intentHash) => {
+    if (!intentHash || !chainId) return;
+    setStatus("prompt_wallet_confirm");
+    setErrorMessage(null);
+    try {
+      if (version === "v3" && client) {
+        await client.releaseFundsToPayer({ intentHash });
+      } else {
+        if (!escrowAddress) throw new Error("Missing escrow address");
+        const gasInputs = await getTransactionGasInputs(chainId);
+        const hash = await writeContractAsync({
+          address: escrowAddress,
+          abi: abis.V2EscrowAbi,
+          functionName: "releaseFundsToPayer",
+          args: [intentHash],
+          ...gasInputs
+        });
+        if (publicClient2) await publicClient2.waitForTransactionReceipt({ hash });
+        if (provex?.indexer) {
+          await checkTransactionIndexed({ queryTransaction: provex.indexer.getTransactionByHash, hash });
+        }
+      }
+      setStatus("success");
+      onSuccess?.();
+    } catch (error) {
+      const isRejection = error instanceof ProveXError && error.isRejection || isUserRejectionError(error);
+      if (isRejection) {
+        setStatus("idle");
+        setErrorMessage(null);
+      } else {
+        setStatus("error");
+        setErrorMessage(error instanceof Error ? error.message : "Transaction failed");
+      }
+    } finally {
+      onSettled?.();
+    }
+  }, [chainId, escrowAddress, version, client, publicClient2, writeContractAsync, provex, onSuccess, onSettled]);
+  return {
+    releaseFundsToPayer,
+    status,
+    isLoading,
+    errorMessage,
+    version
+  };
+};
+var useV3Escrow = ({
+  chainId,
+  escrowAddress,
+  onSlowSync,
+  onTransactionConfirmed,
+  onError
+}) => {
+  const provex = useOptionalProvex();
+  const wallet = useWagmiWallet();
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState(null);
+  const [txHash, setTxHash] = react.useState(null);
+  const escrow = react.useMemo(() => {
+    if (escrowAddress) return escrowAddress;
+    if (!chainId) return null;
+    return contracts.getLatestContract(chainId, "escrow", "v3");
+  }, [chainId, escrowAddress]);
+  const isLoading = react.useMemo(
+    () => status === "prompt_wallet_confirm" || status === "writing_tx" || status === "confirming" || status === "syncing",
+    [status]
+  );
+  const client = react.useMemo(() => {
+    if (!provex || !chainId) return null;
+    return createProveXClient({
+      chain: provex.config.chain,
+      apiUrl: provex.config.apiUrl,
+      wallet: wallet ?? void 0,
+      indexer: provex.indexer,
+      escrowAddress: escrow ?? void 0,
+      onTransactionHash: (hash) => {
+        setTxHash(hash);
+        setStatus("confirming");
+      },
+      onSlowSync: () => {
+        setStatus("syncing");
+        onSlowSync?.();
+      }
+    });
+  }, [provex, chainId, wallet, escrow, onSlowSync]);
+  const { data: orchestratorAddress, refetch: refetchOrchestrator } = wagmi.useReadContract({
+    address: escrow ?? void 0,
+    abi: abis.V3EscrowAbi,
+    functionName: "orchestrator",
+    query: { enabled: !!escrow }
+  });
+  const { data: depositCounter, refetch: refetchDepositCounter } = wagmi.useReadContract({
+    address: escrow ?? void 0,
+    abi: abis.V3EscrowAbi,
+    functionName: "depositCounter",
+    query: { enabled: !!escrow }
+  });
+  const executeClientMethod = react.useCallback(async (method, action) => {
+    if (!client || !chainId) {
+      const msg = "Client or chain not configured";
+      setError(msg);
+      onError?.(new Error(msg));
+      return null;
+    }
+    try {
+      setStatus("prompt_wallet_confirm");
+      setError(null);
+      setTxHash(null);
+      const result = await method();
+      setStatus("success");
+      onTransactionConfirmed?.({ hash: result.hash, chainId, action });
+      return result.hash;
+    } catch (err) {
+      if (err instanceof ProveXError && err.isRejection) {
+        setStatus("idle");
+        setError(null);
+        return null;
+      }
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setStatus("error");
+      setError(errorObj.message);
+      onError?.(errorObj);
+      return null;
+    }
+  }, [client, chainId, onTransactionConfirmed, onError]);
+  const createDeposit = react.useCallback(
+    (params) => executeClientMethod(() => client.createDepositRaw(params), "Deposit created"),
+    [client, executeClientMethod]
+  );
+  const addFunds = react.useCallback(
+    (depositId, amount) => executeClientMethod(() => client.addFunds({ depositId, amount }), "Funds added"),
+    [client, executeClientMethod]
+  );
+  const removeFunds = react.useCallback(
+    (depositId, amount) => executeClientMethod(() => client.removeFunds({ depositId, amount }), "Funds removed"),
+    [client, executeClientMethod]
+  );
+  const withdrawDeposit = react.useCallback(
+    (depositId) => executeClientMethod(() => client.withdrawDeposit({ depositId }), "Deposit withdrawn"),
+    [client, executeClientMethod]
+  );
+  const pruneExpiredIntents = react.useCallback(
+    (depositId) => executeClientMethod(() => client.pruneExpiredIntents({ depositId }), "Expired intents pruned"),
+    [client, executeClientMethod]
+  );
+  const setAcceptingIntents = react.useCallback(
+    (depositId, accepting) => executeClientMethod(() => client.setAcceptingIntents({ depositId, accepting }), "Deposit updated"),
+    [client, executeClientMethod]
+  );
+  const setRetainOnEmpty = react.useCallback(
+    (depositId, retain) => executeClientMethod(() => client.setRetainOnEmpty({ depositId, retain }), "Deposit updated"),
+    [client, executeClientMethod]
+  );
+  const setIntentRange = react.useCallback(
+    (depositId, intentAmountRange) => executeClientMethod(() => client.setIntentRange({ depositId, ...intentAmountRange }), "Amount range updated"),
+    [client, executeClientMethod]
+  );
+  const setPaymentMethodActive = react.useCallback(
+    (depositId, paymentMethod, active) => executeClientMethod(() => client.setPaymentMethodActive({ depositId, paymentMethod, active }), "Platform updated"),
+    [client, executeClientMethod]
+  );
+  const setCurrencyMinRate = react.useCallback(
+    (params) => executeClientMethod(() => client.setCurrencyMinRate({
+      depositId: params.depositId,
+      paymentMethod: params.paymentMethod,
+      currency: params.currency,
+      rate: params.newMinConversionRate
+    }), "Conversion rate updated"),
+    [client, executeClientMethod]
+  );
+  const addCurrencies = react.useCallback(
+    (params) => executeClientMethod(() => client.addCurrencies(params), "Currencies added"),
+    [client, executeClientMethod]
+  );
+  const deactivateCurrency = react.useCallback(
+    (params) => executeClientMethod(() => client.deactivateCurrency(params), "Currency deactivated"),
+    [client, executeClientMethod]
+  );
+  const addPaymentMethods = react.useCallback(
+    (params) => executeClientMethod(() => client.addPaymentMethods(params), "Payment method added"),
+    [client, executeClientMethod]
+  );
+  const getDeposit = react.useCallback(
+    async (depositId) => {
+      if (!client) return null;
+      try {
+        return await client.getDeposit(depositId);
+      } catch {
+        return null;
+      }
+    },
+    [client]
+  );
+  const getAccountDeposits = react.useCallback(
+    async (account) => {
+      if (!client) return [];
+      try {
+        return await client.getAccountDeposits(account);
+      } catch {
+        return [];
+      }
+    },
+    [client]
+  );
+  const reset = react.useCallback(() => {
+    setStatus("idle");
+    setError(null);
+    setTxHash(null);
+  }, []);
+  return {
+    status,
+    error,
+    isLoading,
+    escrow,
+    orchestratorAddress,
+    depositCounter,
+    txHash,
+    createDeposit,
+    addFunds,
+    removeFunds,
+    withdrawDeposit,
+    pruneExpiredIntents,
+    setAcceptingIntents,
+    setRetainOnEmpty,
+    setIntentRange,
+    setPaymentMethodActive,
+    setCurrencyMinRate,
+    addCurrencies,
+    deactivateCurrency,
+    addPaymentMethods,
+    getDeposit,
+    getAccountDeposits,
+    reset,
+    refetchOrchestrator,
+    refetchDepositCounter
+  };
+};
+var useTransactionWithIndexer = (options = {}) => {
+  const { onSuccess, onError, onSlowSync, onTransactionConfirmed, onTransactionError, indexer: indexerParam } = options;
+  const provex = useOptionalProvex();
+  const indexer = indexerParam ?? provex?.indexer;
+  const [phase, setPhase] = react.useState("idle");
+  const publicClient2 = wagmi.usePublicClient();
+  const waitForTransaction = react.useCallback(async ({
+    hash,
+    chainId,
+    action
+  }) => {
+    try {
+      setPhase("confirming");
+      await publicClient2?.waitForTransactionReceipt({ hash });
+      if (indexer) {
+        setPhase("syncing");
+        await checkTransactionIndexed({
+          queryTransaction: indexer.getTransactionByHash,
+          hash,
+          onSlowSync
+        });
+      }
+      setPhase("complete");
+      onTransactionConfirmed?.({ hash, chainId, action });
+      onSuccess?.();
+    } catch (e) {
+      setPhase("error");
+      const error = e instanceof Error ? e : new Error(String(e));
+      onTransactionError?.(getUserFriendlyErrorMessage(error));
+      onError?.(error);
+      throw e;
+    }
+  }, [publicClient2, indexer, onSuccess, onError, onSlowSync, onTransactionConfirmed, onTransactionError]);
+  const waitForMutation = react.useCallback(async ({
+    hash,
+    depositId,
+    chainId,
+    status,
+    action
+  }) => {
+    try {
+      setPhase("confirming");
+      await publicClient2?.waitForTransactionReceipt({ hash });
+      if (indexer) {
+        setPhase("syncing");
+        const escrow = contracts.getLatestContract(chainId, "escrow");
+        const depositIdHex = ids.orderId.deposit.serialize({
+          escrow,
+          depositId,
+          chainId
+        });
+        await checkMutation({
+          queryDeposit: indexer.getDepositById,
+          depositIdHex,
+          status,
+          onSlowSync
+        });
+      }
+      setPhase("complete");
+      onTransactionConfirmed?.({ hash, chainId, action });
+      onSuccess?.();
+    } catch (e) {
+      setPhase("error");
+      const error = e instanceof Error ? e : new Error(String(e));
+      onTransactionError?.(getUserFriendlyErrorMessage(error));
+      onError?.(error);
+      throw e;
+    }
+  }, [publicClient2, indexer, onSuccess, onError, onSlowSync, onTransactionConfirmed, onTransactionError]);
+  const reset = react.useCallback(() => {
+    setPhase("idle");
+  }, []);
+  const isLoading = phase === "submitting" || phase === "confirming" || phase === "syncing";
+  const loadingText = phase === "syncing" ? "Syncing..." : phase === "confirming" ? "Confirming..." : void 0;
+  return {
+    phase,
+    isLoading,
+    loadingText,
+    waitForTransaction,
+    waitForMutation,
+    reset,
+    setPhase
+  };
+};
+function useProveXClient(wallet) {
+  const { config, indexer } = useProvex();
+  return react.useMemo(
+    () => new ProveXClient({
+      chain: config.chain,
+      apiUrl: config.apiUrl,
+      wallet,
+      indexer
+    }),
+    [config.chain, config.apiUrl, wallet, indexer]
+  );
+}
+
+exports.BrowsePhase = BrowsePhase;
+exports.CommittedPhase = CommittedPhase;
+exports.CompletePhase = CompletePhase;
+exports.ProveXClient = ProveXClient;
+exports.ProveXError = ProveXError;
+exports.ProvexBuy = ProvexBuy;
+exports.ProvexBuyProvider = ProvexBuyProvider;
+exports.ProvexBuyWagmi = ProvexBuyWagmi;
+exports.ProvexProvider = ProvexProvider;
+exports.ProvingPhase = ProvingPhase;
+exports.createApiClient = createApiClient;
+exports.createProveXClient = createProveXClient;
+exports.getRate = getRate;
+exports.getTierDisplayInfo = getTierDisplayInfo;
+exports.intentStatuses = intentStatuses;
+exports.useAllowance = useAllowance;
+exports.useCancelIntent = useCancelIntent;
+exports.useDeposits = useDeposits;
+exports.useNullifierRegistry = useNullifierRegistry;
+exports.usePayeeDetails = usePayeeDetails;
+exports.useProtocolFeePercentage = useProtocolFeePercentage;
+exports.useProtocolFees = useProtocolFees;
+exports.useProveXClient = useProveXClient;
+exports.useProvex = useProvex;
+exports.useProvexBuy = useProvexBuy;
+exports.useProvexBuyContext = useProvexBuyContext;
+exports.useReleaseFundsToPayer = useReleaseFundsToPayer;
+exports.useReputation = useReputation;
+exports.useReputationLimits = useReputationLimits;
+exports.useSignalIntent = useSignalIntent;
+exports.useTransactionWithIndexer = useTransactionWithIndexer;
+exports.useV3Escrow = useV3Escrow;
+exports.useWagmiWallet = useWagmiWallet;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map