@provex/react 1.11.0 → 2.0.0

package/dist/index.d.cts

@@ -1,10 +1,13 @@
-import { C as CreateDepositRawParams, I as IndexerAdapter, P as ProveXClientConfig, a as PaginationOptions, b as PaginatedResult, c as IndexedDeposit, d as IndexedIntent, R as ReputationData, W as WritableMethod, F as FulfillIntentParams, e as CreateDepositParams$1, T as TransactionResult, f as PreparedTransaction, S as SignalIntentParams, g as SignalIntentResult, h as PayeeDetails, M as MakerRegistrationParams, A as AttestationParams, i as AttestationResponse, j as WalletAdapter, U as UseProvexBuyOptions, k as UseProvexBuyReturn, l as PhaseRenderProps, B as BuyProps } from './ProvexProvider-BAFqjyNz.cjs';
-export { y as ApiClient, n as BuyPhase, Y as DepositInfo, D as DepositPaymentMethod, a0 as IndexedVerifier, Z as IntentStatus, _ as PayeeInfo, p as PhaseComponentProps, t as ProveXError, v as ProveXErrorCode, m as ProvexConfig, r as ProvexContextValue, q as ProvexProvider, s as ProvexProviderProps, o as ProvexTheme, X as ReputationLimits, V as ReputationLimitsParams, w as SignalIntentRawParams, $ as SignalIntentStatus, x as createApiClient, G as getRate, J as intentStatuses, E as useDeposits, N as useOptionalProvexPublicClient, Q as useOptionalProvexWallet, H as usePayeeDetails, u as useProvex, L as useProvexPublicClient, O as useProvexWallet, z as useReputationLimits, K as useSignalIntent } from './ProvexProvider-BAFqjyNz.cjs';
+import { C as CreateDepositRawParams, I as IndexerAdapter, P as ProveXClientConfig, a as PaginationOptions, b as PaginatedResult, c as IndexedDeposit, d as IndexedIntent, R as ReputationData, W as WritableMethod, F as FulfillIntentParams, e as CreateDepositParams$1, T as TransactionResult, f as PreparedTransaction, S as SignalIntentParams, g as SignalIntentResult, h as PayeeDetails, M as MakerRegistrationParams, i as WalletAdapter, U as UseProvexBuyOptions, j as UseProvexBuyReturn, k as PhaseRenderProps, B as BuyProps } from './ProvexProvider-BG3DefVn.cjs';
+export { A as ApiClient, m as BuyPhase, K as DEFAULT_SIGNAL_INTENT_MESSAGES, Y as DepositInfo, D as DepositPaymentMethod, a5 as IndexedVerifier, Z as IntentStatus, _ as PayeeInfo, o as PhaseComponentProps, t as ProveXError, v as ProveXErrorCode, l as ProvexConfig, r as ProvexContextValue, p as ProvexProvider, s as ProvexProviderProps, n as ProvexTheme, X as ReputationLimits, V as ReputationLimitsParams, a0 as SignalIntentDeposit, a2 as SignalIntentMessages, w as SignalIntentRawParams, $ as SignalIntentStatus, a1 as SignalIntentTransaction, a4 as StartOrderParams, a3 as UseSignalIntentOptions, x as createApiClient, E as getRate, H as intentStatuses, q as useClock, z as useDeposits, N as useOptionalProvexPublicClient, Q as useOptionalProvexWallet, G as usePayeeDetails, u as useProvex, L as useProvexPublicClient, O as useProvexWallet, y as useReputationLimits, J as useSignalIntent } from './ProvexProvider-BG3DefVn.cjs';
+import { C as Clock } from './clock-BDtn-Itb.cjs';
+export { T as TimerHandle, s as systemClock } from './clock-BDtn-Itb.cjs';
+import { Hex, Chain, PublicClient } from 'viem';
+import { ProvingClient, CaptureRequest, CaptureAdapter, ProvingState, ManualTransactionSelect } from '@provex/proving';
 export { CaptureAdapter, CaptureCandidate, ProvingState } from '@provex/proving';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React from 'react';
 import React__default from 'react';
-import { Hex, Chain, PublicClient } from 'viem';
 import { ChainId } from '@provex/utils/chain';
 import { FeeInfo } from '@provex/utils/fees';
 import { TakerTier } from '@provex/utils/payment';
@@ -14,8 +17,8 @@ import { Version } from '@provex/utils/contracts';
 import { WriteHookParams } from '@valve-tech/wallet-adapter';
 import * as _tanstack_query_core from '@tanstack/query-core';
 import { UseQueryResult } from '@tanstack/react-query';
+import { V3AttestationResponseObject } from '@provex/utils';
 import '@provex/utils/currencies';
-import '@provex/utils';
 
 /**
  * @fileoverview Hook for reading protocol fee configuration.
@@ -96,37 +99,168 @@ declare function useProtocolFees({ chainId, escrowAddress, enabled, }: UseProtoc
 declare function useProtocolFeePercentage(params: UseProtocolFeesParams): string | undefined;
 
 /**
- * @fileoverview Hook for fetching user reputation (taker tier).
+ * @fileoverview The three-state answer to "is this wallet on the president
+ * (VIP) allowlist", and the filtering rule that follows from it.
  *
- * Calculates the user's reputation tier based on:
- * - Fulfilled volume (in USDC, 1:1 with USD)
- * - Lock score (penalty for cancellations)
- * - Cooldown status
+ * Before a session exists, VIP status is not "no". It is "not known yet".
+ * Reading unknown as "not VIP" would apply normal cooldowns and caps to a
+ * VIP and hide providers they may use. The rule here keeps unknown from
+ * acting as "not VIP".
+ */
+
+/** The standing of a wallet on the president (VIP) allowlist. */
+type VipStatus = 'unknown' | 'normal' | 'vip';
+/**
+ * The tier that buyer-facing cooldown and cap filtering should use, or
+ * `null` for "do not filter".
  *
- * Uses the IndexerAdapter for data — no direct Ponder queries.
+ * - `'unknown'` returns `null`: never hide a provider, or block an amount,
+ *   for a rule that may not apply to this wallet.
+ * - `'vip'` returns president: no cap, no cooldown.
+ * - `'normal'` returns the wallet's own tier.
+ */
+declare function filteringTierFor(options: {
+    vipStatus: VipStatus;
+    tier: TakerTier;
+}): TakerTier | null;
+
+/**
+ * @fileoverview Hook for a wallet's reputation: tier, cooldown and lock score.
+ *
+ * Reputation counts both sides of a trade. Taker (buyer) and maker (seller)
+ * volume add at one-to-one weight, so sellers climb the tier ladder next to
+ * buyers. Volumes stay `bigint` in base units until the display layer.
+ *
+ * The hook is headless. It reads no build-time environment value and needs
+ * no wallet-connect, router or design-system package. The host app injects:
+ *   - `source`: where the stats come from (default: the `ProvexProvider`
+ *     indexer adapter). An app with live subscriptions passes its own.
+ *   - `vipStatus`: the answer from its sign-in session (default: `'normal'`).
+ *   - `disabled`: the kill switch (default: `config.reputationDisabled` from
+ *     `ProvexProvider`, then `false`).
+ *
+ * @remarks
+ * Reputation is PulseChain-only. The `chainId` option stays on the signature
+ * for backward compatibility and does not change the data source.
  *
  * @see {@link @provex/utils/reputation} for tier definitions
- * @see {@link useReputationLimits} for applying limits to specific payments
+ * @see {@link useReputationLimits} for applying limits to a specific payment
  */
 
 /**
- * Hook to fetch and calculate user reputation tier.
- *
- * @param address - User's wallet address
- * @param chainId - Current chain ID
- * @returns User reputation data and loading state
+ * The stats row the tier is computed from. Structurally the same as the
+ * indexer client's `UserReputationStats`, so an app can pass that row as is.
+ * Maker fields are optional until the indexer reindex lands; `undefined`
+ * reads as zero.
  */
-declare function useReputation({ address, chainId, }: {
+interface ReputationStats {
+    /** Taker-side fulfilled volume in USDC base units (6 decimals). */
+    fulfilledVolume: bigint;
+    /** Taker-side fulfilled intent count. */
+    fulfilledCount: number;
+    /** Maker-side fulfilled volume in USDC base units. */
+    fulfilledMakerVolume?: bigint;
+    /** Maker-side fulfilled intent count. */
+    fulfilledMakerCount?: number;
+    /** Late cancellations (pruned more than 15 minutes after signal). */
+    lateCancellations: number;
+}
+/** What a {@link ReputationSource} reports for one wallet. */
+interface ReputationSourceResult {
+    /** The stats row, or `null` when not loaded. */
+    stats: ReputationStats | null;
+    /** Seconds since epoch of the last signaled intent, or `null` for never. */
+    lastSignaledTimestamp: bigint | number | null;
+    /** True while the first load is in flight. */
+    isLoading: boolean;
+    /** The load error, if any. */
+    error: Error | null;
+    /** Ask the source to reload. */
+    refetch: () => void | Promise<unknown>;
+}
+/**
+ * A hook that supplies reputation data for a wallet. It is called on every
+ * render, so pass the same function each time (a module-level hook).
+ */
+type ReputationSource = (params: {
     address: Hex | undefined;
-    chainId: ChainId;
-}): {
+}) => ReputationSourceResult;
+/** Options for {@link useUserReputation}. */
+interface UseUserReputationOptions {
+    /** The wallet to score. */
+    address: Hex | undefined;
+    /** @deprecated Reputation is PulseChain-only. Kept for compatibility. */
+    chainId?: ChainId;
+    /** Data source. Defaults to the `ProvexProvider` indexer adapter. */
+    source?: ReputationSource;
+    /** VIP status from the host's session. Defaults to `'normal'`. */
+    vipStatus?: VipStatus;
+    /**
+     * Kill switch. When true the hook reports the neutral default and never
+     * filters. Defaults to `ProvexProvider` `config.reputationDisabled`.
+     */
+    disabled?: boolean;
+}
+/** Return value of {@link useUserReputation}. */
+interface UseUserReputationResult {
     reputation: UserReputation;
+    /**
+     * The most recent signaled intent timestamp (ms since epoch). Pair with
+     * `getCooldownHours({ tier, providerKey })` to derive per-provider
+     * cooldown. Null if the wallet never signaled an intent.
+     */
+    lastSignaledIntentMs: number | null;
+    /** The wallet's VIP status as the host reported it. */
+    vipStatus: VipStatus;
+    /**
+     * The tier buyer-facing cooldown and cap filtering should use, or `null`
+     * for "do not filter" (VIP status unknown, or the kill switch is on). Use
+     * this, not `reputation.tier`, for anything that hides providers or blocks
+     * amounts.
+     */
+    filteringTier: TakerTier | null;
     isLoading: boolean;
     error: Error | null;
-    refetch: () => void;
-};
+    refetch: () => Promise<void>;
+}
+/**
+ * Compute the user-facing reputation from one stats row and the last
+ * signaled-intent timestamp that starts the cooldown clock.
+ *
+ * Taker and maker volume add at 1.0x weight. The lock score is diluted by
+ * the combined fulfilled count, so a long history earns relief from late
+ * cancellations. Each penalty step drops the tier by one rung.
+ *
+ * @param stats - The raw stats row, or `null` when not yet loaded
+ * @param pulseTimestamp - Last signaled intent in seconds, or `null` if never
+ * @param now - Clock injection for tests (defaults to the current time)
+ */
+declare function computeUserReputation({ stats, pulseTimestamp, now, }: {
+    stats: ReputationStats | null | undefined;
+    pulseTimestamp: bigint | number | null | undefined;
+    now?: () => Date;
+}): UserReputation;
+/**
+ * The default {@link ReputationSource}: reads the `ProvexProvider` indexer
+ * adapter. The adapter row has no maker fields, so tiers from this source
+ * count taker volume only. Apps with maker stats pass their own source.
+ */
+declare const useIndexerReputationSource: ReputationSource;
+/**
+ * Fetch and compute a wallet's reputation tier.
+ *
+ * @example
+ * ```ts
+ * const { reputation, filteringTier } = useUserReputation({
+ *   address,
+ *   vipStatus,           // from your session
+ *   disabled: false,     // your kill switch
+ * })
+ * ```
+ */
+declare function useUserReputation({ address, source, vipStatus, disabled, }: UseUserReputationOptions): UseUserReputationResult;
 /**
- * Get display info for a tier.
+ * Display info for a tier: name, caps, cooldown, badge color and volume band.
  */
 declare function getTierDisplayInfo(tier: TakerTier): {
     name: string;
@@ -136,6 +270,37 @@ declare function getTierDisplayInfo(tier: TakerTier): {
     volumeRangeDisplay: string;
 };
 
+/**
+ * @fileoverview Deprecated alias for the reputation hook.
+ *
+ * `useReputation` was the first reputation hook in `@provex/react`. The
+ * maker+taker model in {@link useUserReputation} replaced it. This file keeps
+ * the old export names working so the change stays non-breaking in 1.x.
+ *
+ * @deprecated Import `useUserReputation` and `getTierDisplayInfo` from
+ *   `@provex/react` instead.
+ */
+
+/**
+ * Fetch and compute a wallet's reputation tier through the
+ * `ProvexProvider` indexer adapter.
+ *
+ * Reputation is PulseChain-only now, so `chainId` no longer changes the data
+ * source. It stays on the signature for compatibility.
+ *
+ * @deprecated Use {@link useUserReputation}. It adds maker volume, VIP
+ *   status, `filteringTier` and an explicit kill switch.
+ */
+declare function useReputation({ address, chainId, }: {
+    address: Hex | undefined;
+    chainId: ChainId;
+}): {
+    reputation: UserReputation;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+};
+
 /**
  * @fileoverview Hook for checking nullifier usage (double-spend prevention).
  *
@@ -359,6 +524,59 @@ declare const useV3Escrow: ({ chainId, escrowAddress, onSlowSync, onTransactionC
     refetchDepositCounter: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<bigint, Error>>;
 };
 
+/**
+ * @fileoverview Indexer sync utilities for waiting on blockchain state.
+ *
+ * Provides polling functions to wait for transactions and state changes
+ * to be indexed before updating the UI.
+ *
+ * @remarks
+ * These functions accept query callbacks instead of importing a specific
+ * indexer implementation. This allows consumers to bring their own data
+ * source (Ponder, The Graph, custom API, etc.).
+ *
+ * @see {@link useTransactionWithIndexer} for the React hook wrapper
+ */
+
+/**
+ * Poll until a deposit reaches a specific status.
+ *
+ * @param queryDeposit - Function to query deposit state (from IndexerAdapter)
+ * @param depositIdHex - Serialized deposit orderId hex
+ * @param status - Target status to wait for
+ * @param onSuccess - Called when status is reached
+ * @param onSlowSync - Called once if sync exceeds threshold
+ * @param slowSyncThresholdMs - Threshold in ms before calling onSlowSync (default 15000)
+ * @param clock - Time source for the poll delay and the threshold (default systemClock)
+ */
+declare const checkMutation: ({ queryDeposit, depositIdHex, status, onSuccess, onSlowSync, slowSyncThresholdMs, clock, }: {
+    queryDeposit: IndexerAdapter["getDepositById"];
+    depositIdHex: Hex;
+    status: string;
+    onSuccess?: () => void;
+    onSlowSync?: () => void;
+    slowSyncThresholdMs?: number;
+    clock?: Clock;
+}) => Promise<void>;
+/**
+ * Poll until a transaction is indexed.
+ *
+ * @param queryTransaction - Function to query transaction state (from IndexerAdapter)
+ * @param hash - Transaction hash to wait for
+ * @param onSuccess - Called when the transaction is found
+ * @param onSlowSync - Called once if sync exceeds threshold
+ * @param slowSyncThresholdMs - Threshold in ms before calling onSlowSync (default 15000)
+ * @param clock - Time source for the poll delay and the threshold (default systemClock)
+ */
+declare const checkTransactionIndexed: ({ queryTransaction, hash, onSuccess, onSlowSync, slowSyncThresholdMs, clock, }: {
+    queryTransaction: IndexerAdapter["getTransactionByHash"];
+    hash: Hex;
+    onSuccess?: () => void;
+    onSlowSync?: () => void;
+    slowSyncThresholdMs?: number;
+    clock?: Clock;
+}) => Promise<void>;
+
 /**
  * Phase of the transaction lifecycle.
  */
@@ -615,7 +833,7 @@ declare class ProveXClient {
      * Handles all encoding internally:
      * 1. Registers payee details with the API (so buyers can discover them)
      * 2. Hashes provider keys and currency codes to bytes32
-     * 3. Expands sub-providers (e.g., 'zelle' → zelle-chase, zelle-bofa, zelle-citi)
+     * 3. Collapses bank-level keys to their rail (e.g., 'zelle-chase' → 'zelle'); Zelle is one rail
      * 4. Encodes gating service witness signers
      * 5. Submits the on-chain transaction
      *
@@ -702,12 +920,6 @@ declare class ProveXClient {
     registerMaker(params: MakerRegistrationParams): Promise<{
         id: string;
     } | 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.
-     */
-    getAttestation(params: AttestationParams): Promise<AttestationResponse>;
     /** Make a POST request to the API. */
     private apiPost;
     waitForTransactionIndexed(hash: Hex): Promise<void>;
@@ -797,6 +1009,145 @@ declare function useOrchestratorAddress({ escrowAddress, chainId, enabled, }: {
     enabled?: boolean;
 }): UseQueryResult<Hex, Error>;
 
+/**
+ * @fileoverview Pure builder for the wallet-backed {@link ProvingClient} that
+ * {@link useProvingFlow} hands to the shared `@provex/proving` machine.
+ *
+ * It holds the `fulfillIntent` body that lived in the Provex app's
+ * `useProvingClientShim`. The body mirrors the order the transaction-flight
+ * strip depends on. No React and no wallet library is imported here: the
+ * caller injects the wallet write, the public client and the gas inputs.
+ */
+
+/** Fee inputs that a gas oracle returns for one transaction. */
+interface GasInputs {
+    maxPriorityFeePerGas?: bigint;
+    maxFeePerGas?: bigint;
+}
+/** Arguments the wallet write receives for the `fulfillIntent` call. */
+interface WalletFulfillWriteArgs extends GasInputs {
+    address: Hex;
+    abi: unknown;
+    functionName: 'fulfillIntent';
+    args: readonly unknown[];
+    /**
+     * Pins the broadcast to the settlement chain. A wallet library that honors
+     * this field refuses to send on another chain, so the nullifier can only
+     * settle on the chain we intend.
+     */
+    chainId?: number;
+}
+/** Encoded `fulfillIntent` call for one attestation. */
+interface EncodedFulfill {
+    args: readonly unknown[];
+    calldata: Hex;
+    abi: unknown;
+}
+/** Data for the speed-up prefill that the transaction-flight strip stores. */
+interface FulfillPrefill {
+    to: Hex;
+    data: Hex;
+    value: bigint;
+    originalTip?: bigint;
+}
+/** Everything {@link createWalletProvingClient} needs. All values are resolved. */
+interface WalletProvingClientOptions {
+    /** Orchestrator contract address for the settlement chain. */
+    orchestratorAddress: Hex;
+    /** Settlement chain. It also pins the wallet write. */
+    chainId: number;
+    /** Wallet write bound to the connected wallet. */
+    writeContract: (args: WalletFulfillWriteArgs) => Promise<Hex>;
+    /**
+     * Public client used to wait for the receipt. When it is undefined (before
+     * wallet hydration) the client skips the wait and returns no receipt.
+     */
+    publicClient: {
+        waitForTransactionReceipt: (args: {
+            hash: Hex;
+        }) => Promise<unknown>;
+    } | undefined;
+    /** Registry read. It already holds the payment method, so it takes the nullifier only. */
+    checkNullifierUsed: (nullifier: Hex) => Promise<boolean | null>;
+    /** Gas oracle for this transaction. */
+    getGasInputs: () => Promise<GasInputs>;
+    /** Replaces {@link encodeOrchestratorFulfill}. Optional. */
+    encodeFulfill?: (attestation: V3AttestationResponseObject, verificationData: Hex, intentHash: Hex) => EncodedFulfill;
+    /** Called after the broadcast and before the hash callback. Optional. */
+    onPrefill?: (prefill: FulfillPrefill, gasInputs: GasInputs, hash: Hex) => void;
+}
+
+/**
+ * @fileoverview useProvingFlow — the one headless hook that drives the enclave
+ * proving pipeline (authenticate, capture, attest, fulfill) for @provex/react
+ * consumers and for the Provex app.
+ *
+ * It wraps `useProving` from @provex/proving. It imports no Chakra, no router
+ * and no wallet-connect library. The caller injects wallet writes and gas
+ * inputs through the `rail` option.
+ */
+
+/** The rail submits the transaction through an injected wallet write. */
+interface WalletProvingRail extends Omit<WalletProvingClientOptions, 'chainId'> {
+    kind: 'wallet';
+}
+/** The rail submits the transaction through a ready-made `fulfillIntent`. */
+interface ClientProvingRail {
+    kind: 'client';
+    /** For example `ProveXClient.fulfillIntent`. */
+    fulfillIntent: ProvingClient['fulfillIntent'];
+    /** Registry read. It already holds the payment method, so it takes the nullifier only. */
+    checkNullifierUsed: (nullifier: Hex) => Promise<boolean | null>;
+}
+/** How the flow reads the nullifier registry and submits `fulfillIntent`. */
+type ProvingRail = WalletProvingRail | ClientProvingRail;
+/** Options for {@link useProvingFlow}. All values are already resolved. */
+interface UseProvingFlowOptions {
+    /** Wallet write, gas inputs and registry read. Memoize it: a new object builds a new client. */
+    rail: ProvingRail;
+    /** The capture request for the selected deposit, payment method and intent. */
+    request: CaptureRequest;
+    /** Payment method id for the nullifier registry lookup. */
+    paymentMethodId: Hex;
+    /**
+     * Settlement chain that pins the rail. Defaults to `request.chainId`.
+     * `useProving` refuses to run when the two differ.
+     */
+    chainId?: number;
+    /**
+     * Capture adapter override. When it is omitted, the hook builds the
+     * extension enclave adapter from `window.peer`. Tests inject a fake here.
+     */
+    captureAdapter?: CaptureAdapter;
+    /** Gate origin for the default extension enclave adapter. */
+    attestationBaseUrl: string;
+    /** Enclave origin for the default adapter. Left out when it is undefined. */
+    attestationServiceUrl?: string;
+    /** Fires when the wallet popup is about to open. */
+    onAwaitingSignature?: () => void;
+    /** Receives the broadcast transaction hash. */
+    onTransactionHash?: (hash: Hex) => void;
+    /** Fires once when the flow reaches `complete`. */
+    onComplete?: (attestation: V3AttestationResponseObject) => void;
+}
+/** Return shape of {@link useProvingFlow}. */
+interface UseProvingFlowReturn {
+    state: ProvingState;
+    authenticate: () => Promise<void>;
+    fulfill: () => Promise<void>;
+    retryVerification: () => Promise<void>;
+    retrySubmission: () => Promise<void>;
+    /** Bridge for the transaction picker that the capture adapter opens. */
+    manualSelect: ManualTransactionSelect;
+}
+/**
+ * Drive the enclave proving pipeline.
+ *
+ * @param options - Resolved dependencies. The hook resolves no contract itself.
+ * @returns The `useProving` state and actions, plus the manual-select bridge.
+ */
+declare function useProvingFlow(options: UseProvingFlowOptions): UseProvingFlowReturn;
+
 /**
  * @fileoverview useProvexBuy — headless state machine for the buy flow.
  *
@@ -950,4 +1301,4 @@ declare function CompletePhase({ className, style, render, }: PhaseRenderProps<C
  */
 declare function ProvexBuy({ wallet, onIntentSignaled, onComplete, paymentMethods, className, style, theme, }: BuyProps): react_jsx_runtime.JSX.Element;
 
-export { AttestationParams, AttestationResponse, BrowsePhase, type BrowsePhaseState, BuyProps, type CancelIntentStatus, CommittedPhase, type CommittedPhaseState, CompletePhase, type CompletePhaseState, CreateDepositParams$1 as CreateDepositParams, CreateDepositRawParams, FulfillIntentParams, IndexedDeposit, IndexedIntent, IndexerAdapter, MakerRegistrationParams, type MutationSyncOptions, PaginatedResult, PaginationOptions, PayeeDetails, PhaseRenderProps, PreparedTransaction, type ProtocolFeesResult, ProveXClient, ProveXClientConfig, ProvexBuy, ProvexBuyProvider, type ProvexBuyProviderProps, ProvingPhase, type ProvingPhaseActions, type ProvingPhaseState, type ReleaseFundsStatus, ReputationData, SignalIntentParams, SignalIntentResult, type TransactionPhase, TransactionResult, type TransactionSyncOptions, type UseProtocolFeesParams, UseProvexBuyOptions, UseProvexBuyReturn, type UseTransactionWithIndexerOptions, type CreateDepositParams as V3EscrowCreateDepositParams, type V3EscrowStatus, WalletAdapter, WritableMethod, createProveXClient, getTierDisplayInfo, useAllowance, useCancelIntent, useNullifierRegistry, useOrchestratorAddress, useProtocolFeePercentage, useProtocolFees, useProveXClient, useProvexBuy, useProvexBuyContext, useReleaseFundsToPayer, useReputation, useTransactionWithIndexer, useV3Escrow };
+export { BrowsePhase, type BrowsePhaseState, BuyProps, type CancelIntentStatus, type ClientProvingRail, Clock, CommittedPhase, type CommittedPhaseState, CompletePhase, type CompletePhaseState, CreateDepositParams$1 as CreateDepositParams, CreateDepositRawParams, type EncodedFulfill, FulfillIntentParams, type FulfillPrefill, type GasInputs, IndexedDeposit, IndexedIntent, IndexerAdapter, MakerRegistrationParams, type MutationSyncOptions, PaginatedResult, PaginationOptions, PayeeDetails, PhaseRenderProps, PreparedTransaction, type ProtocolFeesResult, ProveXClient, ProveXClientConfig, ProvexBuy, ProvexBuyProvider, type ProvexBuyProviderProps, ProvingPhase, type ProvingPhaseActions, type ProvingPhaseState, type ProvingRail, type ReleaseFundsStatus, ReputationData, type ReputationSource, type ReputationSourceResult, type ReputationStats, SignalIntentParams, SignalIntentResult, type TransactionPhase, TransactionResult, type TransactionSyncOptions, type UseProtocolFeesParams, UseProvexBuyOptions, UseProvexBuyReturn, type UseProvingFlowOptions, type UseProvingFlowReturn, type UseTransactionWithIndexerOptions, type UseUserReputationOptions, type UseUserReputationResult, type CreateDepositParams as V3EscrowCreateDepositParams, type V3EscrowStatus, type VipStatus, WalletAdapter, type WalletFulfillWriteArgs, type WalletProvingRail, WritableMethod, checkMutation, checkTransactionIndexed, computeUserReputation, createProveXClient, filteringTierFor, getTierDisplayInfo, useAllowance, useCancelIntent, useIndexerReputationSource, useNullifierRegistry, useOrchestratorAddress, useProtocolFeePercentage, useProtocolFees, useProveXClient, useProvexBuy, useProvexBuyContext, useProvingFlow, useReleaseFundsToPayer, useReputation, useTransactionWithIndexer, useUserReputation, useV3Escrow };