@hyperbridge/sdk 2.8.2 → 2.8.4

package/dist/node/{intents-helpers-D_km9I2f.d.ts → intents-helpers-CkPAsLHB.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 } from 'viem';
+import { PublicClient, TransactionReceipt, Hex, Log, ContractFunctionArgs, Chain as Chain$1 } from 'viem';
 import { Chain } from 'viem/chains';
 import { ApiPromise } from '@polkadot/api';
 import { KeyringPair } from '@polkadot/keyring/types';
@@ -886,7 +886,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;
@@ -1015,7 +1017,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 = "";
@@ -1056,6 +1058,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;
@@ -1372,6 +1380,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.
@@ -1403,8 +1430,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
@@ -1432,6 +1492,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.
@@ -1458,11 +1520,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).
@@ -1471,22 +1566,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
@@ -1500,8 +1635,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;
     /**
@@ -1542,6 +1682,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).
@@ -1589,7 +1763,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
@@ -1602,9 +1782,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;
 }
 
 /**
@@ -2473,6 +2665,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
@@ -2766,25 +2969,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;
@@ -3230,6 +3459,16 @@ type ERC7821Call = {
     data: `0x${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;
+
 declare function encodeERC7821ExecuteBatch(calls: ERC7821Call[]): HexString$1;
 declare function decodeERC7821ExecuteBatch(callData: HexString$1): ERC7821Call[] | null;
 
@@ -4649,16 +4888,38 @@ declare const FILL_ORDER_ABI: readonly [{
     readonly name: "WrongChain";
     readonly inputs: readonly [];
 }];
+/** 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;
 /** ERC-4626 vaults per chain, keyed by chain id then lowercase underlying token address. */
 type YieldVaultMap = Record<string, Record<string, string[]>>;
@@ -4695,6 +4956,15 @@ interface LpBalance {
     /** State machine id of the chain the balance was measured on (e.g. EVM-8453). */
     chain: string;
     tokenAddress: HexString;
+    /**
+     * Wallet ERC-20, redeemable ERC-4626 vault shares, and the withdrawable amount held in the
+     * solver's declared Uniswap V4 positions — the same total the leg weights are built from, so a
+     * provider's reported inventory and the depth attributed to it cannot disagree.
+     *
+     * The V4 share is only ever included on the chain whose bid declared the positions: a bid is
+     * per chain, so no other chain's sweep can know about them. Consumers must therefore treat the
+     * larger of two readings for the same (chain, token, block) as the complete one.
+     */
     balance: bigint;
 }
 /** One verified solver behind a leg's quote, holding inventory to deliver it. */
@@ -4771,7 +5041,14 @@ type RecoverBidSigner = (userOp: PackedUserOperation, entryPoint: HexString, cha
  * indexer injects an ethers equivalent (see the note at the top of this file).
  */
 declare const recoverBidSignerViem: RecoverBidSigner;
+/** Promise-caching delegation reader produced by {@link memoizedDelegationCheck}. */
+type DelegationReader = (evmRpcUrl: string, account: string, solverAccount: string) => Promise<boolean>;
 declare function fetchBidsForOrder(nodeUrl: string, commitment: string): Promise<RpcBidInfo[]>;
+/** PositionManager + StateView addresses for a chain's Uniswap V4 deployment. */
+interface UniswapV4Contracts {
+    positionManager: string;
+    stateView: string;
+}
 /** Promise-caching balance reader produced by [`memoizedSolverBalance`]. */
 type SolverBalanceReader = (evmRpcUrl: string, chain: string, token: string, solver: string) => Promise<bigint>;
 declare function memoizedSolverBalance(yieldVaults: YieldVaultMap): SolverBalanceReader;
@@ -4791,8 +5068,15 @@ declare function memoizedSolverBalance(yieldVaults: YieldVaultMap): SolverBalanc
  * `extractFill` decodes a bid's ERC-7821 calldata into the fill's order/output and `recoverSigner`
  * recovers its solver signature; both default to the viem implementations, but the indexer injects
  * VM2-safe variants (viem's keccak throws in the SubQuery sandbox).
+ *
+ * The whole run is retried up to {@link AGGREGATION_ATTEMPTS} times on any error, because every
+ * error that escapes the per-bid handling means some input could not be read, and a snapshot
+ * computed from a partial bid set is worse than none: it publishes a confident price and zeroes
+ * depth that exists. Throws if every attempt fails, leaving the window unsnapshotted — consumers
+ * see the previous rate with a stale lastUpdatedBlock, which is a state they can already detect.
  */
-declare function aggregatePhantomBids(params: {
+declare function aggregatePhantomBids(params: Parameters<typeof runAggregation>[0]): Promise<PhantomAggregation | null>;
+declare function runAggregation(params: {
     nodeUrl: string;
     /** RPC URL per supported EVM chain (stateMachineId -> url); must include the destination chain. */
     evmRpcUrls: Record<string, string>;
@@ -4812,8 +5096,16 @@ declare function aggregatePhantomBids(params: {
      * same `yieldVaults` passed here — the memo bakes in the vault map its balances include.
      */
     getBalance?: SolverBalanceReader;
+    /**
+     * Uniswap V4 deployment per chain. Supply it to let bids that declare positions have those
+     * positions counted; without it a declaration is simply ignored, and the weight stays the
+     * plain balance as before.
+     */
+    uniswapV4?: Record<string, UniswapV4Contracts>;
+    /** keccak256 over hex; defaults to viem's, which the VM2 sandbox must replace. */
+    keccak?: (hex: HexString) => HexString;
     logger?: AggregationLogger;
-}): Promise<PhantomAggregation | null>;
+}, isDelegated: DelegationReader): Promise<PhantomAggregation | null>;
 
 declare const ABI: readonly [{
     readonly type: "constructor";
@@ -7626,4 +7918,4 @@ declare const _default: {
     }];
 };
 
-export { type BidStorageEntry as $, type AssetTeleported as A, type Bid as B, ChainConfigService as C, type EstimateFillOrderParams as D, type EstimateGasCallData as E, type FillerBid as F, type GetRequestWithStatus as G, type HexString$1 as H, type IChain as I, type FillOrderEstimate as J, type OrderFeesQuote as K, type ERC7821Call as L, type OrderWithStatus as M, OrderStatus as N, type Order as O, type PostRequestWithStatus as P, type TokenGatewayAssetTeleportedWithStatus as Q, type RetryConfig as R, type StateMachineIdParams as S, type Transaction as T, TeleportStatus as U, type DecodedOrderPlacedLog as V, type DecodedPostRequestEvent as W, type DecodedPostResponseEvent as X, type AllStatusKey as Y, type AssetTeleportedResponse as Z, type AvailableLiquidityByChain as _, type IEvmConfig as a, type TokenPrice as a$, type BidSubmissionResult as a0, type BlockMetadata as a1, type BytesLikeHex as a2, type CancelOptions as a3, type ChainConfig as a4, type ChainConfigData as a5, Chains as a6, type ConfiguredAssetSymbol as a7, type Deployment as a8, type DispatchGet as a9, IntentOrderStatus as aA, type IntentOrderStatusKey as aB, type IsmpRequest as aC, type OrderResponse as aD, type OrderStatusMetadata as aE, type PaymentInfo as aF, type PhantomOrderEvent as aG, type PhantomOrderLeg as aH, type PhantomOrderPriceSnapshot as aI, type PhantomOrderPriceSnapshotsResponse as aJ, type PollPhantomOrdersOptions as aK, type PostRequestStatus as aL, type RequestBody as aM, type RequestCommitment as aN, RequestKind as aO, type RequestResponse as aP, RequestStatus as aQ, type RequestStatusKey as aR, type SelectOptions as aS, type SigningAccount as aT, type StateMachineId as aU, type StateMachineResponse as aV, type StorageFacade as aW, TimeoutStatus as aX, type TimeoutStatusKey as aY, type TokenGatewayAssetTeleportedResponse as aZ, type TokenInfo as a_, type DispatchInfo as aa, type DispatchPost as ab, type Erc4626VaultConfigData as ac, type ExecuteIntentOrderOptions as ad, type ExecutionResult as ae, type FillOptions as af, type FillerConfig as ag, type GetRequestResponse as ah, type GetResponseByRequestIdResponse as ai, type GetResponseStorageValues as aj, type HostParams as ak, HyperClientStatus as al, type IBatchConsensusAndGetResponseMessage as am, type IBatchConsensusAndPostRequestMessage as an, type IConfig as ao, type IConsensusMessage as ap, type IGetRequestMessage as aq, type IGetResponse as ar, type IGetResponseMessage as as, type IHyperbridgeConfig as at, type IPostResponse as au, type IRequestMessage as av, type ISubstrateConfig as aw, type ITimeoutPostRequestMessage as ax, ABI as ay, type IntentGatewayParams as az, type IMessage as b, type TokenPricesResponse as b0, type UniswapV4PoolConfigData as b1, chainConfigs as b2, convertCodecToIGetRequest as b3, convertCodecToIProof as b4, convertIGetRequestToCodec as b5, convertIProofToCodec as b6, convertStateIdToStateMachineId as b7, convertStateMachineEnumToString as b8, convertStateMachineIdToEnum as b9, type LpBalance as bA, type OrderCommitmentFn as bB, type PhantomAggregation as bC, type PhantomLegAggregation as bD, type PhantomLegBidder as bE, type RecoverBidSigner as bF, type RpcBidInfo as bG, type SolverBalanceReader as bH, type YieldVaultMap as bI, aggregatePhantomBids as bJ, extractFillData as bK, fetchBidsForOrder as bL, memoizedSolverBalance as bM, orderCommitmentFromDecoded as bN, recoverBidSignerViem as bO, setAggregationFetch as bP, splitBidSignature as bQ, weightedMedian as bR, zipFillLegs as bS, decodeAcceptedSourceChains as ba, decodeERC7821ExecuteBatch as bb, decodeUserOpScale as bc, encodeAcceptedSourceChains as bd, encodeERC7821ExecuteBatch as be, encodeISMPMessage as bf, encodeUserOpScale as bg, getChainId as bh, getConfigByStateMachineId as bi, getViemChain as bj, hyperbridgeAddress as bk, pharosAtlantic as bl, pharosMainnet as bm, polkadotAssetHubPaseo as bn, polkadotHubMainnet as bo, tronChainIds as bp, tronNile as bq, type AggregationLogger as br, type BidNonceKeyFn as bs, type BidSignature as bt, ENTRY_POINT_V08_ADDRESS as bu, FILL_ORDER_ABI as bv, type FetchLike as bw, type FillData as bx, type HexString as by, _default as bz, type StateMachineHeight as c, type IIsmpMessage as d, type IPostRequest as e, type IGetRequest as f, type IPolkadotHubConfig as g, type IPharosConfig as h, type StateMachineUpdate as i, type ResponseCommitmentWithValues as j, type RequestStatusWithMetadata as k, type PostRequestTimeoutStatus as l, SubstrateChain as m, type ClientConfig as n, type IndexerQueryClient as o, type IProof as p, type IEvmChain as q, IntentsCoprocessor as r, type AvailableLiquiditySnapshot as s, type IntentOrderStatusUpdate as t, type SelectBidResult as u, type ResumeIntentOrderOptions as v, type CancelOrderOptions as w, type CancelQuote as x, type SubmitBidOptions as y, type PackedUserOperation as z };
+export { type AssetTeleportedResponse as $, type AssetTeleported as A, type BuyAndSellRates as B, ChainConfigService as C, type Bid as D, type EstimateGasCallData as E, type FillerBid as F, type GetRequestWithStatus as G, type HexString$1 as H, type IChain as I, type EstimateFillOrderParams as J, type FillOrderEstimate as K, type OrderFeesQuote as L, type ERC7821Call as M, type OrderWithStatus as N, type Order as O, type PostRequestWithStatus as P, type QueryBuyAndSellRatesParams as Q, type RetryConfig as R, type StateMachineIdParams as S, type Transaction as T, OrderStatus as U, type TokenGatewayAssetTeleportedWithStatus as V, TeleportStatus as W, type DecodedOrderPlacedLog as X, type DecodedPostRequestEvent as Y, type DecodedPostResponseEvent as Z, type AllStatusKey as _, type IEvmConfig as a, type SigningAccount as a$, type BidStorageEntry as a0, type BidSubmissionResult as a1, type BlockMetadata as a2, type BytesLikeHex as a3, type CancelOptions as a4, type ChainConfig as a5, type ChainConfigData as a6, Chains as a7, type ConfiguredAssetSymbol as a8, type ConfiguredAssetSymbolInput as a9, type ITimeoutPostRequestMessage as aA, ABI as aB, type IntentGatewayParams as aC, IntentOrderStatus as aD, type IntentOrderStatusKey as aE, type IsmpRequest as aF, type LiquiditySlice as aG, type OrderResponse as aH, type OrderStatusMetadata as aI, type PaymentInfo as aJ, type PhantomBid as aK, type PhantomBidBatchResult as aL, type PhantomBidDeclaration as aM, type PhantomBidOutcome as aN, type PhantomOrderEvent as aO, type PhantomOrderLeg as aP, type PhantomOrderPriceSnapshot as aQ, type PhantomOrderPriceSnapshotsResponse as aR, type PollPhantomOrdersOptions as aS, type PostRequestStatus as aT, type RequestBody as aU, type RequestCommitment as aV, RequestKind as aW, type RequestResponse as aX, RequestStatus as aY, type RequestStatusKey as aZ, type SelectOptions as a_, type Deployment as aa, type DispatchGet as ab, type DispatchInfo as ac, type DispatchPost as ad, type Erc4626VaultConfigData as ae, type ExecuteIntentOrderOptions as af, type ExecutionResult as ag, type FillOptions as ah, type FillerConfig as ai, type GetRequestResponse as aj, type GetResponseByRequestIdResponse as ak, type GetResponseStorageValues as al, type HostParams as am, HyperClientStatus as an, type IBatchConsensusAndGetResponseMessage as ao, type IBatchConsensusAndPostRequestMessage as ap, type IConfig as aq, type IConsensusMessage as ar, type IGetRequestMessage as as, type IGetResponse as at, type IGetResponseMessage as au, type IHyperbridgeConfig as av, INCLUSION_TIMEOUT_MS as aw, type IPostResponse as ax, type IRequestMessage as ay, type ISubstrateConfig as az, type IMessage as b, recoverBidSignerViem as b$, type StateMachineId as b0, type StateMachineResponse as b1, type StorageFacade as b2, TimeoutStatus as b3, type TimeoutStatusKey as b4, type TokenGatewayAssetTeleportedResponse as b5, type TokenInfo as b6, type TokenPrice as b7, type TokenPricesResponse as b8, type UniswapV4PoolConfigData as b9, poolSlug as bA, sortPoolSymbols as bB, tronChainIds as bC, tronNile as bD, type AggregationLogger as bE, type BidNonceKeyFn as bF, type BidSignature as bG, ENTRY_POINT_V08_ADDRESS as bH, FILL_ORDER_ABI as bI, type FetchLike as bJ, type FillData as bK, type HexString as bL, _default as bM, type LpBalance as bN, type OrderCommitmentFn as bO, type PhantomAggregation as bP, type PhantomLegAggregation as bQ, type PhantomLegBidder as bR, type RecoverBidSigner as bS, type RpcBidInfo as bT, type SolverBalanceReader as bU, type YieldVaultMap as bV, aggregatePhantomBids as bW, extractFillData as bX, fetchBidsForOrder as bY, memoizedSolverBalance as bZ, orderCommitmentFromDecoded as b_, chainConfigs as ba, convertCodecToIGetRequest as bb, convertCodecToIProof as bc, convertIGetRequestToCodec as bd, convertIProofToCodec as be, convertStateIdToStateMachineId as bf, convertStateMachineEnumToString as bg, convertStateMachineIdToEnum as bh, decodeAcceptedSourceChains as bi, decodeERC7821ExecuteBatch as bj, decodePhantomBidDeclaration as bk, decodeUserOpScale as bl, deriveHttpUrl as bm, encodeAcceptedSourceChains as bn, encodeERC7821ExecuteBatch as bo, encodeISMPMessage as bp, encodePhantomBidDeclaration as bq, encodeUserOpScale as br, getChainId as bs, getConfigByStateMachineId as bt, getViemChain as bu, hyperbridgeAddress as bv, pharosAtlantic as bw, pharosMainnet as bx, polkadotAssetHubPaseo as by, polkadotHubMainnet as bz, type StateMachineHeight as c, setAggregationFetch as c0, splitBidSignature as c1, weightedMedian as c2, zipFillLegs as c3, type IIsmpMessage as d, type IPostRequest as e, type IGetRequest as f, type IPolkadotHubConfig as g, type IPharosConfig as h, type StateMachineUpdate as i, type ResponseCommitmentWithValues as j, type RequestStatusWithMetadata as k, type PostRequestTimeoutStatus as l, SubstrateChain as m, type ClientConfig as n, type IndexerQueryClient as o, type IProof as p, type IEvmChain as q, IntentsCoprocessor as r, type AvailableLiquidity as s, type IntentOrderStatusUpdate as t, type SelectBidResult as u, type ResumeIntentOrderOptions as v, type CancelOrderOptions as w, type CancelQuote as x, type SubmitBidOptions as y, type PackedUserOperation as z };