@nexus-cross/dapp-ui 1.3.9 → 1.3.10-beta.10

package/dist/index.d.cts

@@ -3,6 +3,7 @@ import * as React from 'react';
 import { Component, ReactNode, ErrorInfo, CSSProperties } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryOptions } from '@tanstack/react-query';
 
 type Environment = "dev" | "stage" | "production";
 type Theme = "dark" | "light";
@@ -91,8 +92,8 @@ declare class DappUiErrorBoundary extends Component<DappUiErrorBoundaryProps, Da
     render(): ReactNode;
 }
 
-type DappUiFeature = "app_launcher" | "bridge" | "connect_button" | "send" | "skills" | "wallet_connect" | "wallet_info" | "wallet_portfolio";
-type DappUiFlow = "connect" | "send" | "bridge" | "withdraw";
+type DappUiFeature = "app_launcher" | "bridge" | "connect_button" | "relay" | "send" | "skills" | "wallet_connect" | "wallet_info" | "wallet_portfolio";
+type DappUiFlow = "connect" | "send" | "bridge" | "withdraw" | "relay";
 type DappUiFailureReason = "user-rejected" | "insufficient-gas" | "timeout" | "contract-reverted" | "network" | "unknown";
 interface TrackDappUiFunnelOptions {
     status?: "success" | "failure";
@@ -280,7 +281,7 @@ interface SendTransactionArgs {
     maxFeePerGas?: bigint;
     maxPriorityFeePerGas?: bigint;
 }
-type SendTransactionFn = (args: SendTransactionArgs) => Promise<`0x${string}`>;
+type SendTransactionFn$1 = (args: SendTransactionArgs) => Promise<`0x${string}`>;
 interface GetTransactionReceiptArgs {
     hash: `0x${string}`;
     chainId?: number;
@@ -398,7 +399,7 @@ type LpBalanceReaderFn = (pairAddresses: string[]) => Promise<Record<string, LpB
  * game-swap `/portfolio` pool 항목의 토큰 참조.
  * NOTE: CROSS 쪽(token_b)은 백엔드가 메타데이터 없이 내려준다 —
  * `symbol: ""`, `name: ""`, `decimals: 0`, `logo_url` 누락. 소비 측에서
- * symbol은 "CROSS"로, decimals는 18로 간주해야 한다 (실응답 확인 기준).
+ * symbol은 "ONE"으로, decimals는 18로 간주해야 한다 (실응답 확인 기준).
  */
 interface GameSwapTokenRef {
     address: string;
@@ -679,7 +680,7 @@ interface SendPageProps {
     token: SendAsset;
     tokens?: SendAsset[];
     onTokenChange?: (token: SendAsset) => void;
-    sendTransaction?: SendTransactionFn;
+    sendTransaction?: SendTransactionFn$1;
     getTransactionReceipt?: GetTransactionReceiptFn;
     /**
      * 확인 단계에서 표시할 가스/수수료 추정 함수. 주입되지 않으면 Gas/Est.Time/Max.Gas 행은 "—"로 표시된다.
@@ -715,7 +716,7 @@ interface SendFlowProps {
     token: SendAsset;
     tokens?: SendAsset[];
     onTokenChange?: (token: SendAsset) => void;
-    sendTransaction?: SendTransactionFn;
+    sendTransaction?: SendTransactionFn$1;
     getTransactionReceipt?: GetTransactionReceiptFn;
     estimateGas?: EstimateGasFn;
     getTokenPriceUsd?: (token: SendAsset) => number | undefined;
@@ -976,7 +977,7 @@ interface WalletInfoProps {
      * Send 페이지의 일반 토큰 전송에 사용할 외부 트랜잭션 전송 함수.
      * wagmi의 `sendTransactionAsync`를 그대로 전달해도 호환된다.
      */
-    sendTransaction?: SendTransactionFn;
+    sendTransaction?: SendTransactionFn$1;
     getTransactionReceipt?: GetTransactionReceiptFn;
     /**
      * Send 확인 단계에서 표시할 가스/수수료 추정 함수.
@@ -1244,7 +1245,7 @@ interface WalletPortfolioProps {
      * wagmi의 `sendTransactionAsync`를 그대로 전달해도 호환된다.
      * 미주입 시 Withdraw는 기존 외부 링크로 폴백한다.
      */
-    sendTransaction?: SendTransactionFn;
+    sendTransaction?: SendTransactionFn$1;
     /** 내장 Withdraw 확인 화면의 가스 추정 콜백. 미주입 시 지갑 추정에 위임. */
     estimateGas?: EstimateGasFn;
     /**
@@ -1302,7 +1303,7 @@ interface WalletPortfolioBodyProps {
      * wagmi의 `sendTransactionAsync`를 그대로 전달해도 호환된다.
      * 미주입 시 Withdraw는 기존 외부 링크로 폴백한다.
      */
-    sendTransaction?: SendTransactionFn;
+    sendTransaction?: SendTransactionFn$1;
     /** 내장 Withdraw 확인 화면의 가스 추정 콜백. 미주입 시 지갑 추정에 위임. */
     estimateGas?: EstimateGasFn;
     /**
@@ -1619,7 +1620,7 @@ interface ConnectButtonProps {
     modal?: boolean;
     connectorId?: ConnectorId;
     /** Send 페이지의 일반 토큰 전송에 사용할 외부 트랜잭션 전송 함수. */
-    sendTransaction?: SendTransactionFn;
+    sendTransaction?: SendTransactionFn$1;
     getTransactionReceipt?: GetTransactionReceiptFn;
     /**
      * Send 확인 단계의 가스/수수료 추정 함수. 미주입 시 SendPage Confirm 화면의
@@ -1748,4 +1749,924 @@ interface SkillsButtonProps {
 declare const DEFAULT_SKILLS_HREF = "https://www.onechain.nexus/skills";
 declare function SkillsButton({ label, href, onClick, className, style, theme, disabled, isLoading, loadingLabel, openInNewTab, type, }: SkillsButtonProps): react_jsx_runtime.JSX.Element;
 
-export { APPLE_ICON, AppLauncher, AppLauncherContent, type AppLauncherContentProps, type AppLauncherProps, AppLauncherTrigger, type AppLauncherTriggerProps, type AppLauncherTriggerStyle, type AppLauncherUsageMode, BINANCE_ICON, type BridgeAmountSource, type BridgeApprovalInfo, type BridgeApproveFn, type BridgeFailedInfo, BridgeFlow, type BridgeFlowProps, type BridgeGetApprovalFn, type BridgeGetToTokensFn, type BridgeHistoryItem, type BridgeInfoRow, type BridgeInfoTokenRef, type BridgeLiquidityInfo, type BridgePathType, type BridgeQuoteFn, type BridgeQuoteInput, type BridgeQuoteResult, type BridgeStatus, type BridgeStep, type BridgeSubmitFn, type BridgeSubmittedInfo, type BridgeToken, type BridgeTxSummary, CHAINS_CONFIG_FILE, CONNECTOR_REGISTRY, CROSSX_ICON, type ChainDisplayMeta, type ChainId, type ChainsConfig, ConnectButton, type ConnectButtonProps, type ConnectButtonStyle, ConnectorId, type ConnectorMeta, type CrossdPosition, type CrossdPositionDetail, type CrossdPositionPoolRef, type CrossdPositionTokenRef, DEFAULT_SKILLS_HREF, DappUiErrorBoundary, type DappUiErrorBoundaryProps, type DappUiFailureReason, type DappUiFeature, type DappUiFlow, type DrawerDirection$1 as DrawerDirection, type Environment, type EstimateGasArgs, type EstimateGasFn, GOOGLE_ICON, type GameSwapPool, type GameSwapTokenRef, type GasEstimate, type GetTransactionReceiptArgs, type GetTransactionReceiptFn, type GlobalMenu, type GlobalMenuItem, type GlobalMenuItemAssetUrl, type GlobalMenuItemServiceStatus, type GlobalMenuItemUrl, type InitDappUiSentryOptions, type LpBalanceInfo, type LpBalanceReaderFn, METAMASK_ICON, type OnOutlink, type OutlinkCategory, type OutlinkContext, type OutlinkOrigin, PORTFOLIO_SECTIONS, type PortfolioSection, type PreferredToken, type RecentSendAddress, SOCIAL_REGISTRY, type SendAccount, type SendAsset, SendFlow, type SendFlowProps, type SendPageProps, type SendStatus, type SendTransactionArgs, type SendTransactionFn, SkillsButton, type SkillsButtonProps, type SkillsButtonStyle, type SocialConfig, type SocialHandlers, type SocialId, type StakingRewardsInfo, type StakingRewardsReaderFn, TOKEN_STATS_QUERY_KEY, type Theme, type TokenBalance, type TokenBalanceResponse, type TokenStats, type TokenStatsResponse, type TrackDappUiFunnelOptions, type TransactionReceiptResult, USER_BALANCE_QUERY_KEY, WALLET_REGISTRY, type WalletConfig, WalletConnectModal, type WalletConnectModalContentProps, type WalletConnectModalProps, type WalletConnectModalStyle, type WalletConnectModalTriggerProps, type WalletHandlers, type WalletId, WalletInfo, type WalletInfoContentProps, type WalletInfoFooterProps, type WalletInfoNavProps, type WalletInfoProps, type WalletInfoStyle, type WalletInfoTriggerProps, WalletPortfolio, WalletPortfolioBody, type WalletPortfolioBodyProps, type WalletPortfolioContentProps, type WalletPortfolioProps, type WalletPortfolioTriggerProps, type WalletProvider, announceAppLauncherUsage, captureDappUiException, getChainDisplay, getDappUiSentryScope, initDappUiSentry, normalizeFailureReason, resolveEnvironment, setDappUiAnalyticsUser, trackDappUiEvent, trackDappUiFunnel, useChainDisplay, useChainsConfig, useGlobalMenu, useTokenBalance, useTokenStats, useWalletDetect };
+/** One origin-side ERC-20 (or native, address = zero) token the UI may offer. */
+interface Token {
+    symbol: string;
+    address: string;
+    decimals: number;
+    logoUrl?: string;
+}
+/** The fixed destination asset every order delivers: crossd on CROSS. */
+interface Destination {
+    symbol: string;
+    chainId: number;
+    address: string;
+    decimals: number;
+    note?: string;
+}
+/** Origin chain VM family: "evm" (default) or "svm" (Solana). */
+type ChainKind = 'evm' | 'svm';
+/**
+ * One delivery-side asset an order's crossd-equivalent output may be paid
+ * out as -- the default target (isDefault: true) is crossd itself
+ * (byte-identical to Catalog.destination); non-default targets are
+ * alternate payout assets the user may opt into (see GET /v1/deposit-address's
+ * `target` query param). `external: true` marks a target delivered via an
+ * external adapter (e.g. pONEUSD) rather than natively minted -- the UI
+ * shows an extra trust note for these (Task 9).
+ */
+type Target = {
+    symbol: string;
+    address: string;
+    decimals: number;
+    isDefault: boolean;
+    external: boolean;
+};
+/** One supported (chain, token) pair the UI can offer as an order's source. */
+interface OriginOption {
+    chainId: number;
+    chainName: string;
+    /**
+     * VM family of the origin chain. "svm" (Solana) origins are display-only:
+     * the connected EVM wallet cannot sign them, so no one-click deposit or
+     * balance read is offered -- the user pays out-of-band from a Solana wallet.
+     */
+    kind: ChainKind;
+    token: Token;
+    /** Smallest-unit base-10 integer string (matches Token.decimals). */
+    minAmount: string;
+    /** Smallest-unit base-10 integer string; absent = no configured cap. */
+    maxAmount?: string;
+}
+/**
+ * Which order-creation flow is live: "standing" (GET /v1/deposit-address
+ * returns a stable, reusable per-user address) or "per_order" (the legacy
+ * flow, a fresh forwarder minted per POST /v1/orders). See
+ * internal/catalog.Catalog.AddressMode's doc comment.
+ */
+type AddressMode = 'standing' | 'per_order';
+/** GET /v1/config response: the curated catalog of origins + fixed destination. */
+interface Catalog {
+    destination: Destination;
+    origins: OriginOption[];
+    addressMode: AddressMode;
+    /**
+     * The user-selectable delivery targets an order may pay out as (Task 4).
+     * Always includes the default target (crossd, byte-identical to
+     * `destination`). Defaults to `[]` when the backend response omits this
+     * field entirely -- back-compat with an older backend that predates
+     * per-target delivery (see createRelayClient's getConfig).
+     */
+    targets: Target[];
+}
+/** POST /v1/quote request body. */
+interface QuoteRequest {
+    originChainId: number;
+    originCurrency: string;
+    /** Smallest-unit base-10 integer string. */
+    amount: string;
+}
+/** POST /v1/quote response body. */
+interface QuoteResult {
+    /** Smallest-unit (BSC USDT, 18 decimals) base-10 integer string. */
+    expectedBscUsdt: string;
+    belowMin: boolean;
+    /**
+     * Smallest-unit (crossd, catalog.destination.decimals) base-10 integer
+     * string. Currently assumed at 1:1 parity with BSC USDT -- see
+     * assumesParity.
+     */
+    expectedCrossd: string;
+    assumesParity: boolean;
+    /**
+     * The fee DEDUCTED FROM the bridged amount, in USD, as a decimal string --
+     * Relay's relayer fee plus any app surcharge (upstream af35dd5). It is
+     * exactly what accounts for the gap between what the user sends and
+     * `expectedBscUsdt`.
+     *
+     * It deliberately EXCLUDES the user's own origin-chain gas: that is paid from
+     * their wallet in the origin chain's native token, the wallet already quotes
+     * it at signing time, and none of it comes out of the bridged amount.
+     *
+     * Absent means UNKNOWN, never free -- render absence as absence. "$0.00" for
+     * a fee nobody could compute is the one wrong reading. (A genuine zero, e.g.
+     * the direct BSC-USDT route with no Relay leg, is also absent rather than
+     * "0": no Relay leg means no relayer fee to report.)
+     */
+    feeUsd?: string;
+    /**
+     * How many seconds this quote stays valid. Drives the refresh cadence in
+     * useDepositAddress -- the widget previously hardcoded 30s with no
+     * relationship to the quote's real lifetime. Absent when the backend has no
+     * TTL configured, in which case the client keeps its own default interval.
+     *
+     * There is deliberately no eta/duration field here. An earlier version of
+     * this type carried `etaSeconds` on the assumption that Relay's quote
+     * reports timing; it does not -- the response has no ETA field of any kind
+     * -- so it was removed rather than left permanently undefined.
+     */
+    ttl?: number;
+}
+/** GET /v1/deposit-address request query params -- no amount: a standing
+ * address is resolved purely from (user, originChainId, originCurrency),
+ * independent of any deposit size. */
+interface DepositAddressRequest {
+    user: string;
+    originChainId: number;
+    originCurrency: string;
+}
+/**
+ * GET /v1/deposit-address response body -- a stable, reusable deposit
+ * address for this (user, origin chain, origin token). The same request
+ * always resolves to the same address; no order/deposit is created by
+ * fetching it, and it accepts any number of deposits over time (see
+ * internal/standing.Service.GetOrCreateDepositAddress).
+ */
+interface DepositAddressResult {
+    user: string;
+    forwarder: string;
+    version: number;
+    depositAddress: string;
+    originChainId: number;
+    originCurrency: string;
+}
+/**
+ * One row of GET /v1/orders?user=...'s "orders" array. A single order can
+ * aggregate several deposits made to the same reusable forwarder; `deposits[]`
+ * is the per-arrival identity. Amount fields are smallest-unit base-10 integer
+ * strings, "" when not yet known.
+ */
+interface OrderSummary {
+    orderId: string;
+    status: string;
+    source: string;
+    amountIn: string;
+    expectedOut: string;
+    bscBridgeTx: string;
+    originChainId: number;
+    originCurrency: string;
+    /** CROSS delivery-token symbol this order pays out as (a Catalog.targets
+     * symbol, e.g. "pONEUSD"); "" / omitted means the default target. Used to
+     * label the "out" side with the actual delivered token. */
+    target?: string;
+    forwarderVersion: number;
+    /** RFC3339 timestamp. */
+    createdAt: string;
+    /** What the user ACTUALLY received, observed from the CROSS delivery
+     * transfer. Distinct from expectedOut, which is the pre-delivery projection
+     * after fees -- the two differ by swap slippage and any executor fallback.
+     * "" until delivery, and for orders delivered before the backend recorded it. */
+    amountOut?: string;
+    /** The CROSS-side transaction that delivered the funds. "" until delivery. */
+    deliveryTxHash?: string;
+    /** RFC3339 timestamp of the COMPLETED transition -- when the user received
+     * the funds. Absent for orders that never completed. */
+    completedAt?: string;
+    /** The individual deposits this delivery paid out, oldest first. There can be
+     * SEVERAL: a user may top up a little at a time and the sweeper aggregates
+     * whatever has arrived into one order. Empty when the backend has not
+     * attributed the deposits to this order yet. */
+    deposits?: OrderDeposit[];
+}
+/** One deposit inside an order, as GET /v1/orders reports it.
+ *
+ * originChainId/originCurrency are the chain and token the user ACTUALLY paid,
+ * which the order itself cannot report (one reusable deposit address serves
+ * every origin route, so the swept balance carries no memory of where it came
+ * from). They are absent when the backend has not attributed the deposit --
+ * for a DIRECT BSC deposit that is permanent and correct, since it has no
+ * cross-chain leg. */
+interface OrderDeposit {
+    /** Amount that arrived at the forwarder, in BSC USDT base units. NOT the
+     * amount sent on the origin chain, which is larger by Relay's fees and
+     * denominated in the origin token's own decimals. */
+    amount: string;
+    blockNumber: number;
+    originChainId?: number;
+    originCurrency?: string;
+    /** The BSC-side arrival (transfer into the forwarder). */
+    txHash: string;
+    /** The user's own send on the ORIGIN chain -- what the "Deposit" step links
+     * to. Absent when unattributed. */
+    originTxHash?: string;
+}
+type StepStatus = 'done' | 'active' | 'pending';
+interface OrderStep {
+    key: string;
+    label: string;
+    status: StepStatus;
+}
+/**
+ * GET /v1/orders/{orderId} response body. "status" is the raw backend state
+ * (e.g. "AWAITING_DEPOSIT", "COMPLETED", "FAILED", ...); "steps" is the
+ * friendlier 3-stage deposit -> bridge -> deliver breakdown the UI renders.
+ */
+interface Order {
+    orderId: string;
+    status: string;
+    steps: OrderStep[];
+    bridgeIndex: string;
+    txs: {
+        bscBridge: string;
+        crossFinalize: string;
+        crossExecute: string;
+    };
+}
+/**
+ * GET /v1/recovery?user=... response body -- the permissionless self-recovery
+ * status for a user's standing forwarder on BSC. Task 1's endpoint; consumed
+ * by useRecovery (Task 2) to drive the settings-menu "Recover stuck funds"
+ * panel. Every recovery tx (factory.deploy, forwarder.execute/sweepToUser)
+ * takes no destination argument -- funds always route to `forwarder`'s
+ * immutable recipient, so this info is advisory/orientation only, never a
+ * capability check the UI should use to block the user.
+ */
+interface RecoveryInfo {
+    user: string;
+    /** The user's forwarder address on BSC for the requested target (CREATE2, deterministic from
+     * user+version+target). */
+    forwarder: string;
+    /** Whether `forwarder` has been deployed on-chain yet. */
+    isDeployed: boolean;
+    /** BSC USDT token contract address -- always BSC USDT regardless of `target` (the forwarder
+     * holds BSC USDT pre-bridge in every case). */
+    token: string;
+    decimals: number;
+    /** Smallest-unit base-10 integer string -- the forwarder's current token balance. */
+    balance: string;
+    /** The factory that deploys/derives `forwarder` for the requested target: the
+     * DepositorForwarderFactory for a depositor-kind target, the StandingForwarderFactory
+     * otherwise (recovery follow-up, multi-target). */
+    factory: string;
+    version: number;
+    /** Smallest-unit base-10 integer string -- the bridge's configured minimum. */
+    bridgeMinWei: string;
+    /** Server's best-effort recommendation: "execute" (balance clears the bridge minimum, so a
+     * normal delivery can complete), "sweep" (below minimum -- recover directly instead), or
+     * "none" (no balance to act on). Advisory only -- never used to disable an action. */
+    suggestedAction: 'execute' | 'sweep' | 'none';
+    /** True when the backend sees this balance as possibly mid-flight (e.g. a sweep/bridge job
+     * already in progress) -- advisory caution only, must NOT disable either recovery action. */
+    inFlight: boolean;
+    inFlightReason?: string;
+    /**
+     * Task 6/7: every known BSC token held at `forwarder` (not just the primary `token`/`balance`
+     * pair above, which only ever reports BSC USDT) -- lets the UI surface a MISDEPOSITED token
+     * (e.g. someone sent BUSD to a USDT-swap forwarder) that the top-level fields alone can't
+     * represent. Optional/omitted for an older backend that predates this field -- back-compat,
+     * byte-identical to pre-Task-6 behavior when absent (the UI falls back to `token`/`balance`).
+     * Each entry's `suggestedAction` mirrors the top-level one's semantics, per-token.
+     */
+    tokens?: {
+        address: string;
+        symbol: string;
+        decimals: number;
+        /** Smallest-unit base-10 integer string -- this token's current balance at `forwarder`. */
+        balance: string;
+        /** Server's advisory recoverable flag for this token -- never used to disable the sweep
+         * action (see `recover`'s doc in useRecovery.ts), only to decide which tokens the UI lists. */
+        recoverable: boolean;
+        suggestedAction: 'execute' | 'sweep' | 'none';
+    }[];
+}
+/** GET /v1/recovery request query params. */
+interface RecoveryRequest {
+    user: string;
+    /** Selected CROSS delivery target symbol (mirrors DepositAddressRequest's `target`) -- omitted
+     * (or empty) selects the configured default, preserving pre-multi-target behavior
+     * byte-for-byte. Passed through verbatim as "?target=" when set. */
+    target?: string;
+}
+
+/** Thrown for any non-2xx API response. `status` is the HTTP status code. */
+declare class RelayApiError extends Error {
+    status: number;
+    /** Parsed JSON error body when the response was valid JSON, else undefined. */
+    body?: unknown;
+    constructor(status: number, message: string, body?: unknown);
+}
+interface RelayClientOptions {
+    /** API origin, e.g. "https://orchestrator.example.com". Trailing slashes are stripped. */
+    baseUrl: string;
+}
+interface RelayClient {
+    /** GET /v1/config -- the curated origin catalog + fixed crossd destination. */
+    getConfig(): Promise<Catalog>;
+    /** POST /v1/quote -- a price-only preview, no order/deposit is created. */
+    getQuote(req: QuoteRequest): Promise<QuoteResult>;
+    /**
+     * GET /v1/deposit-address -- resolves the stable, reusable deposit
+     * address for (user, originChainId, originCurrency). No amount is
+     * involved and no order is created; the same address can receive any
+     * number of deposits of any size. Several deposits can be aggregated into
+     * one order when they jointly fund the same reusable forwarder.
+     *
+     * `target` (Task 8) is the delivery asset's symbol from
+     * `Catalog.targets` -- sent as `&target=<symbol>` only when it's a
+     * non-empty string; omitted otherwise, in which case the backend
+     * resolves the default target (byte-identical to pre-Task-6 behavior).
+     */
+    getDepositAddress(req: DepositAddressRequest, target?: string): Promise<DepositAddressResult>;
+    /**
+     * GET /v1/orders/{orderId} -- current status + stepper progress for one
+     * order. Reads are public (unauthenticated).
+     */
+    getOrder(orderId: string): Promise<Order>;
+    /**
+     * GET /v1/orders?user=... -- every order swept from deposits to that
+     * user's standing address(es) (newest-first, capped server-side).
+     */
+    listOrders(user: string): Promise<OrderSummary[]>;
+    /** Absolute URL of the SSE order-change stream for `user`
+     * (GET /v1/orders/stream?user=...). Emits `event: connected` on open,
+     * `event: orders-changed` when that user's orders change, and `:
+     * heartbeat` comments -- it carries no order data itself, so consumers
+     * always follow up with `listOrders`. */
+    ordersStreamUrl(user: string): string;
+    /**
+     * GET /v1/recovery?user=... -- permissionless self-recovery status for a
+     * user's forwarder on BSC (Task 1). `req.target` (optional) selects which
+     * per-target forwarder/factory to report -- omitted selects the
+     * configured default, byte-identical to pre-multi-target behavior.
+     * Purely informational -- fetching it never triggers or blocks any
+     * on-chain action. The response's `tokens[]` (Task 6/7 -- every known BSC
+     * token held at the forwarder) flows through as-is: it's plain JSON, so no
+     * extra parsing/mapping is needed beyond RecoveryInfo's own typing, and
+     * it's simply absent/undefined for an older backend that predates it.
+     */
+    getRecovery(req: RecoveryRequest): Promise<RecoveryInfo>;
+}
+/**
+ * Builds a framework-agnostic Relay API client. Uses plain `fetch` only --
+ * no react-query, no RainbowKit/wagmi. `baseUrl` is passed in explicitly (no
+ * `import.meta.env` coupling) so the widget can be embedded in any host app's
+ * own config/env story.
+ *
+ * No API key: the backend has no inbound key gate (upstream 83845fb removed
+ * the dead `apiKey`/X-API-Key plumbing -- a security control that does not
+ * exist must not appear in a public type).
+ */
+declare function createRelayClient(options: RelayClientOptions): RelayClient;
+
+interface DefaultToken {
+    chainId: number;
+    /** Token contract address, or the zero address for the chain's native asset. */
+    address: string;
+}
+
+type Hex = `0x${string}`;
+interface RelayTxRequest {
+    chainId: number;
+    to: Hex;
+    value?: bigint;
+    data?: Hex;
+}
+interface RelayContractCall {
+    chainId: number;
+    address: Hex;
+    abi: readonly unknown[];
+    functionName: string;
+    args: readonly unknown[];
+}
+interface RelayBalance {
+    value: bigint;
+    decimals: number;
+    symbol: string;
+}
+type SendTransactionFn = (req: RelayTxRequest) => Promise<Hex>;
+type WriteContractFn = (call: RelayContractCall) => Promise<Hex>;
+type ReadContractFn = (call: RelayContractCall) => Promise<unknown>;
+type SwitchChainFn = (chainId: number) => Promise<void>;
+type WaitForReceiptFn = (p: {
+    chainId: number;
+    hash: Hex;
+}) => Promise<{
+    status: "success" | "reverted";
+}>;
+type GetBalanceFn = (p: {
+    chainId: number;
+    address: Hex;
+    token?: Hex;
+}) => Promise<RelayBalance>;
+/** 지갑 주입 props — 전부 optional, 미주입 시 graceful degradation. */
+interface RelayWalletProps {
+    walletAddress?: string;
+    walletChainId?: number;
+    sendTransaction?: SendTransactionFn;
+    writeContract?: WriteContractFn;
+    readContract?: ReadContractFn;
+    switchChain?: SwitchChainFn;
+    waitForReceipt?: WaitForReceiptFn;
+    getBalance?: GetBalanceFn;
+}
+/** A recovery transaction confirmed successfully on BNB Smart Chain. */
+interface RecoverySuccessResult {
+    action: "execute" | "sweep";
+    forwarder: string;
+    actionTxHash: string;
+    /** Present only when this attempt first had to deploy the forwarder. */
+    deployTxHash?: string;
+}
+type RelayTheme = "dark" | "light";
+type RelayDrawerDirection = "bottom" | "left" | "right" | "top";
+/**
+ * Props of the `<RelayDeposit>` compound root (Task 11) — the union of
+ *
+ *   * `RelayWalletProps` (injected wallet capabilities, all optional),
+ *   * the source widget's own configuration props (relay-protocol
+ *     `packages/relay-widget/src/components/RelayDeposit.tsx`), minus its
+ *     `theme: 'auto'` option, which the shared modal shell doesn't have, and
+ *   * `ResponsiveShellProps`' modal/drawer knobs (theme/breakpoint/size/open),
+ *     re-declared here rather than extended so the public surface reads as one
+ *     flat prop list.
+ *
+ * `children` holds `<RelayDeposit.Trigger>` / `<RelayDeposit.Content>`.
+ */
+interface RelayDepositProps extends RelayWalletProps {
+    /** Pre-built client. Takes precedence over apiBaseUrl. */
+    client?: RelayClient;
+    /** Used to build a client via createRelayClient when `client` isn't passed. */
+    apiBaseUrl?: string;
+    /**
+     * Selects a built-in default relay API base URL (dev/stage/production) when
+     * `apiBaseUrl` isn't passed. `client`/`apiBaseUrl` still take precedence --
+     * this is only consulted when neither is provided. Omitted falls back to
+     * the same global environment resolution every other dapp-ui feature uses
+     * (see `resolveEnvironment`), defaulting to production.
+     */
+    environment?: Environment;
+    /** Restrict the catalog's origins to these chain ids. */
+    chains?: number[];
+    /** Controlled recipient; when provided the recipient input is hidden and no wallet
+     * connection is required to fetch a deposit address. Defaults to `walletAddress`. */
+    recipient?: string;
+    /** Require a valid connected wallet before the deposit flow can issue an
+     * address, quote an amount, or start live order/recovery reads. When enabled,
+     * the recipient is pinned to `walletAddress`; a controlled `recipient` cannot
+     * redirect the connected user's deposit. Defaults to `true` when
+     * `showRecipientInput` is explicitly `false`, otherwise `false` for the
+     * low-level public-address integration. `CrossRelayDeposit` always enables
+     * this guard. */
+    requireWalletConnection?: boolean;
+    /** Hide the editable recipient input even when `recipient` is NOT controlled
+     * (default `true` = original behavior). Hosts that lock the recipient to the
+     * connected wallet set this `false` so a disconnected user sees a connect
+     * prompt instead of a free-form address field — the deposit address can then
+     * only ever resolve to the logged-in wallet. */
+    showRecipientInput?: boolean;
+    /** Controlled human-decimal amount; when provided the amount input is hidden. Optional —
+     * it only drives the quote preview, and never blocks the deposit address. */
+    amount?: string;
+    /** Hide the amount input entirely (address-only, send-any-amount). Independent of `amount`. */
+    hideAmount?: boolean;
+    /** Render the EVM one-click deposit button (default `false`: the modal only
+     * offers the QR / copy-address manual deposit path). Opt in with `true` for
+     * hosts whose users connect external wallets that can sign on the origin
+     * chains — CROSS embedded-wallet users never can, hence the off default. */
+    showOneClickDeposit?: boolean;
+    /** Render the recovery gear menu ("Recover stuck funds", default `false`).
+     * Recovery signs on BSC with the connected wallet, which CROSS embedded-wallet
+     * users can never do — so the gear is hidden unless a host serving external
+     * wallets opts in. Even opted in, it still requires the injected
+     * `writeContract`/`readContract`/`waitForReceipt` capability trio. */
+    showRecovery?: boolean;
+    /** Which (chainId, token address) to default-select once the catalog loads. */
+    defaultToken?: DefaultToken;
+    /** Restricts the delivery-token picker to these symbols from `Catalog.targets`. */
+    targetTokens?: string[];
+    /** Which delivery-token symbol to select initially, instead of the catalog's own default. */
+    defaultTarget?: string;
+    /** Whether to render the delivery-token picker at all. Default `true`; the picker only
+     * ever renders when there is more than one target to choose from either way. */
+    showTargetSelector?: boolean;
+    /** Overrides the pinned factory set the one-click deposit verifies the forwarder against. */
+    trustedFactories?: readonly string[];
+    onDepositAddress?: (result: DepositAddressResult) => void;
+    /** Fired once per one-click deposit that CONFIRMED successfully, with the tx
+     * hash. NOT fired on submission, and NOT fired for a tx that reverted --
+     * watch `depositState` (phase/txHash/reverted) for those. Safe to treat as
+     * "the funds moved" (upstream 83845fb). */
+    onDeposited?: (txHash: string) => void;
+    /** Fired once after a recovery action receipt confirms successfully. */
+    onRecoverySuccess?: (result: RecoverySuccessResult) => void;
+    onError?: (error: Error) => void;
+    /** Called by the `Connect Wallet` CTA under the locked card that stands in for the QR
+     * while the required connected wallet (or, in low-level public-address mode,
+     * a usable recipient) is absent. Omitted — the locked card renders as text
+     * only, with no button. */
+    onRequestConnect?: () => void;
+    /** @deprecated The Deposit footer entry was removed. Retained as a no-op
+     * compatibility prop so existing hosts do not need an immediate migration. */
+    onOpenHistory?: () => void;
+    /** Extra class name(s) for the modal/drawer content element. */
+    className?: string;
+    theme?: RelayTheme;
+    mobileBreakpoint?: number;
+    drawerDirection?: RelayDrawerDirection;
+    dialogWidth?: string;
+    drawerMaxWidth?: string;
+    drawerMinWidth?: string;
+    style?: CSSProperties;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+/**
+ * Props of the `<RelayRecovery>` compound root — the standalone
+ * "Recover stuck funds" modal, i.e. the deposit wizard's gear panel lifted out
+ * into a modal of its own so a host can offer recovery WITHOUT the deposit
+ * flow (the gear inside `<RelayDeposit>` is unaffected and still opt-in via
+ * `showRecovery`).
+ *
+ * Extends `RelayWalletProps` because recovery is signing-first: unlike
+ * `<RelayHistory>` (read-only, no wallet capabilities at all), the whole point
+ * of this modal is that the USER signs the permissionless recovery tx on BSC.
+ * A wallet missing the `writeContract`/`readContract`/`waitForReceipt` trio
+ * gets a short note instead of a dead panel.
+ *
+ * `children` holds `<RelayRecovery.Trigger>` / `<RelayRecovery.Content>`.
+ */
+interface RelayRecoveryProps extends RelayWalletProps {
+    /** Pre-built client. Takes precedence over apiBaseUrl. */
+    client?: RelayClient;
+    /** Used to build a client via createRelayClient when `client` isn't passed. */
+    apiBaseUrl?: string;
+    /**
+     * Selects a built-in default relay API base URL (dev/stage/production) when
+     * `apiBaseUrl` isn't passed. `client`/`apiBaseUrl` still take precedence --
+     * this is only consulted when neither is provided. Omitted falls back to
+     * the same global environment resolution every other dapp-ui feature uses
+     * (see `resolveEnvironment`), defaulting to production.
+     */
+    environment?: Environment;
+    /**
+     * Optional assertion of whose forwarder to check/recover. Recovery is always
+     * pinned to the valid connected `walletAddress`; when this value is supplied
+     * it must match that wallet. A missing/invalid wallet or mismatch renders a
+     * short note and makes ZERO requests (no catalog, no recovery lookup).
+     */
+    recipient?: string;
+    /**
+     * Overrides the pinned factory allowlist recovery verifies against before
+     * signing -- only needed by a self-hosted deployment running its own
+     * factories. Same meaning (and the same fail-closed reasoning) as
+     * `RelayDepositProps.trustedFactories`.
+     */
+    trustedFactories?: readonly string[];
+    /** Fired once after a recovery action receipt confirms successfully. */
+    onRecoverySuccess?: (result: RecoverySuccessResult) => void;
+    onError?: (e: Error) => void;
+    /** Extra class name(s) for the modal/drawer content element. */
+    className?: string;
+    theme?: RelayTheme;
+    mobileBreakpoint?: number;
+    drawerDirection?: RelayDrawerDirection;
+    dialogWidth?: string;
+    drawerMaxWidth?: string;
+    drawerMinWidth?: string;
+    style?: CSSProperties;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+/**
+ * Props of the `<RelayHistory>` compound root (Task 12) — the standalone
+ * transfer-history modal built on the shared `ResponsiveShell` +
+ * `useRelayOrders`. `RelayDepositProps`'s simpler sibling: no wizard step,
+ * no catalog/target picking, no wallet-injected send/write capabilities —
+ * just an address to look up orders for and a list to render.
+ *
+ * `children` holds `<RelayHistory.Trigger>` / `<RelayHistory.Content>`.
+ */
+interface RelayHistoryProps {
+    /** Pre-built client. Takes precedence over apiBaseUrl. */
+    client?: RelayClient;
+    /** Used to build a client via createRelayClient when `client` isn't passed. */
+    apiBaseUrl?: string;
+    /**
+     * Selects a built-in default relay API base URL (dev/stage/production) when
+     * `apiBaseUrl` isn't passed. `client`/`apiBaseUrl` still take precedence --
+     * this is only consulted when neither is provided. Omitted falls back to
+     * the same global environment resolution every other dapp-ui feature uses
+     * (see `resolveEnvironment`), defaulting to production.
+     */
+    environment?: Environment;
+    /** History subject. Falls back to `walletAddress`; empty-state UI when
+     * neither resolves to a valid address. */
+    recipient?: string;
+    walletAddress?: string;
+    onError?: (e: Error) => void;
+    /** Notified with the resolved explorer URL when a history row's tx link is
+     * clicked. Fire-and-forget -- unlike `OnOutlink` elsewhere in dapp-ui, it
+     * does not intercept navigation; the link still opens in a new tab as normal. */
+    onOutlink?: (url: string) => void;
+    /** Extra class name(s) for the modal/drawer content element. */
+    className?: string;
+    theme?: RelayTheme;
+    mobileBreakpoint?: number;
+    drawerDirection?: RelayDrawerDirection;
+    dialogWidth?: string;
+    drawerMaxWidth?: string;
+    drawerMinWidth?: string;
+    style?: CSSProperties;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+}
+
+interface RelayDepositContentProps {
+    /** Extra class name(s) for the dialog/drawer content element. Falls back to
+     * `<RelayDeposit>`'s own `className`. */
+    className?: string;
+}
+/**
+ * `<RelayDeposit.Content>` — the modal/drawer surface. The deposit body is a
+ * child of `ShellContent`, i.e. of radix's `Dialog.Portal` / vaul's
+ * `Drawer.Portal`, which render nothing while closed. The state it renders is
+ * NOT its own any more: `<RelayDeposit>` mounts the wizard engine above the
+ * shell for exactly as long as the modal is open, so "no request before open"
+ * and "everything resets on close" still hold -- while a breakpoint crossing
+ * mid-flow now only rebuilds this DOM, not the flow.
+ */
+declare function RelayDepositContent({ className }: RelayDepositContentProps): react_jsx_runtime.JSX.Element;
+
+interface RelayDepositTriggerProps {
+    /** Render the child as the trigger instead of wrapping it. Defaults to
+     * `true` whenever a child is supplied, matching
+     * `WalletConnectModalTrigger`'s `asChild ?? children != null`. */
+    asChild?: boolean;
+    children?: ReactNode;
+}
+/**
+ * Thin pass-through to `ShellTrigger` (radix `Dialog.Trigger` on desktop /
+ * vaul `Drawer.Trigger` on mobile) so hosts write
+ * `<RelayDeposit.Trigger><button>…</button></RelayDeposit.Trigger>` without
+ * knowing which primitive is active. Falls back to a plain default button when
+ * no child is given, same as `WalletConnectModalTrigger`.
+ *
+ * Wrapped in `<TrackingBoundary feature="relay">` for the same reason
+ * `WalletConnectModalTrigger` is: the `data-track="open"` attribute below (and
+ * on any host-supplied child that carries one) is only picked up by the
+ * analytics delegate a boundary installs. Without it the open click is silently
+ * untracked, since the trigger lives OUTSIDE the portaled `<Content>` boundary.
+ */
+declare function RelayDepositTrigger({ asChild, children }: RelayDepositTriggerProps): react_jsx_runtime.JSX.Element;
+
+declare function RelayDepositRoot(props: RelayDepositProps): react_jsx_runtime.JSX.Element;
+declare const RelayDeposit: typeof RelayDepositRoot & {
+    Trigger: typeof RelayDepositTrigger;
+    Content: typeof RelayDepositContent;
+};
+
+interface RelayHistoryContentProps {
+    /** Extra class name(s) for the dialog/drawer content element. Falls back to
+     * `<RelayHistory>`'s own `className`. */
+    className?: string;
+}
+/**
+ * `<RelayHistory.Content>` — the modal/drawer surface. Like
+ * `RelayDepositContent`, this is a child of `ShellContent`, i.e. of radix's
+ * `Dialog.Portal` / vaul's `Drawer.Portal`, which render nothing while
+ * closed: no `listOrders` request happens before the modal is opened, and the
+ * subtree unmounts on close -- there is no per-open state here to reset
+ * explicitly (unlike `RelayDepositBody`'s step/panel state), so
+ * unmount-by-portal is the whole story.
+ */
+declare function RelayHistoryContent({ className }: RelayHistoryContentProps): react_jsx_runtime.JSX.Element;
+
+interface RelayHistoryTriggerProps {
+    /** Render the child as the trigger instead of wrapping it. Defaults to
+     * `true` whenever a child is supplied, matching `RelayDepositTrigger`'s
+     * (and `WalletConnectModalTrigger`'s) `asChild ?? children != null` rule. */
+    asChild?: boolean;
+    children?: ReactNode;
+}
+/**
+ * Thin pass-through to `ShellTrigger` (radix `Dialog.Trigger` on desktop /
+ * vaul `Drawer.Trigger` on mobile), mirroring `RelayDepositTrigger` so hosts
+ * write `<RelayHistory.Trigger><button>…</button></RelayHistory.Trigger>`
+ * without knowing which primitive is active. Falls back to a plain default
+ * button when no child is given.
+ *
+ * Wrapped in `<TrackingBoundary feature="relay">` for the same reason
+ * `RelayDepositTrigger`/`WalletConnectModalTrigger` are: `data-track="open"` is
+ * only read by the delegate a boundary installs, and this trigger sits OUTSIDE
+ * the portaled `<Content>`'s own boundary.
+ */
+declare function RelayHistoryTrigger({ asChild, children }: RelayHistoryTriggerProps): react_jsx_runtime.JSX.Element;
+
+declare function RelayHistoryRoot(props: RelayHistoryProps): react_jsx_runtime.JSX.Element;
+declare const RelayHistory: typeof RelayHistoryRoot & {
+    Trigger: typeof RelayHistoryTrigger;
+    Content: typeof RelayHistoryContent;
+};
+
+interface RelayRecoveryContentProps {
+    /** Extra class name(s) for the dialog/drawer content element. Falls back to
+     * `<RelayRecovery>`'s own `className`. */
+    className?: string;
+}
+/**
+ * `<RelayRecovery.Content>` — the modal/drawer surface. Same portal-scoped
+ * lifecycle as `<RelayHistory.Content>`: nothing is requested before the modal
+ * is opened, and the whole subtree (including `useRecovery`'s state and any
+ * in-flight recovery tracking) unmounts on close, so there is no per-open state
+ * to reset explicitly.
+ */
+declare function RelayRecoveryContent({ className }: RelayRecoveryContentProps): react_jsx_runtime.JSX.Element;
+
+interface RelayRecoveryTriggerProps {
+    /** Render the child as the trigger instead of wrapping it. Defaults to
+     * `true` whenever a child is supplied, matching `RelayHistoryTrigger`'s
+     * (and `RelayDepositTrigger`'s) `asChild ?? children != null` rule. */
+    asChild?: boolean;
+    children?: ReactNode;
+}
+/**
+ * Thin pass-through to `ShellTrigger` (radix `Dialog.Trigger` on desktop /
+ * vaul `Drawer.Trigger` on mobile), mirroring `RelayHistoryTrigger` so hosts
+ * write `<RelayRecovery.Trigger><button>…</button></RelayRecovery.Trigger>`
+ * without knowing which primitive is active. Falls back to a plain-text
+ * "Recover" button when no child is given -- unstyled like the sibling
+ * `RelayDepositTrigger`/`RelayHistoryTrigger` defaults, so it inherits the
+ * host's own button chrome instead of shipping a look of its own.
+ *
+ * The default button renders NO count badge (2026-07-30: removed on request --
+ * the number read as an unread-notification alarm). The root's cross-target
+ * recoverable count still reaches the trigger element as
+ * `data-rd-recovery-count` (radix/vaul merge Trigger props onto the `asChild`
+ * child too), so a host that WANTS a badge can opt in with its own CSS -- e.g.
+ * `button[data-rd-recovery-count]:not([data-rd-recovery-count="0"])::after` --
+ * without refetching anything.
+ *
+ * Wrapped in `<TrackingBoundary feature="relay">` for the same reason
+ * `RelayHistoryTrigger` is: `data-track="open"` is only read by the delegate a
+ * boundary installs, and this trigger sits OUTSIDE the portaled `<Content>`'s
+ * own boundary.
+ */
+declare function RelayRecoveryTrigger({ asChild, children }: RelayRecoveryTriggerProps): react_jsx_runtime.JSX.Element;
+
+declare function RelayRecoveryRoot(props: RelayRecoveryProps): react_jsx_runtime.JSX.Element;
+declare const RelayRecovery: typeof RelayRecoveryRoot & {
+    Trigger: typeof RelayRecoveryTrigger;
+    Content: typeof RelayRecoveryContent;
+};
+
+interface UseRelayOrdersOptions {
+    client: RelayClient;
+    /** Valid EVM address, or undefined -- undefined clears the list and stops polling. */
+    recipient?: string;
+    /** Gate: wait for truthy before the first fetch (RelayDeposit passes rawCatalog). Default true. */
+    enabled?: boolean;
+    /** REST safety-net cadence in milliseconds. Defaults to 30s; the open Deposit popup uses 1s
+     * so completion still appears promptly when the SSE event is absent. */
+    refetchInterval?: number;
+    /** @deprecated Use `refetchInterval`. Retained for compatibility. */
+    fallbackPollMs?: number;
+    onError?: (e: Error) => void;
+}
+interface UseRelayOrdersResult {
+    /** Every order swept from deposits to this recipient so far, newest-first
+     * as served by the API. Polled continuously once `recipient` is a valid address. */
+    orders: OrderSummary[];
+    ordersLoading: boolean;
+    ordersError?: Error;
+    /** Recipient the current snapshot belongs to. Undefined while a new
+     * subscription is waiting for its first accepted fetch, so consumers never
+     * baseline a previous recipient's rows as fresh deposits. */
+    ordersForRecipient?: string;
+    /** Increments after every accepted fetch, even when the client returns the
+     * same array reference or the request fails. Consumers use this as a
+     * low-frequency refresh signal for related read models such as /recovery. */
+    ordersRevision: number;
+    /** True once at least one fetch has COMPLETED (success or failure) for the
+     * current (recipient, enabled) subscription; false again when it resets.
+     * Distinct from `!ordersLoading`, which is also true BEFORE the first fetch
+     * has even started -- consumers that snapshot the list (e.g. the deposit
+     * wizard's new-order watch) must wait for this, or they baseline against
+     * the initial empty state and misread every existing order as new. */
+    ordersInitialized: boolean;
+}
+declare function useRelayOrders(opts: UseRelayOrdersOptions): UseRelayOrdersResult;
+
+interface UseRelayConfigOptions {
+    /** Pre-built client. Takes precedence over apiBaseUrl. */
+    client?: RelayClient;
+    /** Used to build a client when `client` is not supplied. */
+    apiBaseUrl?: string;
+    /** Stops the request and clears the current snapshot. Defaults to true. */
+    enabled?: boolean;
+    /** Optional automatic REST refresh cadence in milliseconds. Disabled when omitted or <= 0. */
+    refetchInterval?: number;
+    onError?: (error: Error) => void;
+}
+interface UseRelayConfigResult {
+    /** Latest GET /v1/config response. */
+    config?: Catalog;
+    loading: boolean;
+    error?: Error;
+    /** Re-fetches GET /v1/config using the current client. */
+    refresh: () => void;
+}
+/**
+ * Public read-only hook for Relay's origin/destination/target catalog.
+ *
+ * The response is a normal REST snapshot, not an SSE stream. Use
+ * `refetchInterval` for periodic refreshes or call `refresh` for an immediate
+ * read without replacing the client or remounting the component.
+ */
+declare function useRelayConfig(opts?: UseRelayConfigOptions): UseRelayConfigResult;
+
+type RecoveryAction = "execute" | "sweep";
+/** Per-attempt progress for `recover()`. "switching" = prompting a chain switch to BSC;
+ * "deploying" = the factory.deploy() write is in flight/confirming (only needed when the
+ * forwarder wasn't deployed yet); "recovering" = the execute()/sweepToUser() write is in
+ * flight/confirming; "done"/"error" are terminal for this attempt. */
+type RecoveryStep = "idle" | "switching" | "deploying" | "recovering" | "done" | "error";
+interface RecoveryState {
+    step: RecoveryStep;
+    /** Tx hash of the factory.deploy() write -- only set when this attempt needed one. */
+    deployTxHash?: string;
+    /** Tx hash of the execute()/sweepToUser() write. */
+    actionTxHash?: string;
+    error?: string;
+}
+
+type RelayRecoveryQueryKey = readonly [
+    "relay",
+    "recovery",
+    number,
+    string | null,
+    string | null
+];
+/**
+ * React Query policies accepted by useRelayRecovery. The SDK owns the request
+ * identity and response shape, so callers cannot replace queryKey/queryFn or
+ * inject/select recovery balances.
+ */
+type RelayRecoveryQueryOptions = Omit<UseQueryOptions<RecoveryInfo, Error, RecoveryInfo, RelayRecoveryQueryKey>, "queryKey" | "queryFn" | "select" | "initialData" | "initialDataUpdatedAt" | "placeholderData">;
+interface UseRelayRecoveryOptions {
+    /** Pre-built client. Takes precedence over apiBaseUrl. */
+    client?: RelayClient;
+    /** Used to build a client via createRelayClient when client isn't passed. */
+    apiBaseUrl?: string;
+    /** Connected EVM wallet whose recoverable forwarder balances are queried. */
+    recipient?: string;
+    /** Optional CROSS delivery target passed to GET /v1/recovery. */
+    target?: string;
+    /** React Query lifecycle, cache, retry, and refetch policies. */
+    query?: RelayRecoveryQueryOptions;
+    /** Optional wallet capabilities. Read-only consumers may omit this. */
+    wallet?: RelayWalletProps;
+    /** Called when GET /v1/recovery returns 401. */
+    onUnauthorized?: () => void;
+    /** Called after a terminal query or recovery-action error. */
+    onError?: (error: Error) => void;
+    /** Called once after a recovery transaction confirms successfully. */
+    onRecoverySuccess?: (result: RecoverySuccessResult) => void;
+    /** Trusted factory override for a self-hosted deployment. */
+    trustedFactories?: readonly string[];
+}
+interface UseRelayRecoveryResult {
+    info?: RecoveryInfo;
+    loading: boolean;
+    error?: Error;
+    /** True for background refetches as well as the first request. */
+    isFetching: boolean;
+    /** Invalidates no identities; immediately refetches this hook's fixed query. */
+    refresh: () => void;
+    /** Signs a recovery transaction for the currently fetched info. */
+    recover: (action: RecoveryAction, tokenAddress?: string) => Promise<void>;
+    recoveryState: RecoveryState;
+}
+/**
+ * Public Recovery API hook. Unlike the widget-internal useRecovery fetch, this
+ * hook uses the host QueryClient and accepts React Query policies through
+ * `query`. queryKey/queryFn and balance-shaping options remain SDK-owned.
+ */
+declare function useRelayRecovery(opts?: UseRelayRecoveryOptions): UseRelayRecoveryResult;
+
+interface StatusTrackerProps {
+    orderId: string;
+    /** Latest polled order (steps/txs) from GET /v1/orders/{orderId}, owned by the caller. */
+    order?: Order;
+    /** Latest poll error, owned by the caller. */
+    error?: Error;
+}
+declare function StatusTracker({ orderId, order, error }: StatusTrackerProps): react_jsx_runtime.JSX.Element;
+
+/** Every StandingForwarderFactory / DepositorForwarderFactory this deployment
+ * has issued deposit addresses from, on BSC.
+ *
+ * Superseded factories stay listed on purpose. A forwarder's factory is pinned
+ * per address at issuance time (`standing_addresses.factory`, copied onto each
+ * order), so a user recovering an address minted before a rotation legitimately
+ * gets an older factory back from the API -- dropping it here would block that
+ * user from recovering their own funds, which is a worse outcome than the
+ * narrow trust gain. Every entry is one of ours either way.
+ *
+ * Rotation (see backends/deploy/RUNBOOK-canary.md): ADD the new factory, keep
+ * the old ones. */
+declare const DEFAULT_TRUSTED_FACTORIES: readonly string[];
+
+export { APPLE_ICON, AppLauncher, AppLauncherContent, type AppLauncherContentProps, type AppLauncherProps, AppLauncherTrigger, type AppLauncherTriggerProps, type AppLauncherTriggerStyle, type AppLauncherUsageMode, BINANCE_ICON, type BridgeAmountSource, type BridgeApprovalInfo, type BridgeApproveFn, type BridgeFailedInfo, BridgeFlow, type BridgeFlowProps, type BridgeGetApprovalFn, type BridgeGetToTokensFn, type BridgeHistoryItem, type BridgeInfoRow, type BridgeInfoTokenRef, type BridgeLiquidityInfo, type BridgePathType, type BridgeQuoteFn, type BridgeQuoteInput, type BridgeQuoteResult, type BridgeStatus, type BridgeStep, type BridgeSubmitFn, type BridgeSubmittedInfo, type BridgeToken, type BridgeTxSummary, CHAINS_CONFIG_FILE, CONNECTOR_REGISTRY, CROSSX_ICON, type Catalog, type ChainDisplayMeta, type ChainId, type ChainsConfig, ConnectButton, type ConnectButtonProps, type ConnectButtonStyle, ConnectorId, type ConnectorMeta, type CrossdPosition, type CrossdPositionDetail, type CrossdPositionPoolRef, type CrossdPositionTokenRef, DEFAULT_SKILLS_HREF, DEFAULT_TRUSTED_FACTORIES, DappUiErrorBoundary, type DappUiErrorBoundaryProps, type DappUiFailureReason, type DappUiFeature, type DappUiFlow, type DepositAddressResult, type DrawerDirection$1 as DrawerDirection, type Environment, type EstimateGasArgs, type EstimateGasFn, GOOGLE_ICON, type GameSwapPool, type GameSwapTokenRef, type GasEstimate, type GetBalanceFn, type GetTransactionReceiptArgs, type GetTransactionReceiptFn, type GlobalMenu, type GlobalMenuItem, type GlobalMenuItemAssetUrl, type GlobalMenuItemServiceStatus, type GlobalMenuItemUrl, type InitDappUiSentryOptions, type LpBalanceInfo, type LpBalanceReaderFn, METAMASK_ICON, type OnOutlink, type OrderSummary, type OriginOption, type OutlinkCategory, type OutlinkContext, type OutlinkOrigin, PORTFOLIO_SECTIONS, type PortfolioSection, type PreferredToken, type QuoteResult, type ReadContractFn, type RecentSendAddress, type RecoveryInfo, type RecoverySuccessResult, RelayApiError, type RelayBalance, type RelayClient, type RelayClientOptions, type RelayContractCall, RelayDeposit, type RelayDepositContentProps, type RelayDepositProps, type RelayDepositTriggerProps, type RelayDrawerDirection, type Hex as RelayHex, RelayHistory, type RelayHistoryContentProps, type RelayHistoryProps, type RelayHistoryTriggerProps, RelayRecovery, type RecoveryAction as RelayRecoveryAction, type RelayRecoveryContentProps, type RelayRecoveryProps, type RelayRecoveryQueryKey, type RelayRecoveryQueryOptions, type RecoveryState as RelayRecoveryState, type RecoveryStep as RelayRecoveryStep, type RelayRecoveryTriggerProps, type SendTransactionFn as RelaySendTransactionFn, type RelayTheme, type RelayTxRequest, type RelayWalletProps, SOCIAL_REGISTRY, type SendAccount, type SendAsset, SendFlow, type SendFlowProps, type SendPageProps, type SendStatus, type SendTransactionArgs, type SendTransactionFn$1 as SendTransactionFn, SkillsButton, type SkillsButtonProps, type SkillsButtonStyle, type SocialConfig, type SocialHandlers, type SocialId, type StakingRewardsInfo, type StakingRewardsReaderFn, StatusTracker, type StatusTrackerProps, type SwitchChainFn, TOKEN_STATS_QUERY_KEY, type Theme, type TokenBalance, type TokenBalanceResponse, type TokenStats, type TokenStatsResponse, type TrackDappUiFunnelOptions, type TransactionReceiptResult, USER_BALANCE_QUERY_KEY, type UseRelayConfigOptions, type UseRelayConfigResult, type UseRelayOrdersOptions, type UseRelayOrdersResult, type UseRelayRecoveryOptions, type UseRelayRecoveryResult, WALLET_REGISTRY, type WaitForReceiptFn, type WalletConfig, WalletConnectModal, type WalletConnectModalContentProps, type WalletConnectModalProps, type WalletConnectModalStyle, type WalletConnectModalTriggerProps, type WalletHandlers, type WalletId, WalletInfo, type WalletInfoContentProps, type WalletInfoFooterProps, type WalletInfoNavProps, type WalletInfoProps, type WalletInfoStyle, type WalletInfoTriggerProps, WalletPortfolio, WalletPortfolioBody, type WalletPortfolioBodyProps, type WalletPortfolioContentProps, type WalletPortfolioProps, type WalletPortfolioTriggerProps, type WalletProvider, type WriteContractFn, announceAppLauncherUsage, captureDappUiException, createRelayClient, getChainDisplay, getDappUiSentryScope, initDappUiSentry, normalizeFailureReason, resolveEnvironment, setDappUiAnalyticsUser, trackDappUiEvent, trackDappUiFunnel, useChainDisplay, useChainsConfig, useGlobalMenu, useRelayConfig, useRelayOrders, useRelayRecovery, useTokenBalance, useTokenStats, useWalletDetect };