@blazephoenix/sdk 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,805 @@
+type Address = `0x${string}`;
+type Hex = `0x${string}`;
+/** Chain selector: id (1, 8453, 10, 42161) or name ("base", "eth", …). */
+type ChainRef = number | string;
+/** Token selector: 0x-address, ETH / WETH / USDC / BZPX, or (single-quote
+ *  endpoint only) ANY traded symbol — the API resolves unknown tickers to the
+ *  deepest-liquidity token on that chain and echoes the resolution back in
+ *  `resolved`. Pass 0x addresses when you need precision; the batch endpoint
+ *  takes addresses/built-in symbols only. */
+type TokenRef = string;
+interface QuoteRequest {
+    chain: ChainRef;
+    tokenIn: TokenRef;
+    tokenOut: TokenRef;
+    /** Input amount in the token's base units (wei-style). */
+    amountIn: bigint | string;
+    /** When set, the response includes ready-to-send `tx` calldata. */
+    recipient?: Address;
+    /** 0–5000. Default: the protocol's own execution floor (effectiveMinOut). */
+    slippageBps?: number;
+    /** 10–3600 seconds. Default 120. */
+    deadlineSec?: number;
+    /** Execution-grade re-quote (previewPlanExact) — slower, sharper. */
+    exact?: boolean;
+}
+interface QuoteLeg {
+    pool: Address;
+    hooks: Address;
+    kind: number;
+    fee: number;
+    tickSpacing: number;
+    zeroForOne: boolean;
+    stable: boolean;
+    amountIn: string;
+    expectedOut: string;
+    auxId: Hex;
+}
+interface QuoteHop {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    expectedOut: string;
+    legs: QuoteLeg[];
+}
+interface QuoteRoute {
+    hops: QuoteHop[];
+    totalOut: string;
+    singleOut: string;
+    singleOutFloor: string;
+    expectedImpactBps: string;
+    confidenceWad: string;
+    estGas: string;
+    hasSurplus: boolean;
+    isV4Bundle: boolean;
+}
+interface QuoteSummary {
+    grossOut: string;
+    protocolFee: string;
+    netOut: string;
+    ironFloor: string;
+    effectiveMinOut: string;
+    impactBps: number;
+    estGas: string;
+    hops: number;
+    legs: number;
+    canExecute: boolean;
+    hasSurplus: boolean;
+    feeBps: number;
+}
+interface QuoteTx {
+    to: Address;
+    data: Hex;
+    value: '0';
+}
+interface QuoteResponse {
+    ok: true;
+    mode: 'preview' | 'exact';
+    chainId: number;
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    /** Net output after the protocol fee — the number to compare across venues. */
+    amountOut: string;
+    quote?: QuoteSummary;
+    route: QuoteRoute;
+    tx?: QuoteTx;
+    wrapRequired: boolean;
+    unwrapAfter?: boolean;
+    /** Present when a symbol was resolved server-side: per side
+     *  { symbol, address, name?, liquidityUsd }. Always check it when quoting
+     *  by ticker — it tells you exactly which token you got. */
+    resolved?: Record<string, {
+        symbol: string;
+        address: Address;
+        name?: string;
+        liquidityUsd: number;
+    }>;
+    resolvedNote?: string;
+    executeWith?: {
+        router: Address;
+        function: string;
+        note: string;
+    };
+    meta: {
+        quotedAt: number;
+        latencyMs: number;
+        rpcTried: number;
+    };
+}
+interface ApiErrorBody {
+    ok: false;
+    code: string;
+    error: string;
+    chainId?: number;
+}
+type BatchResult = QuoteResponse | ApiErrorBody;
+interface BatchResponse {
+    ok: true;
+    count: number;
+    results: BatchResult[];
+}
+interface ManifestChain {
+    chainId: number;
+    name: string;
+    live: boolean;
+    explorer: string;
+    contracts: {
+        hub: Address;
+        solver: Address;
+        router: Address;
+        quoter: Address;
+        staking: Address;
+    };
+    weth: Address;
+    usdc: Address;
+    bzpx?: Address;
+}
+interface ManifestResponse {
+    ok: true;
+    name: string;
+    version: string;
+    url: string;
+    docs: string;
+    quoteApi: string;
+    token: {
+        symbol: string;
+        chain: string;
+        address: Address;
+        basescan: string;
+        totalSupply: string;
+    };
+    feeBps: number;
+    chains: ManifestChain[];
+    events: Record<string, {
+        signature: string;
+        topic0: Hex;
+    }>;
+    contact: string;
+}
+interface HealthResponse {
+    ok: true;
+    service: string;
+    version: string;
+    now: number;
+    chains: {
+        chainId: number;
+        name: string;
+        live: boolean;
+    }[];
+}
+/** A decoded on-chain fill (Router `Swap` event). */
+interface Fill {
+    txHash: Hex;
+    blockNumber: bigint;
+    user: Address;
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    amountOut: bigint;
+    legs: bigint;
+}
+
+declare class BlazeApiError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status: number);
+}
+interface ClientOptions {
+    /** Override the API origin (e.g. a mirror). Default: https://blazephoenix.xyz */
+    baseUrl?: string;
+    /** Custom fetch (tests, proxies). Default: globalThis.fetch. */
+    fetchFn?: typeof fetch;
+    /** Per-request timeout in ms. Default 15000. */
+    timeoutMs?: number;
+    /** Extra attempts on transient failures (network, 429, 502-504), honouring
+     *  the server's retry-after. Default 2. Set 0 to disable. */
+    retries?: number;
+    /** Micro-cache for PREVIEW quotes (no recipient, no exact) — absorbs hot
+     *  loops without serving stale execution data. Default 1000ms; 0 disables. */
+    cacheTtlMs?: number;
+}
+declare class BlazePhoenix {
+    private readonly base;
+    private readonly fetchFn;
+    private readonly timeoutMs;
+    private readonly retries;
+    private readonly cacheTtlMs;
+    constructor(opts?: ClientOptions);
+    /** Build the GET /api/quote URL for a request (useful for logging/debugging). */
+    quoteUrl(req: QuoteRequest): string;
+    private call;
+    /** One quote — previewPlan computed on-chain. Throws BlazeApiError on failure.
+     *  Identical concurrent calls share one request; preview quotes ride a tiny
+     *  micro-cache (cacheTtlMs) so hot loops never hammer the wire. */
+    quote(req: QuoteRequest): Promise<QuoteResponse>;
+    /** Up to 10 quotes in one round-trip (screeners / arb loops).
+     *  Per-item failures come back inline — the batch itself only throws on
+     *  transport/validation errors. Identical concurrent batches coalesce. */
+    quoteBatch(reqs: QuoteRequest[]): Promise<BatchResponse>;
+    /** Service health + per-chain live flags. Zero upstream cost server-side —
+     *  poll it from your monitor as often as you like. */
+    health(): Promise<HealthResponse>;
+    /** Machine-readable protocol manifest — near-static, cached for 1h. */
+    manifest(): Promise<ManifestResponse>;
+}
+interface PollOptions {
+    /** Tick interval in ms (min 500, default 4000). */
+    intervalMs?: number;
+    onError?: (e: unknown) => void;
+}
+/** Poll a pair and get called back with each fresh quote — the heartbeat of a
+ *  price bot in one line. Overlap-safe (a slow tick is skipped, not stacked).
+ *  Returns a stop function. */
+declare function pollQuote(client: BlazePhoenix, req: QuoteRequest, onQuote: (q: QuoteResponse) => void, opts?: PollOptions): () => void;
+/** The ready-to-broadcast transaction from a quote (requires `recipient` in the
+ *  request and an ERC-20 input). Throws with a precise reason otherwise. */
+declare function buildSwapTx(q: QuoteResponse): QuoteTx;
+interface DeepLinkOptions {
+    chain?: number | string;
+    tokenIn?: string;
+    tokenOut?: string;
+    /** Human units for the pay field (e.g. "0.5"). */
+    amount?: string;
+    tab?: 'home' | 'swap' | 'staking' | 'airdrop' | 'api';
+    baseUrl?: string;
+}
+/** A shareable link that opens the site pre-filled — bot buttons, referral posts. */
+declare function deepLink(opts?: DeepLinkOptions): string;
+
+/** Coalesce concurrent identical work — leader runs, followers share. */
+declare function singleflight<T>(key: string, fn: () => Promise<T>): Promise<T>;
+interface RetryOptions {
+    /** Extra attempts after the first (default 2). */
+    retries?: number;
+    /** Base backoff in ms; grows ×3 per attempt with jitter (default 250). */
+    backoffMs?: number;
+    timeoutMs?: number;
+}
+/** fetch with timeout + polite retries. Returns the final Response (which may
+ *  still be an error status — non-transient statuses are never retried). */
+declare function resilientFetch(fetchFn: typeof fetch, url: string, init: RequestInit | undefined, opts?: RetryOptions): Promise<Response>;
+
+declare const API_BASE = "https://blazephoenix.xyz";
+type SupportedChainId = 1 | 8453 | 10 | 42161;
+interface ChainInfo {
+    chainId: SupportedChainId;
+    name: string;
+    explorer: string;
+    weth: `0x${string}`;
+    usdc: `0x${string}`;
+    bzpx?: `0x${string}`;
+    contracts: {
+        hub: `0x${string}`;
+        solver: `0x${string}`;
+        router: `0x${string}`;
+        quoter: `0x${string}`;
+    };
+}
+declare const CHAINS: Record<SupportedChainId, ChainInfo>;
+/** Accepts a chain id (number or numeric string) or a human alias. */
+declare function resolveChain(chain: number | string): SupportedChainId;
+/** Public, KEYLESS RPC endpoints per chain — community infrastructure, no
+ *  providers, no keys (enforced by tests). They make the on-chain module work
+ *  with ZERO configuration; production integrations should still bring their
+ *  own `rpcUrl` for guaranteed throughput. */
+declare const PUBLIC_RPCS: Record<SupportedChainId, string[]>;
+/** Protocol fee (bps) applied to quoted output; execution surplus is fee-exempt. */
+declare const FEE_BPS = 28;
+/** Router event topic0 hashes (one `Swap` per fill — index everything with them).
+ *  Verified against the ABIs by `npm test` (viem toEventSelector). */
+declare const SWAP_TOPIC0: "0xd6d34547c69c5ee3d2667625c188acf1006abb93e0ee7cf03925c67cf7760413";
+declare const SURPLUS_TOPIC0: "0x1a3afef0f067eb51a6bfec6ab3625a4408dd8c3571b72836483e68feb70d1026";
+
+declare const QUOTER_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "previewPlan";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tIn";
+        readonly type: "address";
+    }, {
+        readonly name: "tOut";
+        readonly type: "address";
+    }, {
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "pv";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "route";
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly name: "hops";
+                readonly type: "tuple[]";
+                readonly components: readonly [{
+                    readonly name: "tokenIn";
+                    readonly type: "address";
+                }, {
+                    readonly name: "tokenOut";
+                    readonly type: "address";
+                }, {
+                    readonly name: "amountIn";
+                    readonly type: "uint256";
+                }, {
+                    readonly name: "expectedOut";
+                    readonly type: "uint256";
+                }, {
+                    readonly name: "legs";
+                    readonly type: "tuple[]";
+                    readonly components: readonly [{
+                        readonly name: "pool";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "hooks";
+                        readonly type: "address";
+                    }, {
+                        readonly name: "kind";
+                        readonly type: "uint8";
+                    }, {
+                        readonly name: "fee";
+                        readonly type: "uint24";
+                    }, {
+                        readonly name: "tickSpacing";
+                        readonly type: "int24";
+                    }, {
+                        readonly name: "zeroForOne";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "stable";
+                        readonly type: "bool";
+                    }, {
+                        readonly name: "amountIn";
+                        readonly type: "uint256";
+                    }, {
+                        readonly name: "expectedOut";
+                        readonly type: "uint256";
+                    }, {
+                        readonly name: "auxId";
+                        readonly type: "bytes32";
+                    }];
+                }];
+            }, {
+                readonly name: "totalOut";
+                readonly type: "uint256";
+            }, {
+                readonly name: "singleOut";
+                readonly type: "uint256";
+            }, {
+                readonly name: "singleOutFloor";
+                readonly type: "uint256";
+            }, {
+                readonly name: "expectedImpactBps";
+                readonly type: "uint256";
+            }, {
+                readonly name: "confidenceWad";
+                readonly type: "uint256";
+            }, {
+                readonly name: "estGas";
+                readonly type: "uint256";
+            }, {
+                readonly name: "hasSurplus";
+                readonly type: "bool";
+            }, {
+                readonly name: "isV4Bundle";
+                readonly type: "bool";
+            }];
+        }, {
+            readonly name: "grossOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "protocolFee";
+            readonly type: "uint256";
+        }, {
+            readonly name: "safetyBuffer";
+            readonly type: "uint256";
+        }, {
+            readonly name: "netOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "ironFloor";
+            readonly type: "uint256";
+        }, {
+            readonly name: "userMinOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "effectiveMinOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "estGas";
+            readonly type: "uint256";
+        }, {
+            readonly name: "hops";
+            readonly type: "uint256";
+        }, {
+            readonly name: "legs";
+            readonly type: "uint256";
+        }, {
+            readonly name: "topology";
+            readonly type: "uint8";
+        }, {
+            readonly name: "bridgeUsed";
+            readonly type: "address";
+        }, {
+            readonly name: "canExecute";
+            readonly type: "bool";
+        }];
+    }, {
+        readonly name: "fallbackRoute";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "hops";
+            readonly type: "tuple[]";
+            readonly components: readonly [{
+                readonly name: "tokenIn";
+                readonly type: "address";
+            }, {
+                readonly name: "tokenOut";
+                readonly type: "address";
+            }, {
+                readonly name: "amountIn";
+                readonly type: "uint256";
+            }, {
+                readonly name: "expectedOut";
+                readonly type: "uint256";
+            }, {
+                readonly name: "legs";
+                readonly type: "tuple[]";
+                readonly components: readonly [{
+                    readonly name: "pool";
+                    readonly type: "address";
+                }, {
+                    readonly name: "hooks";
+                    readonly type: "address";
+                }, {
+                    readonly name: "kind";
+                    readonly type: "uint8";
+                }, {
+                    readonly name: "fee";
+                    readonly type: "uint24";
+                }, {
+                    readonly name: "tickSpacing";
+                    readonly type: "int24";
+                }, {
+                    readonly name: "zeroForOne";
+                    readonly type: "bool";
+                }, {
+                    readonly name: "stable";
+                    readonly type: "bool";
+                }, {
+                    readonly name: "amountIn";
+                    readonly type: "uint256";
+                }, {
+                    readonly name: "expectedOut";
+                    readonly type: "uint256";
+                }, {
+                    readonly name: "auxId";
+                    readonly type: "bytes32";
+                }];
+            }];
+        }, {
+            readonly name: "totalOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "singleOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "singleOutFloor";
+            readonly type: "uint256";
+        }, {
+            readonly name: "expectedImpactBps";
+            readonly type: "uint256";
+        }, {
+            readonly name: "confidenceWad";
+            readonly type: "uint256";
+        }, {
+            readonly name: "estGas";
+            readonly type: "uint256";
+        }, {
+            readonly name: "hasSurplus";
+            readonly type: "bool";
+        }, {
+            readonly name: "isV4Bundle";
+            readonly type: "bool";
+        }];
+    }, {
+        readonly name: "hasFallback";
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "previewPlanExact";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "tIn";
+        readonly type: "address";
+    }, {
+        readonly name: "tOut";
+        readonly type: "address";
+    }, {
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "route";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "hops";
+            readonly type: "tuple[]";
+            readonly components: readonly [{
+                readonly name: "tokenIn";
+                readonly type: "address";
+            }, {
+                readonly name: "tokenOut";
+                readonly type: "address";
+            }, {
+                readonly name: "amountIn";
+                readonly type: "uint256";
+            }, {
+                readonly name: "expectedOut";
+                readonly type: "uint256";
+            }, {
+                readonly name: "legs";
+                readonly type: "tuple[]";
+                readonly components: readonly [{
+                    readonly name: "pool";
+                    readonly type: "address";
+                }, {
+                    readonly name: "hooks";
+                    readonly type: "address";
+                }, {
+                    readonly name: "kind";
+                    readonly type: "uint8";
+                }, {
+                    readonly name: "fee";
+                    readonly type: "uint24";
+                }, {
+                    readonly name: "tickSpacing";
+                    readonly type: "int24";
+                }, {
+                    readonly name: "zeroForOne";
+                    readonly type: "bool";
+                }, {
+                    readonly name: "stable";
+                    readonly type: "bool";
+                }, {
+                    readonly name: "amountIn";
+                    readonly type: "uint256";
+                }, {
+                    readonly name: "expectedOut";
+                    readonly type: "uint256";
+                }, {
+                    readonly name: "auxId";
+                    readonly type: "bytes32";
+                }];
+            }];
+        }, {
+            readonly name: "totalOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "singleOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "singleOutFloor";
+            readonly type: "uint256";
+        }, {
+            readonly name: "expectedImpactBps";
+            readonly type: "uint256";
+        }, {
+            readonly name: "confidenceWad";
+            readonly type: "uint256";
+        }, {
+            readonly name: "estGas";
+            readonly type: "uint256";
+        }, {
+            readonly name: "hasSurplus";
+            readonly type: "bool";
+        }, {
+            readonly name: "isV4Bundle";
+            readonly type: "bool";
+        }];
+    }, {
+        readonly name: "exactOut";
+        readonly type: "uint256";
+    }];
+}];
+declare const ROUTER_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "swapExactIn";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "route";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "hops";
+            readonly type: "tuple[]";
+            readonly components: readonly [{
+                readonly name: "tokenIn";
+                readonly type: "address";
+            }, {
+                readonly name: "tokenOut";
+                readonly type: "address";
+            }, {
+                readonly name: "amountIn";
+                readonly type: "uint256";
+            }, {
+                readonly name: "expectedOut";
+                readonly type: "uint256";
+            }, {
+                readonly name: "legs";
+                readonly type: "tuple[]";
+                readonly components: readonly [{
+                    readonly name: "pool";
+                    readonly type: "address";
+                }, {
+                    readonly name: "hooks";
+                    readonly type: "address";
+                }, {
+                    readonly name: "kind";
+                    readonly type: "uint8";
+                }, {
+                    readonly name: "fee";
+                    readonly type: "uint24";
+                }, {
+                    readonly name: "tickSpacing";
+                    readonly type: "int24";
+                }, {
+                    readonly name: "zeroForOne";
+                    readonly type: "bool";
+                }, {
+                    readonly name: "stable";
+                    readonly type: "bool";
+                }, {
+                    readonly name: "amountIn";
+                    readonly type: "uint256";
+                }, {
+                    readonly name: "expectedOut";
+                    readonly type: "uint256";
+                }, {
+                    readonly name: "auxId";
+                    readonly type: "bytes32";
+                }];
+            }];
+        }, {
+            readonly name: "totalOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "singleOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "singleOutFloor";
+            readonly type: "uint256";
+        }, {
+            readonly name: "expectedImpactBps";
+            readonly type: "uint256";
+        }, {
+            readonly name: "confidenceWad";
+            readonly type: "uint256";
+        }, {
+            readonly name: "estGas";
+            readonly type: "uint256";
+        }, {
+            readonly name: "hasSurplus";
+            readonly type: "bool";
+        }, {
+            readonly name: "isV4Bundle";
+            readonly type: "bool";
+        }];
+    }, {
+        readonly name: "amountIn";
+        readonly type: "uint256";
+    }, {
+        readonly name: "userMinOut";
+        readonly type: "uint256";
+    }, {
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "amountOut";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Swap";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "tokenIn";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "tokenOut";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "amountIn";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "amountOut";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "legs";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Surplus";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}];
+
+/** Unlimited allowance (2^256 − 1). Prefer EXACT amounts — pass the amount you
+ *  are about to swap; use MAX_UINT256 only when you consciously want one
+ *  approval forever (bots with their own key management). */
+declare const MAX_UINT256: bigint;
+interface ApproveOptions {
+    /** ERC-20 token to approve (the swap's tokenIn). */
+    token: Address;
+    /** Chain id or name — picks the Router as the default spender. */
+    chain: ChainRef;
+    /** Allowance in base units. Be exact; MAX_UINT256 opts into unlimited. */
+    amount: bigint;
+    /** Override the spender (defaults to the BlazePhoenix Router). */
+    spender?: Address;
+}
+/** Ready-to-send `approve` transaction for the Router (or a custom spender).
+ *  Send it once per token before the first swap; then swap freely. */
+declare function buildApproveTx(opts: ApproveOptions): QuoteTx;
+/** "1.5" + 18 decimals → 1500000000000000000n. Pure string math — no floats,
+ *  no precision loss. Rejects more fractional digits than the token carries. */
+declare function toBaseUnits(amount: string, decimals: number): bigint;
+/** 1500000000000000000n + 18 decimals → "1.5" (trailing zeros trimmed).
+ *  `maxDp` optionally truncates the fractional part for display. */
+declare function fromBaseUnits(v: bigint | string, decimals: number, maxDp?: number): string;
+
+interface OnChainOptions {
+    chain: number | string;
+    /** Your RPC endpoint. OPTIONAL since v0.4.0 — omitted, the SDK falls back
+     *  across public keyless endpoints (fine for dev/bots; bring your own node
+     *  for production throughput). The SDK still ships no providers and no keys. */
+    rpcUrl?: string;
+}
+/** previewPlan straight from the chain — the exact numbers the API serves. */
+declare function quoteOnChain(opts: OnChainOptions & {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+}): Promise<{
+    preview: Record<string, unknown>;
+    hasFallback: boolean;
+    chainId: SupportedChainId;
+}>;
+interface WatchFillsOptions extends OnChainOptions {
+    onFill: (fill: Fill) => void;
+    /** Poll interval in ms (default 4000). */
+    pollMs?: number;
+}
+/** Stream every BlazePhoenix fill on a chain (one Router `Swap` event per
+ *  swap). Returns an unwatch function. */
+declare function watchFills(opts: WatchFillsOptions): Promise<() => void>;
+/** Historic fills over a block range (for indexing / the quoted-vs-executed
+ *  verification pattern documented at https://blazephoenix.xyz/?tab=api). */
+declare function getFills(opts: OnChainOptions & {
+    fromBlock: bigint;
+    toBlock: bigint;
+}): Promise<Fill[]>;
+
+export { API_BASE, type Address, type ApiErrorBody, type ApproveOptions, type BatchResponse, type BatchResult, BlazeApiError, BlazePhoenix, CHAINS, type ChainInfo, type ChainRef, type ClientOptions, type DeepLinkOptions, FEE_BPS, type Fill, type Hex, MAX_UINT256, type ManifestChain, type ManifestResponse, type OnChainOptions, PUBLIC_RPCS, type PollOptions, QUOTER_ABI, type QuoteHop, type QuoteLeg, type QuoteRequest, type QuoteResponse, type QuoteRoute, type QuoteSummary, type QuoteTx, ROUTER_ABI, type RetryOptions, SURPLUS_TOPIC0, SWAP_TOPIC0, type SupportedChainId, type TokenRef, type WatchFillsOptions, buildApproveTx, buildSwapTx, deepLink, fromBaseUnits, getFills, pollQuote, quoteOnChain, resilientFetch, resolveChain, singleflight, toBaseUnits, watchFills };