@hyperbridge/sdk 2.8.2 → 2.8.3

package/dist/browser/index.d.ts

@@ -1917,6 +1917,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.
@@ -1948,8 +1959,41 @@ interface PhantomOrderEvent {
      */
     legs: PhantomOrderLeg[];
 }
+/** One phantom bid to place, and the bid it replaces on the same chain. */
+interface PhantomBid {
+    /** The phantom order commitment being bid on. */
+    commitment: HexString$1;
+    /** The SCALE-encoded PackedUserOperation backing the quote. */
+    userOp: HexString$1;
+    /**
+     * A live bid from a previous interval on the same chain, retracted alongside this one to
+     * reclaim its deposit. Best-effort: a retraction that fails never affects the bid.
+     */
+    retractCommitment?: HexString$1;
+}
+/** What became of one bid in a batch. */
+interface PhantomBidOutcome {
+    commitment: HexString$1;
+    success: boolean;
+    /** The dispatch error that rejected this bid, when it failed. */
+    error?: string;
+}
+interface PhantomBidBatchResult {
+    /** One entry per submitted bid, in the order they were given. */
+    bids: PhantomBidOutcome[];
+    /** The block and extrinsic the bids landed in. */
+    blockHash?: HexString$1;
+    extrinsicHash?: HexString$1;
+    /**
+     * The batch reached the pool but its inclusion was not observed, so no per-bid outcome is
+     * known. Same contract as {@link BidSubmissionResult.pending}: in flight, do not re-sign.
+     */
+    pending?: boolean;
+    /** Set when the batch never landed at all, or when its item events could not be attributed. */
+    error?: string;
+}
 interface PollPhantomOrdersOptions {
-    /** How often to check for a new head. Defaults to 6s, roughly one block. */
+    /** How often to check for a new head. Defaults to 15s, or 6s when the runtime is Gargantua. */
     intervalMs?: number;
     /**
      * Most blocks scanned in a single poll, so a long outage catches up over several ticks instead of
@@ -1977,6 +2021,8 @@ declare class IntentsCoprocessor {
     private ownsConnection;
     /** Cached result of whether the node exposes intents_* RPC methods */
     private hasIntentsRpc;
+    /** The HTTP-backed api, connected on first use. Cleared after a failed attempt so it retries. */
+    private httpApi;
     private submissionQueue;
     /**
      * Creates and connects an IntentsCoprocessor to a Hyperbridge node.
@@ -2003,11 +2049,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).
@@ -2018,8 +2097,26 @@ declare class IntentsCoprocessor {
      * 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.
+     *
+     * 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.
@@ -2087,6 +2184,40 @@ declare class IntentsCoprocessor {
      * @returns BidSubmissionResult with success status and block/extrinsic hash
      */
     submitBidWithRetraction(retractCommitment: HexString$1, bidCommitment: HexString$1, userOp: HexString$1): Promise<BidSubmissionResult>;
+    /**
+     * Places every phantom bid of one interval in a single extrinsic, retracting each chain's
+     * previous bid alongside it.
+     *
+     * The pallet registers one phantom order per configured chain in the same block, so this is the
+     * whole interval's set. Submitting them one at a time costs a block per chain: submissions are
+     * serialised on the account nonce and each waits for inclusion, so the last chain's bid is many
+     * blocks behind the first, against a bid window measured in tens of blocks. Batched, every bid
+     * lands in the same block.
+     *
+     * Uses `utility.force_batch`, not `utility.batch`. `batch` stops at the first failing call, so
+     * one rejected bid — a closed window, a duplicate, an insufficient deposit — would silently
+     * drop every bid after it. `force_batch` runs them all and reports each outcome. It needs no
+     * special origin: any signed account may call it, exactly like `batch`.
+     *
+     * @param bids - The bids to place; an empty list is a no-op
+     * @returns Per-bid outcomes, in the order given
+     */
+    submitPhantomBids(bids: PhantomBid[]): Promise<PhantomBidBatchResult>;
+    /**
+     * Reads one outcome per call out of a force_batch's events.
+     *
+     * `ItemFailed` carries no index — pallet-utility emits exactly one `ItemCompleted` or
+     * `ItemFailed` per call, in call order, so the k-th item event belongs to call k.
+     *
+     * A count that does not match the calls submitted means the events are not the ones assumed
+     * here, and every attribution after the discrepancy would be off by one. The bids are then
+     * reported as placed: a bid wrongly recorded as landed is retracted next interval and the
+     * retraction harmlessly fails with `BidNotFound`, whereas one wrongly recorded as failed is
+     * never retracted at all and leaves its deposit reserved.
+     */
+    private readForceBatchItems;
+    /** Renders a DispatchError as `pallet::Error`, falling back to its raw form. */
+    private describeDispatchError;
     /**
      * Fetches all bid storage entries for a given order commitment.
      * Returns the on-chain data only (filler addresses and deposits).
@@ -2134,7 +2265,13 @@ declare class IntentsCoprocessor {
      */
     getPhantomOrdersInBlock(blockNumber: number): Promise<PhantomOrderEvent[]>;
     /**
-     * Polls for newly registered phantom orders, invoking the callback once per order.
+     * Polls for newly registered phantom orders, invoking the callback once per block that carries
+     * any, with all of that block's orders.
+     *
+     * Per block rather than per order because that is how the pallet writes them: one order per
+     * configured chain, all registered in the same `on_initialize`. Delivering them together lets a
+     * caller bid on the whole interval in one extrinsic (see {@link submitPhantomBids}) instead of
+     * one per chain.
      *
      * Each tick reads the current head and scans every block between the last one processed and that
      * head, so the block cursor — not the connection — determines what has been seen. This replaced a
@@ -2147,9 +2284,21 @@ declare class IntentsCoprocessor {
      * cannot drop them, because the cursor only advances past a block whose events were actually
      * read. Recovery replays the backlog.
      *
+     * Every read here goes over HTTP, never the websocket. Polling is a sequence of independent
+     * one-shot requests with no state to lose between them, which is exactly what a stateless
+     * transport does well: a request either answers or fails loudly on this tick, instead of a
+     * socket that looks alive while delivering nothing. It also means a websocket outage does not
+     * pause phantom bidding at all — the two transports fail independently.
+     *
      * Returns a function that stops polling.
      */
-    pollPhantomOrders(callback: (event: PhantomOrderEvent) => void, options?: PollPhantomOrdersOptions): () => void;
+    pollPhantomOrders(callback: (events: PhantomOrderEvent[]) => void, options?: PollPhantomOrdersOptions): () => void;
+    /**
+     * The poll cadence for the runtime this instance is connected to: Gargantua polls every block,
+     * everything else every 15s. Falls back to the slower cadence if the runtime cannot be read,
+     * since an unreachable node is the poll's problem to report, not the cadence lookup's.
+     */
+    private phantomPollIntervalMs;
 }
 
 /**
@@ -3231,6 +3380,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
@@ -5662,6 +5822,12 @@ declare class CryptoUtils {
      * signing infrastructure (hardware wallets, MPC/TEE policy engines) instead
      * of an opaque 32-byte digest.
      *
+     * The payload must be a standard self-describing `eth_signTypedData_v4`
+     * payload — `EIP712Domain` listed in `types`, `chainId` as a JSON number —
+     * because some signing backends (e.g. MPC Vault) hash it server-side from
+     * the JSON rather than locally via viem. viem ignores both details when
+     * hashing, so the digest is unchanged for local signers.
+     *
      * @param userOp - The packed UserOperation to sign (signature field ignored).
      * @param entryPoint - Address of the EntryPoint v0.8 contract.
      * @param chainId - Chain ID of the network on which the operation will execute.
@@ -5675,10 +5841,44 @@ declare class CryptoUtils {
             verifyingContract: `0x${string}`;
         };
         types: {
-            PackedUserOperation: {
-                name: string;
-                type: string;
-            }[];
+            readonly EIP712Domain: readonly [{
+                readonly name: "name";
+                readonly type: "string";
+            }, {
+                readonly name: "version";
+                readonly type: "string";
+            }, {
+                readonly name: "chainId";
+                readonly type: "uint256";
+            }, {
+                readonly name: "verifyingContract";
+                readonly type: "address";
+            }];
+            readonly PackedUserOperation: readonly [{
+                readonly name: "sender";
+                readonly type: "address";
+            }, {
+                readonly name: "nonce";
+                readonly type: "uint256";
+            }, {
+                readonly name: "initCode";
+                readonly type: "bytes";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+            }, {
+                readonly name: "accountGasLimits";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "preVerificationGas";
+                readonly type: "uint256";
+            }, {
+                readonly name: "gasFees";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "paymasterAndData";
+                readonly type: "bytes";
+            }];
         };
         primaryType: "PackedUserOperation";
         message: {
@@ -5803,16 +6003,38 @@ declare class CryptoUtils {
 }
 
 type HexString = `0x${string}`;
+/** What a phantom bid's paymasterAndData declares about the solver behind it. */
+interface PhantomBidDeclaration {
+    /**
+     * Source chains the solver accepts payment from. Null when the bid carries no parseable
+     * declaration (the legacy default: the solver has not restricted its sources); an empty array
+     * is an explicit accepts-nothing. Callers must preserve that distinction.
+     */
+    acceptedSources: string[] | null;
+    /**
+     * Uniswap V4 position tokenIds the solver declares as backing this bid, on the order's own
+     * chain. Empty when none are declared — including for every v1 bid, which predates the field.
+     */
+    uniswapV4Positions: bigint[];
+}
 /**
- * Encodes the accepted source chains (state machine ids, e.g. "EVM-8453") into the
- * paymasterAndData declaration blob.
+ * Encodes a phantom bid's declaration into the paymasterAndData blob. Emits the v1 layout when no
+ * positions are declared, so a solver that only names source chains produces exactly the bytes it
+ * produced before positions existed.
  */
-declare function encodeAcceptedSourceChains(chains: string[]): HexString;
+declare function encodePhantomBidDeclaration(declaration: {
+    acceptedSourceChains?: string[];
+    uniswapV4Positions?: bigint[];
+}): HexString;
 /**
- * Decodes a phantom bid's paymasterAndData into its declared source chains. Returns null for an
- * absent, unversioned or malformed blob — the legacy default — and an empty array only for an
- * explicit zero-entry declaration. Callers must preserve that distinction.
+ * Decodes a phantom bid's paymasterAndData. Understands both layout versions, so bids placed
+ * before positions existed keep decoding unchanged. Anything absent, unversioned or malformed
+ * yields a null `acceptedSources` with no positions — never a partial read.
  */
+declare function decodePhantomBidDeclaration(paymasterAndData: string | undefined | null): PhantomBidDeclaration;
+/** Back-compat wrapper: the source-chain half of {@link encodePhantomBidDeclaration}. */
+declare function encodeAcceptedSourceChains(chains: string[]): HexString;
+/** Back-compat wrapper: the source-chain half of {@link decodePhantomBidDeclaration}. */
 declare function decodeAcceptedSourceChains(paymasterAndData: string | undefined | null): string[] | null;
 
 declare const ABI$1: readonly [{
@@ -10698,4 +10920,4 @@ declare function teleport(teleport_param: {
     extrinsics?: Array<SubmittableExtrinsic<"promise", ISubmittableResult>>;
 }): Promise<ReadableStream<HyperbridgeTxEvents>>;
 
-export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type AvailableLiquidityByChain, type AvailableLiquiditySnapshot, type Bid, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BridgeParams, type BridgeStep, type BundlerGasEstimate, BundlerMethod, type BytesLikeHex, type CancelEvent, type CancelOptions, type CancelOrderOptions, type CancelQuote, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, type ConfiguredAssetSymbol, CryptoUtils, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type Deployment, type DispatchGet, type DispatchInfo, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, type Erc4626VaultConfigData, type EstimateFillOrderParams, type EstimateGasCallData, EvmChain, type EvmChainParams, ABI as EvmHostABI, EvmLanguage, type ExecuteIntentOrderOptions, type ExecutionResult, type FillOptions, type FillOrderEstimate, type FillerBid, type FillerConfig, type GetRequestResponse, type GetRequestWithStatus, type GetResponseByRequestIdResponse, type GetResponseStorageValues, type HexString$1 as HexString, type HostParams, HyperClientStatus, HyperFungibleToken, HyperFungibleTokenABI, type HyperbridgeTxEvents, type IBatchConsensusAndGetResponseMessage, type IBatchConsensusAndPostRequestMessage, type IChain, type IConfig, type IConsensusMessage, type IEvmChain, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, type IPharosConfig, type IPolkadotHubConfig, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, type IndexerQueryClient, IntentGateway, ABI$1 as IntentGatewayABI, type IntentGatewayContext, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, type IntentQuoteStrategy, type IntentQuoteTradeType, IntentsCoprocessor, InvalidPhantomSnapshotError, IsmpClient, type IsmpRequest, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, type Order, type OrderFeesQuote, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, type PhantomOrderEvent, type PhantomOrderLeg, type PhantomOrderPriceSnapshot, type PhantomOrderPriceSnapshotsResponse, type PhantomSnapshotIntentQuoteMetadata, type PhantomSnapshotQuoteIntentResult, PhantomSnapshotUnavailableError, PharosChain, type PharosChainParams, PolkadotHubChain, type PolkadotHubChainParams, type PollPhantomOrdersOptions, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, type QuoteIntentParams, type QuoteIntentResult, type QuoteNativeResult, type QuoteResult, type QuoteUniswapParams, type QuoteUniswapResult, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, type RequestBody, type RequestCommitment, RequestKind, type RequestResponse, RequestStatus, type RequestStatusKey, type RequestStatusWithMetadata, type ResponseCommitmentWithValues, type ResumeIntentOrderOptions, type RetryConfig, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, type SelectBidResult, type SelectOptions, type SigningAccount, type StateMachineHeight, type StateMachineId, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, type StorageFacade, type SubmitBidOptions, SubstrateChain, Swap, TESTNET_CHAINS, type TeleportParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, TokenGateway, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenPrice, type TokenPricesResponse, type Transaction, TronChain, type TronChainParams, USE_ETHERSCAN_CHAINS, type UniswapProtocol, type UniswapQuote, type UniswapQuoteToken, type UniswapTradeType, type UniswapV4IntentQuoteMetadata, type UniswapV4IntentQuoteOptions, type UniswapV4PoolConfigData, type UniswapV4PoolKey, type UniswapV4QuoteIntentResult, UnsupportedIntentQuotePairError, UnsupportedIntentQuoteStrategyError, WrappedHyperFungibleTokenABI, type XcmGatewayParams, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodeUserOpScale, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getContractCallInputs, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, normalizeAddressForEvmBytes32, normalizeAddressForStateMachine, normalizeEvmAddress, normalizeEvmChainId, normalizeStateMachineId, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, polkadotHubMainnet, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
+export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type AvailableLiquidityByChain, type AvailableLiquiditySnapshot, type Bid, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BridgeParams, type BridgeStep, type BundlerGasEstimate, BundlerMethod, type BytesLikeHex, type CancelEvent, type CancelOptions, type CancelOrderOptions, type CancelQuote, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, type ConfiguredAssetSymbol, CryptoUtils, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type Deployment, type DispatchGet, type DispatchInfo, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, type Erc4626VaultConfigData, type EstimateFillOrderParams, type EstimateGasCallData, EvmChain, type EvmChainParams, ABI as EvmHostABI, EvmLanguage, type ExecuteIntentOrderOptions, type ExecutionResult, type FillOptions, type FillOrderEstimate, type FillerBid, type FillerConfig, type GetRequestResponse, type GetRequestWithStatus, type GetResponseByRequestIdResponse, type GetResponseStorageValues, type HexString$1 as HexString, type HostParams, HyperClientStatus, HyperFungibleToken, HyperFungibleTokenABI, type HyperbridgeTxEvents, type IBatchConsensusAndGetResponseMessage, type IBatchConsensusAndPostRequestMessage, type IChain, type IConfig, type IConsensusMessage, type IEvmChain, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, type IPharosConfig, type IPolkadotHubConfig, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, type IndexerQueryClient, IntentGateway, ABI$1 as IntentGatewayABI, type IntentGatewayContext, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, type IntentQuoteStrategy, type IntentQuoteTradeType, IntentsCoprocessor, InvalidPhantomSnapshotError, IsmpClient, type IsmpRequest, MOCK_ADDRESS, ORDER_V2_PARAM_TYPE, type Order, type OrderFeesQuote, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, type 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 QuoteIntentParams, type QuoteIntentResult, type QuoteNativeResult, type QuoteResult, type QuoteUniswapParams, type QuoteUniswapResult, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, type RequestBody, type RequestCommitment, RequestKind, type RequestResponse, RequestStatus, type RequestStatusKey, type RequestStatusWithMetadata, type ResponseCommitmentWithValues, type ResumeIntentOrderOptions, type RetryConfig, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, type SelectBidResult, type SelectOptions, type SigningAccount, type StateMachineHeight, type StateMachineId, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, type StorageFacade, type SubmitBidOptions, SubstrateChain, Swap, TESTNET_CHAINS, type TeleportParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, TokenGateway, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenPrice, type TokenPricesResponse, type Transaction, TronChain, type TronChainParams, USE_ETHERSCAN_CHAINS, type UniswapProtocol, type UniswapQuote, type UniswapQuoteToken, type UniswapTradeType, type UniswapV4IntentQuoteMetadata, type UniswapV4IntentQuoteOptions, type UniswapV4PoolConfigData, type UniswapV4PoolKey, type UniswapV4QuoteIntentResult, UnsupportedIntentQuotePairError, UnsupportedIntentQuoteStrategyError, WrappedHyperFungibleTokenABI, type XcmGatewayParams, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, 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, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };