@hyperbridge/sdk 2.8.0 → 2.8.3

package/dist/node/{intents-helpers-gyGREuyu.d.ts → intents-helpers-CxCDx-hH.d.ts}

@@ -924,6 +924,11 @@ interface ChainConfigData {
         USDT: number;
         cNGN?: number;
         EXT?: number;
+        ZARP?: number;
+        EURC?: number;
+        XSGD?: number;
+        TRYB?: number;
+        USDR?: number;
     };
     tokenStorageSlots?: {
         USDT?: {
@@ -942,6 +947,30 @@ interface ChainConfigData {
             balanceSlot: number;
             allowanceSlot: number;
         };
+        cNGN?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        ZARP?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        EURC?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        XSGD?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        TRYB?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        USDR?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
     };
     addresses: {
         IntentGateway?: `0x${string}`;
@@ -1343,6 +1372,17 @@ declare function convertCodecToIProof(codec: {
 }): IProof;
 declare function encodeISMPMessage(message: IIsmpMessage): Uint8Array;
 
+/**
+ * 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.
@@ -1374,8 +1414,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
@@ -1403,6 +1476,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.
@@ -1429,11 +1504,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).
@@ -1442,16 +1550,55 @@ 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
-     * before the next is signed.
+     * (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.
+     *
+     * 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.
      */
     private sendExtrinsicWithRetries;
     /**
-     * Sends an extrinsic with a timeout
+     * 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
+     * own earlier attempt whose watch handle didn't confirm cleanly. That extrinsic is in flight;
+     * resubmitting can only bounce again or land a duplicate, so these are surfaced as `pending`
+     * rather than failure.
+     */
+    private classifySubmissionError;
+    /**
+     * Sends an extrinsic with a timeout.
+     *
+     * 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.
      */
     private sendWithTimeout;
     /**
@@ -1492,6 +1639,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).
@@ -1539,7 +1720,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
@@ -1552,9 +1739,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;
 }
 
 /**
@@ -2423,6 +2622,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
@@ -2948,6 +3158,15 @@ interface BidSubmissionResult {
      * Error message if submission failed
      */
     error?: string;
+    /**
+     * The extrinsic is (or may still be) in the transaction pool: it was accepted but its
+     * inclusion was not observed before the watch timed out, or a resubmission bounced off an
+     * earlier copy already pooled (RPC 1013/1014). Only meaningful when `success` is false —
+     * the operation is in flight, not failed, and must not be re-signed with the same nonce.
+     * Callers should confirm the outcome later (e.g. re-check on-chain state) instead of
+     * treating this as a terminal failure.
+     */
+    pending?: boolean;
 }
 /**
  * Represents a storage entry from pallet-intents Bids storage
@@ -4590,16 +4809,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[]>>;
@@ -4636,12 +4877,25 @@ 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. */
+/** One verified solver behind a leg's quote, holding inventory to deliver it. */
 interface PhantomLegBidder {
     solver: HexString;
-    /** The solver's output-token inventory on the destination chain — its weight in the median. */
+    /**
+     * The solver's output-token inventory on the destination chain — its weight in the median.
+     * Always greater than zero: a solver quoting a leg it holds none of is dropped, not recorded
+     * at zero, since it can deliver nothing at any price.
+     */
     weight: bigint;
     /**
      * Source chains the solver's signed paymasterAndData declaration accepts payment from. Null
@@ -4658,13 +4912,18 @@ interface PhantomLegAggregation {
     lowestPrice: bigint;
     highestPrice: bigint;
     medianPrice: bigint;
+    /** Backed quotes behind the price. Quotes from solvers holding no inventory are not counted. */
     bidCount: number;
-    /** The verified solvers quoting this leg; bidCount === bidders.length. */
+    /** The verified, inventory-backed solvers quoting this leg; bidCount === bidders.length. */
     bidders: PhantomLegBidder[];
 }
 /** The aggregated result for a single phantom order's bid window. */
 interface PhantomAggregation {
-    /** One entry per leg that at least one solver quoted; legs nobody quoted are absent. */
+    /**
+     * One entry per leg that at least one solver quoted AND at least one of those quotes is backed
+     * by output-token inventory on the destination chain. Legs nobody quoted are absent, and so are
+     * legs every bidder quoted on zero inventory — neither is a price anyone could trade against.
+     */
     legs: PhantomLegAggregation[];
     lpBalances: LpBalance[];
 }
@@ -4703,7 +4962,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;
@@ -4723,8 +4989,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>;
@@ -4744,8 +5017,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";
@@ -7558,4 +7839,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 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, TimeoutStatus 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 PhantomBid as aG, type PhantomBidBatchResult as aH, type PhantomBidDeclaration as aI, type PhantomBidOutcome as aJ, type PhantomOrderEvent as aK, type PhantomOrderLeg as aL, type PhantomOrderPriceSnapshot as aM, type PhantomOrderPriceSnapshotsResponse as aN, type PollPhantomOrdersOptions as aO, type PostRequestStatus as aP, type RequestBody as aQ, type RequestCommitment as aR, RequestKind as aS, type RequestResponse as aT, RequestStatus as aU, type RequestStatusKey as aV, type SelectOptions as aW, type SigningAccount as aX, type StateMachineId as aY, type StateMachineResponse as aZ, type StorageFacade 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 TimeoutStatusKey as b0, type TokenGatewayAssetTeleportedResponse as b1, type TokenInfo as b2, type TokenPrice as b3, type TokenPricesResponse as b4, type UniswapV4PoolConfigData as b5, chainConfigs as b6, convertCodecToIGetRequest as b7, convertCodecToIProof as b8, convertIGetRequestToCodec as b9, type BidSignature as bA, ENTRY_POINT_V08_ADDRESS as bB, FILL_ORDER_ABI as bC, type FetchLike as bD, type FillData as bE, type HexString as bF, _default as bG, type LpBalance as bH, type OrderCommitmentFn as bI, type PhantomAggregation as bJ, type PhantomLegAggregation as bK, type PhantomLegBidder as bL, type RecoverBidSigner as bM, type RpcBidInfo as bN, type SolverBalanceReader as bO, type YieldVaultMap as bP, aggregatePhantomBids as bQ, extractFillData as bR, fetchBidsForOrder as bS, memoizedSolverBalance as bT, orderCommitmentFromDecoded as bU, recoverBidSignerViem as bV, setAggregationFetch as bW, splitBidSignature as bX, weightedMedian as bY, zipFillLegs as bZ, convertIProofToCodec as ba, convertStateIdToStateMachineId as bb, convertStateMachineEnumToString as bc, convertStateMachineIdToEnum as bd, decodeAcceptedSourceChains as be, decodeERC7821ExecuteBatch as bf, decodePhantomBidDeclaration as bg, decodeUserOpScale as bh, deriveHttpUrl as bi, encodeAcceptedSourceChains as bj, encodeERC7821ExecuteBatch as bk, encodeISMPMessage as bl, encodePhantomBidDeclaration as bm, encodeUserOpScale as bn, getChainId as bo, getConfigByStateMachineId as bp, getViemChain as bq, hyperbridgeAddress as br, pharosAtlantic as bs, pharosMainnet as bt, polkadotAssetHubPaseo as bu, polkadotHubMainnet as bv, tronChainIds as bw, tronNile as bx, type AggregationLogger as by, type BidNonceKeyFn 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 };