@hyperbridge/sdk 2.8.8 → 2.8.10

package/dist/browser/index.d.ts

@@ -6,6 +6,7 @@ import { PublicClient, TransactionReceipt, Hex, Log, ContractFunctionArgs, Chain
 import { Chain } from 'viem/chains';
 import { ApiPromise } from '@polkadot/api';
 import { KeyringPair } from '@polkadot/keyring/types';
+import { RuntimeVersion } from '@polkadot/types/interfaces';
 import * as unstorage from 'unstorage';
 import { SignerOptions, SubmittableExtrinsic } from '@polkadot/api/types';
 import { ISubmittableResult } from '@polkadot/types/types';
@@ -1975,6 +1976,20 @@ interface PhantomOrderEvent {
      */
     legs: PhantomOrderLeg[];
 }
+/** The pallet's phantom order timings, as the chain currently has them. */
+interface PhantomTimings {
+    /**
+     * Blocks after registration during which the pallet accepts a bid: the `PhantomBidWindow`
+     * storage value, or the `PhantomOrderBidWindowBlocks` runtime constant when that value is zero,
+     * which is the same fallback the pallet's own `phantom_bid_window()` applies.
+     */
+    bidWindowBlocks: number;
+    /**
+     * Blocks between generations (`PhantomOrderInterval`). Zero is meaningful rather than unset —
+     * the pallet generates once and never regenerates — so there is no constant to fall back to.
+     */
+    intervalBlocks: number;
+}
 /** One phantom bid to place, and the bid it replaces on the same chain. */
 interface PhantomBid {
     /** The phantom order commitment being bid on. */
@@ -2013,17 +2028,22 @@ interface PollPhantomOrdersOptions {
     intervalMs?: number;
     /**
      * Most blocks scanned in a single poll, so a long outage catches up over several ticks instead of
-     * one unbounded scan. Defaults to 500.
+     * one burst. Defaults to 10 — several times the rate the chain produces blocks, so recovery is
+     * still quick, but small enough to bound both the work one `state_queryStorage` call asks of the
+     * node and the requests the per-block fallback queues ahead of a bid submission.
      */
     maxBlocksPerPoll?: number;
-    /**
-     * How many blocks before the current head to start from on the first poll. Defaults to 0 (start
-     * at the head). Set this to the runtime's bid window to have a restarting process pick up orders
-     * whose window is still open.
-     */
-    lookbackBlocks?: number;
     /** Notified when a poll fails; polling continues regardless. */
     onError?: (err: unknown) => void;
+    /**
+     * Notified when the cursor was forced forward past a backlog too old to bid on, with the range
+     * that was never scanned. Nothing else reports it, and skipping blocks is worth a line in the log.
+     */
+    onSkip?: (skipped: {
+        from: number;
+        to: number;
+        head: number;
+    }) => void;
 }
 /**
  * Service for interacting with Hyperbridge's pallet-intents coprocessor.
@@ -2037,8 +2057,14 @@ declare class IntentsCoprocessor {
     private ownsConnection;
     /** Cached result of whether the node exposes intents_* RPC methods */
     private hasIntentsRpc;
+    /** The pallet's phantom timings, read once. Cleared on failure so the read retries. */
+    private phantomTimingsRead;
     /** The HTTP-backed api, connected on first use. Cleared after a failed attempt so it retries. */
     private httpApi;
+    /** Last runtime version read from the node, for {@link confirmedRuntimeVersion} to compare against. */
+    private lastRuntimeVersion;
+    /** Set once the node refuses `state_queryStorage`, so the poll stops asking for it. */
+    private rangeQueryUnavailable;
     private submissionQueue;
     /**
      * Creates and connects an IntentsCoprocessor to a Hyperbridge node.
@@ -2305,8 +2331,58 @@ declare class IntentsCoprocessor {
     fetchPhantomOrder(commitment: HexString$1): Promise<Order | null>;
     /**
      * Reads the PhantomOrderRegistered events emitted in a single block.
+     *
+     * Costs two RPCs per block when `knownVersion` is supplied and four without it, which is why the
+     * poll goes to the trouble of establishing one. `api.at(hash)` has to work out which metadata to
+     * decode the block against, and with nothing to go on it fetches the header and then the runtime
+     * version at its parent — every block, forever. Its cheaper paths are a registry already pinned
+     * to this exact hash (only ever the previous block's) or one matching a version the caller
+     * names, so naming the version is the only way out. See `getBlockRegistry` in
+     * `@polkadot/api/base/Init`; the `getUpgradeVersion` shortcut that would otherwise skip the
+     * lookup only covers chains hardcoded in `@polkadot/types-known`, which Hyperbridge is not.
+     *
+     * @param knownVersion - the runtime version this block is known to run, if the caller has
+     *   established one. Passing a version the block does not actually run decodes it against the
+     *   wrong metadata, so this is for callers that have checked, not a place to pass a guess.
+     */
+    getPhantomOrdersInBlock(blockNumber: number, knownVersion?: RuntimeVersion): Promise<PhantomOrderEvent[]>;
+    /**
+     * The same read, for a caller that already holds the block's hash.
+     *
+     * Split out so the poll can fetch a whole range's hashes in one concurrent wave — which the
+     * provider coalesces into a single batched request — and then read each block's events knowing
+     * its hash. `chain_getBlockHash` is the half of the pair that parallelises safely: it takes no
+     * historic block hash, so it never triggers polkadot-js's per-hash registry resolution, and
+     * concurrent calls cannot race each other's registry state.
      */
-    getPhantomOrdersInBlock(blockNumber: number): Promise<PhantomOrderEvent[]>;
+    getPhantomOrdersAtHash(blockHash: HexString$1, knownVersion?: RuntimeVersion): Promise<PhantomOrderEvent[]>;
+    /**
+     * Every block's phantom orders across a whole range, in one `state_queryStorage` call.
+     *
+     * This is the cheap path: the request cost of a scan stops depending on how many blocks it
+     * covers. The events key is the only key queried, and both bounds are block hashes the caller
+     * already holds.
+     *
+     * Two properties of the RPC shape the result.
+     *
+     * It returns *diffs*: `query_storage_unfiltered` in `sc-rpc` pushes a change set for a block only
+     * when the value differs from the previous block in the range (`has_changed`, and the set is
+     * dropped when empty), so a block whose events encode byte-for-byte identically to its
+     * predecessor's is simply absent. That happens on a quiet chain, where consecutive blocks carry
+     * nothing but the timestamp inherent's `ExtrinsicSuccess`. It is safe here because an absent
+     * block provably carries no phantom orders: a `PhantomOrderRegistered` commitment is derived from
+     * the block number (`phantom_order_commitment`), so a block that registered orders can never
+     * encode identically to any other block. Absent therefore means "same as the previous block",
+     * and the previous block having orders would contradict that.
+     *
+     * And it is gated by `--rpc-methods` (`check_if_safe` in `sc-rpc`), which answers a denied call
+     * with `Method not found`. The node this reads from must already run unsafe RPC to serve
+     * `offchain_localStorageGet` for the orders themselves, so this is normally available; the poll
+     * falls back to reading block by block when it is not.
+     *
+     * @returns one entry per block the node reported a change for, in ascending block order.
+     */
+    getPhantomOrdersInRange(fromBlockHash: HexString$1, toBlockHash: HexString$1): Promise<PhantomOrderEvent[][]>;
     /**
      * Polls for newly registered phantom orders, invoking the callback once per block that carries
      * any, with all of that block's orders.
@@ -2333,9 +2409,87 @@ declare class IntentsCoprocessor {
      * socket that looks alive while delivering nothing. It also means a websocket outage does not
      * pause phantom bidding at all — the two transports fail independently.
      *
+     * What the cadence does *not* describe is the request rate, which is what rate limiters police.
+     * A tick costs four requests whatever the range covers — the head, the runtime version, the two
+     * bounding block hashes as one batched request, and one `state_queryStorage` for every block's
+     * events — and they go out back-to-back, so an interval well under any per-second limit could
+     * still arrive as a burst over it. Three things keep that in bounds: the provider coalesces
+     * concurrent calls into one request and paces requests through the endpoint's token bucket (see
+     * `http`), and `maxBlocksPerPoll` bounds the range. A 429 that gets through anyway backs the
+     * poll off for a doubling number of ticks, so a limiter that is already shedding load is not
+     * handed the next window's budget in rejections too.
+     *
+     * Where the node will not serve `state_queryStorage` the poll reads block by block instead, at
+     * three requests plus one per block; see {@link scanRangeAtOnce}.
+     *
      * Returns a function that stops polling.
      */
     pollPhantomOrders(callback: (events: PhantomOrderEvent[]) => void, options?: PollPhantomOrdersOptions): () => void;
+    /**
+     * The Hyperbridge head, over HTTP like every other read here.
+     *
+     * Exposed for callers that have to know how old something is: a phantom order carries the block
+     * it was registered at, and only against the head does that become "still biddable" or "long
+     * expired".
+     */
+    latestBlockNumber(): Promise<number>;
+    /**
+     * The pallet's phantom timings, read from chain state.
+     *
+     * Both are governance-settable and neither is derivable: on Nexus today the window is 15 while
+     * the runtime constant behind it is 25, so anything hard-coded is wrong in one direction or the
+     * other — too tight and live orders are dropped, too loose and bids are sent into a closed
+     * window for the pallet to reject.
+     *
+     * Read once per instance and cached, because a governance change to either is rare and a read
+     * per poll tick would be a request per tick forever. The cost is that a change is picked up on
+     * the next restart rather than immediately. A failed read is not cached, so it retries.
+     */
+    phantomTimings(): Promise<PhantomTimings>;
+    private readPhantomTimings;
+    /**
+     * A whole range of blocks in one `state_queryStorage` call, or `null` when that is not available
+     * and the caller should read block by block.
+     *
+     * Two conditions have to hold, and both are about decoding rather than the range itself.
+     *
+     * The version must be confirmed for this tick — an upgrade inside the range means blocks decode
+     * against different metadata, and one call cannot do that.
+     *
+     * And that confirmed version must still be the one the api's own registry was built for.
+     * `state_queryStorage` declares no historic block hash, so rpc-core skips its registry swap and
+     * decodes the reply against the default registry — fixed at connect, with no
+     * `subscribeRuntimeVersion` on an HTTP api to refresh it. After an upgrade the two diverge, and
+     * the per-block path takes over for good: `api.at(hash, version)` resolves, and builds, the right
+     * registry. That costs a restart to get the cheap path back, which is the correct direction to
+     * fail in.
+     */
+    private scanRangeAtOnce;
+    /**
+     * The runtime version this tick's blocks may be decoded against, or `undefined` when that cannot
+     * be established and each block must resolve its own.
+     *
+     * Naming a version to `api.at` is what removes two of the four RPCs a block scan costs, and it
+     * is only sound while the version is actually the block's. Getting that wrong is not a loud
+     * failure: events decoded against the wrong metadata come back as a shape the scan does not
+     * recognise, so the block reads as carrying no phantom orders and the cursor advances past it —
+     * exactly the silent miss the block cursor exists to rule out.
+     *
+     * So the version is read fresh each tick and only used when it matches the previous reading.
+     * `specVersion` only ever increases, and this read happens *after* the head read, so two equal
+     * readings mean no upgrade landed anywhere in between — and therefore none in the range about to
+     * be scanned. A reading that differs means an upgrade landed inside the range: that tick falls
+     * back to per-block resolution, which is exact, and the version is used from the next tick on
+     * once it has been seen twice.
+     *
+     * The gap this leaves is a backlog reaching back past an upgrade, whose oldest blocks predate
+     * even the previous reading. Recovering from an outage that long means those bid windows closed
+     * many upgrades ago, so nothing is lost that was still winnable.
+     *
+     * A version that cannot be read at all yields `undefined` rather than an error: the scan is
+     * about to make the same request against the same endpoint and is the better place to report it.
+     */
+    private confirmedRuntimeVersion;
     /**
      * The poll cadence for the runtime this instance is connected to: Gargantua polls every block,
      * everything else every 15s. Falls back to the slower cadence if the runtime cannot be read,
@@ -3846,6 +4000,18 @@ interface CancelOrderOptions {
 interface FillOptions {
     relayerFee: bigint;
     nativeDispatchFee: bigint;
+    /**
+     * Last block number at which this fill may execute. `0n` means no bound.
+     *
+     * A solver bidding through the coprocessor signs this calldata and then has no further
+     * say in when it is used: the order's `deadline` is placer-chosen with no ceiling, and
+     * retracting the bid on Hyperbridge does not reach the destination chain. Without a bound
+     * the placer can sit on a signed bid and execute it once the price has moved their way.
+     *
+     * In blocks, matching `order.deadline`, so both read against the same clock. Dropped when
+     * encoding against a gateway whose implementation predates the field.
+     */
+    validUntil: bigint;
     outputs: TokenInfo[];
 }
 interface PackedUserOperation {
@@ -3944,8 +4110,9 @@ interface OrderFeesQuote {
     /**
      * The amount to set as `Order.fees`, denominated in the source-chain fee
      * token. Same-chain fills carry a 2x margin over the estimated fill gas without
-     * a gas-price bump. Cross-chain gas is priced with 10% SDK-only headroom before
-     * adding the settlement relayer fee and a further 5% buffer over the whole sum.
+     * a gas-price bump. Cross-chain orders originating on Ethereum mainnet use 50%
+     * SDK-only gas-price headroom; other source chains use 10%. The settlement
+     * relayer fee is then added with a further 5% buffer over the whole sum.
      */
     fees: bigint;
     /**
@@ -5404,8 +5571,9 @@ declare class IntentGateway {
      * **Yield/receive protocol:**
      * 1. If `order.fees` is unset or zero, prices the fee on an internal copy
      *    via {@link quoteOrderFees}: same-chain fees are twice the fill-gas
-     *    estimate without a gas-price bump; cross-chain gas is priced 10% above
-     *    the live price before attaching (fill gas + the settlement relayer fee)
+     *    estimate without a gas-price bump; cross-chain order fees originating on
+     *    Ethereum price gas 50% above the live price, while other source chains use
+     *    10%, before attaching (fill gas + the settlement relayer fee)
      *    with a further 5% buffer over the whole sum — strictly above the solver's
      *    unpadded requirement. Direct solver estimates remain unbumped. The wei
      *    cost used for the `value` field receives a 2% buffer.
@@ -5641,7 +5809,8 @@ declare class IntentGateway {
      * transaction (check the native balance).
      *
      * @param order - The order to quote. `order.fees` is ignored and not mutated.
-     * Gas prices used to derive cross-chain `fees` receive 10% SDK-only headroom.
+     * Gas prices used to derive cross-chain `fees` receive 50% SDK-only headroom
+     * when the source chain is Ethereum mainnet and 10% for other source chains.
      * Same-chain quotes and direct calls to {@link estimateFillOrder}, including
      * Simplex solver estimates, remain unbumped.
      *
@@ -6125,6 +6294,210 @@ declare class CryptoUtils {
     decodeERC7821Execute(callData: HexString$1): ERC7821Call[] | null;
 }
 
+/**
+ * `FillOptions` gained a `validUntil` field. Adding a field to a struct changes the
+ * enclosing function's selector, so `fillOrder` has two incompatible shapes in the wild:
+ *
+ *   v1  fillOrder(Order, (uint256 relayerFee, uint256 nativeDispatchFee, TokenInfo[] outputs))
+ *   v2  fillOrder(Order, (uint256 relayerFee, uint256 nativeDispatchFee, uint256 validUntil, TokenInfo[] outputs))
+ *
+ * The selectors differ (`0x5cfb1ea5` vs `0xa5470064`), so a v2 payload sent to a v1
+ * deployment finds no matching function and reverts rather than mis-decoding — which is the
+ * safe failure, but it does mean callers have to know which shape a gateway speaks.
+ */
+type FillOptionsVersion = 1 | 2;
+/**
+ * The v1 `fillOrder`, kept only so we can still talk to deployments that predate `validUntil`.
+ *
+ * Exported because consumers that cannot use {@link decodeFillOrder} still have to accept both
+ * shapes. The indexer decodes bid calldata with ethers rather than viem (viem's byte handling
+ * throws inside SubQuery's VM2 sandbox), so it rebuilds this decode itself and needs the same
+ * definition rather than a second copy that can drift out of step with this one.
+ */
+declare const FILL_ORDER_V1_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "fillOrder";
+    readonly stateMutability: "payable";
+    readonly outputs: readonly [];
+    readonly inputs: readonly [{
+        readonly name: "order";
+        readonly type: "tuple";
+        readonly internalType: "struct Order";
+        readonly components: readonly [{
+            readonly name: "user";
+            readonly type: "bytes32";
+            readonly internalType: "bytes32";
+        }, {
+            readonly name: "source";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "destination";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "fees";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "session";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "predispatch";
+            readonly type: "tuple";
+            readonly internalType: "struct DispatchInfo";
+            readonly components: readonly [{
+                readonly name: "assets";
+                readonly type: "tuple[]";
+                readonly internalType: "struct TokenInfo[]";
+                readonly components: readonly [{
+                    readonly name: "token";
+                    readonly type: "bytes32";
+                    readonly internalType: "bytes32";
+                }, {
+                    readonly name: "amount";
+                    readonly type: "uint256";
+                    readonly internalType: "uint256";
+                }];
+            }, {
+                readonly name: "call";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }, {
+            readonly name: "inputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct TokenInfo[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "bytes32";
+                readonly internalType: "bytes32";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "output";
+            readonly type: "tuple";
+            readonly internalType: "struct PaymentInfo";
+            readonly components: readonly [{
+                readonly name: "beneficiary";
+                readonly type: "bytes32";
+                readonly internalType: "bytes32";
+            }, {
+                readonly name: "assets";
+                readonly type: "tuple[]";
+                readonly internalType: "struct TokenInfo[]";
+                readonly components: readonly [{
+                    readonly name: "token";
+                    readonly type: "bytes32";
+                    readonly internalType: "bytes32";
+                }, {
+                    readonly name: "amount";
+                    readonly type: "uint256";
+                    readonly internalType: "uint256";
+                }];
+            }, {
+                readonly name: "call";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }];
+    }, {
+        readonly name: "options";
+        readonly type: "tuple";
+        readonly internalType: "struct FillOptions";
+        readonly components: readonly [{
+            readonly name: "relayerFee";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "nativeDispatchFee";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "outputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct TokenInfo[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "bytes32";
+                readonly internalType: "bytes32";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }];
+    }];
+}];
+/**
+ * IntentGateway implementations deployed before `FillOptions.validUntil` existed.
+ *
+ * The list is of *legacy* implementations rather than current ones, so the default is v2 and
+ * nothing has to be added here when a new implementation ships — only when an old one is
+ * discovered. Once every deployment is upgraded this set is vestigial and still correct.
+ *
+ * The alternative, listing known-good implementations, would be the version constant this
+ * replaced wearing a different hat: a value someone must remember to update on every upgrade,
+ * where forgetting breaks every fill on the chain.
+ */
+declare const LEGACY_FILL_OPTIONS_IMPLEMENTATIONS: Set<string>;
+/**
+ * Chains whose IntentGateway has not been redeployed with `FillOptions.validUntil` yet.
+ *
+ * A blunter instrument than {@link LEGACY_FILL_OPTIONS_IMPLEMENTATIONS} and used for the same
+ * reason: those chains run a pre-`validUntil` implementation whose address is not tracked here,
+ * so the address check would wrongly read them as current and every fill would revert on a
+ * selector that does not exist.
+ *
+ * Delete a chain from this set when its gateway is redeployed. Once the set is empty the
+ * implementation-address check covers everything on its own.
+ */
+declare const CHAINS_WITHOUT_VALID_UNTIL: Set<number>;
+/** Test seam: drop memoised detection results. */
+declare function resetFillOptionsVersionCache(): void;
+/**
+ * Works out which `FillOptions` shape a gateway accepts from the implementation it delegates to.
+ *
+ * EIP-1967 standardises three slots, all holding addresses — there is no version field to read,
+ * and the contract deliberately does not carry one either: a hand-maintained version constant is
+ * a second source of truth that has to be bumped on the right upgrade. The implementation address
+ * is the value the proxy already updates, so it is what identifies the deployed code.
+ */
+declare function getFillOptionsVersion(client: PublicClient, gateway: HexString$1): Promise<FillOptionsVersion>;
+/**
+ * ABI-encodes a `fillOrder` call in the shape the target gateway understands.
+ *
+ * On a v1 gateway `validUntil` is dropped — there is nowhere to put it and no check on the
+ * other side. That is a real loss of protection, so callers that rely on the bound should
+ * surface it rather than assume it took effect.
+ */
+declare function encodeFillOrder(order: Order, options: FillOptions, version: FillOptionsVersion): HexString$1;
+/**
+ * Decodes a `fillOrder` call of either shape.
+ *
+ * v2 is tried first and v1 is the fallback; the selectors differ, so there is no shape a
+ * decode could silently get wrong. `validUntil` reads as `0n` for a v1 payload, which is the
+ * same value that means "no bound" in v2 — accurate, since a v1 fill genuinely has none.
+ *
+ * @returns The decoded order and options, or `null` if the calldata is not a `fillOrder`.
+ */
+declare function decodeFillOrder(data: HexString$1): {
+    order: Order;
+    options: FillOptions;
+} | null;
+
 type HexString = `0x${string}`;
 /** What a phantom bid's paymasterAndData declares about the solver behind it. */
 interface PhantomBidDeclaration {
@@ -6164,13 +6537,24 @@ declare function decodeAcceptedSourceChains(paymasterAndData: string | undefined
  *
  * A bid that declares V4 positions is quoting off those pools, and a pool price is what a trade
  * gets BEFORE the pool takes its fee — so the amount such a bid names is more than the solver
- * would actually be left holding once the swap that sources it clears. 30bps is the fee tier the
- * pools these positions sit in charge, so netting it out here is what makes a pool-priced quote
- * comparable to a wallet-funded one, whose inventory has already paid its cost of goods.
+ * would actually be left holding once the swap that sources it clears. Netting that cost out here
+ * is what makes a pool-priced quote comparable to a wallet-funded one, whose inventory has already
+ * paid its cost of goods.
  */
-declare const UNISWAP_QUOTE_HAIRCUT_BPS = 30n;
+declare const UNISWAP_QUOTE_HAIRCUT_BPS = 10n;
+/**
+ * Haircut applied to every phantom quote that is NOT priced off a Uniswap V4 pool, in basis points.
+ *
+ * A wallet-funded quote is still the best case the solver sees at bid time; the published rate is
+ * what the protocol tells takers they can trade against, so it is shaded by this margin rather
+ * than being the most optimistic number any bidder named. Pool-priced quotes pay
+ * {@link UNISWAP_QUOTE_HAIRCUT_BPS} instead of this — not on top of it.
+ */
+declare const PHANTOM_QUOTE_HAIRCUT_BPS = 5n;
 /** Applies {@link UNISWAP_QUOTE_HAIRCUT_BPS} to a quoted output amount, rounding down. */
 declare function applyUniswapQuoteHaircut(amount: bigint): bigint;
+/** Applies {@link PHANTOM_QUOTE_HAIRCUT_BPS} to a quoted output amount, rounding down. */
+declare function applyPhantomQuoteHaircut(amount: bigint): bigint;
 
 declare const ABI$1: readonly [{
     readonly type: "constructor";
@@ -6561,6 +6945,10 @@ declare const ABI$1: readonly [{
             readonly name: "nativeDispatchFee";
             readonly type: "uint256";
             readonly internalType: "uint256";
+        }, {
+            readonly name: "validUntil";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
         }, {
             readonly name: "outputs";
             readonly type: "tuple[]";
@@ -11055,4 +11443,4 @@ declare function teleport(teleport_param: {
     extrinsics?: Array<SubmittableExtrinsic<"promise", ISubmittableResult>>;
 }): Promise<ReadableStream<HyperbridgeTxEvents>>;
 
-export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type AvailableLiquidity, type Bid, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BridgeParams, type BridgeStep, type BundlerGasEstimate, BundlerMethod, type BuyAndSellRates, type BytesLikeHex, 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 IndexedRateIntentQuoteMetadata, type IndexedRateQuoteIntentResult, type IndexedRateSide, IndexedRateUnavailableError, type IndexerQueryClient, IntentGateway, ABI$1 as IntentGatewayABI, type IntentGatewayContext, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, type IntentQuoteStrategy, type IntentQuoteTradeType, IntentsCoprocessor, InvalidIndexedRateError, InvalidLiquidityIndexerResponseError, InvalidPhantomSnapshotError, IsmpClient, type IsmpRequest, 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, UNISWAP_QUOTE_HAIRCUT_BPS, USE_ETHERSCAN_CHAINS, type UniswapProtocol, type UniswapQuote, type UniswapQuoteToken, type UniswapTradeType, type UniswapV4IntentQuoteMetadata, type UniswapV4IntentQuoteOptions, type UniswapV4PoolConfigData, type UniswapV4PoolKey, type UniswapV4QuoteIntentResult, UnsupportedIntentQuotePairError, UnsupportedIntentQuoteStrategyError, UnsupportedLiquidityAssetError, UnsupportedLiquidityChainError, WrappedHyperFungibleTokenABI, type XcmGatewayParams, __test, adjustDecimals, applyUniswapQuoteHaircut, 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 };
+export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type AvailableLiquidity, type Bid, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BridgeParams, type BridgeStep, type BundlerGasEstimate, BundlerMethod, type BuyAndSellRates, type BytesLikeHex, CHAINS_WITHOUT_VALID_UNTIL, type CancelEvent, type CancelOptions, type CancelOrderOptions, type CancelQuote, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, type ConfiguredAssetSymbol, type ConfiguredAssetSymbolInput, CryptoUtils, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type Deployment, type DispatchGet, type DispatchInfo, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, type Erc4626VaultConfigData, type EstimateFillOrderParams, type EstimateGasCallData, EvmChain, type EvmChainParams, ABI as EvmHostABI, EvmLanguage, type ExecuteIntentOrderOptions, type ExecutionResult, FILL_ORDER_V1_ABI, type FillOptions, type FillOptionsVersion, type FillOrderEstimate, type FillerBid, type FillerConfig, type GetRequestResponse, type GetRequestWithStatus, type GetResponseByRequestIdResponse, type GetResponseStorageValues, type HexString$1 as HexString, type HostParams, HyperClientStatus, HyperFungibleToken, HyperFungibleTokenABI, type HyperbridgeTxEvents, type IBatchConsensusAndGetResponseMessage, type IBatchConsensusAndPostRequestMessage, type IChain, type IConfig, type IConsensusMessage, type IEvmChain, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, INCLUSION_TIMEOUT_MS, type IPharosConfig, type IPolkadotHubConfig, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, type IndexedRateIntentQuoteMetadata, type IndexedRateQuoteIntentResult, type IndexedRateSide, IndexedRateUnavailableError, type IndexerQueryClient, IntentGateway, ABI$1 as IntentGatewayABI, type IntentGatewayContext, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, type IntentQuoteStrategy, type IntentQuoteTradeType, IntentsCoprocessor, InvalidIndexedRateError, InvalidLiquidityIndexerResponseError, InvalidPhantomSnapshotError, IsmpClient, type IsmpRequest, LEGACY_FILL_OPTIONS_IMPLEMENTATIONS, type LiquiditySlice, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, type Order, type OrderFeesQuote, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PHANTOM_QUOTE_HAIRCUT_BPS, 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, type PhantomTimings, PharosChain, type PharosChainParams, PolkadotHubChain, type PolkadotHubChainParams, type PollPhantomOrdersOptions, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, type QueryBuyAndSellRatesParams, type QuoteIntentParams, type QuoteIntentResult, type QuoteNativeResult, type QuoteResult, type QuoteUniswapParams, type QuoteUniswapResult, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, type RequestBody, type RequestCommitment, RequestKind, type RequestResponse, RequestStatus, type RequestStatusKey, type RequestStatusWithMetadata, type ResponseCommitmentWithValues, type ResumeIntentOrderOptions, type RetryConfig, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, type SelectBidResult, type SelectOptions, type SigningAccount, type StateMachineHeight, type StateMachineId, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, type StorageFacade, type SubmitBidOptions, SubstrateChain, Swap, TESTNET_CHAINS, type TeleportParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, TokenGateway, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenPrice, type TokenPricesResponse, type Transaction, TronChain, type TronChainParams, UNISWAP_QUOTE_HAIRCUT_BPS, USE_ETHERSCAN_CHAINS, type UniswapProtocol, type UniswapQuote, type UniswapQuoteToken, type UniswapTradeType, type UniswapV4IntentQuoteMetadata, type UniswapV4IntentQuoteOptions, type UniswapV4PoolConfigData, type UniswapV4PoolKey, type UniswapV4QuoteIntentResult, UnsupportedIntentQuotePairError, UnsupportedIntentQuoteStrategyError, UnsupportedLiquidityAssetError, UnsupportedLiquidityChainError, WrappedHyperFungibleTokenABI, type XcmGatewayParams, __test, adjustDecimals, applyPhantomQuoteHaircut, applyUniswapQuoteHaircut, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodeFillOrder, decodePhantomBidDeclaration, decodeUserOpScale, deriveHttpUrl, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeFillOrder, encodeISMPMessage, encodePhantomBidDeclaration, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getContractCallInputs, getFillOptionsVersion, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, normalizeAddressForEvmBytes32, normalizeAddressForStateMachine, normalizeEvmAddress, normalizeEvmChainId, normalizeStateMachineId, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, polkadotHubMainnet, poolSlug, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, requestCommitmentKey, resetFillOptionsVersionCache, responseCommitmentKey, retryPromise, sortPoolSymbols, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };