@hyperbridge/sdk 2.8.13 → 2.8.17

package/dist/browser/index.d.ts

@@ -1,12 +1,11 @@
-import { ConsolaInstance } from 'consola';
 import Decimal from 'decimal.js';
 import { GraphQLClient } from 'graphql-request';
 import * as viem from 'viem';
 import { PublicClient, TransactionReceipt, Hex, Log, ContractFunctionArgs, Chain as Chain$1, Address } from 'viem';
 import { Chain } from 'viem/chains';
+import { ConsolaInstance } from 'consola';
 import { ApiPromise } from '@polkadot/api';
 import { KeyringPair } from '@polkadot/keyring/types';
-import { RuntimeVersion } from '@polkadot/types/interfaces';
 import * as unstorage from 'unstorage';
 import { SignerOptions, SubmittableExtrinsic } from '@polkadot/api/types';
 import { ISubmittableResult } from '@polkadot/types/types';
@@ -895,12 +894,6 @@ declare const tronChainIds: Set<number>;
 type ConfiguredAssetSymbol = "WETH" | "DAI" | "USDC" | "USDT" | "cNGN" | "EXT" | "ZARP" | "EURC" | "XSGD" | "TRYB" | "USDR";
 /** A configured asset symbol in its canonical, lowercase, or uppercase form. */
 type ConfiguredAssetSymbolInput = ConfiguredAssetSymbol | Lowercase<ConfiguredAssetSymbol> | Uppercase<ConfiguredAssetSymbol>;
-interface UniswapV4PoolConfigData {
-    tokens: readonly [ConfiguredAssetSymbol, ConfiguredAssetSymbol];
-    fee: number;
-    tickSpacing: number;
-    hooks?: `0x${string}`;
-}
 /** A known ERC-4626 vault fillers can use as a stablecoin treasury. */
 interface Erc4626VaultConfigData {
     /** Display label, e.g. "Aave stataUSDC" */
@@ -1016,7 +1009,6 @@ interface ChainConfigData {
     consensusStateId: string;
     coingeckoId: string;
     popularTokens?: string[];
-    uniswapV4Pools?: UniswapV4PoolConfigData[];
     /** Known ERC-4626 treasury vaults on this chain */
     erc4626Vaults?: Erc4626VaultConfigData[];
     /** LayerZero Endpoint ID for cross-chain messaging */
@@ -1095,7 +1087,6 @@ declare class ChainConfigService {
     getUniswapV4PositionManagerAddress(chain: string): HexString$1;
     getUniswapV4PoolManagerAddress(chain: string): HexString$1;
     getUniswapV4StateViewAddress(chain: string): HexString$1;
-    getUniswapV4PoolConfigs(chain: string): UniswapV4PoolConfigData[];
     getPermit2Address(chain: string): HexString$1;
     getSolverAccountAddress(chain: string): HexString$1 | undefined;
     getCoingeckoId(chain: string): string | undefined;
@@ -1940,9 +1931,9 @@ declare const INCLUSION_TIMEOUT_MS = 20000;
  * `ws(s)://` url rather than guessing at an endpoint.
  *
  * The HTTP endpoint is always derived, never configured, because it must be the *same node* as the
- * websocket: phantom orders are read out of that node's offchain worker storage, which is
- * node-local and not replicated, so a separately configured host would return nothing for orders
- * the events said exist.
+ * websocket: bids are read out of that node's offchain worker storage, which is node-local and
+ * not replicated, so a separately configured host would return nothing for bids its storage said
+ * exist.
  */
 declare function deriveHttpUrl(wsUrl: string): string;
 /**
@@ -1960,91 +1951,6 @@ declare function encodeUserOpScale(userOp: PackedUserOperation): HexString$1;
  * @returns The decoded PackedUserOperation
  */
 declare function decodeUserOpScale(hex: HexString$1): PackedUserOperation;
-/** One directed leg of a phantom order: `standardAmount` of `tokenA` quoted in `tokenB`. */
-interface PhantomOrderLeg {
-    tokenA: HexString$1;
-    tokenB: HexString$1;
-    standardAmount: bigint;
-}
-interface PhantomOrderEvent {
-    commitment: HexString$1;
-    chain: string;
-    createdAt: number;
-    /**
-     * Every configured pair expands into its configured direction plus the reverse. Listed in
-     * the same order as the order's asset lists, so index `i` here is the order's leg `i`.
-     */
-    legs: PhantomOrderLeg[];
-}
-/** The pallet's phantom order timings, as the chain currently has them. */
-interface PhantomTimings {
-    /**
-     * Blocks after registration during which the pallet accepts a bid: the `PhantomBidWindow`
-     * storage value, or the `PhantomOrderBidWindowBlocks` runtime constant when that value is zero,
-     * which is the same fallback the pallet's own `phantom_bid_window()` applies.
-     */
-    bidWindowBlocks: number;
-    /**
-     * Blocks between generations (`PhantomOrderInterval`). Zero is meaningful rather than unset —
-     * the pallet generates once and never regenerates — so there is no constant to fall back to.
-     */
-    intervalBlocks: number;
-}
-/** One phantom bid to place, and the bid it replaces on the same chain. */
-interface PhantomBid {
-    /** The phantom order commitment being bid on. */
-    commitment: HexString$1;
-    /** The SCALE-encoded PackedUserOperation backing the quote. */
-    userOp: HexString$1;
-    /**
-     * A live bid from a previous interval on the same chain, retracted alongside this one to
-     * reclaim its deposit. Best-effort: a retraction that fails never affects the bid.
-     */
-    retractCommitment?: HexString$1;
-}
-/** What became of one bid in a batch. */
-interface PhantomBidOutcome {
-    commitment: HexString$1;
-    success: boolean;
-    /** The dispatch error that rejected this bid, when it failed. */
-    error?: string;
-}
-interface PhantomBidBatchResult {
-    /** One entry per submitted bid, in the order they were given. */
-    bids: PhantomBidOutcome[];
-    /** The block and extrinsic the bids landed in. */
-    blockHash?: HexString$1;
-    extrinsicHash?: HexString$1;
-    /**
-     * The batch reached the pool but its inclusion was not observed, so no per-bid outcome is
-     * known. Same contract as {@link BidSubmissionResult.pending}: in flight, do not re-sign.
-     */
-    pending?: boolean;
-    /** Set when the batch never landed at all, or when its item events could not be attributed. */
-    error?: string;
-}
-interface PollPhantomOrdersOptions {
-    /** How often to check for a new head. Defaults to 15s, or 6s when the runtime is Gargantua. */
-    intervalMs?: number;
-    /**
-     * Most blocks scanned in a single poll, so a long outage catches up over several ticks instead of
-     * one burst. Defaults to 10 — several times the rate the chain produces blocks, so recovery is
-     * still quick, but small enough to bound both the work one `state_queryStorage` call asks of the
-     * node and the requests the per-block fallback queues ahead of a bid submission.
-     */
-    maxBlocksPerPoll?: number;
-    /** Notified when a poll fails; polling continues regardless. */
-    onError?: (err: unknown) => void;
-    /**
-     * Notified when the cursor was forced forward past a backlog too old to bid on, with the range
-     * that was never scanned. Nothing else reports it, and skipping blocks is worth a line in the log.
-     */
-    onSkip?: (skipped: {
-        from: number;
-        to: number;
-        head: number;
-    }) => void;
-}
 /**
  * Service for interacting with Hyperbridge's pallet-intents coprocessor.
  * Handles bid submission and retrieval for the IntentGatewayV2 protocol.
@@ -2057,15 +1963,11 @@ declare class IntentsCoprocessor {
     private ownsConnection;
     /** Cached result of whether the node exposes intents_* RPC methods */
     private hasIntentsRpc;
-    /** The pallet's phantom timings, read once. Cleared on failure so the read retries. */
-    private phantomTimingsRead;
     /** The HTTP-backed api, connected on first use. Cleared after a failed attempt so it retries. */
     private httpApi;
-    /** Last runtime version read from the node, for {@link confirmedRuntimeVersion} to compare against. */
-    private lastRuntimeVersion;
-    /** Set once the node refuses `state_queryStorage`, so the poll stops asking for it. */
-    private rangeQueryUnavailable;
     private submissionQueue;
+    /** The highest nonce this instance has put into the pool, so the next submission clears it. */
+    private lastPooledNonce;
     /**
      * Creates and connects an IntentsCoprocessor to a Hyperbridge node.
      * This creates and manages its own API connection.
@@ -2118,9 +2020,8 @@ declare class IntentsCoprocessor {
      *
      * The connection attempt is bounded on both sides. `isReadyOrError` rejects on a failed
      * handshake, where plain `isReady` would simply never resolve, and the timeout covers an
-     * endpoint that accepts the request and then goes quiet. An unbounded wait here would hang the
-     * poll tick awaiting it, which is precisely the silent stall that polling exists to avoid. A
-     * failed attempt is not cached, so the next call tries again.
+     * endpoint that accepts the request and then goes quiet, so a caller awaiting it never hangs
+     * silently. A failed attempt is not cached, so the next call tries again.
      */
     private http;
     /**
@@ -2168,7 +2069,7 @@ declare class IntentsCoprocessor {
      * Two kinds of failure are retried, and the difference is the nonce.
      *
      * An attempt that verifiably went nowhere (rejected before the pool, dropped, invalid) leaves
-     * the account nonce free, so the next attempt simply re-signs with the auto-nonce.
+     * the account nonce free, so the next attempt simply re-signs with the pool-aware nonce.
      *
      * An attempt that reached the pool and was still there when the watch timed out (`stalled`) is
      * retried as a *replacement*: the same nonce it was signed with, and double the tip. Substrate's
@@ -2214,77 +2115,49 @@ declare class IntentsCoprocessor {
      * replacement rather than a second extrinsic queued behind the first. Left undefined on the
      * first attempt, where the api's auto-nonce is correct.
      */
+    /**
+     * The nonce the next submission signs with, or undefined when the node cannot be asked.
+     *
+     * Submissions are serialised, but a watch gives up while its extrinsic is still in the pool
+     * (`stalled`, reported as `pending`), and a pooled extrinsic does not advance the account's
+     * on-chain nonce. An extrinsic signed against on-chain state would then take the nonce of the
+     * one ahead of it and bounce off it (1013/1014) instead of queueing behind it.
+     *
+     * `system_accountNextIndex` is the only pool-aware source here. `signAndSend`'s own `nonce: -1`
+     * is not: on a runtime carrying `AccountNonceApi`, which Hyperbridge does, polkadot-js reads the
+     * nonce through that runtime call and never sees the pool.
+     *
+     * The RPC covers the ready queue, so anything of this instance's that has left it — retried,
+     * queued as future, or simply not counted yet — is covered by `lastPooledNonce` instead, which
+     * is the highest nonce this instance has put into the pool. The two are combined rather than
+     * trusted separately, so a burst never reuses a nonce and a restart still picks up the chain's.
+     */
+    private nextNonce;
     private sendWithTimeout;
     /**
      * Submits a bid to Hyperbridge's pallet-intents
      *
+     * A filler can hold several bids on one order, one per price it offers, and `bid` tells them
+     * apart: submitting again under an identifier the filler already holds replaces that bid alone.
+     * By convention it is `keccak256` of the UserOp's `callData`, which is also what gives each bid
+     * its own nonce key on the `SolverAccount` (see `CryptoUtils.bidId`).
+     *
      * @param commitment - The order commitment hash (bytes32)
      * @param userOp - The encoded PackedUserOperation as hex string
+     * @param bid - Identifies this bid among the filler's bids on the order (bytes32)
      * @returns BidSubmissionResult with success status and block/extrinsic hash
      */
-    submitBid(commitment: HexString$1, userOp: HexString$1): Promise<BidSubmissionResult>;
+    submitBid(commitment: HexString$1, userOp: HexString$1, bid: HexString$1): Promise<BidSubmissionResult>;
     /**
      * Retracts a bid from Hyperbridge and reclaims the deposit
      *
      * Use this to remove unused quotes and claim back deposited BRIDGE tokens.
      *
      * @param commitment - The order commitment hash (bytes32)
+     * @param bid - Which of the filler's bids on the order to retract (bytes32)
      * @returns BidSubmissionResult with success status and block/extrinsic hash
      */
-    retractBid(commitment: HexString$1): Promise<BidSubmissionResult>;
-    /**
-     * Places a new bid and retracts a previous one in a single transaction via utility.batch.
-     *
-     * The new bid is the primary operation, so `placeBid` MUST run first. `utility.batch` is
-     * non-atomic: a failing call interrupts the batch (via a BatchInterrupted event) without
-     * reverting the calls that already succeeded. Placing first guarantees the new bid lands even
-     * when the retraction then fails — which it routinely does, because a previous commitment's bid
-     * may already be gone (or was itself never placed), making `retractBid` return `BidNotFound`.
-     *
-     * Ordering retraction first (the previous behaviour) caused a self-sustaining cascade: a
-     * `BidNotFound` on the leading retract skipped the trailing `placeBid`, so the current bid never
-     * landed, so the *next* interval's retract of that never-placed commitment also failed, and so
-     * on — silently, because the batch extrinsic itself reports success. The deposit reclaim is
-     * best-effort; landing the bid is not.
-     *
-     * @param retractCommitment - The order commitment of the bid to retract (bytes32)
-     * @param bidCommitment - The order commitment of the new bid (bytes32)
-     * @param userOp - The encoded PackedUserOperation as hex string
-     * @returns BidSubmissionResult with success status and block/extrinsic hash
-     */
-    submitBidWithRetraction(retractCommitment: HexString$1, bidCommitment: HexString$1, userOp: HexString$1): Promise<BidSubmissionResult>;
-    /**
-     * Places every phantom bid of one interval in a single extrinsic, retracting each chain's
-     * previous bid alongside it.
-     *
-     * The pallet registers one phantom order per configured chain in the same block, so this is the
-     * whole interval's set. Submitting them one at a time costs a block per chain: submissions are
-     * serialised on the account nonce and each waits for inclusion, so the last chain's bid is many
-     * blocks behind the first, against a bid window measured in tens of blocks. Batched, every bid
-     * lands in the same block.
-     *
-     * Uses `utility.force_batch`, not `utility.batch`. `batch` stops at the first failing call, so
-     * one rejected bid — a closed window, a duplicate, an insufficient deposit — would silently
-     * drop every bid after it. `force_batch` runs them all and reports each outcome. It needs no
-     * special origin: any signed account may call it, exactly like `batch`.
-     *
-     * @param bids - The bids to place; an empty list is a no-op
-     * @returns Per-bid outcomes, in the order given
-     */
-    submitPhantomBids(bids: PhantomBid[]): Promise<PhantomBidBatchResult>;
-    /**
-     * Reads one outcome per call out of a force_batch's events.
-     *
-     * `ItemFailed` carries no index — pallet-utility emits exactly one `ItemCompleted` or
-     * `ItemFailed` per call, in call order, so the k-th item event belongs to call k.
-     *
-     * A count that does not match the calls submitted means the events are not the ones assumed
-     * here, and every attribution after the discrepancy would be off by one. The bids are then
-     * reported as placed: a bid wrongly recorded as landed is retracted next interval and the
-     * retraction harmlessly fails with `BidNotFound`, whereas one wrongly recorded as failed is
-     * never retracted at all and leaves its deposit reserved.
-     */
-    private readForceBatchItems;
+    retractBid(commitment: HexString$1, bid: HexString$1): Promise<BidSubmissionResult>;
     /** Renders a DispatchError as `pallet::Error`, falling back to its raw form. */
     private describeDispatchError;
     /**
@@ -2318,184 +2191,8 @@ declare class IntentsCoprocessor {
     private getBidsViaStorage;
     /** Decodes SCALE-encoded Bid struct and SCALE-encoded PackedUserOperation */
     private decodeBid;
-    /** Builds offchain storage key: "intents::bid::" + commitment + filler */
+    /** Builds offchain storage key: "intents::bid::" + commitment + filler + bid */
     private buildOffchainBidKey;
-    /**
-     * Fetches the ABI-encoded phantom order from offchain storage and decodes it
-     * into an `Order` object. The pallet writes the order bytes under the key
-     * `intents::phantom::order::<commitment>` when it calls `on_initialize`.
-     *
-     * Returns `null` if the key is absent (e.g. the node is not an offchain worker
-     * or the commitment has expired and been cleared).
-     */
-    fetchPhantomOrder(commitment: HexString$1): Promise<Order | null>;
-    /**
-     * Reads the PhantomOrderRegistered events emitted in a single block.
-     *
-     * Costs two RPCs per block when `knownVersion` is supplied and four without it, which is why the
-     * poll goes to the trouble of establishing one. `api.at(hash)` has to work out which metadata to
-     * decode the block against, and with nothing to go on it fetches the header and then the runtime
-     * version at its parent — every block, forever. Its cheaper paths are a registry already pinned
-     * to this exact hash (only ever the previous block's) or one matching a version the caller
-     * names, so naming the version is the only way out. See `getBlockRegistry` in
-     * `@polkadot/api/base/Init`; the `getUpgradeVersion` shortcut that would otherwise skip the
-     * lookup only covers chains hardcoded in `@polkadot/types-known`, which Hyperbridge is not.
-     *
-     * @param knownVersion - the runtime version this block is known to run, if the caller has
-     *   established one. Passing a version the block does not actually run decodes it against the
-     *   wrong metadata, so this is for callers that have checked, not a place to pass a guess.
-     */
-    getPhantomOrdersInBlock(blockNumber: number, knownVersion?: RuntimeVersion): Promise<PhantomOrderEvent[]>;
-    /**
-     * The same read, for a caller that already holds the block's hash.
-     *
-     * Split out so the poll can fetch a whole range's hashes in one concurrent wave — which the
-     * provider coalesces into a single batched request — and then read each block's events knowing
-     * its hash. `chain_getBlockHash` is the half of the pair that parallelises safely: it takes no
-     * historic block hash, so it never triggers polkadot-js's per-hash registry resolution, and
-     * concurrent calls cannot race each other's registry state.
-     */
-    getPhantomOrdersAtHash(blockHash: HexString$1, knownVersion?: RuntimeVersion): Promise<PhantomOrderEvent[]>;
-    /**
-     * Every block's phantom orders across a whole range, in one `state_queryStorage` call.
-     *
-     * This is the cheap path: the request cost of a scan stops depending on how many blocks it
-     * covers. The events key is the only key queried, and both bounds are block hashes the caller
-     * already holds.
-     *
-     * Two properties of the RPC shape the result.
-     *
-     * It returns *diffs*: `query_storage_unfiltered` in `sc-rpc` pushes a change set for a block only
-     * when the value differs from the previous block in the range (`has_changed`, and the set is
-     * dropped when empty), so a block whose events encode byte-for-byte identically to its
-     * predecessor's is simply absent. That happens on a quiet chain, where consecutive blocks carry
-     * nothing but the timestamp inherent's `ExtrinsicSuccess`. It is safe here because an absent
-     * block provably carries no phantom orders: a `PhantomOrderRegistered` commitment is derived from
-     * the block number (`phantom_order_commitment`), so a block that registered orders can never
-     * encode identically to any other block. Absent therefore means "same as the previous block",
-     * and the previous block having orders would contradict that.
-     *
-     * And it is gated by `--rpc-methods` (`check_if_safe` in `sc-rpc`), which answers a denied call
-     * with `Method not found`. The node this reads from must already run unsafe RPC to serve
-     * `offchain_localStorageGet` for the orders themselves, so this is normally available; the poll
-     * falls back to reading block by block when it is not.
-     *
-     * @returns one entry per block the node reported a change for, in ascending block order.
-     */
-    getPhantomOrdersInRange(fromBlockHash: HexString$1, toBlockHash: HexString$1): Promise<PhantomOrderEvent[][]>;
-    /**
-     * Polls for newly registered phantom orders, invoking the callback once per block that carries
-     * any, with all of that block's orders.
-     *
-     * Per block rather than per order because that is how the pallet writes them: one order per
-     * configured chain, all registered in the same `on_initialize`. Delivering them together lets a
-     * caller bid on the whole interval in one extrinsic (see {@link submitPhantomBids}) instead of
-     * one per chain.
-     *
-     * Each tick reads the current head and scans every block between the last one processed and that
-     * head, so the block cursor — not the connection — determines what has been seen. This replaced a
-     * system.events subscription, which was only as reliable as its socket: polkadot-js reconnects
-     * the transport but does not reliably re-establish storage subscriptions, and anything emitted
-     * while disconnected was lost silently. With a bid window measured in a handful of blocks, that
-     * meant silently missed bids.
-     *
-     * Scanning a block range is gap-free rather than merely self-healing: an outage delays orders but
-     * cannot drop them, because the cursor only advances past a block whose events were actually
-     * read. Recovery replays the backlog.
-     *
-     * Every read here goes over HTTP, never the websocket. Polling is a sequence of independent
-     * one-shot requests with no state to lose between them, which is exactly what a stateless
-     * transport does well: a request either answers or fails loudly on this tick, instead of a
-     * socket that looks alive while delivering nothing. It also means a websocket outage does not
-     * pause phantom bidding at all — the two transports fail independently.
-     *
-     * What the cadence does *not* describe is the request rate, which is what rate limiters police.
-     * A tick costs four requests whatever the range covers — the head, the runtime version, the two
-     * bounding block hashes as one batched request, and one `state_queryStorage` for every block's
-     * events — and they go out back-to-back, so an interval well under any per-second limit could
-     * still arrive as a burst over it. Three things keep that in bounds: the provider coalesces
-     * concurrent calls into one request and paces requests through the endpoint's token bucket (see
-     * `http`), and `maxBlocksPerPoll` bounds the range. A 429 that gets through anyway backs the
-     * poll off for a doubling number of ticks, so a limiter that is already shedding load is not
-     * handed the next window's budget in rejections too.
-     *
-     * Where the node will not serve `state_queryStorage` the poll reads block by block instead, at
-     * three requests plus one per block; see {@link scanRangeAtOnce}.
-     *
-     * Returns a function that stops polling.
-     */
-    pollPhantomOrders(callback: (events: PhantomOrderEvent[]) => void, options?: PollPhantomOrdersOptions): () => void;
-    /**
-     * The Hyperbridge head, over HTTP like every other read here.
-     *
-     * Exposed for callers that have to know how old something is: a phantom order carries the block
-     * it was registered at, and only against the head does that become "still biddable" or "long
-     * expired".
-     */
-    latestBlockNumber(): Promise<number>;
-    /**
-     * The pallet's phantom timings, read from chain state.
-     *
-     * Both are governance-settable and neither is derivable: on Nexus today the window is 15 while
-     * the runtime constant behind it is 25, so anything hard-coded is wrong in one direction or the
-     * other — too tight and live orders are dropped, too loose and bids are sent into a closed
-     * window for the pallet to reject.
-     *
-     * Read once per instance and cached, because a governance change to either is rare and a read
-     * per poll tick would be a request per tick forever. The cost is that a change is picked up on
-     * the next restart rather than immediately. A failed read is not cached, so it retries.
-     */
-    phantomTimings(): Promise<PhantomTimings>;
-    private readPhantomTimings;
-    /**
-     * A whole range of blocks in one `state_queryStorage` call, or `null` when that is not available
-     * and the caller should read block by block.
-     *
-     * Two conditions have to hold, and both are about decoding rather than the range itself.
-     *
-     * The version must be confirmed for this tick — an upgrade inside the range means blocks decode
-     * against different metadata, and one call cannot do that.
-     *
-     * And that confirmed version must still be the one the api's own registry was built for.
-     * `state_queryStorage` declares no historic block hash, so rpc-core skips its registry swap and
-     * decodes the reply against the default registry — fixed at connect, with no
-     * `subscribeRuntimeVersion` on an HTTP api to refresh it. After an upgrade the two diverge, and
-     * the per-block path takes over for good: `api.at(hash, version)` resolves, and builds, the right
-     * registry. That costs a restart to get the cheap path back, which is the correct direction to
-     * fail in.
-     */
-    private scanRangeAtOnce;
-    /**
-     * The runtime version this tick's blocks may be decoded against, or `undefined` when that cannot
-     * be established and each block must resolve its own.
-     *
-     * Naming a version to `api.at` is what removes two of the four RPCs a block scan costs, and it
-     * is only sound while the version is actually the block's. Getting that wrong is not a loud
-     * failure: events decoded against the wrong metadata come back as a shape the scan does not
-     * recognise, so the block reads as carrying no phantom orders and the cursor advances past it —
-     * exactly the silent miss the block cursor exists to rule out.
-     *
-     * So the version is read fresh each tick and only used when it matches the previous reading.
-     * `specVersion` only ever increases, and this read happens *after* the head read, so two equal
-     * readings mean no upgrade landed anywhere in between — and therefore none in the range about to
-     * be scanned. A reading that differs means an upgrade landed inside the range: that tick falls
-     * back to per-block resolution, which is exact, and the version is used from the next tick on
-     * once it has been seen twice.
-     *
-     * The gap this leaves is a backlog reaching back past an upgrade, whose oldest blocks predate
-     * even the previous reading. Recovering from an outage that long means those bid windows closed
-     * many upgrades ago, so nothing is lost that was still winnable.
-     *
-     * A version that cannot be read at all yields `undefined` rather than an error: the scan is
-     * about to make the same request against the same endpoint and is the better place to report it.
-     */
-    private confirmedRuntimeVersion;
-    /**
-     * The poll cadence for the runtime this instance is connected to: Gargantua polls every block,
-     * everything else every 15s. Falls back to the slower cadence if the runtime cannot be read,
-     * since an unreachable node is the poll's problem to report, not the cadence lookup's.
-     */
-    private phantomPollIntervalMs;
 }
 
 /**
@@ -2980,7 +2677,18 @@ interface RetryConfig {
      */
     backoffMs: number;
     logMessage?: string;
-    logger?: ConsolaInstance;
+    /**
+     * Where retry attempts are recorded. Structural on purpose: `retryPromise`
+     * only ever calls `trace`, and callers outside this package log through
+     * their own stack (pino, in simplex's case). Typing it as a full
+     * `ConsolaInstance` forced those callers to omit the logger entirely, which
+     * sent every retry to the silent default and made a retrying call — up to
+     * `maxRetries` × the transport's own timeout budget — indistinguishable
+     * from a hang.
+     */
+    logger?: {
+        trace: (message: string) => void;
+    };
     /** Return false to stop retrying and immediately rethrow the error. */
     shouldRetry?: (error: unknown) => boolean;
 }
@@ -3029,7 +2737,9 @@ declare enum OrderStatus {
     PLACED = "PLACED",
     FILLED = "FILLED",
     REDEEMED = "REDEEMED",
-    REFUNDED = "REFUNDED"
+    REFUNDED = "REFUNDED",
+    /** Cancellation has been initiated; escrow refund is still pending. */
+    CANCELLED = "CANCELLED"
 }
 declare enum TeleportStatus {
     TELEPORTED = "TELEPORTED",
@@ -3511,7 +3221,15 @@ declare enum RequestKind {
     /**
      * Identifies a request for refunding escrowed tokens after cancellation
      */
-    RefundEscrow = 4
+    RefundEscrow = 4,
+    /**
+     * Identifies a governance call the gateway runs against itself, such as an upgrade
+     */
+    Execute = 5,
+    /**
+     * Identifies a request for redeeming a slice of an escrow after a partial fill, leaving the order open
+     */
+    RedeemEscrowPartial = 6
 }
 /**
  * Configuration for the IntentFiller
@@ -3570,17 +3288,6 @@ interface FillerConfig {
      * Example: { 1: true, 56: false } - watch-only on Ethereum, normal execution on BSC
      */
     watchOnly?: Record<number, boolean>;
-    /**
-     * Uniswap V4 position tokenIds this filler holds, per chain (state machine id -> tokenIds as
-     * decimal strings), declared inside its phantom bids' paymasterAndData for the bid's own chain.
-     *
-     * Liquidity parked in a V4 position is invisible to the snapshot's inventory read, which sees
-     * only ERC-20 balances and ERC-4626 vault shares — so without this a venue-funded filler is
-     * weighted at zero and its quotes are discarded. The declaration is only a POINTER: the indexer
-     * reads each position's liquidity on-chain and checks it is owned by the solver that signed the
-     * bid, so naming a position cannot inflate it and naming someone else's achieves nothing.
-     */
-    uniswapV4PositionsByChain?: Record<string, string[]>;
 }
 /**
  * Result of an order execution attempt
@@ -3846,74 +3553,7 @@ interface OrderResponse {
         }>;
     };
 }
-interface PhantomOrderPriceSnapshot {
-    commitment: HexString$1;
-    tokenA: HexString$1;
-    tokenB: HexString$1;
-    standardAmount: bigint;
-    blockNumber: bigint;
-    medianPrice: bigint;
-    lowestPrice?: bigint;
-    highestPrice?: bigint;
-    bidCount: number;
-    snapshotTime: Date;
-}
-interface PhantomOrderPriceSnapshotsResponse {
-    phantomOrderPriceSnapshots: {
-        nodes: Array<{
-            commitment: string;
-            tokenA: string;
-            tokenB: string;
-            standardAmount: string;
-            blockNumber: string;
-            medianPrice: string | null;
-            lowestPrice: string | null;
-            highestPrice: string | null;
-            bidCount: number;
-            snapshotTime: string;
-        }>;
-    };
-}
-/** One independently reported slice of indexed liquidity. */
-interface LiquiditySlice {
-    totalLiquidity: string;
-    providerCount: number;
-}
-/**
- * Indexed destination capacity and its source-routing slices.
- *
- * The SDK reports the indexer's facts separately and does not decide whether a
- * source chain is covered by the legacy unrestricted-bidder policy.
- */
-interface AvailableLiquidity {
-    sourceChain: Chains;
-    destinationChain: Chains;
-    tokenAddress: HexString$1;
-    updatedAt: Date;
-    destination: LiquiditySlice;
-    unrestricted: LiquiditySlice;
-    explicitRoute: (LiquiditySlice & {
-        updatedAt: Date;
-    }) | null;
-}
-/**
- * Aggregate indexed pool buy and sell rates expressed as quote-token units per
- * one base token. The quote token is the less valuable currency when the rates
- * establish an ordering (for example, cNGN in a USDC/cNGN pair).
- */
-interface BuyAndSellRates {
-    baseTokenSymbol: ConfiguredAssetSymbol;
-    quoteTokenSymbol: ConfiguredAssetSymbol;
-    sourceChain: Chains;
-    destinationChain: Chains;
-    /** Quote-token units received when buying the quote token with one base token. */
-    buyRate: string | null;
-    /** Quote-token units sold to receive one base token. */
-    sellRate: string | null;
-    buyRateUpdatedAt: Date | null;
-    sellRateUpdatedAt: Date | null;
-}
-/** Symbol-only input for querying an indexed pool's rates. */
+/** Symbol-only input for querying a pair's orderbook rates on a route. */
 interface QueryBuyAndSellRatesParams {
     tokenInSymbol: ConfiguredAssetSymbolInput;
     tokenOutSymbol: ConfiguredAssetSymbolInput;
@@ -4005,7 +3645,10 @@ interface FillOptions {
      * encoding against a gateway whose implementation predates the field.
      */
     validUntil: bigint;
+    /** Positional output budgets. Actual payment follows the quoted rate and released input. */
     outputs: TokenInfo[];
+    /** Required positional maximum input takes. Paired outputs/inputs declare each leg's rate. */
+    inputs: TokenInfo[];
 }
 interface PackedUserOperation {
     sender: HexString$1;
@@ -4055,6 +3698,10 @@ interface SubmitBidOptions {
 }
 interface EstimateFillOrderParams {
     order: Order;
+    /** Positional input takes. Required with custom outputs; otherwise estimates a full fill at the order's rate. */
+    inputs?: TokenInfo[];
+    /** Output slice offered by the solver. Defaults to the order's full requested outputs. */
+    outputs?: TokenInfo[];
     /**
      * Optional ERC-7821 calls to prepend before the fillOrder call in the
      * simulated UserOp. Used for funding calls (e.g. LP withdrawal) so the
@@ -4076,6 +3723,8 @@ interface EstimateFillOrderParams {
 }
 interface FillOrderEstimate {
     fillOptions: FillOptions;
+    /** Normalized positional input takes used by the estimated calldata. */
+    inputs: TokenInfo[];
     callGasLimit: bigint;
     verificationGasLimit: bigint;
     preVerificationGas: bigint;
@@ -4153,15 +3802,25 @@ interface BidSubmissionResult {
      */
     pending?: boolean;
 }
+/** One bid as the `intents_getBidsForOrder` RPC returns it: hex-encoded, the filler as raw AccountId bytes. */
+interface RpcBidInfo {
+    commitment: HexString$1;
+    filler: HexString$1;
+    /** Which of the filler's bids on the order this is (bytes32; by convention `keccak256(callData)`). */
+    bid: HexString$1;
+    user_op: HexString$1;
+}
 /**
- * Represents a storage entry from pallet-intents Bids storage
- * StorageDoubleMap<_, Blake2_128Concat, H256, Blake2_128Concat, AccountId, Balance>
+ * Represents a storage entry from pallet-intents `OrderBids` storage:
+ * StorageNMap<(H256 commitment, AccountId filler, H256 bid), Balance>
  */
 interface BidStorageEntry {
     /** The order commitment hash (H256) */
     commitment: HexString$1;
     /** The filler's Substrate account ID (SS58 encoded) */
     filler: string;
+    /** Which of the filler's bids on the order this is (bytes32; by convention `keccak256(callData)`) */
+    bid: HexString$1;
     /** The deposit amount stored on-chain (BalanceOf<T> = u128) */
     deposit: bigint;
 }
@@ -4172,6 +3831,11 @@ interface BidStorageEntry {
 interface FillerBid {
     /** The filler's Substrate account ID (SS58 encoded) */
     filler: string;
+    /**
+     * Which of the filler's bids on the order this is. A filler offering several prices bids once
+     * per price; by convention the identifier is `keccak256` of the UserOp's `callData`.
+     */
+    bid: HexString$1;
     /** The decoded PackedUserOperation */
     userOp: PackedUserOperation;
     /** The deposit amount stored on-chain (in plancks) */
@@ -4205,8 +3869,10 @@ interface SelectOptions {
 interface Bid {
     /** The solver account that submitted this bid (`userOp.sender`). */
     readonly solverAddress: HexString$1;
-    /** Decoded `FillOptions.outputs` — the tokens and amounts the solver offers. */
+    /** Decoded output budgets; these are not settlement payments or credited progress. */
     readonly outputs: TokenInfo[];
+    /** Positional input takes from `FillOptions.inputs`, one per leg. */
+    readonly inputs: TokenInfo[];
     /** Relayer fee from the decoded fill options. */
     readonly relayerFee: bigint;
     /** Hyperbridge native dispatch fee from the decoded fill options. */
@@ -4245,6 +3911,7 @@ declare const IntentOrderStatus: Readonly<{
     BID_SELECTED: "BID_SELECTED";
     FILLED: "FILLED";
     PARTIAL_FILL: "PARTIAL_FILL";
+    CANCELLED: "CANCELLED";
     EXPIRED: "EXPIRED";
     FAILED: "FAILED";
 }>;
@@ -4301,11 +3968,18 @@ type IntentOrderStatusUpdate = {
 } | {
     status: "FILLED";
     commitment: HexString$1;
-    userOpHash: HexString$1;
+    /** Absent when the completing fill was not executed here, e.g. after a restart. */
+    userOpHash?: HexString$1;
     selectedSolver: HexString$1;
     transactionHash?: HexString$1;
     totalFilledAssets: TokenInfo[];
     remainingAssets: TokenInfo[];
+} | {
+    /** The order was cancelled on its destination chain before it was completely filled. */
+    status: "CANCELLED";
+    commitment: HexString$1;
+    totalFilledAssets: TokenInfo[];
+    remainingAssets: TokenInfo[];
 } | {
     status: "PARTIAL_FILL";
     commitment: HexString$1;
@@ -5288,152 +4962,350 @@ interface IntentGatewayContext {
     swap: Swap;
 }
 
-type IntentQuoteStrategy = "indexed_rates" | "uniswap_v4" | "phantom_snapshot";
-type IntentQuoteTradeType = "EXACT_INPUT" | "EXACT_OUTPUT";
-type IndexedRateSide = "buy" | "sell";
-/**
- * Full Uniswap V4 PoolKey. V4 pools cannot be discovered from a token pair alone.
- */
-interface UniswapV4PoolKey {
-    currency0: HexString$1;
-    currency1: HexString$1;
-    fee: number;
-    tickSpacing: number;
-    hooks: HexString$1;
-}
-interface UniswapV4IntentQuoteOptions {
-    /** Explicit pool override for pairs not yet present in SDK chain config. */
-    poolKey?: UniswapV4PoolKey & {
-        quoterAddress?: HexString$1;
-        /**
-         * Destination-side address of the input currency. Defaults to
-         * `tokenIn`, which only works for same-chain quotes; pass this
-         * explicitly when source and destination chains differ. Must equal
-         * `currency0` or `currency1`.
-         */
-        currencyIn?: HexString$1;
-    };
+/** The HyperFX orderbook deployments, one per network. */
+declare const ORDERBOOK_URLS: {
+    readonly mainnet: "https://orderbook.hyperfx.finance/mainnet/graphql";
+    readonly testnet: "https://orderbook.hyperfx.finance/testnet/graphql";
+};
+/** The orderbook deployment that serves `stateMachineId`: the testnet book for a testnet chain, else mainnet. */
+declare function orderbookUrlFor(stateMachineId: string): string;
+/** Every amount and rate the orderbook takes or returns is fixed-point at 1e18, whatever the token's decimals. */
+declare const ORDERBOOK_DECIMALS = 18;
+/** `BID` takes a swap selling the book's base; `ASK` takes a swap buying it. */
+type OrderbookSide = "BID" | "ASK";
+/** `SAME_CHAIN` is served by every order on the chain; `CROSS_CHAIN` only by orders declaring the source. */
+type OrderbookRouteKind = "SAME_CHAIN" | "CROSS_CHAIN";
+/** A swap route, by token symbol and state machine id (`EVM-8453`). */
+interface OrderbookRoute {
+    tokenIn: string;
+    tokenOut: string;
+    /** Where the swapper's `tokenIn` is escrowed. */
+    sourceChain: string;
+    /** Where `tokenOut` is delivered, which is the chain the order is filled on. */
+    destinationChain: string;
+}
+/** A configured book. Every rate on it is `quote` per 1 `base`. */
+interface OrderbookBook {
+    id: string;
+    base: string;
+    quote: string;
+}
+/** The best price level for one direction on one fill chain. Amounts and rates at 1e18. */
+interface OrderbookRate {
+    side: OrderbookSide;
+    fillChain: string;
+    /** The level's best single-order price, quote per 1 base. */
+    rate: bigint;
+    /** Virtual depth: the level's summed order sizes, in tokenIn and tokenOut. */
+    depthIn: bigint;
+    depthOut: bigint;
+    /** True liquidity: each solver's largest validated order in the level, summed, in tokenOut. */
+    backingLiquidity: bigint;
+    sourceChains: string[];
+    orderCount: number;
+    solverCount: number;
+}
+/** What a route holds, without an amount. Amounts and rates at 1e18. */
+interface OrderbookRouteLiquidity {
+    route: OrderbookRouteKind;
+    /** The book the route trades on, which names the units of `bestRate`. */
+    book: OrderbookBook;
+    /** `BID` when tokenIn is the book's base, `ASK` when it is the quote. */
+    side: OrderbookSide;
+    /** Quote per 1 base, before the protocol fee; null when no order serves the route. */
+    bestRate: bigint | null;
+    /** The destination chain's protocol fee in basis points, which the gateway takes out of what the orders deliver. */
+    slippageBps: number;
+    /** Virtual depth: the serving orders' sizes summed, in tokenIn and tokenOut. */
+    depthIn: bigint;
+    depthOut: bigint;
+    /** True liquidity in tokenOut: each serving solver's largest validated order, summed. */
+    availableLiquidity: bigint;
+    /** The largest tokenIn amount the route could fill with its orders combined. */
+    maxFillableIn: bigint;
+    orderCount: number;
+    solverCount: number;
+}
+/** One order an optimistic quote takes, at the order's own price. Amounts and rates at 1e18. */
+interface OrderbookQuoteFill {
+    /** The order's full advertised size, not just the part this fill takes. */
+    advertisedSize: bigint;
+    /** The order's own price, quote per 1 base, before the protocol fee: what this fill settles at. */
+    orderRate: bigint;
+    /** The tokenIn this fill takes, in whole raw units on the source chain. */
+    amountIn: bigint;
+    /** The tokenOut this fill delivers, after the protocol fee, floored to a whole raw unit on the destination chain. */
+    amountOut: bigint;
 }
 /**
- * Parameters for `IntentGateway.quoteIntent`. The source and destination
- * chains come from the gateway instance itself.
+ * An optimistic quote for an input amount on a route: the trade split across the route's orders,
+ * best price first, each at its own price. There is no one rate and no total output; the fills are
+ * the quote. Amounts and rates at 1e18.
+ */
+interface OrderbookSwapQuote {
+    route: OrderbookRouteKind;
+    side: OrderbookSide;
+    /** The tokenIn priced, floored to a whole raw unit on the source chain. */
+    amountIn: bigint;
+    /** The destination chain's protocol fee in basis points, already taken off every fill's `amountOut`. */
+    slippageBps: number;
+    fillable: boolean;
+    /** The largest tokenIn amount the route's orders could take together, each at its own price. */
+    maxFillableIn: bigint;
+    /** The orders used, best price first; empty when not fillable. */
+    fills: OrderbookQuoteFill[];
+}
+/**
+ * A pessimistic quote for an input amount on a route: one price, from the first level, best first,
+ * deep enough to fill the whole trade by itself, or else the route's worst price when its levels
+ * together can. Amounts and rates at 1e18.
+ */
+interface OrderbookLevelQuote {
+    route: OrderbookRouteKind;
+    side: OrderbookSide;
+    /** The tokenIn priced, floored to a whole raw unit on the source chain. */
+    amountIn: bigint;
+    /** The tokenOut delivered at `rate`, after the protocol fee, floored to a whole raw unit on the destination chain; 0 when not fillable. */
+    amountOut: bigint;
+    /** The worst single-order price in the level that fills it, quote per 1 base, before the protocol fee; null when not fillable. */
+    rate: bigint | null;
+    /** The price bucket of that level; null when not fillable. */
+    priceBucket: bigint | null;
+    /** The destination chain's protocol fee in basis points, already taken off `amountOut`. */
+    slippageBps: number;
+    fillable: boolean;
+    /** The largest tokenIn amount this quote could fill: any one level at its worst price, or the whole route at its worst. */
+    maxFillableIn: bigint;
+}
+/** The best bid and ask a route can reach, with the book that orients them. */
+interface OrderbookTopOfBook {
+    book: OrderbookBook;
+    /** Highest bid: the most quote a seller of 1 base receives. */
+    bid: OrderbookRate | null;
+    /** Lowest ask: the least quote a buyer of 1 base pays. */
+    ask: OrderbookRate | null;
+}
+/** The orderbook could not answer: a transport failure, or a GraphQL error such as a pair no book trades. */
+declare class OrderbookRequestError extends Error {
+    constructor(message: string);
+}
+/** Every document the client sends, so they can be checked against the orderbook's published schema. */
+declare const ORDERBOOK_QUERIES: {
+    readonly topOfBook: "\nquery TopOfBook($tokenA: String!, $tokenB: String!, $fillChain: String!, $sourceChain: String!) {\n  books { id base quote }\n  aToB: bestRate(tokenIn: $tokenA, tokenOut: $tokenB, fillChain: $fillChain, sourceChain: $sourceChain) { side fillChain rate depthIn depthOut backingLiquidity sourceChains orderCount solverCount }\n  bToA: bestRate(tokenIn: $tokenB, tokenOut: $tokenA, fillChain: $fillChain, sourceChain: $sourceChain) { side fillChain rate depthIn depthOut backingLiquidity sourceChains orderCount solverCount }\n}";
+    readonly routeLiquidity: "\nquery RouteLiquidity($route: RouteInput!) {\n  books { id base quote }\n  routeLiquidity(route: $route) {\n    route bestRate slippageBps depthIn depthOut availableLiquidity maxFillableIn orderCount solverCount\n  }\n}";
+    readonly quote: "\nquery Quote($route: RouteInput!, $amountIn: BigInt!) {\n  quote(route: $route, amountIn: $amountIn) {\n    route side amountIn slippageBps fillable maxFillableIn\n    fills { advertisedSize orderRate amountIn amountOut }\n  }\n}";
+    readonly quotePessimistic: "\nquery QuotePessimistic($route: RouteInput!, $amountIn: BigInt!) {\n  quotePessimistic(route: $route, amountIn: $amountIn) {\n    route side amountIn amountOut rate priceBucket slippageBps fillable maxFillableIn\n  }\n}";
+};
+/**
+ * Read-only client for the HyperFX orderbook's GraphQL API.
  *
- * Quotes default to the aggregate pool's `indexed_rates`. Legacy Phantom
- * snapshots and Uniswap V4 remain available as explicit strategies. `tokenIn`
- * and `tokenOut` are token addresses; the SDK resolves configured token
- * metadata and decimals internally. Provide exactly one amount.
+ * Tokens are named by symbol and chains by state machine id. Every amount and
+ * rate is a `bigint` at 1e18, as the orderbook serves it; rates are quote per 1
+ * base of the pair's book.
+ */
+declare class HyperFxOrderbook {
+    private readonly client;
+    /** @param urlOrClient - The orderbook's GraphQL URL, or a configured `graphql-request` client. */
+    constructor(urlOrClient?: string | GraphQLClient);
+    /**
+     * The best bid and ask on `fillChain` for the pair `tokenA`/`tokenB`, counting
+     * only orders a swap from `sourceChain` can use.
+     */
+    topOfBook(params: {
+        tokenA: string;
+        tokenB: string;
+        fillChain: string;
+        sourceChain: string;
+    }): Promise<OrderbookTopOfBook>;
+    /** Total liquidity on a route, no amount required. */
+    routeLiquidity(route: OrderbookRoute): Promise<OrderbookRouteLiquidity>;
+    /**
+     * The optimistic quote for `amountIn` (1e18 tokenIn) on a route: the route's orders, best price
+     * first, each taking what it can at its own price. The fills' `amountOut`s sum to the output.
+     */
+    quote(route: OrderbookRoute, amountIn: bigint): Promise<OrderbookSwapQuote>;
+    /**
+     * The pessimistic quote for `amountIn` (1e18 tokenIn) on a route: one price, from the first level
+     * deep enough to fill the whole trade by itself, at which every order in it fills; the route's
+     * worst price when no one level can but its levels together can.
+     */
+    quotePessimistic(route: OrderbookRoute, amountIn: bigint): Promise<OrderbookLevelQuote>;
+    private request;
+}
+
+/**
+ * Parameters for `IntentGateway.quoteIntent`. The source and destination chains
+ * come from the gateway instance itself. `tokenIn` and `tokenOut` are token
+ * addresses; the SDK resolves their configured symbols and decimals. Provide
+ * exactly one amount, in the token's raw units.
  */
 interface QuoteIntentParams {
-    strategy?: IntentQuoteStrategy;
     /** Token address on the source chain. */
     tokenIn: HexString$1;
     /** Token address on the destination chain. */
     tokenOut: HexString$1;
     amountIn?: bigint;
     amountOut?: bigint;
-    uniswapV4?: UniswapV4IntentQuoteOptions;
-}
-interface UniswapV4IntentQuoteMetadata {
-    /** Chain whose Uniswap pool and quoter were used for the quote. */
-    quoteChain: string;
-    poolKey: UniswapV4PoolKey;
-    quoterAddress: HexString$1;
     /**
-     * IntentGateway protocol fee on the source chain, already applied to the
-     * returned amounts. Exposed so callers can reconstruct the swap-side
-     * (post-fee) amount if needed.
+     * Return the orderbook's optimistic quote (`QuoteIntentResult`): one leg per
+     * order, each at its own price. Defaults to the pessimistic quote
+     * (`PessimisticQuoteIntentResult`): the whole trade at one price.
      */
-    protocolFeeBps: bigint;
-}
-interface PhantomSnapshotIntentQuoteMetadata {
-    /** Canonical chain whose directional Phantom pair addresses identify the feed. */
-    quoteChain: string;
-    /** Phantom order whose bids produced this snapshot. */
-    commitment: HexString$1;
-    tokenA: HexString$1;
-    tokenB: HexString$1;
-    /** Benchmark input and liquidity-weighted median output, both in raw token units. */
-    standardAmount: bigint;
-    medianPrice: bigint;
-    lowestPrice?: bigint;
-    highestPrice?: bigint;
-    blockNumber: bigint;
-    snapshotTime: Date;
-    bidCount: number;
-    /** Source gateway protocol fee already reflected in the returned quote amounts. */
-    protocolFeeBps: bigint;
-}
-interface IndexedRateIntentQuoteMetadata {
-    sourceChain: Chains;
-    destinationChain: Chains;
-    baseTokenSymbol: ConfiguredAssetSymbol;
-    quoteTokenSymbol: ConfiguredAssetSymbol;
-    /** Directional pool rate used for this order. */
-    rateSide: IndexedRateSide;
-    /** Quote-token units per one base token. */
-    rate: string;
-    rateUpdatedAt: Date;
-    /** Source gateway protocol fee already reflected in the returned quote amounts. */
-    protocolFeeBps: bigint;
+    optimistic?: boolean;
 }
 /**
- * Quote data partners need before constructing an IntentGateway V2 order.
- *
- * `amountIn` and `amountOut` already account for the IntentGateway protocol
- * fee that the gateway deducts from order inputs (see `quoteMetadata`). No
- * further fee or slippage adjustment is required before placing the order.
+ * One order an optimistic intent quote takes, at the order's own price. Amounts
+ * are raw token units; the rate stays at 1e18.
  */
-interface UniswapV4QuoteIntentResult {
-    strategy: "uniswap_v4";
-    tradeType: IntentQuoteTradeType;
+interface IntentQuoteLeg {
+    /** The order's full advertised size in `tokenOut`, not just the part this leg takes. */
+    advertisedSize: bigint;
+    /** The order's own price, quote per 1 base at 1e18, before the protocol fee: what this leg settles at. */
+    orderRate: bigint;
+    /** The `tokenIn` this leg takes. The legs' inputs sum to the quote's `amountIn`. */
     amountIn: bigint;
+    /** The `tokenOut` this leg delivers, with the destination's protocol fee already taken off. */
     amountOut: bigint;
-    quoteMetadata: UniswapV4IntentQuoteMetadata;
 }
-interface PhantomSnapshotQuoteIntentResult {
-    strategy: "phantom_snapshot";
-    tradeType: IntentQuoteTradeType;
+/**
+ * `quoteIntent`'s result with `optimistic: true`, the orderbook's optimistic `quote`: the trade split across the
+ * route's orders, best price first, each at its own price. There is no single
+ * rate or total output; the legs are the quote, and their `amountOut`s sum to
+ * what the order should require. Amounts are raw token units.
+ */
+interface QuoteIntentResult {
+    /** `SAME_CHAIN`, or `CROSS_CHAIN` when only orders accepting the source chain can fill it. */
+    route: OrderbookRouteKind;
+    /** `BID` when the order sells the book's base token, `ASK` when it buys it. */
+    side: OrderbookSide;
+    /** The `tokenIn` priced: the requested input, or the input found to deliver the requested output. */
     amountIn: bigint;
-    amountOut: bigint;
-    quoteMetadata: PhantomSnapshotIntentQuoteMetadata;
-}
-interface IndexedRateQuoteIntentResult {
-    strategy: "indexed_rates";
-    tradeType: IntentQuoteTradeType;
+    /** The destination's protocol fee in basis points, already taken off every leg's `amountOut`. */
+    slippageBps: number;
+    fillable: boolean;
+    /** The largest `amountIn` the route's orders could take together, each at its own price. */
+    maxFillableIn: bigint;
+    /** The orders used, best price first. */
+    legs: IntentQuoteLeg[];
+}
+/**
+ * `quoteIntent`'s default result, the orderbook's `quotePessimistic`: the whole trade at one
+ * price, the worst single-order price of the first level, best first, deep
+ * enough to fill it by itself, or the route's worst price when no one level
+ * can. Amounts are raw token units; rates stay at 1e18.
+ */
+interface PessimisticQuoteIntentResult {
+    route: OrderbookRouteKind;
+    side: OrderbookSide;
+    /** The `tokenIn` priced: the requested input, or the input found to deliver the requested output. */
     amountIn: bigint;
+    /** The `tokenOut` delivered at `rate`, with the destination's protocol fee already taken off. */
     amountOut: bigint;
-    quoteMetadata: IndexedRateIntentQuoteMetadata;
-}
-type QuoteIntentResult = IndexedRateQuoteIntentResult | UniswapV4QuoteIntentResult | PhantomSnapshotQuoteIntentResult;
-declare class UnsupportedIntentQuoteStrategyError extends Error {
-    constructor(strategy: string);
+    /** Quote per 1 base, before the protocol fee: every order in the level fills at it. */
+    rate: bigint | null;
+    /** The price bucket of that level. */
+    priceBucket: bigint | null;
+    /** The destination's protocol fee in basis points, already taken off `amountOut`. */
+    slippageBps: number;
+    fillable: boolean;
+    /** The largest `amountIn` this quote could fill: any one level at its worst price, or the whole route at its worst. */
+    maxFillableIn: bigint;
 }
-declare class UnsupportedIntentQuotePairError extends Error {
-    constructor(params: {
-        source: string;
-        destination: string;
-        tokenIn: HexString$1;
-        tokenOut: HexString$1;
-        quoteSource?: string;
-    });
-}
-declare class PhantomSnapshotUnavailableError extends Error {
-    constructor(tokenA: HexString$1, tokenB: HexString$1);
+/**
+ * What the orderbook holds for one route, with no amount given. Amounts are
+ * decimal strings in whole tokens.
+ */
+interface AvailableLiquidity {
+    sourceChain: Chains;
+    destinationChain: Chains;
+    tokenInSymbol: ConfiguredAssetSymbol;
+    tokenOutSymbol: ConfiguredAssetSymbol;
+    /** `tokenOut` on the destination chain. */
+    tokenAddress: HexString$1;
+    route: OrderbookRouteKind;
+    side: OrderbookSide;
+    baseTokenSymbol: ConfiguredAssetSymbol;
+    quoteTokenSymbol: ConfiguredAssetSymbol;
+    /** The best rate on the route in quote-token units per one base token, or `null` when no order serves it. */
+    bestRate: string | null;
+    /** True liquidity in `tokenOut`: each serving solver's largest balance-checked order, summed. */
+    availableLiquidity: string;
+    /** Virtual depth: every serving order's size summed, in `tokenIn` and `tokenOut`. Can exceed what solvers hold. */
+    depthIn: string;
+    depthOut: string;
+    /** The largest `tokenIn` amount the route could fill with its orders combined. */
+    maxFillableIn: string;
+    orderCount: number;
+    solverCount: number;
+}
+/**
+ * The best bid and ask for a pair on a route, in quote-token units per one base
+ * token, as decimal strings. Either side is `null` while it has no orders.
+ */
+interface BuyAndSellRates {
+    baseTokenSymbol: ConfiguredAssetSymbol;
+    quoteTokenSymbol: ConfiguredAssetSymbol;
+    sourceChain: Chains;
+    destinationChain: Chains;
+    /** Highest bid: the quote token a seller receives per one base token. */
+    bid: string | null;
+    /** Lowest ask: the quote token a buyer pays per one base token. */
+    ask: string | null;
+    /** Midpoint of `bid` and `ask`; `null` unless both sides have orders. */
+    mid: string | null;
+    /** `ask - bid`; `null` when a side is empty or the book is crossed. */
+    spread: string | null;
+    /** `spread` over `mid` in basis points, to two decimal places. */
+    spreadBps: number | null;
 }
-declare class InvalidPhantomSnapshotError extends Error {
-    constructor(commitment: HexString$1, reason: string);
+declare class UnsupportedLiquidityAssetError extends Error {
+    constructor(chain: string, asset: string);
 }
-declare class IndexedRateUnavailableError extends Error {
-    constructor(params: {
-        source?: string;
-        destination?: string;
-        tokenIn?: string;
-        tokenOut?: string;
-        side?: IndexedRateSide;
-    });
+declare class UnsupportedLiquidityChainError extends Error {
+    constructor(chainId: number | string);
 }
-declare class InvalidIndexedRateError extends Error {
-    constructor(reason: string);
+/**
+ * An exact-output quote did not settle on an input within its rounds: each quoted input's clearing
+ * price still fell short of the output. The route may have the depth; the book moved or its levels
+ * are too steep to converge on in time. Retrying, or quoting an exact input, may succeed.
+ */
+declare class OrderbookQuoteNotConvergedError extends Error {
+    readonly route: {
+        tokenIn: string;
+        tokenOut: string;
+        sourceChain: string;
+        destinationChain: string;
+    };
+    readonly rounds: number;
+    /** The last input quoted, in the source token's raw units. */
+    readonly lastAmountIn: bigint;
+    constructor(route: {
+        tokenIn: string;
+        tokenOut: string;
+        sourceChain: string;
+        destinationChain: string;
+    }, rounds: number, 
+    /** The last input quoted, in the source token's raw units. */
+    lastAmountIn: bigint);
+}
+/** The orderbook cannot fill the requested amount on this route. */
+declare class InsufficientOrderbookLiquidityError extends Error {
+    readonly route: {
+        tokenIn: string;
+        tokenOut: string;
+        sourceChain: string;
+        destinationChain: string;
+    };
+    /** The largest `amountIn` the route can fill, in the source token's raw units. */
+    readonly maxFillableIn: bigint;
+    constructor(route: {
+        tokenIn: string;
+        tokenOut: string;
+        sourceChain: string;
+        destinationChain: string;
+    }, 
+    /** The largest `amountIn` the route can fill, in the source token's raw units. */
+    maxFillableIn: bigint);
 }
 
 /**
@@ -5441,8 +5313,7 @@ declare class InvalidIndexedRateError extends Error {
  *
  * `IntentGateway` orchestrates the complete lifecycle of an intent-based
  * cross-chain swap:
- * - **Quoting** — prices the order's input/output amounts from aggregate
- *   indexed pool rates by default, with legacy quote strategies available explicitly.
+ * - **Quoting** — prices orders, liquidity and rates from the HyperFX orderbook.
  * - **Order placement** — encodes and yields `placeOrder` calldata; caller
  *   signs and submits the transaction.
  * - **Order execution** — polls the Hyperbridge coprocessor for solver bids,
@@ -5484,8 +5355,10 @@ declare class IntentGateway {
     private readonly bidManager;
     /** Estimates gas costs for filling an order and converts them to fee-token amounts. */
     private readonly gasEstimator;
-    /** Quote strategies for pricing orders before placement, keyed by strategy name. */
-    private readonly quoteStrategies;
+    /** The HyperFX orderbook quotes, liquidity and rates are read from. */
+    private orderbook;
+    /** Prices intents, liquidity and rates from {@link orderbook}. */
+    private readonly market;
     /**
      * Private constructor — use {@link IntentGateway.create} instead.
      *
@@ -5521,42 +5394,57 @@ declare class IntentGateway {
      */
     private init;
     /**
-     * Quotes an intent between this gateway's source and destination chains.
+     * Points quotes, liquidity and rate reads at a HyperFX orderbook other than
+     * the destination chain's network deployment ({@link ORDERBOOK_URLS}).
+     * Returns `this` for chaining.
+     *
+     * @param orderbook - The orderbook's GraphQL URL, or a configured client.
+     */
+    withOrderbook(orderbook: string | HyperFxOrderbook): this;
+    /**
+     * Quotes an intent between this gateway's source and destination chains from
+     * the HyperFX orderbook. Provide exactly one of `amountIn` or `amountOut`, in
+     * raw token units. The result has the orderbook's shape, in raw token units.
      *
-     * Uses the indexer's latest aggregate directional pool rate by default. Pass
-     * `strategy: "phantom_snapshot"` or `strategy: "uniswap_v4"` only when
-     * explicitly requesting a legacy quote source. Provide exactly one of
-     * `amountIn` or `amountOut`.
+     * By default the quote is pessimistic (`PessimisticQuoteIntentResult`): the
+     * whole trade at one price, the worst single-order price of the first level,
+     * best first, deep enough to fill it by itself, or the route's worst price
+     * when no one level can. With `optimistic: true` it is the orderbook's
+     * optimistic quote (`QuoteIntentResult`): the route's orders, best price
+     * first, each filling what it can of the trade at its own price, one leg per
+     * order. There is no total output; the legs' `amountOut`s sum to it.
      *
-     * The gateway's source and destination chains resolve the configured order
-     * tokens; the indexer supplies the depth-weighted pool rate. Returned
-     * `amountIn`/`amountOut` already account for the gateway's protocol fee
-     * (`quoteMetadata.protocolFeeBps`), which the gateway deducts from order inputs.
+     * Every `amountOut` already has the destination's protocol fee taken off. For
+     * an exact output, the quote is for an input that delivers `amountOut`. A
+     * cross-chain route only counts orders whose solvers accept the source chain.
      *
-     * @param params - Token pair, amount, and optional strategy/pool overrides.
-     * @returns The quoted amounts plus strategy-specific metadata.
-     * @throws {UnsupportedIntentQuoteStrategyError} For unknown strategies.
-     * @throws {UnsupportedIntentQuotePairError} When the selected strategy does not support the pair.
-     * @throws {IndexedRateUnavailableError} When the requested direction has no indexed rate.
+     * @throws {InsufficientOrderbookLiquidityError} When the route cannot fill the amount.
+     * @throws {OrderbookQuoteNotConvergedError} When an exact-output quote does not settle on an input.
+     * @throws {OrderbookRequestError} When the orderbook is unreachable or trades no book for the pair.
      */
-    quoteIntent(params: QuoteIntentParams): Promise<QuoteIntentResult>;
+    quoteIntent(params: QuoteIntentParams & {
+        optimistic: true;
+    }): Promise<QuoteIntentResult>;
+    quoteIntent(params: QuoteIntentParams & {
+        optimistic?: false;
+    }): Promise<PessimisticQuoteIntentResult>;
+    quoteIntent(params: QuoteIntentParams): Promise<QuoteIntentResult | PessimisticQuoteIntentResult>;
     /**
-     * Returns indexed destination liquidity and its source-routing slices.
-     *
-     * Destination, unrestricted, and explicit-route capacity come exclusively
-     * from the indexer's pair-centric liquidity entities. The SDK does not decide
-     * whether unrestricted bidders cover the source chain. Amounts reflect the
-     * latest rolling sample; they are not reservations or fill guarantees.
+     * Returns the orderbook liquidity serving a swap of `tokenIn` on the source
+     * chain for `tokenOut` on the destination chain: the best rate, true and
+     * virtual depth, and the largest input the route can fill.
      *
-     * Requires a prior call to {@link withQueryClient}.
+     * Amounts reflect the live book; they are not reservations or fill guarantees.
      */
-    queryAvailableLiquidity(params: Pick<QuoteIntentParams, "tokenIn" | "tokenOut">): Promise<AvailableLiquidity | undefined>;
+    queryAvailableLiquidity(params: Pick<QuoteIntentParams, "tokenIn" | "tokenOut">): Promise<AvailableLiquidity>;
     /**
-     * Returns aggregate indexed pool buy and sell rates in less-valued quote-token
-     * units without requiring token addresses. Symbols are matched
-     * case-insensitively; chain IDs resolve configured token deployments.
+     * Returns the orderbook's best bid and ask for a pair, with the mid and
+     * spread, in quote-token units per one base token. Only orders filled on the
+     * destination chain that accept swaps from the source chain are counted.
+     * Symbols are matched case-insensitively; chain IDs resolve configured token
+     * deployments.
      */
-    queryBuyAndSellRates(params: QueryBuyAndSellRatesParams): Promise<BuyAndSellRates | undefined>;
+    queryBuyAndSellRates(params: QueryBuyAndSellRatesParams): Promise<BuyAndSellRates>;
     /**
      * Bidirectional async generator that orchestrates the full order lifecycle:
      * placement, fee estimation, bid collection, and execution.
@@ -5695,6 +5583,8 @@ declare class IntentGateway {
     /**
      * Returns both the native token cost and the relayer fee for cancelling an
      * order. Use `relayerFee` to approve the ERC-20 spend before submitting.
+     * Same-chain orders use the direct local route for either `from` option and
+     * return `{ nativeValue: 0n, relayerFee: 0n }`.
      *
      * Delegates to {@link OrderCanceller.quoteCancelOrder}.
      *
@@ -5712,9 +5602,17 @@ declare class IntentGateway {
      *
      * Delegates to {@link OrderCanceller.cancelOrder}.
      *
+     * Same-chain orders always use the direct source-gateway route. The order
+     * user may call through the deadline; any account may call strictly after
+     * it, pays the transaction gas, and cannot change the refund beneficiary.
+     * The SDK yields unsigned transaction fields and accepts either the caller's
+     * signed raw transaction or its already-broadcast transaction hash.
+     *
      * @param order - The order to cancel.
-     * @param indexerClient - Indexer client used for ISMP request status streaming.
-     * @param options - Choose the initiation side. Defaults to source-side cancellation.
+     * @param indexerClient - Indexer client used for cross-chain ISMP request
+     *   status streaming; the same-chain route does not access it.
+     * @param options - Choose the cross-chain initiation side. Defaults to source;
+     *   ignored for routing when source and destination are the same chain.
      * @yields {@link CancelEvent} objects describing each cancellation stage.
      */
     cancelOrder(order: Order, indexerClient: IsmpClient, options?: CancelOrderOptions): AsyncGenerator<CancelEvent>;
@@ -5836,15 +5734,23 @@ declare class IntentGateway {
      */
     decodeERC7821Execute(callData: HexString$1): ERC7821Call[] | null;
     /**
-     * Checks whether an order has been filled on the destination chain.
+     * Checks whether an order is finalized on the destination chain.
      *
      * Delegates to {@link OrderStatusChecker.isOrderFilled}.
      *
      * @param order - The order to check.
-     * @returns `true` if the order's commitment slot on the destination chain is
-     *   non-zero (i.e. `fillOrder` has been called successfully).
+     * @returns `true` once a completing fill or a destination-side cancellation
+     *   has finalized the order; `false` while it is open or only partly filled.
      */
     isOrderFilled(order: Order): Promise<boolean>;
+    /**
+     * Output credited to the order so far, one entry per leg.
+     *
+     * Delegates to {@link OrderStatusChecker.getFillProgress}.
+     *
+     * @param order - The order to check.
+     */
+    getFillProgress(order: Order): Promise<TokenInfo[]>;
     /**
      * Checks whether all escrowed inputs for an order have been refunded on the
      * source chain.
@@ -5852,8 +5758,8 @@ declare class IntentGateway {
      * Delegates to {@link OrderStatusChecker.isOrderRefunded}.
      *
      * @param order - The order to check.
-     * @returns `true` if every input token's escrowed amount has been zeroed out
-     *   in the `_orders` mapping on the source chain.
+     * @returns `true` if every input's escrowed amount has been zeroed out
+     *   in the per-leg `_orders` mapping on the source chain.
      */
     isOrderRefunded(order: Order): Promise<boolean>;
     /**
@@ -5902,16 +5808,6 @@ declare class IntentGateway {
     }, void>;
 }
 
-declare class InvalidLiquidityIndexerResponseError extends Error {
-    constructor(reason: string);
-}
-declare class UnsupportedLiquidityAssetError extends Error {
-    constructor(chain: string, asset: string);
-}
-declare class UnsupportedLiquidityChainError extends Error {
-    constructor(chainId: number | string);
-}
-
 /**
  * Canonical symbol order used by the SDK and indexer pool IDs.
  *
@@ -5936,20 +5832,28 @@ declare class OrderStatusChecker {
      */
     constructor(ctx: IntentGatewayContext);
     /**
-     * Checks if a V2 order has been filled by reading the commitment storage slot on the destination chain.
-     *
-     * Reads the storage slot returned by `calculateCommitmentSlotHash` on the IntentGatewayV2 contract.
-     * A non-zero value at that slot means the solver has called `fillOrder` and the order is complete
-     * from the user's perspective (the beneficiary has received their tokens).
+     * Whether the order is finalized on the destination chain, read from the gateway's `_filled`
+     * getter. It is set by the completing fill, and by a cancellation, which records the refund
+     * beneficiary there. A partially filled order reads false; see {@link getFillProgress}.
      *
      * @param order - The V2 order to check. `order.id` is used as the commitment; if not set it is computed.
-     * @returns True if the order has been filled on the destination chain, false otherwise.
      */
     isOrderFilled(order: Order): Promise<boolean>;
+    /**
+     * Output credited to the order so far, one entry per leg, read from `_partialFills` on the
+     * destination chain. Several solvers can each fill a slice of a same-chain or cross-chain order,
+     * so this, not {@link isOrderFilled}, says how far along an open order is. Surplus paid above
+     * the order's rate is not counted.
+     *
+     * @param order - The V2 order to check. `order.id` is used as the commitment; if not set it is computed.
+     */
+    getFillProgress(order: Order): Promise<TokenInfo[]>;
     /**
      * Checks if a V2 order has been refunded by reading the `_orders` mapping on the source chain.
      *
-     * Calls `_orders(commitment, tokenAddress)` for each input token. When the order is placed the
+     * Calls `_orders(commitment, index)` for each input: escrow is held per leg, keyed by the input's
+     * index, so inputs that repeat a token are read separately. A gateway not yet upgraded to per-leg
+     * escrow is read by token instead, see {@link readLegEscrow}. When the order is placed the
      * escrowed amounts are stored there. After a successful refund the contract zeroes them out.
      * An order is considered refunded when all escrowed input amounts have been returned (i.e. are 0).
      *
@@ -5959,6 +5863,31 @@ declare class OrderStatusChecker {
     isOrderRefunded(order: Order): Promise<boolean>;
 }
 
+type ReadClient = Pick<PublicClient, "readContract">;
+/**
+ * Escrow held for leg `index` of an order on its source chain: `_orders(commitment, index)`, or
+ * `_orders(commitment, token)` on a gateway that has not been upgraded to per-leg escrow.
+ *
+ * @param client - Public client of the order's source chain.
+ * @param gateway - IntentGatewayV2 address on that chain.
+ * @param commitment - The order commitment.
+ * @param index - Leg index into `order.inputs`.
+ * @param token - `order.inputs[index].token`, as bytes32 or a 20-byte address.
+ */
+declare function readLegEscrow(client: ReadClient, gateway: HexString$1, commitment: HexString$1, index: number, token: HexString$1): Promise<bigint>;
+/**
+ * Output delivered so far for leg `index` of an order on its destination chain:
+ * `_partialFills(commitment, index)`, or `_partialFills(commitment, token)` on a gateway that has not
+ * been upgraded to per-leg escrow.
+ *
+ * @param client - Public client of the order's destination chain.
+ * @param gateway - IntentGatewayV2 address on that chain.
+ * @param commitment - The order commitment.
+ * @param index - Leg index into `order.output.assets`.
+ * @param token - `order.output.assets[index].token` as bytes32.
+ */
+declare function readLegPartialFill(client: ReadClient, gateway: HexString$1, commitment: HexString$1, index: number, token: HexString$1): Promise<bigint>;
+
 declare function encodeERC7821ExecuteBatch(calls: ERC7821Call[]): HexString$1;
 declare function decodeERC7821ExecuteBatch(callData: HexString$1): ERC7821Call[] | null;
 
@@ -6088,19 +6017,34 @@ declare class CryptoUtils {
     static computeUserOpHash(userOp: PackedUserOperation, entryPoint: Hex, chainId: bigint): Hex;
     /**
      * Derives the ERC-4337 nonce key that binds a bid UserOperation to its
-     * order and session key: the lower 192 bits of
-     * `keccak256(commitment ‖ sessionKey)`. `SolverAccount` rejects bid
-     * operations whose nonce key differs — this is what lets the solver sign
-     * the plain userOpHash while staying committed to the order and to the
-     * session key it bid against.
+     * order, session key and calldata: the lower 192 bits of
+     * `keccak256(commitment ‖ sessionKey ‖ keccak256(callData))`. `SolverAccount`
+     * rejects bid operations whose nonce key differs — this is what lets the
+     * solver sign the plain userOpHash while staying committed to the order and
+     * to the session key it bid against.
+     *
+     * The calldata gives every bid its own key. A solver bidding several prices
+     * on one order signs one op per price, and each is sequence 0 of its own key,
+     * so they execute independently rather than in a sequence where one bid that
+     * is never selected blocks the rest.
      *
      * @param commitment - The order commitment (`order.id`).
      * @param sessionKey - The order's session key address (`order.session`).
+     * @param callData - The UserOperation's `callData`.
      * @returns The 192-bit nonce key as a bigint (pass to `EntryPoint.getNonce`).
      */
-    static bidNonceKey(commitment: HexString$1, sessionKey: HexString$1): bigint;
+    static bidNonceKey(commitment: HexString$1, sessionKey: HexString$1, callData: HexString$1): bigint;
     /**
-     * Builds the EIP-712 typed-data payload whose digest is the EntryPoint v0.8
+     * The identifier Hyperbridge files a bid under: `keccak256` of the UserOp's
+     * `callData`. It is the same hash {@link bidNonceKey} takes, so a bid's
+     * identifier and its nonce key both follow from the op itself, and one
+     * solver's bids on one order are kept apart for the same reason on both sides.
+     *
+     * @param callData - The UserOperation's `callData`.
+     */
+    static bidId(callData: HexString$1): HexString$1;
+    /**
+     * Builds the EIP-712 typed-data payload whose digest is the EntryPoint v0.8
      * `userOpHash` (i.e. `hashTypedData(packedUserOpTypedData(...)) ===
      * computeUserOpHash(...)`). Signing this typed data is bit-identical to
      * signing the raw userOpHash, but keeps the full operation visible to
@@ -6287,213 +6231,54 @@ declare class CryptoUtils {
     decodeERC7821Execute(callData: HexString$1): ERC7821Call[] | null;
 }
 
-/**
- * `FillOptions` gained a `validUntil` field. Adding a field to a struct changes the
- * enclosing function's selector, so `fillOrder` has two incompatible shapes in the wild:
- *
- *   v1  fillOrder(Order, (uint256 relayerFee, uint256 nativeDispatchFee, TokenInfo[] outputs))
- *   v2  fillOrder(Order, (uint256 relayerFee, uint256 nativeDispatchFee, uint256 validUntil, TokenInfo[] outputs))
- *
- * The selectors differ (`0x5cfb1ea5` vs `0xa5470064`), so a v2 payload sent to a v1
- * deployment finds no matching function and reverts rather than mis-decoding — which is the
- * safe failure, but it does mean callers have to know which shape a gateway speaks.
- */
-type FillOptionsVersion = 1 | 2;
-/**
- * The v1 `fillOrder`, kept only so we can still talk to deployments that predate `validUntil`.
- *
- * Exported because consumers that cannot use {@link decodeFillOrder} still have to accept both
- * shapes. The indexer decodes bid calldata with ethers rather than viem (viem's byte handling
- * throws inside SubQuery's VM2 sandbox), so it rebuilds this decode itself and needs the same
- * definition rather than a second copy that can drift out of step with this one.
- */
-declare const FILL_ORDER_V1_ABI: readonly [{
+type DecodedFillOrder = {
+    order: Order;
+    options: FillOptions;
+};
+/** `fillOrder(Order, FillOptions)` selector, pinned by codec tests; avoids import-time hashing in VM2. */
+declare const FILL_ORDER_SELECTOR: "0x68ddf058";
+/** The gateway release this SDK speaks. SolverAccount carries no version, so only the gateway is read. */
+declare const SUPPORTED_INTENTS_VERSION = 3n;
+declare const CONTRACT_VERSION_ABI: readonly [{
     readonly type: "function";
-    readonly name: "fillOrder";
-    readonly stateMutability: "payable";
-    readonly outputs: readonly [];
-    readonly inputs: readonly [{
-        readonly name: "order";
-        readonly type: "tuple";
-        readonly internalType: "struct Order";
-        readonly components: readonly [{
-            readonly name: "user";
-            readonly type: "bytes32";
-            readonly internalType: "bytes32";
-        }, {
-            readonly name: "source";
-            readonly type: "bytes";
-            readonly internalType: "bytes";
-        }, {
-            readonly name: "destination";
-            readonly type: "bytes";
-            readonly internalType: "bytes";
-        }, {
-            readonly name: "deadline";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }, {
-            readonly name: "nonce";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }, {
-            readonly name: "fees";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }, {
-            readonly name: "session";
-            readonly type: "address";
-            readonly internalType: "address";
-        }, {
-            readonly name: "predispatch";
-            readonly type: "tuple";
-            readonly internalType: "struct DispatchInfo";
-            readonly components: readonly [{
-                readonly name: "assets";
-                readonly type: "tuple[]";
-                readonly internalType: "struct TokenInfo[]";
-                readonly components: readonly [{
-                    readonly name: "token";
-                    readonly type: "bytes32";
-                    readonly internalType: "bytes32";
-                }, {
-                    readonly name: "amount";
-                    readonly type: "uint256";
-                    readonly internalType: "uint256";
-                }];
-            }, {
-                readonly name: "call";
-                readonly type: "bytes";
-                readonly internalType: "bytes";
-            }];
-        }, {
-            readonly name: "inputs";
-            readonly type: "tuple[]";
-            readonly internalType: "struct TokenInfo[]";
-            readonly components: readonly [{
-                readonly name: "token";
-                readonly type: "bytes32";
-                readonly internalType: "bytes32";
-            }, {
-                readonly name: "amount";
-                readonly type: "uint256";
-                readonly internalType: "uint256";
-            }];
-        }, {
-            readonly name: "output";
-            readonly type: "tuple";
-            readonly internalType: "struct PaymentInfo";
-            readonly components: readonly [{
-                readonly name: "beneficiary";
-                readonly type: "bytes32";
-                readonly internalType: "bytes32";
-            }, {
-                readonly name: "assets";
-                readonly type: "tuple[]";
-                readonly internalType: "struct TokenInfo[]";
-                readonly components: readonly [{
-                    readonly name: "token";
-                    readonly type: "bytes32";
-                    readonly internalType: "bytes32";
-                }, {
-                    readonly name: "amount";
-                    readonly type: "uint256";
-                    readonly internalType: "uint256";
-                }];
-            }, {
-                readonly name: "call";
-                readonly type: "bytes";
-                readonly internalType: "bytes";
-            }];
-        }];
-    }, {
-        readonly name: "options";
-        readonly type: "tuple";
-        readonly internalType: "struct FillOptions";
-        readonly components: readonly [{
-            readonly name: "relayerFee";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }, {
-            readonly name: "nativeDispatchFee";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }, {
-            readonly name: "outputs";
-            readonly type: "tuple[]";
-            readonly internalType: "struct TokenInfo[]";
-            readonly components: readonly [{
-                readonly name: "token";
-                readonly type: "bytes32";
-                readonly internalType: "bytes32";
-            }, {
-                readonly name: "amount";
-                readonly type: "uint256";
-                readonly internalType: "uint256";
-            }];
-        }];
+    readonly name: "version";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint64";
     }];
 }];
-/**
- * IntentGateway implementations deployed before `FillOptions.validUntil` existed.
- *
- * The list is of *legacy* implementations rather than current ones, so the default is v2 and
- * nothing has to be added here when a new implementation ships — only when an old one is
- * discovered. Once every deployment is upgraded this set is vestigial and still correct.
- *
- * The alternative, listing known-good implementations, would be the version constant this
- * replaced wearing a different hat: a value someone must remember to update on every upgrade,
- * where forgetting breaks every fill on the chain.
- */
-declare const LEGACY_FILL_OPTIONS_IMPLEMENTATIONS: Set<string>;
-/**
- * Chains whose IntentGateway has not been redeployed with `FillOptions.validUntil` yet.
- *
- * A blunter instrument than {@link LEGACY_FILL_OPTIONS_IMPLEMENTATIONS} and used for the same
- * reason: those chains run a pre-`validUntil` implementation whose address is not tracked here,
- * so the address check would wrongly read them as current and every fill would revert on a
- * selector that does not exist.
- *
- * Delete a chain from this set when its gateway is redeployed. Once the set is empty the
- * implementation-address check covers everything on its own.
- */
-declare const CHAINS_WITHOUT_VALID_UNTIL: Set<number>;
-/** Test seam: drop memoised detection results. */
-declare function resetFillOptionsVersionCache(): void;
-/**
- * Works out which `FillOptions` shape a gateway accepts from the implementation it delegates to.
+/** Whether the gateway reports the supported release. RPC failures propagate. */
+declare function supportsRateFills(client: PublicClient, gateway: HexString$1): Promise<boolean>;
+/** The gateway must report release {@link SUPPORTED_INTENTS_VERSION}; a missing getter or any other release throws. */
+declare function assertGatewayRelease(client: PublicClient, gateway: HexString$1): Promise<void>;
+/** A bytes32 token whose upper 12 bytes are zero, the only form the gateway accepts. */
+declare function isCanonicalEvmToken(token: string): boolean;
+/** ABI-encodes a `fillOrder` call. Every leg must carry a validated quote. */
+declare function encodeFillOrder(order: Order, options: FillOptions): HexString$1;
+/**
+ * Decodes a `fillOrder` call.
  *
- * EIP-1967 standardises three slots, all holding addresses — there is no version field to read,
- * and the contract deliberately does not carry one either: a hand-maintained version constant is
- * a second source of truth that has to be bumped on the right upgrade. The implementation address
- * is the value the proxy already updates, so it is what identifies the deployed code.
+ * @returns The decoded order and options, or `null` if the calldata is not a `fillOrder` call in
+ *   the current shape or its quotes do not cover the order's legs.
  */
-declare function getFillOptionsVersion(client: PublicClient, gateway: HexString$1): Promise<FillOptionsVersion>;
-/**
- * ABI-encodes a `fillOrder` call in the shape the target gateway understands.
- *
- * On a v1 gateway `validUntil` is dropped — there is nowhere to put it and no check on the
- * other side. That is a real loss of protection, so callers that rely on the bound should
- * surface it rather than assume it took effect.
- */
-declare function encodeFillOrder(order: Order, options: FillOptions, version: FillOptionsVersion): HexString$1;
-/**
- * Decodes a `fillOrder` call of either shape.
- *
- * v2 is tried first and v1 is the fallback; the selectors differ, so there is no shape a
- * decode could silently get wrong. `validUntil` reads as `0n` for a v1 payload, which is the
- * same value that means "no bound" in v2 — accurate, since a v1 fill genuinely has none.
- *
- * @returns The decoded order and options, or `null` if the calldata is not a `fillOrder`.
- */
-declare function decodeFillOrder(data: HexString$1): {
-    order: Order;
-    options: FillOptions;
-} | null;
+declare function decodeFillOrder(data: HexString$1): DecodedFillOrder | null;
+
+interface RateFillPreview {
+    credit: bigint;
+    release: bigint;
+    delivered: bigint;
+    surplus: bigint;
+}
+/** Estimates settlement at the supplied progress. The signed take/offered amounts remain caps. */
+declare function previewRateFill(escrow: bigint, required: bigint, filled: bigint, take: bigint, offered: bigint): RateFillPreview;
 
 type HexString = `0x${string}`;
 /** A complete Permit2-sponsored paymasterAndData, before any declaration is appended. */
 declare const PERMIT2_SPONSORSHIP_BYTES: number;
+/** Upper bound on declared chains and positions alike; one byte of count each. */
+declare const MAX_DECLARED_ENTRIES = 255;
 /**
  * The Permit2 sponsorship a bid's paymasterAndData carries when it was built on the real-bid path:
  * which paymaster it names and the fee-token permit it signed for that paymaster. Read for the
@@ -6519,8 +6304,8 @@ interface PhantomBidDeclaration {
      */
     acceptedSources: string[] | null;
     /**
-     * Uniswap V4 position tokenIds the solver declares as backing this bid, on the order's own
-     * chain. Empty when none are declared — including for every v1 bid, which predates the field.
+     * Uniswap V4 position tokenIds from a v2 declaration. Decoded for compatibility only; nothing
+     * prices them. Empty when none are declared — including for every v1 bid.
      */
     uniswapV4Positions: bigint[];
 }
@@ -6572,7 +6357,7 @@ declare function decodePhantomBidDeclaration(paymasterAndData: string | undefine
  *
  * `sponsorship` is the packed EntryPoint v0.8 paymasterAndData the paymaster builder produced. It
  * must be exactly the Permit2-mode layout — the only one the decoder recognises — so a caller
- * cannot sign bytes the aggregation would read as "no declaration"; anything else throws. Empty
+ * cannot sign bytes a decoder would read as "no declaration"; anything else throws. Empty
  * or omitted, the result is the bare declaration, byte-identical to what unsponsored bids carry.
  */
 declare function encodePhantomBidPaymasterAndData(bid: {
@@ -6584,39 +6369,15 @@ declare function encodePhantomBidPaymasterAndData(bid: {
 declare function encodeAcceptedSourceChains(chains: string[]): HexString;
 /** Back-compat wrapper: the source-chain half of {@link decodePhantomBidDeclaration}. */
 declare function decodeAcceptedSourceChains(paymasterAndData: string | undefined | null): string[] | null;
-/**
- * Haircut applied to a quote that is priced off a Uniswap V4 pool, in basis points.
- *
- * A bid that declares V4 positions is quoting off those pools, and a pool price is what a trade
- * gets BEFORE the pool takes its fee — so the amount such a bid names is more than the solver
- * would actually be left holding once the swap that sources it clears. Netting that cost out here
- * is what makes a pool-priced quote comparable to a wallet-funded one, whose inventory has already
- * paid its cost of goods.
- */
-declare const UNISWAP_QUOTE_HAIRCUT_BPS = 10n;
-/** Applies {@link UNISWAP_QUOTE_HAIRCUT_BPS} to a quoted output amount, rounding down. */
-declare function applyUniswapQuoteHaircut(amount: bigint): bigint;
-/**
- * The protocol fee haircut: the fee the IntentGateway at `gatewayAddress` charges on order inputs,
- * in basis points, read live from its `params()`.
- *
- * A wallet-funded quote is shaded by exactly this, so the published rate is the one a taker
- * actually realizes after the gateway takes its cut, and it moves with governance rather than
- * with a constant someone has to remember to keep in step. Read on the phantom order's own chain,
- * which is the chain whose gateway will collect the fee on the fills this rate is published for.
- *
- * Fails loudly rather than defaulting: a gateway that returns no code, or a fee at or above 100%,
- * is a misconfiguration, and pricing a window unhaircut on the back of it would publish a rate
- * nobody can trade at. The `PhantomRpcError` lets the run's retry loop have another go first.
- */
-declare function readProtocolFeeHaircutBps(evmRpcUrl: string, gatewayAddress: string): Promise<bigint>;
-/** Applies the protocol fee haircut (see {@link readProtocolFeeHaircutBps}) to a quoted output amount, rounding down. */
-declare function applyProtocolFeeHaircut(amount: bigint, protocolFeeBps: bigint): bigint;
 
 declare const ABI$1: readonly [{
     readonly type: "constructor";
     readonly inputs: readonly [{
-        readonly name: "owner";
+        readonly name: "intrinsic";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "extrinsic";
         readonly type: "address";
         readonly internalType: "address";
     }];
@@ -6691,8 +6452,8 @@ declare const ABI$1: readonly [{
         readonly internalType: "bytes32";
     }, {
         readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly outputs: readonly [{
         readonly name: "";
@@ -6702,32 +6463,50 @@ declare const ABI$1: readonly [{
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "_owner";
-    readonly inputs: readonly [];
+    readonly name: "_partialFills";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
     readonly outputs: readonly [{
         readonly name: "";
-        readonly type: "address";
-        readonly internalType: "address";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "_partialFills";
+    readonly name: "_protocolFees";
     readonly inputs: readonly [{
         readonly name: "";
         readonly type: "bytes32";
         readonly internalType: "bytes32";
     }, {
         readonly name: "";
-        readonly type: "bytes32";
-        readonly internalType: "bytes32";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
     }];
     readonly outputs: readonly [{
-        readonly name: "";
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "committed";
         readonly type: "uint256";
         readonly internalType: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "acceptOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly name: "calculateCommitmentSlotHash";
@@ -6889,6 +6668,16 @@ declare const ABI$1: readonly [{
         readonly internalType: "uint256[]";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "extrinsicModule";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "fillOrder";
@@ -7015,6 +6804,19 @@ declare const ABI$1: readonly [{
                 readonly type: "uint256";
                 readonly internalType: "uint256";
             }];
+        }, {
+            readonly name: "inputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct TokenInfo[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "bytes32";
+                readonly internalType: "bytes32";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
         }];
     }];
     readonly outputs: readonly [];
@@ -7033,42 +6835,51 @@ declare const ABI$1: readonly [{
     readonly type: "function";
     readonly name: "initialize";
     readonly inputs: readonly [{
-        readonly name: "p";
+        readonly name: "init";
         readonly type: "tuple";
-        readonly internalType: "struct Params";
+        readonly internalType: "struct InitParams";
         readonly components: readonly [{
-            readonly name: "host";
-            readonly type: "address";
-            readonly internalType: "address";
+            readonly name: "params";
+            readonly type: "tuple";
+            readonly internalType: "struct Params";
+            readonly components: readonly [{
+                readonly name: "host";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "dispatcher";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "solverSelection";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "surplusShareBps";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "protocolFeeBps";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }, {
+                readonly name: "priceOracle";
+                readonly type: "address";
+                readonly internalType: "address";
+            }];
         }, {
-            readonly name: "dispatcher";
+            readonly name: "peerChains";
+            readonly type: "bytes[]";
+            readonly internalType: "bytes[]";
+        }, {
+            readonly name: "relayer";
             readonly type: "address";
             readonly internalType: "address";
         }, {
-            readonly name: "solverSelection";
-            readonly type: "bool";
-            readonly internalType: "bool";
-        }, {
-            readonly name: "surplusShareBps";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }, {
-            readonly name: "protocolFeeBps";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }, {
-            readonly name: "priceOracle";
+            readonly name: "owner";
             readonly type: "address";
             readonly internalType: "address";
         }];
-    }, {
-        readonly name: "peerChains";
-        readonly type: "bytes[]";
-        readonly internalType: "bytes[]";
-    }, {
-        readonly name: "relayer";
-        readonly type: "address";
-        readonly internalType: "address";
     }];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
@@ -7086,11 +6897,21 @@ declare const ABI$1: readonly [{
         readonly internalType: "address";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "intrinsicModule";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "migrate";
     readonly inputs: readonly [{
-        readonly name: "relayer";
+        readonly name: "owner_";
         readonly type: "address";
         readonly internalType: "address";
     }];
@@ -7148,7 +6969,7 @@ declare const ABI$1: readonly [{
     readonly type: "function";
     readonly name: "onGetResponse";
     readonly inputs: readonly [{
-        readonly name: "incoming";
+        readonly name: "";
         readonly type: "tuple";
         readonly internalType: "struct IncomingGetResponse";
         readonly components: readonly [{
@@ -7314,6 +7135,16 @@ declare const ABI$1: readonly [{
     }];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "owner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "params";
@@ -7349,6 +7180,32 @@ declare const ABI$1: readonly [{
         }];
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pause";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "paused";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pendingOwner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "placeOrder";
@@ -7545,6 +7402,12 @@ declare const ABI$1: readonly [{
         readonly internalType: "address";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "renounceOwnership";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly name: "select";
@@ -7574,9 +7437,9 @@ declare const ABI$1: readonly [{
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly name: "setRelayer";
+    readonly name: "transferOwnership";
     readonly inputs: readonly [{
-        readonly name: "relayer";
+        readonly name: "newOwner";
         readonly type: "address";
         readonly internalType: "address";
     }];
@@ -7584,16 +7447,8 @@ declare const ABI$1: readonly [{
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly name: "upgradeToAndCall";
-    readonly inputs: readonly [{
-        readonly name: "newImplementation";
-        readonly type: "address";
-        readonly internalType: "address";
-    }, {
-        readonly name: "data";
-        readonly type: "bytes";
-        readonly internalType: "bytes";
-    }];
+    readonly name: "unpause";
+    readonly inputs: readonly [];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
@@ -7708,6 +7563,11 @@ declare const ABI$1: readonly [{
         readonly type: "bytes32";
         readonly indexed: true;
         readonly internalType: "bytes32";
+    }, {
+        readonly name: "solver";
+        readonly type: "address";
+        readonly indexed: false;
+        readonly internalType: "address";
     }, {
         readonly name: "tokens";
         readonly type: "tuple[]";
@@ -7894,6 +7754,36 @@ declare const ABI$1: readonly [{
         readonly internalType: "bytes32";
     }];
     readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferStarted";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "OwnershipTransferred";
+    readonly inputs: readonly [{
+        readonly name: "previousOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "newOwner";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
 }, {
     readonly type: "event";
     readonly name: "ParamsUpdated";
@@ -8004,37 +7894,59 @@ declare const ABI$1: readonly [{
     readonly anonymous: false;
 }, {
     readonly type: "event";
-    readonly name: "RelayerUpdated";
+    readonly name: "Paused";
     readonly inputs: readonly [{
-        readonly name: "previous";
+        readonly name: "account";
         readonly type: "address";
         readonly indexed: false;
         readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "ProtocolFeeRefunded";
+    readonly inputs: readonly [{
+        readonly name: "commitment";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
     }, {
-        readonly name: "current";
+        readonly name: "token";
         readonly type: "address";
-        readonly indexed: false;
+        readonly indexed: true;
         readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
     }];
     readonly anonymous: false;
 }, {
     readonly type: "event";
-    readonly name: "Upgraded";
+    readonly name: "RelayerUpdated";
     readonly inputs: readonly [{
-        readonly name: "implementation";
+        readonly name: "previous";
         readonly type: "address";
-        readonly indexed: true;
+        readonly indexed: false;
+        readonly internalType: "address";
+    }, {
+        readonly name: "current";
+        readonly type: "address";
+        readonly indexed: false;
         readonly internalType: "address";
     }];
     readonly anonymous: false;
 }, {
-    readonly type: "error";
-    readonly name: "AddressEmptyCode";
+    readonly type: "event";
+    readonly name: "Unpaused";
     readonly inputs: readonly [{
-        readonly name: "target";
+        readonly name: "account";
         readonly type: "address";
+        readonly indexed: false;
         readonly internalType: "address";
     }];
+    readonly anonymous: false;
 }, {
     readonly type: "error";
     readonly name: "Cancelled";
@@ -8061,23 +7973,15 @@ declare const ABI$1: readonly [{
     }];
 }, {
     readonly type: "error";
-    readonly name: "ERC1967InvalidImplementation";
-    readonly inputs: readonly [{
-        readonly name: "implementation";
-        readonly type: "address";
-        readonly internalType: "address";
-    }];
-}, {
-    readonly type: "error";
-    readonly name: "ERC1967NonPayable";
+    readonly name: "EnforcedPause";
     readonly inputs: readonly [];
 }, {
     readonly type: "error";
-    readonly name: "Expired";
+    readonly name: "ExpectedPause";
     readonly inputs: readonly [];
 }, {
     readonly type: "error";
-    readonly name: "FailedCall";
+    readonly name: "Expired";
     readonly inputs: readonly [];
 }, {
     readonly type: "error";
@@ -8111,10 +8015,34 @@ declare const ABI$1: readonly [{
     readonly type: "error";
     readonly name: "NotInitializing";
     readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableInvalidOwner";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "OwnableUnauthorizedAccount";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
 }, {
     readonly type: "error";
     readonly name: "PartialFillNotAllowed";
     readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "RateBelowOrder";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "RateFillTooSmall";
+    readonly inputs: readonly [];
 }, {
     readonly type: "error";
     readonly name: "ReentrancyGuardReentrantCall";
@@ -11639,4 +11567,4 @@ declare function teleport(teleport_param: {
     extrinsics?: Array<SubmittableExtrinsic<"promise", ISubmittableResult>>;
 }): Promise<ReadableStream<HyperbridgeTxEvents>>;
 
-export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type AvailableLiquidity, type Bid, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BridgeParams, type BridgeStep, type BundlerGasEstimate, BundlerMethod, type BuyAndSellRates, type BytesLikeHex, CHAINS_WITHOUT_VALID_UNTIL, type CancelEvent, type CancelOptions, type CancelOrderOptions, type CancelQuote, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, type ConfiguredAssetSymbol, type ConfiguredAssetSymbolInput, CryptoUtils, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type Deployment, type DispatchGet, type DispatchInfo, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, type Erc4626VaultConfigData, type EstimateFillOrderParams, type EstimateGasCallData, EvmChain, type EvmChainParams, ABI as EvmHostABI, EvmLanguage, type ExecuteIntentOrderOptions, type ExecutionResult, FILL_ORDER_V1_ABI, type FillOptions, type FillOptionsVersion, type FillOrderEstimate, type FillerBid, type FillerConfig, type GetRequestResponse, type GetRequestWithStatus, type GetResponseByRequestIdResponse, type GetResponseStorageValues, type HexString$1 as HexString, type HostParams, HyperClientStatus, HyperFungibleToken, HyperFungibleTokenABI, type HyperbridgeTxEvents, type IBatchConsensusAndGetResponseMessage, type IBatchConsensusAndPostRequestMessage, type IChain, type IConfig, type IConsensusMessage, type IEvmChain, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, INCLUSION_TIMEOUT_MS, type IPharosConfig, type IPolkadotHubConfig, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, type IndexedRateIntentQuoteMetadata, type IndexedRateQuoteIntentResult, type IndexedRateSide, IndexedRateUnavailableError, type IndexerQueryClient, IntentGateway, ABI$1 as IntentGatewayABI, type IntentGatewayContext, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, type IntentQuoteStrategy, type IntentQuoteTradeType, IntentsCoprocessor, InvalidIndexedRateError, InvalidLiquidityIndexerResponseError, InvalidPhantomSnapshotError, IsmpClient, type IsmpRequest, LEGACY_FILL_OPTIONS_IMPLEMENTATIONS, type LiquiditySlice, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, type Order, type OrderFeesQuote, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PERMIT2_SPONSORSHIP_BYTES, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, type PhantomBid, type PhantomBidBatchResult, type PhantomBidDeclaration, type PhantomBidOutcome, type PhantomBidPaymasterAndData, type PhantomBidSponsorship, type PhantomOrderEvent, type PhantomOrderLeg, type PhantomOrderPriceSnapshot, type PhantomOrderPriceSnapshotsResponse, type PhantomSnapshotIntentQuoteMetadata, type PhantomSnapshotQuoteIntentResult, PhantomSnapshotUnavailableError, type PhantomTimings, PharosChain, type PharosChainParams, PolkadotHubChain, type PolkadotHubChainParams, type PollPhantomOrdersOptions, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, type QueryBuyAndSellRatesParams, type QuoteIntentParams, type QuoteIntentResult, type QuoteNativeResult, type QuoteResult, type QuoteUniswapParams, type QuoteUniswapResult, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, type RequestBody, type RequestCommitment, RequestKind, type RequestResponse, RequestStatus, type RequestStatusKey, type RequestStatusWithMetadata, type ResponseCommitmentWithValues, type ResumeIntentOrderOptions, type RetryConfig, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, type SelectBidResult, type SelectOptions, type SigningAccount, type StateMachineHeight, type StateMachineId, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, type StorageFacade, type SubmitBidOptions, SubstrateChain, Swap, TESTNET_CHAINS, type TeleportParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, TokenGateway, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenPrice, type TokenPricesResponse, type Transaction, TronChain, type TronChainParams, UNISWAP_QUOTE_HAIRCUT_BPS, USE_ETHERSCAN_CHAINS, type UniswapProtocol, type UniswapQuote, type UniswapQuoteToken, type UniswapTradeType, type UniswapV4IntentQuoteMetadata, type UniswapV4IntentQuoteOptions, type UniswapV4PoolConfigData, type UniswapV4PoolKey, type UniswapV4QuoteIntentResult, UnsupportedIntentQuotePairError, UnsupportedIntentQuoteStrategyError, UnsupportedLiquidityAssetError, UnsupportedLiquidityChainError, WrappedHyperFungibleTokenABI, type XcmGatewayParams, __test, adjustDecimals, applyProtocolFeeHaircut, applyUniswapQuoteHaircut, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodeFillOrder, decodePhantomBidDeclaration, decodePhantomBidPaymasterAndData, decodeUserOpScale, deriveHttpUrl, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeFillOrder, encodeISMPMessage, encodePhantomBidDeclaration, encodePhantomBidPaymasterAndData, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getContractCallInputs, getFillOptionsVersion, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, normalizeAddressForEvmBytes32, normalizeAddressForStateMachine, normalizeEvmAddress, normalizeEvmChainId, normalizeStateMachineId, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, polkadotHubMainnet, poolSlug, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, readProtocolFeeHaircutBps, requestCommitmentKey, resetFillOptionsVersionCache, responseCommitmentKey, retryPromise, sortPoolSymbols, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
+export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type AvailableLiquidity, type Bid, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BridgeParams, type BridgeStep, type BundlerGasEstimate, BundlerMethod, type BuyAndSellRates, type BytesLikeHex, CONTRACT_VERSION_ABI, type CancelEvent, type CancelOptions, type CancelOrderOptions, type CancelQuote, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, type ConfiguredAssetSymbol, type ConfiguredAssetSymbolInput, CryptoUtils, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedFillOrder, type DecodedOrderPlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type Deployment, type DispatchGet, type DispatchInfo, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, type Erc4626VaultConfigData, type EstimateFillOrderParams, type EstimateGasCallData, EvmChain, type EvmChainParams, ABI as EvmHostABI, EvmLanguage, type ExecuteIntentOrderOptions, type ExecutionResult, FILL_ORDER_SELECTOR, type FillOptions, type FillOrderEstimate, type FillerBid, type FillerConfig, type GetRequestResponse, type GetRequestWithStatus, type GetResponseByRequestIdResponse, type GetResponseStorageValues, type HexString$1 as HexString, type HostParams, HyperClientStatus, HyperFungibleToken, HyperFungibleTokenABI, HyperFxOrderbook, type HyperbridgeTxEvents, type IBatchConsensusAndGetResponseMessage, type IBatchConsensusAndPostRequestMessage, type IChain, type IConfig, type IConsensusMessage, type IEvmChain, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, INCLUSION_TIMEOUT_MS, type IPharosConfig, type IPolkadotHubConfig, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, type IndexerQueryClient, InsufficientOrderbookLiquidityError, IntentGateway, ABI$1 as IntentGatewayABI, type IntentGatewayContext, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, type IntentQuoteLeg, IntentsCoprocessor, IsmpClient, type IsmpRequest, MAX_DECLARED_ENTRIES, MOCK_ADDRESS, ORDERBOOK_DECIMALS, ORDERBOOK_QUERIES, ORDERBOOK_URLS, ORDER_V2_PARAM_TYPE, type Order, type OrderFeesQuote, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, type OrderbookBook, type OrderbookLevelQuote, type OrderbookQuoteFill, OrderbookQuoteNotConvergedError, type OrderbookRate, OrderbookRequestError, type OrderbookRoute, type OrderbookRouteKind, type OrderbookRouteLiquidity, type OrderbookSide, type OrderbookSwapQuote, type OrderbookTopOfBook, PACKED_USEROP_TYPEHASH, PERMIT2_SPONSORSHIP_BYTES, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, type PessimisticQuoteIntentResult, type PhantomBidDeclaration, type PhantomBidPaymasterAndData, type PhantomBidSponsorship, PharosChain, type PharosChainParams, PolkadotHubChain, type PolkadotHubChainParams, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, type QueryBuyAndSellRatesParams, type QuoteIntentParams, type QuoteIntentResult, type QuoteNativeResult, type QuoteResult, type QuoteUniswapParams, type QuoteUniswapResult, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, type RateFillPreview, type RequestBody, type RequestCommitment, RequestKind, type RequestResponse, RequestStatus, type RequestStatusKey, type RequestStatusWithMetadata, type ResponseCommitmentWithValues, type ResumeIntentOrderOptions, type RetryConfig, type RpcBidInfo, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, SUPPORTED_INTENTS_VERSION, type SelectBidResult, type SelectOptions, type SigningAccount, type StateMachineHeight, type StateMachineId, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, type StorageFacade, type SubmitBidOptions, SubstrateChain, Swap, TESTNET_CHAINS, type TeleportParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, TokenGateway, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenPrice, type TokenPricesResponse, type Transaction, TronChain, type TronChainParams, USE_ETHERSCAN_CHAINS, type UniswapProtocol, type UniswapQuote, type UniswapQuoteToken, type UniswapTradeType, UnsupportedLiquidityAssetError, UnsupportedLiquidityChainError, WrappedHyperFungibleTokenABI, type XcmGatewayParams, __test, adjustDecimals, assertGatewayRelease, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodeFillOrder, decodePhantomBidDeclaration, decodePhantomBidPaymasterAndData, decodeUserOpScale, deriveHttpUrl, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeFillOrder, encodeISMPMessage, encodePhantomBidDeclaration, encodePhantomBidPaymasterAndData, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getContractCallInputs, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, isCanonicalEvmToken, maxBigInt, normalizeAddressForEvmBytes32, normalizeAddressForStateMachine, normalizeEvmAddress, normalizeEvmChainId, normalizeStateMachineId, orderCommitment, orderbookUrlFor, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, polkadotHubMainnet, poolSlug, postRequestCommitment, previewRateFill, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, readLegEscrow, readLegPartialFill, requestCommitmentKey, responseCommitmentKey, retryPromise, sortPoolSymbols, supportsRateFills, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };