@rhea-finance/cross-chain-aggregation-dex 1.0.6 → 2.0.0

package/dist/index.d.ts

@@ -1,278 +1,306 @@
-/**
- * Cross-chain DEX aggregation SDK core type definitions
- */
-interface TokenInfo {
-    address: string;
-    symbol: string;
-    decimals: number;
-    chain: string;
+import { S as SwapQuoteRequestRaw, a as SwapQuoteDataRaw, b as SwapBuildRequestRaw, c as SwapBuildDataRaw, d as SwapOrderSubmitRequestRaw, e as SwapOrderSubmitDataRaw, f as SwapOrderStatusParamsRaw, g as SwapOrderStatusDataRaw, h as SwapReportRequestRaw, i as SwapReportDataRaw, j as SwapHistoryParamsRaw, k as SwapHistoryDataRaw, Q as QuoteRequest, l as Quote, m as SwapMcaPayloadRaw, W as WaitMode, n as SwapLifecycleEvent, o as SwapExecutionResult, C as ChainRef, A as AssetRef, B as BaseUnitAmount, p as SwapHistoryRecordRaw, q as ChainExecutor, E as ExecutorRegistry, r as SwapBuild, s as ExecuteSwapInput, t as SwapInput, O as OrderStatusResult, u as WaitForOrderInput, N as NearTransaction, v as SwapMcaRelayerRequestRaw } from './registry-DRYUqs7T.js';
+export { a1 as BuildContext, J as ChainExecutionResult, Z as DepositInfo, U as EvmApproval, V as EvmSigningRequest, T as EvmTx, K as ExecutionContext, L as ExecutorIdentityProvider, P as ExecutorMessageSigner, M as MessageSignOptions, Y as OrderReference, H as OrderStatus, a0 as RouteSummary, G as SignRequestPreview, X as SolanaMetadata, w as SwapApiResponse, x as SwapApiTokenMetaRaw, D as SwapBuildApproveRaw, $ as SwapExecution, y as SwapMcaSignerPayloadRaw, _ as SwapReportContext, z as SwapSigningRequestRaw, F as SwapWarning, R as assertBaseUnitAmount, I as normalizeOrderStatus } from './registry-DRYUqs7T.js';
+
+type SwapErrorCode = "HTTP_ERROR" | "API_ERROR" | "RATE_LIMITED" | "AUTH_FAILED" | "REQUEST_ABORTED" | "REQUEST_TIMEOUT" | "INVALID_REQUEST" | "INVALID_API_RESPONSE" | "QUOTE_EXPIRED" | "ROUTE_NOT_FOUND" | "EXECUTOR_NOT_FOUND" | "UNSUPPORTED_CHAIN" | "CHAIN_MISMATCH" | "INVALID_TRANSACTION" | "USER_REJECTED" | "INSUFFICIENT_BALANCE" | "APPROVAL_FAILED" | "SIGNING_FAILED" | "BROADCAST_FAILED" | "ORDER_SUBMIT_FAILED" | "ORDER_TIMEOUT" | "REPORT_FAILED";
+type SwapErrorStage = "quote" | "build" | "approve" | "sign" | "broadcast" | "submit" | "report" | "status" | "history";
+interface SwapSdkErrorOptions {
+    retryable?: boolean;
+    cause?: unknown;
+    details?: Record<string, unknown>;
 }
-interface Route {
-    pools: PoolInfo[];
-    amountIn: string;
-    amountOut: string;
+declare class SwapSdkError extends Error {
+    readonly code: SwapErrorCode;
+    readonly stage: SwapErrorStage;
+    readonly options: SwapSdkErrorOptions;
+    readonly name = "SwapSdkError";
+    constructor(code: SwapErrorCode, stage: SwapErrorStage, message: string, options?: SwapSdkErrorOptions);
+    get retryable(): boolean;
+    get cause(): unknown;
+    get details(): Record<string, unknown> | undefined;
 }
-interface PoolInfo {
-    pool_id: number;
-    token_in: string;
-    token_out: string;
-    amount_in?: string;
-    amount_out?: string;
-    fee?: number;
+declare function asSwapSdkError(error: unknown, stage: SwapErrorStage): SwapSdkError;
+
+type SdkLogLevel = "debug" | "warn";
+interface SdkLogEntry {
+    level: SdkLogLevel;
+    event: "api.request" | "api.response" | "api.retry";
+    path: string;
+    stage: SwapErrorStage;
+    attempt: number;
+    status?: number;
+    durationMs?: number;
+    code?: SwapErrorCode;
 }
-interface QuoteParams {
-    tokenIn: TokenInfo;
-    tokenOut: TokenInfo;
-    amountIn: string;
-    /** Slippage tolerance in bps (e.g. 50 = 0.5%). */
-    slippage: number;
-    swapType?: "EXACT_INPUT" | "EXACT_OUTPUT";
-    recipient?: string;
+interface SdkLogger {
+    log(entry: SdkLogEntry): void;
 }
-interface QuoteResult {
-    success: boolean;
-    tokenIn: TokenInfo;
-    tokenOut: TokenInfo;
-    amountIn: string;
-    amountOut: string;
-    minAmountOut: string;
-    routes: Route[];
-    /**
-     * Optional: Raw route data returned by chain router/aggregator
-     * - Used for scenarios where aggregator-specific fields need to be passed through in executeSwap
-     * - Kept optional to avoid tightly coupling implementation details into core logic
-     */
-    rawRoutes?: any[];
-    priceImpact?: number;
-    avgFee?: number;
-    estimatedGas?: string;
-    error?: string;
+
+interface ApiClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+    getAccessToken?: () => string | Promise<string>;
+    fetch?: typeof globalThis.fetch;
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    timeoutMs?: number;
+    retry?: Partial<RetryConfig>;
+    logger?: SdkLogger;
 }
-interface ExecuteParams {
-    quote: QuoteResult;
-    recipient: string;
-    depositAddress?: string;
-    deadline?: number;
+interface ApiRequestOptions {
+    signal?: AbortSignal;
+    idempotencyKey?: string;
+}
+interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    jitter: boolean;
+}
+declare class ApiClient {
+    private readonly config;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(config: ApiClientConfig);
+    quote(body: SwapQuoteRequestRaw, options?: ApiRequestOptions): Promise<SwapQuoteDataRaw>;
+    build(body: SwapBuildRequestRaw, options?: ApiRequestOptions): Promise<SwapBuildDataRaw>;
+    submitOrder(body: SwapOrderSubmitRequestRaw, options?: ApiRequestOptions): Promise<SwapOrderSubmitDataRaw>;
+    getOrderStatus(params: SwapOrderStatusParamsRaw, options?: ApiRequestOptions): Promise<SwapOrderStatusDataRaw>;
+    report(body: SwapReportRequestRaw, options?: ApiRequestOptions): Promise<SwapReportDataRaw>;
+    getHistory(params: SwapHistoryParamsRaw, options?: ApiRequestOptions): Promise<SwapHistoryDataRaw>;
+    private request;
+    private requestOnce;
+    private buildUrl;
+    private buildHeaders;
+    private retryConfig;
+    private retryDelay;
+    private log;
+    private parseResponse;
+    private isEnvelope;
+    private readMessage;
+}
+
+type McaFlow = "deposit" | "withdraw";
+type McaSignerChain = "evm" | "solana" | "btc" | "near" | "aptos" | "sui" | "zcash" | "tron";
+interface McaSignerIdentity {
+    chain: McaSignerChain;
+    identityKey: string;
+    accountId?: string;
+}
+interface McaDepositCollateral {
+    useAsCollateral: boolean;
+}
+interface McaWithdrawCollateral {
+    needDecrease: boolean;
+    decreaseAmountBurrow: string;
+    withdrawAll?: boolean;
+}
+interface McaQuoteRequestBase extends QuoteRequest {
+    mcaAccountId: string;
+    signerChain: McaSignerChain;
+    recipientMsgSignatures?: string[];
+    depositSignerProofSignatures?: string[];
 }
-interface ExecuteResult {
-    success: boolean;
-    txHash?: string;
-    txHashArray?: string[];
-    error?: string;
+interface McaDepositQuoteRequest extends McaQuoteRequestBase {
+    flow: "deposit";
+    collateral: McaDepositCollateral;
 }
-type SupportedChain = "near" | "evm" | "solana";
-/**
- * DEX aggregator router abstract interface
- * Each chain/aggregator implements its own quote/executeSwap
- */
-interface DexRouter {
-    /** Router's chain (near/evm/solana...) */
-    getSupportedChain(): SupportedChain | string;
-    quote(params: QuoteParams): Promise<QuoteResult>;
-    executeSwap(params: ExecuteParams): Promise<ExecuteResult>;
+interface McaWithdrawQuoteRequest extends McaQuoteRequestBase {
+    flow: "withdraw";
+    collateral: McaWithdrawCollateral;
+    executionPreference?: "auto" | "near" | "relayer";
+    boundNearAccountId?: string;
 }
-/**
- * Bluechip token configuration
- */
-interface BluechipTokenConfig {
-    address: string;
-    symbol: string;
-    decimals: number;
-    assetId?: string;
+type McaQuoteRequest = McaDepositQuoteRequest | McaWithdrawQuoteRequest;
+interface McaQuoteBase extends Quote {
+    flow: McaFlow;
+    mcaAccountId: string;
+    signer: Readonly<McaSignerIdentity>;
+    request: McaQuoteRequest;
+    mca: Readonly<SwapMcaPayloadRaw>;
+    raw: SwapQuoteDataRaw;
 }
-/**
- * Bluechip tokens list configuration
- */
-interface BluechipTokensConfig {
-    USDT?: BluechipTokenConfig;
-    USDC?: BluechipTokenConfig;
-    NEAR?: BluechipTokenConfig;
-    [key: string]: BluechipTokenConfig | undefined;
+interface McaDepositQuote extends McaQuoteBase {
+    flow: "deposit";
+    executionMode: "deposit";
+    request: McaDepositQuoteRequest;
+    nearDepositTx?: unknown;
 }
+interface McaWithdrawNearQuote extends McaQuoteBase {
+    flow: "withdraw";
+    executionMode: "withdraw-near";
+    request: McaWithdrawQuoteRequest;
+    preview: Record<string, unknown>;
+}
+interface McaWithdrawRelayerQuote extends McaQuoteBase {
+    flow: "withdraw";
+    executionMode: "withdraw-relayer";
+    request: McaWithdrawQuoteRequest;
+    preview: Record<string, unknown>;
+}
+type McaQuote = McaDepositQuote | McaWithdrawNearQuote | McaWithdrawRelayerQuote;
+interface McaSwapInput {
+    quote: McaQuote;
+    waitFor?: WaitMode;
+    signal?: AbortSignal;
+    idempotencyKey?: string;
+    onEvent?: (event: SwapLifecycleEvent) => void;
+    beforeSign?: (preview: {
+        chain: McaSignerChain;
+        identityKey: string;
+        message: string;
+        business: Readonly<Record<string, unknown>>;
+    }) => void | Promise<void>;
+}
+type McaSwapResult = SwapExecutionResult;
 
-/** FindPath API response. */
-interface FindPathResponse {
-    result_code: number;
-    result_msg?: string;
-    result_message?: string;
-    result_data: {
-        routes: any[];
-        amount_out: string;
-    } | null;
+type HistoryStatus = "pending" | "processing" | "completed" | "failed" | "refunded" | "expired" | "unknown";
+interface HistoryRequest {
+    sender: string;
+    page?: number;
+    pageSize?: number;
+    status?: HistoryStatus[];
 }
-/** Adapter for querying DEX routes (FindPath). */
-interface FindPathAdapter {
-    findPath(params: {
-        tokenIn: string;
-        tokenOut: string;
-        amountIn: string;
-        slippage: number;
-        supportLedger?: boolean;
-    }): Promise<FindPathResponse>;
+interface SwapHistoryPage {
+    items: SwapHistoryItem[];
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    totalItems: number;
+    filteredLocally?: boolean;
 }
-/** NearIntents quote result. */
-interface IntentsQuoteResult {
-    quoteStatus: "success" | "error";
-    message?: string;
-    quoteSuccessResult?: {
-        quote: {
-            amountOut: string;
-            depositAddress: string;
-            [key: string]: any;
-        };
-        [key: string]: any;
-    };
-    [key: string]: any;
+interface SwapHistoryItem {
+    id: string;
+    sender: string;
+    recipient?: string;
+    fromChain: ChainRef;
+    toChain: ChainRef;
+    tokenIn: AssetRef;
+    tokenOut: AssetRef;
+    amountIn?: BaseUnitAmount;
+    estimatedOut?: BaseUnitAmount;
+    actualOut?: BaseUnitAmount;
+    sourceTxHash?: string;
+    destinationTxHash?: string;
+    orderId?: string;
+    depositAddress?: string;
+    router?: string;
+    status: HistoryStatus;
+    createdAt?: string;
+    updatedAt?: string;
+    statusResponse?: Record<string, unknown>;
+    raw: SwapHistoryRecordRaw;
 }
-/** Adapter for fetching NearIntents quotes. */
-interface IntentsQuotationAdapter {
-    quote(params: {
-        originAsset: string;
-        destinationAsset: string;
-        amount: string;
-        refundTo: string;
-        recipient: string;
-        slippageTolerance: number;
-        swapType?: "EXACT_INPUT" | "EXACT_OUTPUT" | "FLEX_INPUT";
-        [key: string]: any;
-    }): Promise<IntentsQuoteResult>;
+
+interface SwapClientConfig extends ApiClientConfig {
+    maxQuoteAgeMs?: number | null;
+    reportMode?: "auto" | "manual" | "disabled";
+    executors?: readonly ChainExecutor[];
+    onEvent?: (event: SwapLifecycleEvent) => void;
+    now?: () => number;
 }
-/** Adapter for interacting with NEAR (call/view). */
-interface NearChainAdapter {
-    call(params: {
-        transactions: Array<{
-            contractId: string;
-            methodName: string;
-            args: any;
-            gas?: string;
-            expandDeposit?: string;
-        }>;
-    }): Promise<{
-        status: "success" | "error";
-        txHash?: string;
-        txHashArr?: string[];
-        message?: string;
-    }>;
-    view(params: {
-        contractId: string;
-        methodName: string;
-        args?: any;
-    }): Promise<any>;
+interface BuildSwapInput {
+    quote: Quote;
+    signal?: AbortSignal;
+    idempotencyKey?: string;
 }
-/** Chain-specific configuration provider. */
-interface ConfigAdapter {
-    getRefExchangeId(): string;
-    getWrapNearContractId(): string;
-    getFindPathUrl(): string;
-    /** Storage deposit amount (yoctoNEAR) for `storage_deposit` when needed. */
-    getTokenStorageDepositRead?(): string;
+declare class SwapClient {
+    private readonly managedSwapFlow;
+    protected readonly api: ApiClient;
+    protected readonly registry: ExecutorRegistry;
+    protected readonly reportMode: "auto" | "manual" | "disabled";
+    protected readonly config: SwapClientConfig;
+    private readonly now;
+    private readonly inFlight;
+    private readonly reportRequests;
+    constructor(config: SwapClientConfig);
+    quoteRaw(request: SwapQuoteRequestRaw, options?: ApiRequestOptions): Promise<SwapQuoteDataRaw>;
+    quote(request: McaQuoteRequest, options?: ApiRequestOptions): Promise<McaQuote>;
+    quote(request: QuoteRequest, options?: ApiRequestOptions): Promise<Quote>;
+    private quoteStandard;
+    buildRaw(request: SwapBuildRequestRaw, options?: ApiRequestOptions): Promise<SwapBuildDataRaw>;
+    buildSwap(input: BuildSwapInput): Promise<SwapBuild>;
+    private buildStandardSwap;
+    executeSwap(input: ExecuteSwapInput): Promise<SwapExecutionResult>;
+    swap(input: McaSwapInput): Promise<McaSwapResult>;
+    swap(input: SwapInput): Promise<SwapExecutionResult>;
+    getOrderStatus(input: {
+        orderId: string;
+        router: string;
+        chainId?: string;
+        signal?: AbortSignal;
+    }): Promise<OrderStatusResult>;
+    waitForOrder(input: WaitForOrderInput): Promise<OrderStatusResult>;
+    submitOrderRaw(request: Parameters<ApiClient["submitOrder"]>[0], options?: ApiRequestOptions): Promise<SwapOrderSubmitDataRaw>;
+    getOrderStatusRaw(request: Parameters<ApiClient["getOrderStatus"]>[0], options?: ApiRequestOptions): Promise<SwapOrderStatusDataRaw>;
+    reportRaw(request: SwapReportRequestRaw, options?: ApiRequestOptions): Promise<SwapReportDataRaw>;
+    report(result: SwapExecutionResult): Promise<SwapReportDataRaw>;
+    retryReport(result: SwapExecutionResult): Promise<SwapReportDataRaw>;
+    getHistoryRaw(params: SwapHistoryParamsRaw, options?: ApiRequestOptions): Promise<SwapHistoryDataRaw>;
+    getHistory(request: HistoryRequest, options?: ApiRequestOptions): Promise<SwapHistoryPage>;
+    protected emit(event: SwapLifecycleEvent): void;
+    private assertQuoteFresh;
+    private createReportRequest;
 }
 
-declare const logger: {
-    debug: (...args: any[]) => void;
-    info: (...args: any[]) => void;
-    warn: (...args: any[]) => void;
-    error: (...args: any[]) => void;
-};
+declare function normalizeBuild(raw: SwapBuildDataRaw, executionId?: string, request?: SwapBuildRequestRaw): SwapBuild;
+declare function createExecutionId(): string;
 
-/** Set the SDK-wide bluechip token config used for NearIntents compatibility and intermediate routing. */
-declare function setBluechipTokensConfig(config: BluechipTokensConfig): void;
-/** Get the bluechip token config; returns an empty object (and warns) if unset. */
-declare function getBluechipTokensConfig(): BluechipTokensConfig;
-/**
- * Normalize a NEAR asset id:
- * - strip `nep141:` prefix (if present)
- * - map `near` -> `wrap.near` (overridable via `wrapNearContractId`)
- */
-declare function normalizeTokenId(tokenId: string | undefined | null, wrapNearContractId?: string): string;
-/** True if the token matches a NearIntents-supported bluechip token (by symbol + address/assetId). */
-declare function isNearIntentsSupportedToken(token: TokenInfo, bluechipTokens?: BluechipTokensConfig): boolean;
-/** Pick an intermediate bluechip token (priority: USDT > USDC > wNEAR; fallback to `wrapNearContractId`). */
-declare function findBestBluechipToken(bluechipTokens: BluechipTokensConfig, wrapNearContractId?: string): TokenInfo;
-/**
- * Convert slippage input into bps (1 bps = 0.01%).
- * - `>= 1`: bps (e.g. 50 = 0.5%)
- * - `[0.01, 1)`: percent (e.g. 0.5 = 0.5%)
- * - `(0, 0.01)`: decimal (e.g. 0.005 = 0.5%)
- */
-declare function convertSlippageToBasisPoints(slippage: number): number;
-/** Normalize NearIntents `destinationAsset` (prefix + `near` -> `wrap.near`). */
-declare function normalizeDestinationAsset(assetId: string, wrapNearContractId?: string): string;
+declare function toApiChain(chain: ChainRef): string;
+declare function fromApiChain(chain: string): ChainRef;
+declare function toApiAssetAddress(asset: AssetRef): string;
 
-/** NEAR DEX router implementation (FindPath for routing + REF for execution). */
+declare function normalizeHistory(raw: SwapHistoryDataRaw): SwapHistoryPage;
+declare function normalizeHistoryStatus(status: unknown): HistoryStatus;
 
-interface NearSmartRouterConfig {
-    findPathAdapter: FindPathAdapter;
-    nearChainAdapter: NearChainAdapter;
-    configAdapter: ConfigAdapter;
-}
-declare class NearSmartRouter implements DexRouter {
-    private findPathAdapter;
-    private nearChainAdapter;
-    private configAdapter;
-    private wrapNearContractId;
-    private refExchangeId;
-    private tokenStorageDepositRead;
-    constructor(config: NearSmartRouterConfig);
-    /**
-     * Get a swap quote (normalizes token ids and queries FindPath for routes).
-     */
-    quote(params: QuoteParams): Promise<QuoteResult>;
-    /**
-     * Execute a swap: optionally adds `storage_deposit` for the recipient, then calls REF via `ft_transfer_call`.
-     */
-    executeSwap(params: ExecuteParams): Promise<ExecuteResult>;
-    /**
-     * Get supported chain
-     */
-    getSupportedChain(): "near";
+declare function serializeQuoteRequest(request: QuoteRequest): SwapQuoteRequestRaw;
+declare function normalizeQuote(request: QuoteRequest, raw: SwapQuoteDataRaw, receivedAt?: number): Quote;
+
+interface ResolveMcaWithdrawPolicyInput {
+    collateralBalance: string;
+    availableBalance: string;
+    amountIn: string;
+    isMax: boolean;
 }
+declare function resolveMcaWithdrawPolicy(input: ResolveMcaWithdrawPolicyInput): McaWithdrawCollateral & {
+    withdrawAll: boolean;
+};
 
-/** Composite quote: optional NEAR DEX pre-swap + NearIntents quote. */
+declare function serializeMcaQuoteRequest(request: McaQuoteRequest, signer: McaSignerIdentity): SwapQuoteRequestRaw;
+declare function normalizeMcaQuote(request: McaQuoteRequest, signer: McaSignerIdentity, quote: Quote): McaQuote;
 
-interface CompleteQuoteParams {
-    sourceToken: TokenInfo;
-    targetToken: TokenInfo;
-    sourceChain: string;
-    targetChain: string;
-    amountIn: string;
-    slippage: number;
-    recipient: string;
-    refundTo?: string;
+type McaWalletKey = "EVM" | "Solana" | "Bitcoin" | "Near" | "Aptos" | "Sui" | "Zcash" | "Tron";
+type McaWalletDescriptor = Partial<Record<McaWalletKey, string>>;
+declare const DEFAULT_MCA_SIGNER_PRIORITY: readonly ["evm", "solana", "btc", "aptos", "near", "zcash", "sui", "tron"];
+declare function formatMcaWallet(chain: McaSignerChain, identityKey: string): McaWalletDescriptor;
+declare function selectMcaSigner(boundWallets: ReadonlyArray<Readonly<Record<string, unknown>>>, connectedSigners: readonly McaSignerIdentity[], priority?: readonly McaSignerChain[]): McaSignerIdentity | undefined;
+declare function isSameMcaSignerIdentity(a: Pick<McaSignerIdentity, "chain" | "identityKey">, b: Pick<McaSignerIdentity, "chain" | "identityKey">): boolean;
+
+declare function extractMcaWithdrawBusiness(preview: unknown): Record<string, unknown> | undefined;
+declare function extractMcaWithdrawSignerWallet(preview: unknown): Record<string, unknown> | undefined;
+interface ExtractMcaWithdrawDepositAddressInput {
+    bestQuote?: unknown;
+    preview?: unknown;
+    snapshotDepositAddress?: string | null;
+    storeDepositAddress?: string | null;
 }
-interface CompleteQuoteResult {
-    intents: {
-        /** Raw NearIntents response (passed through). */
-        quote: any;
-        depositAddress: string;
-    };
-    preSwap?: {
-        quote: QuoteResult;
-        tokenIn: TokenInfo;
-        tokenOut: TokenInfo;
-        executor: DexRouter;
-    };
-    finalAmountOut: string;
-    totalPriceImpact?: number;
-    totalFee?: number;
+declare function extractMcaWithdrawDepositAddress(input: ExtractMcaWithdrawDepositAddressInput): string;
+interface BuildNearMcaWithdrawTransactionsInput {
+    business: Record<string, unknown>;
+    signerWallet: Record<string, unknown>;
+    signature?: string;
+    mcaAccountId: string;
 }
-interface CompleteQuoteConfig {
-    intentsQuotationAdapter: IntentsQuotationAdapter;
-    dexRouter: DexRouter;
-    bluechipTokens: BluechipTokensConfig;
-    configAdapter: {
-        getWrapNearContractId(): string;
-    };
+declare function buildNearMcaWithdrawTransactions(preview: unknown, input: BuildNearMcaWithdrawTransactionsInput): NearTransaction[];
+interface BuildMcaWithdrawRelayerRequestInput {
+    quoteBuild: SwapBuildRequestRaw;
+    mcaRelayer: SwapMcaRelayerRequestRaw;
+    isCrossChain: boolean;
+    depositAddress: string;
+    mcaAccountId: string;
+    recipientFallback?: string | null;
 }
-/**
- * Build a "complete quote":
- * - If `sourceToken` is not NearIntents-supported, pre-swap to a bluechip token on NEAR DEX.
- * - Quote NearIntents using (pre-swap output) or `amountIn`.
- *
- * Notes:
- * - Prefer `slippage` in bps (e.g. 50 = 0.5%); we also accept percent/decimal inputs.
- * - `targetChain` is currently reserved for future use.
- */
-declare function completeQuote(params: CompleteQuoteParams, config: CompleteQuoteConfig): Promise<CompleteQuoteResult>;
+declare function buildMcaWithdrawRelayerRequest(input: BuildMcaWithdrawRelayerRequestInput): SwapBuildRequestRaw;
+
+declare function parseUnits(value: string, decimals: number): BaseUnitAmount;
+declare function formatUnits(value: BaseUnitAmount, decimals: number): string;
 
-export { type BluechipTokenConfig, type BluechipTokensConfig, type CompleteQuoteConfig, type CompleteQuoteParams, type CompleteQuoteResult, type ConfigAdapter, type DexRouter, type ExecuteParams, type ExecuteResult, type FindPathAdapter, type FindPathResponse, type IntentsQuotationAdapter, type IntentsQuoteResult, type NearChainAdapter, NearSmartRouter, type NearSmartRouterConfig, type PoolInfo, type QuoteParams, type QuoteResult, type Route, type SupportedChain, type TokenInfo, completeQuote, convertSlippageToBasisPoints, findBestBluechipToken, getBluechipTokensConfig, isNearIntentsSupportedToken, logger, normalizeDestinationAsset, normalizeTokenId, setBluechipTokensConfig };
+export { ApiClient, type ApiClientConfig, type ApiRequestOptions, AssetRef, BaseUnitAmount, type BuildMcaWithdrawRelayerRequestInput, type BuildNearMcaWithdrawTransactionsInput, type BuildSwapInput, ChainExecutor, ChainRef, DEFAULT_MCA_SIGNER_PRIORITY, ExecuteSwapInput, ExecutorRegistry, type ExtractMcaWithdrawDepositAddressInput, type HistoryRequest, type HistoryStatus, type McaDepositCollateral, type McaDepositQuote, type McaDepositQuoteRequest, type McaFlow, type McaQuote, type McaQuoteRequest, type McaSignerChain, type McaSignerIdentity, type McaSwapInput, type McaSwapResult, type McaWalletDescriptor, type McaWalletKey, type McaWithdrawCollateral, type McaWithdrawNearQuote, type McaWithdrawQuoteRequest, type McaWithdrawRelayerQuote, NearTransaction, OrderStatusResult, Quote, QuoteRequest, type ResolveMcaWithdrawPolicyInput, type RetryConfig, type SdkLogEntry, type SdkLogLevel, type SdkLogger, SwapBuild, SwapBuildDataRaw, SwapBuildRequestRaw, SwapClient, type SwapClientConfig, type SwapErrorCode, type SwapErrorStage, SwapExecutionResult, SwapHistoryDataRaw, type SwapHistoryItem, type SwapHistoryPage, SwapHistoryParamsRaw, SwapHistoryRecordRaw, SwapInput, SwapLifecycleEvent, SwapMcaPayloadRaw, SwapMcaRelayerRequestRaw, SwapOrderStatusDataRaw, SwapOrderStatusParamsRaw, SwapOrderSubmitDataRaw, SwapOrderSubmitRequestRaw, SwapQuoteDataRaw, SwapQuoteRequestRaw, SwapReportDataRaw, SwapReportRequestRaw, SwapSdkError, type SwapSdkErrorOptions, WaitForOrderInput, WaitMode, asSwapSdkError, buildMcaWithdrawRelayerRequest, buildNearMcaWithdrawTransactions, createExecutionId, extractMcaWithdrawBusiness, extractMcaWithdrawDepositAddress, extractMcaWithdrawSignerWallet, formatMcaWallet, formatUnits, fromApiChain, isSameMcaSignerIdentity, normalizeBuild, normalizeHistory, normalizeHistoryStatus, normalizeMcaQuote, normalizeQuote, parseUnits, resolveMcaWithdrawPolicy, selectMcaSigner, serializeMcaQuoteRequest, serializeQuoteRequest, toApiAssetAddress, toApiChain };