@hyperbridge/sdk 2.8.2 → 2.8.4

package/dist/browser/index.d.ts

@@ -2,7 +2,7 @@ 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, Address } from 'viem';
+import { PublicClient, TransactionReceipt, Hex, Log, ContractFunctionArgs, Chain as Chain$1, Address } from 'viem';
 import { Chain } from 'viem/chains';
 import { ApiPromise } from '@polkadot/api';
 import { KeyringPair } from '@polkadot/keyring/types';
@@ -891,7 +891,9 @@ declare const tronNile: {
     verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
 };
 declare const tronChainIds: Set<number>;
-type ConfiguredAssetSymbol = "WETH" | "DAI" | "USDC" | "USDT" | "cNGN" | "EXT";
+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;
@@ -1020,7 +1022,7 @@ interface ChainConfigData {
     layerZeroEid?: number;
 }
 declare const chainConfigs: Record<number, ChainConfigData>;
-declare const getConfigByStateMachineId: (id: Chains) => ChainConfigData | undefined;
+declare const getConfigByStateMachineId: (id: string) => ChainConfigData | undefined;
 declare const getChainId: (stateMachineId: string) => number | undefined;
 declare const getViemChain: (chainId: number) => Chain | undefined;
 declare const hyperbridgeAddress = "";
@@ -1061,6 +1063,12 @@ declare class ChainConfigService {
      * it, so a new asset is added once in `chain.ts` and nowhere else.
      */
     getAssetBySymbol(chain: string, symbol: string): HexString$1 | undefined;
+    /** Resolves a configured token symbol case-insensitively on a specific chain. */
+    getAssetMetadataBySymbol(chain: string, symbol: string): {
+        symbol: ConfiguredAssetSymbol;
+        address: HexString$1;
+        decimals?: number;
+    } | undefined;
     getCNgnDecimals(chain: string): number | undefined;
     getExtAsset(chain: string): HexString$1 | undefined;
     getExtDecimals(chain: string): number | undefined;
@@ -1917,6 +1925,25 @@ declare function convertCodecToIProof(codec: {
 }): IProof;
 declare function encodeISMPMessage(message: IIsmpMessage): Uint8Array;
 
+/**
+ * How long a submitted extrinsic has to reach a block before the attempt is treated as stalled.
+ *
+ * Sized against the bid window, not against how long inclusion can conceivably take: a bid is worth
+ * nothing once its window closes, so an extrinsic still sitting in the pool after a few blocks is
+ * better replaced by a higher-tipped copy than waited on.
+ */
+declare const INCLUSION_TIMEOUT_MS = 20000;
+/**
+ * Maps a websocket endpoint onto the HTTP endpoint of the same node — substrate serves both on the
+ * same host and port, so the scheme is the only difference. Throws for anything that is not a
+ * `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.
+ */
+declare function deriveHttpUrl(wsUrl: string): string;
 /**
  * Encodes a PackedUserOperation using SCALE codec for submission to Hyperbridge.
  * This is the recommended way to encode UserOps for the intents coprocessor.
@@ -1948,8 +1975,41 @@ interface PhantomOrderEvent {
      */
     legs: PhantomOrderLeg[];
 }
+/** 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 6s, roughly one block. */
+    /** 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
@@ -1977,6 +2037,8 @@ declare class IntentsCoprocessor {
     private ownsConnection;
     /** Cached result of whether the node exposes intents_* RPC methods */
     private hasIntentsRpc;
+    /** The HTTP-backed api, connected on first use. Cleared after a failed attempt so it retries. */
+    private httpApi;
     private submissionQueue;
     /**
      * Creates and connects an IntentsCoprocessor to a Hyperbridge node.
@@ -2003,11 +2065,44 @@ declare class IntentsCoprocessor {
      */
     static fromApi(api: ApiPromise, substratePrivateKey?: string): IntentsCoprocessor;
     private constructor();
+    /**
+     * The API every RPC query runs on: HTTP, connected to the same node as the websocket. Exposed so
+     * callers query through this connection rather than opening one of their own.
+     *
+     * The split is by what each transport is for. Queries are one-shot request/response, which HTTP
+     * serves without holding any state that can silently rot between calls. The websocket earns its
+     * keep only where subscriptions do — watching a submitted extrinsic to inclusion.
+     */
+    queryApi(): Promise<ApiPromise>;
+    /**
+     * The websocket API, exposed so callers share this one connection instead of opening a second
+     * socket to the same node. Only needed for subscriptions; use {@link queryApi} to read.
+     */
+    get apiConnection(): ApiPromise;
     /**
      * Disconnects the underlying API connection if this instance owns it.
-     * Only disconnects if created via `connect()`, not when using shared connections.
+     * Only disconnects the websocket if created via `connect()`, not when using shared connections.
+     * The HTTP api is always created here, so it is always ours to close.
      */
     disconnect(): Promise<void>;
+    /**
+     * The HTTP api for this node, connected on first use. Every coprocessor has one — the endpoint
+     * is derived from the websocket's own endpoint, so there is nothing to configure and nothing to
+     * be absent.
+     *
+     * 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.
+     */
+    private http;
+    /**
+     * The endpoint the websocket provider is connected to. Read from the provider rather than
+     * remembered from a constructor argument, so it is the one endpoint in use no matter which
+     * factory built this instance.
+     */
+    private wsEndpoint;
     /**
      * Creates a Substrate keypair from the configured private key.
      * Supports hex seed (with or without 0x), mnemonic phrases, and URI derivation paths (//Alice).
@@ -2016,22 +2111,62 @@ declare class IntentsCoprocessor {
     /**
      * Signs and sends an extrinsic. Submissions are serialised through {@link submissionQueue} so
      * concurrent calls never collide on the substrate account nonce — each extrinsic reaches a block
-     * (or is confirmed still pooled and returned as `pending`) before the next is signed; auto-nonce
-     * via `system.accountNextIndex` counts pooled extrinsics, so a pending one is never re-used.
+     * (or is confirmed still pooled and returned as `pending`) before the next is signed. The
+     * auto-nonce is the account's on-chain nonce, so a still-pooled extrinsic does not advance it: a
+     * submission signed behind a pending one bounces off it (1013/1014) and is reported as pending
+     * too, rather than landing as a second copy.
+     *
+     * The extrinsic is built rather than passed in because the api it is built on decides where it
+     * is signed and sent: a websocket that is down when the queue reaches this submission diverts it
+     * to {@link sendViaHttp}, which needs the call bound to the HTTP api instead.
      */
     private signAndSendExtrinsic;
+    /**
+     * Last-resort submission for when the websocket is down at signing time. A bid is only worth
+     * anything inside its window, so waiting for a reconnect usually means not bidding at all.
+     *
+     * HTTP has no subscriptions, so this is `author_submitExtrinsic`: the node accepts the extrinsic
+     * into its pool and returns its hash, and nothing further is observable from here. That is
+     * exactly the `pending` contract — in flight, outcome unknown, do not re-sign — so the result
+     * says so rather than claiming a success it cannot see.
+     *
+     * Only reached when the socket was already down before signing. A submission that got as far as
+     * the pool over the websocket is never retried here: that is the duplicate-nonce race the
+     * `pending` result exists to prevent.
+     */
+    private sendViaHttp;
     /**
      * Signs and sends an extrinsic, handling status updates and errors.
      * Implements retry logic with progressive tip increases for stuck transactions.
      *
-     * A retry only happens when the previous attempt verifiably went nowhere. Once an attempt's
-     * extrinsic is known to be pooled (`pending`), re-signing the same call would race our own
-     * submission: the copy either bounces off the pool (1014, same nonce below the replacement
-     * priority bump) or — if the original lands first, freeing the nonce — executes as a duplicate
-     * and fails on-chain (e.g. `BidNotFound` for a retraction). Neither can succeed, so the pending
-     * result is returned for the caller to confirm later.
+     * 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.
+     *
+     * 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
+     * pool evicts a pooled extrinsic in favour of a higher-priority one at the same (account, nonce),
+     * so exactly one of the two can ever execute. This matters for a bid, which is worth nothing once
+     * its window closes — waiting out a stalled extrinsic usually means not bidding at all.
+     *
+     * Re-signing without pinning the nonce is what must never happen here. The auto-nonce is read
+     * from on-chain state, so it is only the stalled extrinsic's nonce for as long as that extrinsic
+     * stays out of a block — and a stall is precisely the case where it may land at any moment. Once
+     * it does, an unpinned retry takes the *next* nonce and both execute: a duplicate `placeBid` that
+     * fails on-chain, and a second `retractBid` that pulls the bid just placed. When the signed nonce
+     * cannot be read, the stalled result is returned rather than guessed at.
+     *
+     * A rejection that bounced off a copy already pooled (1013/1014) is likewise left alone: that
+     * copy is in flight and its outcome is unknown here, so the `pending` result goes back to the
+     * caller to confirm later.
      */
     private sendExtrinsicWithRetries;
+    /**
+     * The nonce an extrinsic was signed with, or undefined if it carries no readable one — which is
+     * the case before it has ever been signed, and for a stub api in tests.
+     */
+    private signedNonce;
     /**
      * Classifies a submission rejection. Codes 1013 ("already imported") and 1014 ("priority is
      * too low") both mean a copy of this account+nonce is already in the pool — almost always our
@@ -2045,8 +2180,13 @@ declare class IntentsCoprocessor {
      *
      * A timeout is only a failure when the extrinsic never made it into the transaction pool.
      * Once a pool-entry status (Future/Ready/Broadcast/Retracted) has been seen, the extrinsic is
-     * in flight and may well execute after the watch is abandoned — the result is then `pending`,
-     * telling the caller to confirm the outcome later instead of re-signing the same call.
+     * in flight and may well execute after the watch is abandoned — the result is then `pending`
+     * and `stalled`, telling the caller to replace it under the same nonce or confirm it later,
+     * never to re-sign the same call under a fresh one.
+     *
+     * `nonce` pins the submission to a specific account nonce, which is what makes a retry a pool
+     * replacement rather than a second extrinsic queued behind the first. Left undefined on the
+     * first attempt, where the api's auto-nonce is correct.
      */
     private sendWithTimeout;
     /**
@@ -2087,6 +2227,40 @@ declare class IntentsCoprocessor {
      * @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;
+    /** Renders a DispatchError as `pallet::Error`, falling back to its raw form. */
+    private describeDispatchError;
     /**
      * Fetches all bid storage entries for a given order commitment.
      * Returns the on-chain data only (filler addresses and deposits).
@@ -2134,7 +2308,13 @@ declare class IntentsCoprocessor {
      */
     getPhantomOrdersInBlock(blockNumber: number): Promise<PhantomOrderEvent[]>;
     /**
-     * Polls for newly registered phantom orders, invoking the callback once per order.
+     * 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
@@ -2147,9 +2327,21 @@ declare class IntentsCoprocessor {
      * 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.
+     *
      * Returns a function that stops polling.
      */
-    pollPhantomOrders(callback: (event: PhantomOrderEvent) => void, options?: PollPhantomOrdersOptions): () => void;
+    pollPhantomOrders(callback: (events: PhantomOrderEvent[]) => void, options?: PollPhantomOrdersOptions): () => void;
+    /**
+     * 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;
 }
 
 /**
@@ -3231,6 +3423,17 @@ interface FillerConfig {
      * chains"; an empty array declares that no source chain is accepted.
      */
     acceptedSourceChains?: string[];
+    /**
+     * 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
@@ -3524,25 +3727,51 @@ interface PhantomOrderPriceSnapshotsResponse {
         }>;
     };
 }
+/** One independently reported slice of indexed liquidity. */
+interface LiquiditySlice {
+    totalLiquidity: string;
+    providerCount: number;
+}
 /**
- * Total solver liquidity measured at one immutable Phantom price snapshot.
+ * Indexed destination capacity and its source-routing slices.
  *
- * Liquidity amounts are decimal strings formatted with the configured decimals
- * for their respective `tokenAddress` and chain.
+ * 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 AvailableLiquiditySnapshot {
-    totalLiquidity: string;
-    providerCount: number;
+interface AvailableLiquidity {
+    sourceChain: Chains;
+    destinationChain: Chains;
     tokenAddress: HexString$1;
-    snapshotTime: Date;
-    liquidityByChain: AvailableLiquidityByChain[];
+    updatedAt: Date;
+    destination: LiquiditySlice;
+    unrestricted: LiquiditySlice;
+    explicitRoute: (LiquiditySlice & {
+        updatedAt: Date;
+    }) | null;
 }
-/** Liquidity for one chain/token balance group in an availability snapshot. */
-interface AvailableLiquidityByChain {
-    chain: string;
-    tokenAddress: HexString$1;
-    totalLiquidity: string;
-    providerCount: number;
+/**
+ * Chain-specific buy and sell rates expressed as quote-token units per one
+ * base token. The quote token is the less valuable currency when the indexed
+ * 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. */
+interface QueryBuyAndSellRatesParams {
+    tokenInSymbol: ConfiguredAssetSymbolInput;
+    tokenOutSymbol: ConfiguredAssetSymbolInput;
+    sourceChainId: Chain$1["id"];
+    destinationChainId: Chain$1["id"];
 }
 interface TokenPrice {
     symbol: string;
@@ -5066,8 +5295,6 @@ declare class IntentGateway {
     private readonly gasEstimator;
     /** Quote strategies for pricing orders before placement, keyed by strategy name. */
     private readonly quoteStrategies;
-    /** Resolves order tokens to canonical Phantom snapshot market pairs. */
-    private readonly phantomSnapshotPairResolver;
     /**
      * Private constructor — use {@link IntentGateway.create} instead.
      *
@@ -5123,17 +5350,22 @@ declare class IntentGateway {
      */
     quoteIntent(params: QuoteIntentParams): Promise<QuoteIntentResult>;
     /**
-     * Returns the output-token liquidity measured in the latest directional
-     * Phantom snapshot for this gateway's source and destination.
+     * Returns indexed destination liquidity and its source-routing slices.
      *
-     * Pair resolution uses the same canonical Base market as {@link quoteIntent}.
-     * The snapshot itself determines the output token and chain to aggregate. The
-     * amount is in the token's smallest unit and reflects the indexer's
-     * `snapshotTime`; it is not a live reservation or fill guarantee.
+     * 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.
      *
      * Requires a prior call to {@link withQueryClient}.
      */
-    queryAvailableLiquidity(params: Pick<QuoteIntentParams, "tokenIn" | "tokenOut">): Promise<AvailableLiquiditySnapshot | undefined>;
+    queryAvailableLiquidity(params: Pick<QuoteIntentParams, "tokenIn" | "tokenOut">): Promise<AvailableLiquidity | undefined>;
+    /**
+     * Returns chain-specific buy and sell rates in less-valued quote-token units
+     * without requiring token addresses. Symbols are matched case-insensitively;
+     * chain IDs are numeric IDs for chains configured in the SDK.
+     */
+    queryBuyAndSellRates(params: QueryBuyAndSellRatesParams): Promise<BuyAndSellRates | undefined>;
     /**
      * Bidirectional async generator that orchestrates the full order lifecycle:
      * placement, fee estimation, bid collection, and execution.
@@ -5477,6 +5709,26 @@ 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.
+ *
+ * Plain code-unit comparison, never locale-sensitive collation — the result is
+ * a persisted primary key and must sort identically everywhere.
+ */
+declare function sortPoolSymbols<Symbol extends string>(symbolA: Symbol, symbolB: Symbol): [Symbol, Symbol];
+/** Canonical indexer pool ID for a pair of canonical token symbols. */
+declare function poolSlug(symbolA: string, symbolB: string): string;
+
 /**
  * Checks the on-chain fill and refund status of IntentGatewayV2 orders.
  *
@@ -5662,6 +5914,12 @@ declare class CryptoUtils {
      * signing infrastructure (hardware wallets, MPC/TEE policy engines) instead
      * of an opaque 32-byte digest.
      *
+     * The payload must be a standard self-describing `eth_signTypedData_v4`
+     * payload — `EIP712Domain` listed in `types`, `chainId` as a JSON number —
+     * because some signing backends (e.g. MPC Vault) hash it server-side from
+     * the JSON rather than locally via viem. viem ignores both details when
+     * hashing, so the digest is unchanged for local signers.
+     *
      * @param userOp - The packed UserOperation to sign (signature field ignored).
      * @param entryPoint - Address of the EntryPoint v0.8 contract.
      * @param chainId - Chain ID of the network on which the operation will execute.
@@ -5675,10 +5933,44 @@ declare class CryptoUtils {
             verifyingContract: `0x${string}`;
         };
         types: {
-            PackedUserOperation: {
-                name: string;
-                type: string;
-            }[];
+            readonly EIP712Domain: readonly [{
+                readonly name: "name";
+                readonly type: "string";
+            }, {
+                readonly name: "version";
+                readonly type: "string";
+            }, {
+                readonly name: "chainId";
+                readonly type: "uint256";
+            }, {
+                readonly name: "verifyingContract";
+                readonly type: "address";
+            }];
+            readonly PackedUserOperation: readonly [{
+                readonly name: "sender";
+                readonly type: "address";
+            }, {
+                readonly name: "nonce";
+                readonly type: "uint256";
+            }, {
+                readonly name: "initCode";
+                readonly type: "bytes";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+            }, {
+                readonly name: "accountGasLimits";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "preVerificationGas";
+                readonly type: "uint256";
+            }, {
+                readonly name: "gasFees";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "paymasterAndData";
+                readonly type: "bytes";
+            }];
         };
         primaryType: "PackedUserOperation";
         message: {
@@ -5803,16 +6095,38 @@ declare class CryptoUtils {
 }
 
 type HexString = `0x${string}`;
+/** What a phantom bid's paymasterAndData declares about the solver behind it. */
+interface PhantomBidDeclaration {
+    /**
+     * Source chains the solver accepts payment from. Null when the bid carries no parseable
+     * declaration (the legacy default: the solver has not restricted its sources); an empty array
+     * is an explicit accepts-nothing. Callers must preserve that distinction.
+     */
+    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.
+     */
+    uniswapV4Positions: bigint[];
+}
 /**
- * Encodes the accepted source chains (state machine ids, e.g. "EVM-8453") into the
- * paymasterAndData declaration blob.
+ * Encodes a phantom bid's declaration into the paymasterAndData blob. Emits the v1 layout when no
+ * positions are declared, so a solver that only names source chains produces exactly the bytes it
+ * produced before positions existed.
  */
-declare function encodeAcceptedSourceChains(chains: string[]): HexString;
+declare function encodePhantomBidDeclaration(declaration: {
+    acceptedSourceChains?: string[];
+    uniswapV4Positions?: bigint[];
+}): HexString;
 /**
- * Decodes a phantom bid's paymasterAndData into its declared source chains. Returns null for an
- * absent, unversioned or malformed blob — the legacy default — and an empty array only for an
- * explicit zero-entry declaration. Callers must preserve that distinction.
+ * Decodes a phantom bid's paymasterAndData. Understands both layout versions, so bids placed
+ * before positions existed keep decoding unchanged. Anything absent, unversioned or malformed
+ * yields a null `acceptedSources` with no positions — never a partial read.
  */
+declare function decodePhantomBidDeclaration(paymasterAndData: string | undefined | null): PhantomBidDeclaration;
+/** Back-compat wrapper: the source-chain half of {@link encodePhantomBidDeclaration}. */
+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;
 
 declare const ABI$1: readonly [{
@@ -10698,4 +11012,4 @@ declare function teleport(teleport_param: {
     extrinsics?: Array<SubmittableExtrinsic<"promise", ISubmittableResult>>;
 }): Promise<ReadableStream<HyperbridgeTxEvents>>;
 
-export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type AvailableLiquidityByChain, type AvailableLiquiditySnapshot, type Bid, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BridgeParams, type BridgeStep, type BundlerGasEstimate, BundlerMethod, type BytesLikeHex, type CancelEvent, type CancelOptions, type CancelOrderOptions, type CancelQuote, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, type ConfiguredAssetSymbol, 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, 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, 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, type IPharosConfig, type IPolkadotHubConfig, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, type IndexerQueryClient, IntentGateway, ABI$1 as IntentGatewayABI, type IntentGatewayContext, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, type IntentQuoteStrategy, type IntentQuoteTradeType, IntentsCoprocessor, InvalidPhantomSnapshotError, IsmpClient, type IsmpRequest, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, type Order, type OrderFeesQuote, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, type PhantomOrderEvent, type PhantomOrderLeg, type PhantomOrderPriceSnapshot, type PhantomOrderPriceSnapshotsResponse, type PhantomSnapshotIntentQuoteMetadata, type PhantomSnapshotQuoteIntentResult, PhantomSnapshotUnavailableError, PharosChain, type PharosChainParams, PolkadotHubChain, type PolkadotHubChainParams, type PollPhantomOrdersOptions, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, 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, USE_ETHERSCAN_CHAINS, type UniswapProtocol, type UniswapQuote, type UniswapQuoteToken, type UniswapTradeType, type UniswapV4IntentQuoteMetadata, type UniswapV4IntentQuoteOptions, type UniswapV4PoolConfigData, type UniswapV4PoolKey, type UniswapV4QuoteIntentResult, UnsupportedIntentQuotePairError, UnsupportedIntentQuoteStrategyError, WrappedHyperFungibleTokenABI, type XcmGatewayParams, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodeUserOpScale, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getContractCallInputs, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, normalizeAddressForEvmBytes32, normalizeAddressForStateMachine, normalizeEvmAddress, normalizeEvmChainId, normalizeStateMachineId, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, polkadotHubMainnet, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, requestCommitmentKey, responseCommitmentKey, retryPromise, 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, 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, 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, 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, IntentGateway, ABI$1 as IntentGatewayABI, type IntentGatewayContext, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, type IntentQuoteStrategy, type IntentQuoteTradeType, IntentsCoprocessor, InvalidLiquidityIndexerResponseError, InvalidPhantomSnapshotError, IsmpClient, type IsmpRequest, type LiquiditySlice, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, type Order, type OrderFeesQuote, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, type PhantomBid, type PhantomBidBatchResult, type PhantomBidDeclaration, type PhantomBidOutcome, type PhantomOrderEvent, type PhantomOrderLeg, type PhantomOrderPriceSnapshot, type PhantomOrderPriceSnapshotsResponse, type PhantomSnapshotIntentQuoteMetadata, type PhantomSnapshotQuoteIntentResult, PhantomSnapshotUnavailableError, 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, 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, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodePhantomBidDeclaration, decodeUserOpScale, deriveHttpUrl, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeISMPMessage, encodePhantomBidDeclaration, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getContractCallInputs, 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, requestCommitmentKey, responseCommitmentKey, retryPromise, sortPoolSymbols, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };