@provex/react 1.2.5 → 1.3.0

package/dist/index.js

@@ -1,2123 +1,18 @@
-import { createContext, useMemo, useContext, useCallback, useState, useRef, useEffect } from 'react';
-import { QueryClient, QueryClientProvider, useQueryClient, useQuery } from '@tanstack/react-query';
-import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
-import { providerConfigs, providerKeyToContractId, computePayeeDetailsHash, tiers, verifiablePaymentMethods, getPlatformRisk, verifierGetsKey, isSubProviderKey, getParentProviderKey, getPaymentMethodName } from '@provex/utils/payment';
-import { SUPPORTED_CURRENCIES, tickerToContractId } from '@provex/utils/currencies';
-import { getDefaultToken, publicClient } from '@provex/utils/tokens';
-import { parseUnits, formatUnits } from '@provex/utils/units';
-import { convertCurrencyToTokenOutput } from '@provex/utils/conversionRates';
-import { DEFAULT_REPUTATION, getTierFromVolume, TIER_ORDER, TAKER_TIERS, getVolumeRangeDisplay, getCooldownHours, getEffectiveCap } from '@provex/utils/reputation';
-import { getLatestContract, reclaimSigners, getEscrowVersion } from '@provex/utils/contracts';
-import { encodeAbiParameters, parseAbiParameters, zeroAddress, encodeFunctionData, decodeEventLog, createPublicClient, http, maxUint256, erc20Abi } from 'viem';
-import { normalizeFeePrecision } from '@provex/utils/fees';
+import { useOptionalProvexPublicClient, useContractRead, useOptionalProvexWallet, getTransactionGasInputs, useOptionalProvex, createProveXClient, checkTransactionIndexed, ProveXError, isUserRejectionError, getUserFriendlyErrorMessage, checkMutation, useProvex, ProveXClient } from './chunk-7BVFQVKS.js';
+export { BrowsePhase, CommittedPhase, CompletePhase, ProveXClient, ProveXError, ProvexBuy, ProvexBuyProvider, ProvexProvider, ProvingPhase, createApiClient, createProveXClient, getRate, getTierDisplayInfo, intentStatuses, useDeposits, useOptionalProvexPublicClient, useOptionalProvexWallet, usePayeeDetails, useProtocolFeePercentage, useProtocolFees, useProvex, useProvexBuy, useProvexBuyContext, useProvexPublicClient, useProvexWallet, useReputation, useReputationLimits, useSignalIntent } from './chunk-7BVFQVKS.js';
+import { useCallback, useMemo, useState } from 'react';
 import { V3EscrowAbi, OrchestratorAbi, PaymentVerifierRegistryAbi, UnifiedPaymentVerifierAbi, NullifierRegistryAbi, V2EscrowAbi } from '@provex/abis';
-import { chainIdToChain } from '@provex/utils/chain';
-import { base } from 'viem/chains';
-import { useReadContract, useReadContracts, useAccount, useWalletClient, usePublicClient, useConnection, useSwitchChain, useWriteContract } from 'wagmi';
+import { maxUint256, erc20Abi, encodeFunctionData } from 'viem';
+import { getEscrowVersion, getLatestContract } from '@provex/utils/contracts';
 import { orderId } from '@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 = createContext(null);
-var defaultQueryClient = new QueryClient({
-  defaultOptions: {
-    queries: {
-      staleTime: 3e4,
-      refetchOnWindowFocus: false
-    }
-  }
-});
-function ProvexProvider({
-  config,
-  indexer,
-  queryClient,
-  children
-}) {
-  const resolvedQueryClient = queryClient ?? defaultQueryClient;
-  const contextValue = useMemo(() => {
-    const apiClient = createApiClient(config.apiUrl);
-    return { config, indexer, apiClient };
-  }, [config.apiUrl, config.chain, indexer]);
-  return /* @__PURE__ */ jsx(ProvexContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx(QueryClientProvider, { client: resolvedQueryClient, children }) });
-}
-function useProvex() {
-  const context = useContext(ProvexContext);
-  if (!context) {
-    throw new Error("useProvex must be used within a <ProvexProvider>");
-  }
-  return context;
-}
-function useOptionalProvex() {
-  return useContext(ProvexContext);
-}
-var DEFAULT_REFETCH_INTERVAL_MS = 5e3;
-function getRate({
-  deposit,
-  paymentMethod,
-  currency
-}) {
-  if (!deposit) return 0n;
-  const paymentConfig = 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 = 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 = SUPPORTED_CURRENCIES.USD,
-    paymentMethod,
-    refetchIntervalMs = DEFAULT_REFETCH_INTERVAL_MS
-  } = options;
-  const { indexer } = useProvex();
-  const queryClient = useQueryClient();
-  const paymentMethodIds = useMemo(() => {
-    const paymentConfig = providerConfigs(token.chainId)[paymentMethod];
-    return /* @__PURE__ */ new Set([
-      providerKeyToContractId(paymentMethod).toLowerCase(),
-      ...paymentConfig.v2Verifiers.map((v) => v.toLowerCase()),
-      ...Array.from(paymentConfig.subProviders).flatMap((subProvider) => [
-        providerKeyToContractId(subProvider.key).toLowerCase(),
-        ...subProvider.v2Verifiers(token.chainId).map((v) => v.toLowerCase())
-      ])
-    ]);
-  }, [token.chainId, paymentMethod]);
-  const depositsQuery = 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 = useMemo(() => depositsQuery.data ?? [], [depositsQuery.data]);
-  const canAcceptAmount = useCallback((deposit, amount) => {
-    return amount <= deposit.availableFunds && amount >= deposit.minAmount && amount <= deposit.maxAmount;
-  }, []);
-  const filterDepositsByAmount = 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 = 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 = 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 = parseUnits(amountInInt, { decimals: currency?.decimals || 2 });
-      }
-      if (!amountInInt) return [];
-      return filterDepositsByAmount(amountInInt);
-    }
-  };
-}
-var getTransactionGasInputs = async (chainId) => {
-  const chain = chainIdToChain.get(chainId);
-  if (!chain) {
-    throw new Error(`Unsupported chainId: ${chainId}`);
-  }
-  const block = await publicClient(chain).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: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "createDeposit",
-      argsMapper: (params) => [params]
-    });
-    this.addFunds = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "addFunds",
-      argsMapper: (params) => [params.depositId, params.amount]
-    });
-    this.removeFunds = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "removeFunds",
-      argsMapper: (params) => [params.depositId, params.amount]
-    });
-    this.withdrawDeposit = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "withdrawDeposit",
-      argsMapper: (params) => [params.depositId]
-    });
-    this.pruneExpiredIntents = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "pruneExpiredIntents",
-      argsMapper: (params) => [params.depositId]
-    });
-    this.setAcceptingIntents = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "setAcceptingIntents",
-      argsMapper: (params) => [params.depositId, params.accepting]
-    });
-    this.setRetainOnEmpty = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "setRetainOnEmpty",
-      argsMapper: (params) => [params.depositId, params.retain]
-    });
-    this.setIntentRange = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "setIntentRange",
-      argsMapper: (params) => [params.depositId, { min: params.min, max: params.max }]
-    });
-    this.setPaymentMethodActive = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "setPaymentMethodActive",
-      argsMapper: (params) => [params.depositId, params.paymentMethod, params.active]
-    });
-    this.setCurrencyMinRate = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "setCurrencyMinRate",
-      argsMapper: (params) => [params.depositId, params.paymentMethod, params.currency, params.rate]
-    });
-    this.addCurrencies = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "addCurrencies",
-      argsMapper: (params) => [params.depositId, params.paymentMethod, params.currencies]
-    });
-    this.deactivateCurrency = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "deactivateCurrency",
-      argsMapper: (params) => [params.depositId, params.paymentMethod, params.currencyCode]
-    });
-    this.addPaymentMethods = this.buildWritableMethod({
-      abi: V3EscrowAbi,
-      contractResolver: () => this.getEscrowAddress(),
-      functionName: "addPaymentMethods",
-      argsMapper: (params) => [params.depositId, params.paymentMethods, params.paymentMethodData, params.currencies]
-    });
-    this.cancelIntent = this.buildWritableMethod({
-      abi: OrchestratorAbi,
-      contractResolver: () => this.getOrchestratorAddress(),
-      functionName: "cancelIntent",
-      argsMapper: (params) => [params.intentHash]
-    });
-    this.releaseFundsToPayer = this.buildWritableMethod({
-      abi: 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 = 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: 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: OrchestratorAbi, functionName: "protocolFee" }),
-      this.readContract({ address: orchestrator, abi: OrchestratorAbi, functionName: "protocolFeeRecipient" })
-    ]);
-    return {
-      feeRaw,
-      feeInfo: normalizeFeePrecision(feeRaw),
-      feeRecipient
-    };
-  }
-  async getDeposit(depositId) {
-    return this.readContract({
-      address: this.getEscrowAddress(),
-      abi: V3EscrowAbi,
-      functionName: "getDeposit",
-      args: [depositId]
-    });
-  }
-  async getAccountDeposits(account) {
-    return this.readContract({
-      address: this.getEscrowAddress(),
-      abi: V3EscrowAbi,
-      functionName: "getAccountDeposits",
-      args: [account]
-    });
-  }
-  async getDepositCounter() {
-    return this.readContract({
-      address: this.getEscrowAddress(),
-      abi: 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: OrchestratorAbi, functionName: "paymentVerifierRegistry" });
-      const verifier = await this.readContract({ address: verifierRegistry, abi: PaymentVerifierRegistryAbi, functionName: "getVerifier", args: [params.paymentMethodId] });
-      const nullifierRegistry = await this.readContract({ address: verifier, abi: UnifiedPaymentVerifierAbi, functionName: "nullifierRegistry" });
-      return await this.readContract({ address: nullifierRegistry, abi: 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 = providerConfigs(this.chainId);
-    for (const pm of params.paymentMethods) {
-      const hash = 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 = encodeAbiParameters(
-      parseAbiParameters(["address[]"]),
-      [[reclaimSigners.peerWitnessSigner, reclaimSigners.reclaimWitnessSigner]]
-    );
-    const defaultGatingService = getLatestContract(this.chainId, "gatingService", "v3") ?? zeroAddress;
-    return {
-      token: params.token,
-      amount: params.amount,
-      intentAmountRange: {
-        min: params.intentRange?.min ?? 1000000n,
-        max: params.intentRange?.max ?? params.amount
-      },
-      paymentMethods: expanded.map((p) => 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: tickerToContractId(c.code),
-          minConversionRate: c.minRate
-        }))
-      ),
-      delegate: params.delegate ?? zeroAddress,
-      intentGuardian: params.intentGuardian ?? 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: zeroAddress,
-      referrerFee: 0n,
-      gatingServiceSignature: gatingResponse.signature,
-      signatureExpiration: gatingResponse.expiration,
-      postIntentHook: zeroAddress,
-      data: "0x"
-    };
-    const publicClient2 = this.getPublicClient();
-    try {
-      await publicClient2.simulateContract({
-        address: orchestrator,
-        abi: 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 = encodeFunctionData({
-      abi: 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 = decodeEventLog({
-          abi: 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 = createPublicClient({ chain: this.chain, transport: 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 = 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] = useState("input");
-  const [message, setMessage] = useState(null);
-  const client = useMemo(() => {
-    if (!provex) return null;
-    return createProveXClient({
-      chain: provex.config.chain,
-      apiUrl: provex.config.apiUrl,
-      wallet,
-      indexer: provex.indexer
-    });
-  }, [provex, wallet]);
-  const isLoading = useMemo(() => {
-    return status === "loading_payee" || status === "loading_intent" || status === "prompt_wallet_confirm" || status === "writing_intent";
-  }, [status]);
-  const startOrder = 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 = useQueryClient();
-  const isBase = chainId === base.id;
-  const reputationQuery = useQuery({
-    queryKey: ["provex", "reputation", address, isBase ? base.id : "all"],
-    queryFn: async () => {
-      if (!address) return null;
-      return indexer.getUserReputation({
-        address,
-        chainId: isBase ? base.id : void 0
-      });
-    },
-    enabled: !!address,
-    staleTime: 6e4,
-    refetchInterval: 12e4
-  });
-  const reputation = useMemo(() => {
-    const data = reputationQuery.data;
-    if (!data) return DEFAULT_REPUTATION;
-    let tier = 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 = TIER_ORDER.indexOf(tier);
-      const newTierIndex = Math.max(0, currentTierIndex - tierPenalty);
-      tier = TIER_ORDER[newTierIndex] ?? "peasant";
-    }
-    const cooldownHours = TAKER_TIERS[tier].cooldownHours;
-    let cooldownEndsAt = null;
-    let isOnCooldown = false;
-    const baseTimestamp = data.lastSignaledAt[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 = useCallback(() => {
-    queryClient.invalidateQueries({
-      queryKey: ["provex", "reputation", address]
-    });
-  }, [queryClient, address]);
-  return {
-    reputation,
-    isLoading,
-    error: reputationQuery.error,
-    refetch
-  };
-}
-function getTierDisplayInfo(tier) {
-  const config = TAKER_TIERS[tier];
-  const colors = {
-    [tiers.PEASANT]: "gray",
-    [tiers.NEUTRAL]: "blue",
-    [tiers.PLUS]: "green",
-    [tiers.PRO]: "purple",
-    [tiers.PLATINUM]: "yellow",
-    [tiers.PRESIDENT]: "cyan"
-  };
-  return {
-    name: config.name,
-    baseCap: config.baseCap,
-    cooldownHours: config.cooldownHours,
-    color: colors[tier],
-    volumeRangeDisplay: getVolumeRangeDisplay(tier)
-  };
-}
-function useReputationLimits({
-  chainId,
-  selectedPaymentMethod,
-  tier,
-  amountInInt,
-  cooldownEndsAt
-}) {
-  const hasLimits = true;
-  const { cooldownRemaining, isOnCooldown } = useMemo(() => {
-    const providerCooldownHours = 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 = useMemo(() => {
-    const available = verifiablePaymentMethods(chainId);
-    return available.filter((key) => {
-      if (key === selectedPaymentMethod) return false;
-      const platformRisk = getPlatformRisk(chainId, key);
-      if (!platformRisk.hasCooldown) return false;
-      return getCooldownHours({ tier, providerKey: key }) === 0;
-    });
-  }, [hasLimits, chainId, selectedPaymentMethod, tier]);
-  const selectedProviderCooldownHours = useMemo(() => {
-    return getCooldownHours({ tier, providerKey: selectedPaymentMethod });
-  }, [hasLimits, tier, selectedPaymentMethod]);
-  const effectiveCap = useMemo(() => {
-    return getEffectiveCap({ tier, providerKey: selectedPaymentMethod });
-  }, [hasLimits, tier, selectedPaymentMethod]);
-  const amountExceedsCap = useMemo(() => {
-    if (effectiveCap === null) return false;
-    if (!amountInInt) return false;
-    const amountUsd = Number(amountInInt) / 1e6;
-    return amountUsd > effectiveCap;
-  }, [effectiveCap, amountInInt]);
-  const capExceededMessage = useMemo(() => {
-    if (!amountExceedsCap || effectiveCap === null) return null;
-    const providerName = 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 = useQueryClient();
-  const intentQuery = useQuery({
-    queryKey: ["provex", "intent", intentHash, chainId],
-    queryFn: () => indexer.getIntent({ intentHash, chainId }),
-    enabled: !!intentHash,
-    staleTime: Infinity,
-    refetchInterval: false
-  });
-  const indexedIntent = intentQuery.data ?? null;
-  const intentStatus = useMemo(() => {
-    if (!indexedIntent) return null;
-    return indexedIntent.status;
-  }, [indexedIntent]);
-  const intent = 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 = 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 = useMemo(() => {
-    if (!deposit || !indexedIntent) return null;
-    return verifierGetsKey(deposit.chainId, indexedIntent.paymentMethodId);
-  }, [deposit, indexedIntent]);
-  const userId = useMemo(() => {
-    if (!deposit || !providerKey) return null;
-    const verifier = deposit.verifiers.find(
-      (v) => verifierGetsKey(deposit.chainId, v.paymentMethodId) === providerKey
-    );
-    return verifier?.payeeDetailsHash ?? null;
-  }, [deposit, providerKey]);
-  const apiProviderKey = useMemo(() => {
-    if (!providerKey) return null;
-    if (isSubProviderKey(providerKey)) {
-      return getParentProviderKey(providerKey);
-    }
-    return providerKey;
-  }, [providerKey]);
-  const payeeDetailsQuery = 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 = useCallback(() => {
-    queryClient.invalidateQueries({ queryKey: ["provex", "intent", intentHash] });
-  }, [queryClient, intentHash]);
-  const refetchAll = 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 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
-  } = useReadContract({
-    address: escrowAddress,
-    abi: 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
-  } = useReadContracts({
-    contracts: [
-      {
-        address: orchestratorAddress,
-        abi: OrchestratorAbi,
-        functionName: "protocolFee",
-        chainId
-      },
-      {
-        address: orchestratorAddress,
-        abi: 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 = useMemo(() => {
-    if (protocolFeeRaw === void 0) return void 0;
-    return 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 = parseUnits(value, { decimals });
-    return parsed > 0n ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function useProvexBuy({
-  wallet,
-  onIntentSignaled,
-  onComplete,
-  paymentMethods: allowedPaymentMethods
-}) {
-  const { config } = useProvex();
-  const [phase, setPhase] = useState("browse");
-  const [amount, setAmountRaw] = useState("");
-  const [selectedPaymentMethod, setSelectedPaymentMethod] = useState("");
-  const [selectedDeposit, setSelectedDeposit] = useState(null);
-  const [intentHash, setIntentHash] = useState(null);
-  const [errorMessage, setErrorMessage] = useState(null);
-  const chainId = config.chain?.id ?? config.chainId;
-  const token = useMemo(() => getDefaultToken(chainId), [chainId]);
-  const currency = SUPPORTED_CURRENCIES.USD;
-  const availablePaymentMethods = useMemo(() => {
-    const all = verifiablePaymentMethods(chainId);
-    if (!allowedPaymentMethods || allowedPaymentMethods.length === 0) return all;
-    return all.filter((pm) => allowedPaymentMethods.includes(pm));
-  }, [chainId, allowedPaymentMethods]);
-  const activePaymentMethod = useMemo(() => {
-    if (selectedPaymentMethod) return selectedPaymentMethod;
-    return availablePaymentMethods[0] ?? null;
-  }, [selectedPaymentMethod, availablePaymentMethods]);
-  const depositsResult = useDeposits({
-    token,
-    paymentMethod: activePaymentMethod,
-    currency
-  });
-  const { reputation } = useReputation({
-    address: wallet.address,
-    chainId
-  });
-  const amountBigInt = useMemo(
-    () => parseAmountSafe(amount, currency.decimals),
-    [amount, currency.decimals]
-  );
-  const limits = useReputationLimits({
-    chainId,
-    selectedPaymentMethod: activePaymentMethod,
-    tier: reputation.tier,
-    amountInInt: amountBigInt,
-    cooldownEndsAt: reputation.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 = useMemo(
-    () => getLatestContract(chainId, "escrow"),
-    [chainId]
-  );
-  const { feeInfo } = useProtocolFees({
-    chainId,
-    escrowAddress: escrowAddress ?? "0x",
-    enabled: !!escrowAddress
-  });
-  const payeeResult = usePayeeDetails({
-    intentHash,
-    chainId
-  });
-  const refetchAllRef = useRef(payeeResult.refetchAll);
-  refetchAllRef.current = payeeResult.refetchAll;
-  useEffect(() => {
-    if (phase !== "committed" && phase !== "proving") return;
-    if (!intentHash) return;
-    const interval = setInterval(() => {
-      refetchAllRef.current();
-    }, 5e3);
-    return () => clearInterval(interval);
-  }, [phase, intentHash]);
-  useEffect(() => {
-    if (!payeeResult.isFulfilled) return;
-    if (phase === "complete") return;
-    setPhase("complete");
-    if (intentHash) onComplete?.(intentHash, chainId);
-  }, [payeeResult.isFulfilled, phase, intentHash, chainId, onComplete]);
-  useEffect(() => {
-    if (!payeeResult.isPruned) return;
-    if (phase === "browse") return;
-    setErrorMessage("Order expired. Please try again.");
-    setPhase("browse");
-  }, [payeeResult.isPruned, phase]);
-  const intentExpiryTime = useMemo(() => {
-    if (!payeeResult.expiryTime) return null;
-    return new Date(Number(payeeResult.expiryTime) * 1e3);
-  }, [payeeResult.expiryTime]);
-  const matchableDeposits = useMemo(() => {
-    if (!amountBigInt) return [];
-    return depositsResult.getMatchableDeposits(amountBigInt);
-  }, [amountBigInt, depositsResult]);
-  const bestDeposit = matchableDeposits[0] ?? null;
-  const bestRate = useMemo(() => {
-    if (!bestDeposit || !activePaymentMethod) return null;
-    const r = getRate({ deposit: bestDeposit, paymentMethod: activePaymentMethod, currency });
-    return r === 0n ? null : r;
-  }, [bestDeposit, activePaymentMethod, currency]);
-  const tokenAmount = useMemo(() => {
-    if (!amountBigInt || !bestRate || !token) return null;
-    return convertCurrencyToTokenOutput({
-      token,
-      currency,
-      currencyAmountInt: amountBigInt,
-      rate: bestRate
-    });
-  }, [amountBigInt, bestRate, token, currency]);
-  const rateDisplay = 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 = useMemo(() => {
-    if (!tokenAmount || !token) return null;
-    return formatUnits(tokenAmount, { decimals: token.decimals });
-  }, [tokenAmount, token]);
-  const canSubmit = 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 = 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 = useCallback((value) => {
-    if (value === "" || /^\d*\.?\d*$/.test(value)) {
-      setAmountRaw(value);
-      setErrorMessage(null);
-    }
-  }, []);
-  const selectDeposit = useCallback((deposit) => {
-    setSelectedDeposit(deposit);
-  }, []);
-  const submitOrder = useCallback(async () => {
-    if (!canSubmit || !bestDeposit || !tokenAmount || !activePaymentMethod || !wallet.address) return;
-    setSelectedDeposit(bestDeposit);
-    setErrorMessage(null);
-    const paymentMethodContractId = 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 = useCallback(() => {
-    setPhase("proving");
-  }, []);
-  const reset = 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 ?? 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 = createContext(null);
-function useProvexBuyContext() {
-  const ctx = 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__ */ 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__ */ jsx(Fragment, { children: render(state) });
-  const tokenSymbol = ctx.token?.symbol ?? "USDC";
-  const matchCount = ctx.deposits.length;
-  const statusMessage = STATUS_MESSAGES[ctx.intentStatus] ?? "";
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      "data-provex-phase": "browse",
-      "data-provex-section": "browse",
-      className,
-      style,
-      children: [
-        /* @__PURE__ */ jsxs("div", { "data-provex-field": "payment-method", children: [
-          /* @__PURE__ */ jsx("label", { "data-provex-label": "payment-method", htmlFor: "provex-payment-method", children: "Payment Method" }),
-          /* @__PURE__ */ 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__ */ jsx("option", { value: pm, children: getPaymentMethodName(ctx.chainId, pm) }, pm))
-            }
-          )
-        ] }),
-        /* @__PURE__ */ jsxs("div", { "data-provex-field": "amount", children: [
-          /* @__PURE__ */ jsxs("label", { "data-provex-label": "amount", htmlFor: "provex-amount", children: [
-            "Amount (",
-            ctx.currency?.ticker ?? "USD",
-            ")"
-          ] }),
-          /* @__PURE__ */ jsxs("div", { "data-provex-input-group": "amount", children: [
-            /* @__PURE__ */ jsx("span", { "data-provex-input-prefix": "", children: ctx.currency?.symbol ?? "$" }),
-            /* @__PURE__ */ 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__ */ jsxs("div", { "data-provex-info": "rate", children: [
-          /* @__PURE__ */ jsx("span", { "data-provex-label": "rate", children: "Rate" }),
-          /* @__PURE__ */ jsx("span", { "data-provex-value": "rate", children: ctx.rateDisplay })
-        ] }),
-        ctx.tokenAmountDisplay && /* @__PURE__ */ jsxs("div", { "data-provex-info": "receive", children: [
-          /* @__PURE__ */ jsx("span", { "data-provex-label": "receive", children: "You receive" }),
-          /* @__PURE__ */ jsxs("span", { "data-provex-value": "receive", children: [
-            ctx.tokenAmountDisplay,
-            " ",
-            tokenSymbol
-          ] })
-        ] }),
-        ctx.isLoadingDeposits && ctx.amount && /* @__PURE__ */ jsx("div", { "data-provex-info": "loading", children: /* @__PURE__ */ jsx("span", { "data-provex-status": "loading", children: "Searching for orders..." }) }),
-        !ctx.isLoadingDeposits && ctx.amount && matchCount > 0 && /* @__PURE__ */ jsx("div", { "data-provex-info": "match-count", children: /* @__PURE__ */ jsxs("span", { "data-provex-value": "match-count", children: [
-          matchCount,
-          " order",
-          matchCount !== 1 ? "s" : "",
-          " available"
-        ] }) }),
-        ctx.validationMessage && /* @__PURE__ */ jsx("p", { "data-provex-message": "validation", children: ctx.validationMessage }),
-        ctx.intentError && /* @__PURE__ */ jsx("p", { "data-provex-message": "error", children: ctx.intentError }),
-        ctx.isSubmitting && statusMessage && /* @__PURE__ */ jsx("p", { "data-provex-message": "status", children: statusMessage }),
-        /* @__PURE__ */ 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__ */ jsx(Fragment, { children: render(state) });
-  const tokenSymbol = ctx.token?.symbol ?? "USDC";
-  const paymentName = ctx.selectedPaymentMethod ? getPaymentMethodName(ctx.chainId, ctx.selectedPaymentMethod) : "Unknown";
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      "data-provex-phase": "committed",
-      "data-provex-section": "committed",
-      className,
-      style,
-      children: [
-        /* @__PURE__ */ jsxs("div", { "data-provex-info": "order-summary", children: [
-          /* @__PURE__ */ jsx("p", { "data-provex-heading": "committed", children: "Order Placed" }),
-          /* @__PURE__ */ jsxs("div", { "data-provex-detail": "amount", children: [
-            /* @__PURE__ */ jsx("span", { "data-provex-label": "amount", children: "Amount" }),
-            /* @__PURE__ */ jsxs("span", { "data-provex-value": "amount", children: [
-              ctx.currency?.symbol,
-              ctx.amount
-            ] })
-          ] }),
-          /* @__PURE__ */ jsxs("div", { "data-provex-detail": "receive", children: [
-            /* @__PURE__ */ jsx("span", { "data-provex-label": "receive", children: "You receive" }),
-            /* @__PURE__ */ jsxs("span", { "data-provex-value": "receive", children: [
-              ctx.tokenAmountDisplay,
-              " ",
-              tokenSymbol
-            ] })
-          ] }),
-          /* @__PURE__ */ jsxs("div", { "data-provex-detail": "payment-method", children: [
-            /* @__PURE__ */ jsx("span", { "data-provex-label": "payment-method", children: "Pay via" }),
-            /* @__PURE__ */ jsx("span", { "data-provex-value": "payment-method", children: paymentName })
-          ] }),
-          ctx.intentHash && /* @__PURE__ */ jsxs("div", { "data-provex-detail": "intent-hash", children: [
-            /* @__PURE__ */ jsx("span", { "data-provex-label": "intent-hash", children: "Order ID" }),
-            /* @__PURE__ */ jsxs("span", { "data-provex-value": "intent-hash", title: ctx.intentHash, children: [
-              ctx.intentHash.slice(0, 10),
-              "...",
-              ctx.intentHash.slice(-8)
-            ] })
-          ] })
-        ] }),
-        ctx.isPayeeLoading && /* @__PURE__ */ jsx("div", { "data-provex-info": "payee-loading", children: /* @__PURE__ */ jsx("span", { "data-provex-status": "loading", children: "Loading seller details..." }) }),
-        !ctx.isPayeeLoading && ctx.payeeId && /* @__PURE__ */ jsxs("div", { "data-provex-info": "payee", children: [
-          ctx.payeeName && /* @__PURE__ */ jsxs("div", { "data-provex-detail": "payee-name", children: [
-            /* @__PURE__ */ jsx("span", { "data-provex-label": "payee-name", children: "Seller" }),
-            /* @__PURE__ */ jsx("span", { "data-provex-value": "payee-name", children: ctx.payeeName })
-          ] }),
-          /* @__PURE__ */ jsxs("div", { "data-provex-detail": "payee-id", children: [
-            /* @__PURE__ */ jsx("span", { "data-provex-label": "payee-id", children: "Send to" }),
-            /* @__PURE__ */ jsx("span", { "data-provex-value": "payee-id", children: ctx.payeeId })
-          ] })
-        ] }),
-        /* @__PURE__ */ jsx("div", { "data-provex-info": "instructions", children: /* @__PURE__ */ 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__ */ 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__ */ jsx(Fragment, { children: render(state) });
-  const statusText = ctx.indexedIntentStatus === "fulfilled" ? "Payment verified!" : "Generating zero-knowledge proof of your payment...";
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      "data-provex-phase": "proving",
-      "data-provex-section": "proving",
-      className,
-      style,
-      children: [
-        /* @__PURE__ */ jsx("p", { "data-provex-heading": "proving", children: "Verifying Payment" }),
-        /* @__PURE__ */ jsx("p", { "data-provex-text": "proving", children: statusText }),
-        ctx.intentHash && /* @__PURE__ */ jsxs("div", { "data-provex-detail": "intent-hash", children: [
-          /* @__PURE__ */ jsx("span", { "data-provex-label": "intent-hash", children: "Order ID" }),
-          /* @__PURE__ */ jsxs("span", { "data-provex-value": "intent-hash", title: ctx.intentHash, children: [
-            ctx.intentHash.slice(0, 10),
-            "...",
-            ctx.intentHash.slice(-8)
-          ] })
-        ] }),
-        /* @__PURE__ */ jsx("div", { "data-provex-info": "status", children: /* @__PURE__ */ 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__ */ jsx(Fragment, { children: render(state) });
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      "data-provex-phase": "complete",
-      "data-provex-section": "complete",
-      className,
-      style,
-      children: [
-        /* @__PURE__ */ jsx("p", { "data-provex-heading": "complete", children: "Purchase Complete" }),
-        /* @__PURE__ */ jsx("p", { "data-provex-text": "complete", children: "Your tokens have been released to your wallet." }),
-        ctx.intentHash && /* @__PURE__ */ jsxs("div", { "data-provex-detail": "intent-hash", children: [
-          /* @__PURE__ */ jsx("span", { "data-provex-label": "intent-hash", children: "Order ID" }),
-          /* @__PURE__ */ jsxs("span", { "data-provex-value": "intent-hash", title: ctx.intentHash, children: [
-            ctx.intentHash.slice(0, 10),
-            "...",
-            ctx.intentHash.slice(-8)
-          ] })
-        ] }),
-        /* @__PURE__ */ 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__ */ jsx(
-    ProvexBuyProvider,
-    {
-      wallet,
-      onIntentSignaled,
-      onComplete,
-      paymentMethods,
-      children: /* @__PURE__ */ jsx(
-        ProvexBuyRoot,
-        {
-          className,
-          style: applyTheme(style, theme)
-        }
-      )
-    }
-  );
-}
-function ProvexBuyRoot({
-  className,
-  style
-}) {
-  const { phase } = useProvexBuyContext();
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      className,
-      style,
-      "data-provex-root": "",
-      "data-provex-phase": phase,
-      children: [
-        /* @__PURE__ */ jsx(BrowsePhase, {}),
-        /* @__PURE__ */ jsx(CommittedPhase, {}),
-        /* @__PURE__ */ jsx(ProvingPhase, {}),
-        /* @__PURE__ */ jsx(CompletePhase, {})
-      ]
-    }
-  );
-}
-function useWagmiWallet() {
-  const { address } = useAccount();
-  const { data: walletClient } = useWalletClient();
-  return 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__ */ jsx(
-    ProvexBuy,
-    {
-      wallet,
-      onIntentSignaled,
-      onComplete,
-      paymentMethods,
-      className,
-      style,
-      theme
-    }
-  );
-}
 function useNullifierRegistry({
   escrowAddress,
   paymentMethodId,
   chainId
 }) {
-  const publicClient2 = usePublicClient({ chainId });
-  const { data: orchestratorAddress, isLoading: isLoadingOrchestrator } = useReadContract({
+  const publicClient = useOptionalProvexPublicClient(chainId);
+  const { data: orchestratorAddress, isLoading: isLoadingOrchestrator } = useContractRead({
     address: escrowAddress,
     abi: V3EscrowAbi,
     functionName: "orchestrator",
@@ -2126,7 +21,7 @@ function useNullifierRegistry({
       enabled: !!escrowAddress
     }
   });
-  const { data: paymentVerifierRegistryAddress, isLoading: isLoadingRegistry } = useReadContract({
+  const { data: paymentVerifierRegistryAddress, isLoading: isLoadingRegistry } = useContractRead({
     address: orchestratorAddress,
     abi: OrchestratorAbi,
     functionName: "paymentVerifierRegistry",
@@ -2135,7 +30,7 @@ function useNullifierRegistry({
       enabled: !!orchestratorAddress
     }
   });
-  const { data: verifierAddress, isLoading: isLoadingVerifier } = useReadContract({
+  const { data: verifierAddress, isLoading: isLoadingVerifier } = useContractRead({
     address: paymentVerifierRegistryAddress,
     abi: PaymentVerifierRegistryAbi,
     functionName: "getVerifier",
@@ -2145,7 +40,7 @@ function useNullifierRegistry({
       enabled: !!paymentVerifierRegistryAddress && !!paymentMethodId
     }
   });
-  const { data: nullifierRegistryAddress, isLoading: isLoadingNullifierRegistry } = useReadContract({
+  const { data: nullifierRegistryAddress, isLoading: isLoadingNullifierRegistry } = useContractRead({
     address: verifierAddress,
     abi: UnifiedPaymentVerifierAbi,
     functionName: "nullifierRegistry",
@@ -2157,11 +52,11 @@ function useNullifierRegistry({
   const isLoading = isLoadingOrchestrator || isLoadingRegistry || isLoadingVerifier || isLoadingNullifierRegistry;
   const checkNullifierUsed = useCallback(
     async (nullifier) => {
-      if (!nullifierRegistryAddress || !publicClient2) {
+      if (!nullifierRegistryAddress || !publicClient) {
         return null;
       }
       try {
-        const isUsed = await publicClient2.readContract({
+        const isUsed = await publicClient.readContract({
           address: nullifierRegistryAddress,
           abi: NullifierRegistryAbi,
           functionName: "isNullified",
@@ -2173,7 +68,7 @@ function useNullifierRegistry({
         return null;
       }
     },
-    [nullifierRegistryAddress, publicClient2]
+    [nullifierRegistryAddress, publicClient]
   );
   return {
     orchestratorAddress,
@@ -2200,25 +95,19 @@ var useAllowance = ({
     }
     return maxUint256;
   }, [defaultAllowance, balance]);
-  const { chain: currentChain } = useConnection();
-  const { mutateAsync: switchChainAsync } = useSwitchChain();
-  const publicClient2 = usePublicClient({ chainId: token.chainId });
-  const queryEnabled = !!publicClient2 && !!account && !!spender && !!token.address;
-  const { data, isLoading, error, refetch } = useQuery({
-    queryKey: ["allowance", token.address, spender, account, token.chainId],
-    queryFn: async () => {
-      const result = await publicClient2.readContract({
-        abi: erc20Abi,
-        address: token.address,
-        functionName: "allowance",
-        args: [account, spender]
-      });
-      return result;
-    },
-    enabled: queryEnabled
+  const publicClient = useOptionalProvexPublicClient(token.chainId);
+  const wallet = useOptionalProvexWallet();
+  const { data, isLoading, error, refetch } = useContractRead({
+    address: token.address,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: account && spender ? [account, spender] : void 0,
+    chainId: token.chainId,
+    query: {
+      enabled: !!account && !!spender && !!token.address
+    }
   });
   const [approvalPhase, setApprovalPhase] = useState("idle");
-  const { mutateAsync } = useWriteContract();
   const isWritingApproval = approvalPhase !== "idle";
   const approvalLoadingText = approvalPhase === "confirming" ? "Confirming..." : `Approve ${token.symbol}`;
   return {
@@ -2229,25 +118,27 @@ var useAllowance = ({
     approvalLoadingText,
     error,
     writeApproval: async () => {
-      if (!account || !spender || !token.address || !publicClient2) {
+      if (!account || !spender || !token.address || !publicClient || !wallet) {
         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,
+        const callData = encodeFunctionData({
           abi: erc20Abi,
           functionName: "approve",
-          ...gasInputs,
           args: [spender, targetAllowance]
         });
+        const hash = await wallet.sendTransaction({
+          to: token.address,
+          data: callData,
+          value: 0n,
+          chainId: token.chainId,
+          maxFeePerGas: gasInputs.maxFeePerGas,
+          maxPriorityFeePerGas: gasInputs.maxPriorityFeePerGas
+        });
         setApprovalPhase("confirming");
-        await publicClient2.waitForTransactionReceipt({ hash });
+        await publicClient.waitForTransactionReceipt({ hash });
         await refetch();
         onSuccess?.(hash);
       } catch (err) {
@@ -2269,7 +160,8 @@ var useCancelIntent = ({
   version: explicitVersion
 }) => {
   const provex = useOptionalProvex();
-  const wallet = useWagmiWallet();
+  const wallet = useOptionalProvexWallet();
+  const publicClient = useOptionalProvexPublicClient(chainId ?? void 0);
   const [status, setStatus] = useState("idle");
   const [errorMessage, setErrorMessage] = useState(null);
   const isLoading = useMemo(() => status === "prompt_wallet_confirm" || status === "writing_tx", [status]);
@@ -2291,13 +183,11 @@ var useCancelIntent = ({
     return createProveXClient({
       chain: provex.config.chain,
       apiUrl: provex.config.apiUrl,
-      wallet: wallet ?? void 0,
+      wallet,
       indexer: provex.indexer,
       escrowAddress: escrowAddress ?? void 0
     });
   }, [provex, chainId, version, wallet, escrowAddress]);
-  const { mutateAsync: writeContractAsync } = useWriteContract();
-  const publicClient2 = usePublicClient();
   const cancelIntent = useCallback(async (intentHash) => {
     if (!intentHash || !chainId) return;
     setStatus("prompt_wallet_confirm");
@@ -2308,15 +198,22 @@ var useCancelIntent = ({
         await client.cancelIntent({ intentHash });
       } else {
         if (!escrowAddress) throw new Error("Missing escrow address");
+        if (!wallet) throw new Error("No wallet configured on ProvexProvider");
         const gasInputs = await getTransactionGasInputs(chainId);
-        const hash = await writeContractAsync({
-          address: escrowAddress,
+        const data = encodeFunctionData({
           abi: V2EscrowAbi,
           functionName: "cancelIntent",
-          args: [intentHash],
-          ...gasInputs
+          args: [intentHash]
         });
-        if (publicClient2) await publicClient2.waitForTransactionReceipt({ hash });
+        const hash = await wallet.sendTransaction({
+          to: escrowAddress,
+          data,
+          value: 0n,
+          chainId,
+          maxFeePerGas: gasInputs.maxFeePerGas,
+          maxPriorityFeePerGas: gasInputs.maxPriorityFeePerGas
+        });
+        if (publicClient) await publicClient.waitForTransactionReceipt({ hash });
         if (provex?.indexer) {
           await checkTransactionIndexed({ queryTransaction: provex.indexer.getTransactionByHash, hash });
         }
@@ -2335,7 +232,7 @@ var useCancelIntent = ({
     } finally {
       onSettled?.();
     }
-  }, [chainId, escrowAddress, version, client, publicClient2, writeContractAsync, provex, onSuccess, onMutate, onError, onSettled]);
+  }, [chainId, escrowAddress, version, client, publicClient, wallet, provex, onSuccess, onMutate, onError, onSettled]);
   return {
     cancelIntent,
     status,
@@ -2352,7 +249,8 @@ var useReleaseFundsToPayer = ({
   version: explicitVersion
 }) => {
   const provex = useOptionalProvex();
-  const wallet = useWagmiWallet();
+  const wallet = useOptionalProvexWallet();
+  const publicClient = useOptionalProvexPublicClient(chainId ?? void 0);
   const [status, setStatus] = useState("idle");
   const [errorMessage, setErrorMessage] = useState(null);
   const isLoading = useMemo(
@@ -2377,13 +275,11 @@ var useReleaseFundsToPayer = ({
     return createProveXClient({
       chain: provex.config.chain,
       apiUrl: provex.config.apiUrl,
-      wallet: wallet ?? void 0,
+      wallet,
       indexer: provex.indexer,
       escrowAddress: escrowAddress ?? void 0
     });
   }, [provex, chainId, version, wallet, escrowAddress]);
-  const { mutateAsync: writeContractAsync } = useWriteContract();
-  const publicClient2 = usePublicClient();
   const releaseFundsToPayer = useCallback(async (intentHash) => {
     if (!intentHash || !chainId) return;
     setStatus("prompt_wallet_confirm");
@@ -2393,15 +289,22 @@ var useReleaseFundsToPayer = ({
         await client.releaseFundsToPayer({ intentHash });
       } else {
         if (!escrowAddress) throw new Error("Missing escrow address");
+        if (!wallet) throw new Error("No wallet configured on ProvexProvider");
         const gasInputs = await getTransactionGasInputs(chainId);
-        const hash = await writeContractAsync({
-          address: escrowAddress,
+        const data = encodeFunctionData({
           abi: V2EscrowAbi,
           functionName: "releaseFundsToPayer",
-          args: [intentHash],
-          ...gasInputs
+          args: [intentHash]
         });
-        if (publicClient2) await publicClient2.waitForTransactionReceipt({ hash });
+        const hash = await wallet.sendTransaction({
+          to: escrowAddress,
+          data,
+          value: 0n,
+          chainId,
+          maxFeePerGas: gasInputs.maxFeePerGas,
+          maxPriorityFeePerGas: gasInputs.maxPriorityFeePerGas
+        });
+        if (publicClient) await publicClient.waitForTransactionReceipt({ hash });
         if (provex?.indexer) {
           await checkTransactionIndexed({ queryTransaction: provex.indexer.getTransactionByHash, hash });
         }
@@ -2420,7 +323,7 @@ var useReleaseFundsToPayer = ({
     } finally {
       onSettled?.();
     }
-  }, [chainId, escrowAddress, version, client, publicClient2, writeContractAsync, provex, onSuccess, onSettled]);
+  }, [chainId, escrowAddress, version, client, publicClient, wallet, provex, onSuccess, onSettled]);
   return {
     releaseFundsToPayer,
     status,
@@ -2437,7 +340,7 @@ var useV3Escrow = ({
   onError
 }) => {
   const provex = useOptionalProvex();
-  const wallet = useWagmiWallet();
+  const wallet = useOptionalProvexWallet();
   const [status, setStatus] = useState("idle");
   const [error, setError] = useState(null);
   const [txHash, setTxHash] = useState(null);
@@ -2455,7 +358,7 @@ var useV3Escrow = ({
     return createProveXClient({
       chain: provex.config.chain,
       apiUrl: provex.config.apiUrl,
-      wallet: wallet ?? void 0,
+      wallet,
       indexer: provex.indexer,
       escrowAddress: escrow ?? void 0,
       onTransactionHash: (hash) => {
@@ -2468,16 +371,18 @@ var useV3Escrow = ({
       }
     });
   }, [provex, chainId, wallet, escrow, onSlowSync]);
-  const { data: orchestratorAddress, refetch: refetchOrchestrator } = useReadContract({
+  const { data: orchestratorAddress, refetch: refetchOrchestrator } = useContractRead({
     address: escrow ?? void 0,
     abi: V3EscrowAbi,
     functionName: "orchestrator",
+    chainId: chainId ?? void 0,
     query: { enabled: !!escrow }
   });
-  const { data: depositCounter, refetch: refetchDepositCounter } = useReadContract({
+  const { data: depositCounter, refetch: refetchDepositCounter } = useContractRead({
     address: escrow ?? void 0,
     abi: V3EscrowAbi,
     functionName: "depositCounter",
+    chainId: chainId ?? void 0,
     query: { enabled: !!escrow }
   });
   const executeClientMethod = useCallback(async (method, action) => {
@@ -2625,7 +530,7 @@ var useTransactionWithIndexer = (options = {}) => {
   const provex = useOptionalProvex();
   const indexer = indexerParam ?? provex?.indexer;
   const [phase, setPhase] = useState("idle");
-  const publicClient2 = usePublicClient();
+  const publicClient = useOptionalProvexPublicClient();
   const waitForTransaction = useCallback(async ({
     hash,
     chainId,
@@ -2633,7 +538,7 @@ var useTransactionWithIndexer = (options = {}) => {
   }) => {
     try {
       setPhase("confirming");
-      await publicClient2?.waitForTransactionReceipt({ hash });
+      await publicClient?.waitForTransactionReceipt({ hash });
       if (indexer) {
         setPhase("syncing");
         await checkTransactionIndexed({
@@ -2652,7 +557,7 @@ var useTransactionWithIndexer = (options = {}) => {
       onError?.(error);
       throw e;
     }
-  }, [publicClient2, indexer, onSuccess, onError, onSlowSync, onTransactionConfirmed, onTransactionError]);
+  }, [publicClient, indexer, onSuccess, onError, onSlowSync, onTransactionConfirmed, onTransactionError]);
   const waitForMutation = useCallback(async ({
     hash,
     depositId,
@@ -2662,7 +567,7 @@ var useTransactionWithIndexer = (options = {}) => {
   }) => {
     try {
       setPhase("confirming");
-      await publicClient2?.waitForTransactionReceipt({ hash });
+      await publicClient?.waitForTransactionReceipt({ hash });
       if (indexer) {
         setPhase("syncing");
         const escrow = getLatestContract(chainId, "escrow");
@@ -2688,7 +593,7 @@ var useTransactionWithIndexer = (options = {}) => {
       onError?.(error);
       throw e;
     }
-  }, [publicClient2, indexer, onSuccess, onError, onSlowSync, onTransactionConfirmed, onTransactionError]);
+  }, [publicClient, indexer, onSuccess, onError, onSlowSync, onTransactionConfirmed, onTransactionError]);
   const reset = useCallback(() => {
     setPhase("idle");
   }, []);
@@ -2717,6 +622,6 @@ function useProveXClient(wallet) {
   );
 }
 
-export { BrowsePhase, CommittedPhase, CompletePhase, ProveXClient, ProveXError, ProvexBuy, ProvexBuyProvider, ProvexBuyWagmi, ProvexProvider, ProvingPhase, createApiClient, createProveXClient, getRate, getTierDisplayInfo, intentStatuses, useAllowance, useCancelIntent, useDeposits, useNullifierRegistry, usePayeeDetails, useProtocolFeePercentage, useProtocolFees, useProveXClient, useProvex, useProvexBuy, useProvexBuyContext, useReleaseFundsToPayer, useReputation, useReputationLimits, useSignalIntent, useTransactionWithIndexer, useV3Escrow, useWagmiWallet };
+export { useAllowance, useCancelIntent, useNullifierRegistry, useProveXClient, useReleaseFundsToPayer, useTransactionWithIndexer, useV3Escrow };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map