@hyperbridge/sdk 1.9.5 → 2.0.0

package/dist/node/index.d.ts

@@ -13,48 +13,28 @@ export { Account as ViemAccount } from 'viem/accounts';
 
 declare const _default: {
     ABI: readonly [{
-        readonly inputs: readonly [];
-        readonly name: "ChallengePeriodNotElapsed";
-        readonly type: "error";
-    }, {
-        readonly inputs: readonly [];
-        readonly name: "ConsensusClientExpired";
-        readonly type: "error";
-    }, {
-        readonly inputs: readonly [];
-        readonly name: "DuplicateMessage";
-        readonly type: "error";
-    }, {
-        readonly inputs: readonly [];
-        readonly name: "HostFrozen";
-        readonly type: "error";
-    }, {
-        readonly inputs: readonly [];
-        readonly name: "InvalidMessageDestination";
-        readonly type: "error";
-    }, {
-        readonly inputs: readonly [];
-        readonly name: "InvalidProof";
-        readonly type: "error";
-    }, {
-        readonly inputs: readonly [];
-        readonly name: "MessageNotTimedOut";
-        readonly type: "error";
-    }, {
-        readonly inputs: readonly [];
-        readonly name: "MessageTimedOut";
-        readonly type: "error";
-    }, {
-        readonly inputs: readonly [];
-        readonly name: "StateCommitmentNotFound";
-        readonly type: "error";
+        readonly inputs: readonly [{
+            readonly internalType: "bytes[]";
+            readonly name: "calls";
+            readonly type: "bytes[]";
+        }];
+        readonly name: "batchCall";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
     }, {
         readonly inputs: readonly [];
-        readonly name: "UnknownMessage";
-        readonly type: "error";
+        readonly name: "currentEpoch";
+        readonly outputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "";
+            readonly type: "uint256";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
     }, {
         readonly inputs: readonly [{
-            readonly internalType: "contract IIsmpHost";
+            readonly internalType: "contract IHost";
             readonly name: "host";
             readonly type: "address";
         }, {
@@ -68,7 +48,7 @@ declare const _default: {
         readonly type: "function";
     }, {
         readonly inputs: readonly [{
-            readonly internalType: "contract IIsmpHost";
+            readonly internalType: "contract IHost";
             readonly name: "host";
             readonly type: "address";
         }, {
@@ -137,7 +117,7 @@ declare const _default: {
         readonly type: "function";
     }, {
         readonly inputs: readonly [{
-            readonly internalType: "contract IIsmpHost";
+            readonly internalType: "contract IHost";
             readonly name: "host";
             readonly type: "address";
         }, {
@@ -216,7 +196,7 @@ declare const _default: {
                             readonly name: "value";
                             readonly type: "bytes";
                         }];
-                        readonly internalType: "struct StorageValue[]";
+                        readonly internalType: "struct MerklePatricia.StorageValue[]";
                         readonly name: "values";
                         readonly type: "tuple[]";
                     }];
@@ -227,10 +207,6 @@ declare const _default: {
                     readonly internalType: "uint256";
                     readonly name: "index";
                     readonly type: "uint256";
-                }, {
-                    readonly internalType: "uint256";
-                    readonly name: "kIndex";
-                    readonly type: "uint256";
                 }];
                 readonly internalType: "struct GetResponseLeaf[]";
                 readonly name: "responses";
@@ -246,7 +222,7 @@ declare const _default: {
         readonly type: "function";
     }, {
         readonly inputs: readonly [{
-            readonly internalType: "contract IIsmpHost";
+            readonly internalType: "contract IHost";
             readonly name: "host";
             readonly type: "address";
         }, {
@@ -311,7 +287,7 @@ declare const _default: {
         readonly type: "function";
     }, {
         readonly inputs: readonly [{
-            readonly internalType: "contract IIsmpHost";
+            readonly internalType: "contract IHost";
             readonly name: "host";
             readonly type: "address";
         }, {
@@ -379,10 +355,6 @@ declare const _default: {
                     readonly internalType: "uint256";
                     readonly name: "index";
                     readonly type: "uint256";
-                }, {
-                    readonly internalType: "uint256";
-                    readonly name: "kIndex";
-                    readonly type: "uint256";
                 }];
                 readonly internalType: "struct PostRequestLeaf[]";
                 readonly name: "requests";
@@ -398,7 +370,7 @@ declare const _default: {
         readonly type: "function";
     }, {
         readonly inputs: readonly [{
-            readonly internalType: "contract IIsmpHost";
+            readonly internalType: "contract IHost";
             readonly name: "host";
             readonly type: "address";
         }, {
@@ -476,7 +448,7 @@ declare const _default: {
         readonly type: "function";
     }, {
         readonly inputs: readonly [{
-            readonly internalType: "contract IIsmpHost";
+            readonly internalType: "contract IHost";
             readonly name: "host";
             readonly type: "address";
         }, {
@@ -557,10 +529,6 @@ declare const _default: {
                     readonly internalType: "uint256";
                     readonly name: "index";
                     readonly type: "uint256";
-                }, {
-                    readonly internalType: "uint256";
-                    readonly name: "kIndex";
-                    readonly type: "uint256";
                 }];
                 readonly internalType: "struct PostResponseLeaf[]";
                 readonly name: "responses";
@@ -574,6 +542,20 @@ declare const _default: {
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
         readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "authoritySetId";
+            readonly type: "uint256";
+        }];
+        readonly name: "relayerOf";
+        readonly outputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "";
+            readonly type: "address";
+        }];
+        readonly stateMutability: "view";
+        readonly type: "function";
     }, {
         readonly inputs: readonly [{
             readonly internalType: "bytes4";
@@ -588,6 +570,85 @@ declare const _default: {
         }];
         readonly stateMutability: "view";
         readonly type: "function";
+    }, {
+        readonly anonymous: false;
+        readonly inputs: readonly [{
+            readonly indexed: true;
+            readonly internalType: "uint256";
+            readonly name: "authoritySetId";
+            readonly type: "uint256";
+        }, {
+            readonly indexed: true;
+            readonly internalType: "address";
+            readonly name: "relayer";
+            readonly type: "address";
+        }];
+        readonly name: "NewEpoch";
+        readonly type: "event";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "index";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "reason";
+            readonly type: "bytes";
+        }];
+        readonly name: "BatchCallFailed";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "ChallengePeriodNotElapsed";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "ConsensusClientExpired";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "DuplicateMessage";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "EmptyTree";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "HostFrozen";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InvalidMessageDestination";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "InvalidProof";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "MessageNotTimedOut";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "MessageTimedOut";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "OutOfBoundsLeaves";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "ProofExhausted";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "StateCommitmentNotFound";
+        readonly type: "error";
+    }, {
+        readonly inputs: readonly [];
+        readonly name: "UnknownMessage";
+        readonly type: "error";
     }];
 };
 
@@ -638,7 +699,7 @@ declare class ChainConfigService {
     getPopularTokens(chain: string): string[];
     getIntentGatewayV2Address(chain: string): HexString;
     getEntryPointV08Address(chain: string): HexString;
-    getCirclePaymasterV08Address(chain: string): HexString | undefined;
+    getCirclePaymasterAddress(chain: string): HexString | undefined;
     getHyperbridgeAddress(): string;
     /**
      * Get the LayerZero Endpoint ID for the chain
@@ -658,6 +719,9 @@ declare class ChainConfigService {
  * This represents the zero address in EVM chains.
  */
 declare const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+/**
+ * ERC-165 interface ID for IHandlerV2 (bytes4(keccak256("batchCall(bytes[])"))).
+ */
 /**
  * Parameters for an EVM chain.
  */
@@ -724,6 +788,10 @@ declare class EvmChain implements IChain {
     get bundlerUrl(): string | undefined;
     get config(): IEvmConfig;
     get configService(): ChainConfigService;
+    /**
+     * Returns the current authority set epoch from the HandlerV2 contract.
+     */
+    currentEpoch(): Promise<bigint>;
     /**
      * Derives the key for the request receipt.
      * @param {HexString} commitment - The commitment to derive the key from.
@@ -912,7 +980,6 @@ declare function getStateCommitmentSlot(stateMachineId: bigint, height: bigint):
  *   - root: The MMR root hash as a hex string
  *   - proof: An array of hex strings representing the MMR proof for the unmodified request
  *   - index: The index of the unmodified request in the MMR
- *   - kIndex: The k-index of the unmodified request in the MMR
  *   - treeSize: The number of leaves in the MMR
  *   - mmrSize: The size of the MMR in nodes
  */
@@ -920,7 +987,6 @@ declare function generateRootWithProof(postRequest: IPostRequest, treeSize: bigi
     root: HexString;
     proof: HexString[];
     index: bigint;
-    kIndex: bigint;
     treeSize: bigint;
     mmrSize: bigint;
 }>;
@@ -1264,10 +1330,21 @@ declare class SubstrateChain implements IChain {
      */
     encode(message: IIsmpMessage): HexString;
     /**
-     * Returns the index of a pallet by its name, by looking up the pallets in the runtime metadata.
-     * @param {string} name - The name of the pallet.
-     * @returns {number} The index of the pallet.
+     * Queries the latest proven height for this chain from pallet-ismp.
+     */
+    queryLastProvenHeight(): Promise<bigint>;
+    /**
+     * Queries all consensus proofs needed to catch up from a given on-chain epoch
+     * to the latest proven state. Returns rotation proofs (in order) to advance
+     * the authority set, plus the final messaging proof that covers `neededHeight`.
+     *
+     * @param neededHeight - The Hyperbridge block height that must be covered
+     * @param currentEpoch - The current authority set id on the destination EVM chain
      */
+    queryConsensusProofs(neededHeight: bigint, currentEpoch: bigint): Promise<{
+        proofs: HexString[];
+        provenHeight: bigint;
+    } | undefined>;
     private getPalletIndex;
 }
 /**
@@ -1613,10 +1690,102 @@ declare class PolkadotHubChain implements IChain {
     getTransactionReceipt(hash: HexString): Promise<TransactionReceipt>;
 }
 
+/**
+ * Chain parameters for a Pharos EVM chain. Pharos reuses the EVM JSON-RPC
+ * surface for reads, writes and host queries — proof fetching is the only
+ * place where the Pharos client deviates from a standard EVM chain.
+ */
+type PharosChainParams = EvmChainParams;
+/**
+ * Pharos EVM chain client.
+ *
+ * Delegates every standard EVM interaction to {@link EvmChain} and overrides
+ * {@link PharosChain.queryProof} / {@link PharosChain.queryStateProof} to speak
+ * Pharos's custom `eth_getProof` response format — mirroring the Rust
+ * `tesseract-messaging-pharos-evm` client.
+ */
+declare class PharosChain implements IChain {
+    private readonly params;
+    private readonly evm;
+    private readonly rpc;
+    static fromParams(params: PharosChainParams): PharosChain;
+    /**
+     * Creates a `PharosChain` by auto-detecting the EVM chain ID and `IsmpHost`
+     * address via {@link EvmChain.create}.
+     *
+     * @param rpcUrl - HTTP(S) JSON-RPC URL of the Pharos node
+     * @param bundlerUrl - Optional ERC-4337 bundler URL forwarded to `EvmChain.create`
+     */
+    static create(rpcUrl: string, bundlerUrl?: string): Promise<PharosChain>;
+    private constructor();
+    get client(): PublicClient;
+    get host(): HexString;
+    get bundlerUrl(): string | undefined;
+    get configService(): ChainConfigService;
+    get config(): IPharosConfig;
+    private hostAddress;
+    /**
+     * Fetch a storage proof for `slotKeys` under `address` at the given block and
+     * merge the response into the supplied accumulator. Mirrors the membership
+     * proof path of `PharosEvmClient::fetch_pharos_proof` on the Rust side.
+     */
+    private fetchStorageProofInto;
+    /**
+     * Fetch an account proof (no storage keys) at the given block and record it on
+     * the accumulator. Mirrors `PharosEvmClient::fetch_account_proof`.
+     */
+    private fetchAccountProofInto;
+    timestamp(): Promise<bigint>;
+    requestReceiptKey(commitment: HexString): HexString;
+    queryRequestReceipt(commitment: HexString): Promise<HexString | undefined>;
+    /**
+     * Query a Pharos state proof for the request/response commitments in `message`.
+     *
+     * Mirrors `PharosEvmClient::query_requests_proof` / `query_responses_proof`:
+     * for every commitment we derive the second storage slot (`slot1` from
+     * {@link requestCommitmentKey} / {@link responseCommitmentKey}) and request it
+     * from the ISMP host via `eth_getProof`.
+     */
+    queryProof(message: IMessage, _counterparty: string, at?: bigint): Promise<HexString>;
+    /**
+     * Query a Pharos state proof for arbitrary keys.
+     *
+     * Supports the same key shapes as `PharosEvmClient::query_state_proof`:
+     *   - 32-byte keys: ISMP host storage slots
+     *   - 52-byte keys: `address (20) || slot (32)` grouped by contract
+     *   - 20-byte keys: account queries (proves the account leaf itself)
+     *
+     * If `address` is provided, all keys are treated as 32-byte slots under that
+     * contract (matching the `EvmChain.queryStateProof` contract-override shape).
+     */
+    queryStateProof(at: bigint, keys: HexString[], address?: HexString): Promise<HexString>;
+    encode(message: IIsmpMessage): HexString;
+    latestStateMachineHeight(stateMachineId: StateMachineIdParams): Promise<bigint>;
+    challengePeriod(stateMachineId: StateMachineIdParams): Promise<bigint>;
+    stateMachineUpdateTime(stateMachineHeight: StateMachineHeight): Promise<bigint>;
+    getHostNonce(): Promise<bigint>;
+    quoteNative(request: IPostRequest | IGetRequest, fee: bigint): Promise<bigint>;
+    getFeeTokenWithDecimals(): Promise<{
+        address: HexString;
+        decimals: number;
+    }>;
+    getPlaceOrderCalldata(txHash: string, intentGatewayAddress: string): Promise<HexString>;
+    estimateGas(request: IPostRequest): Promise<{
+        gas: bigint;
+        postRequestCalldata: HexString;
+    }>;
+    broadcastTransaction(signedTransaction: HexString): Promise<TransactionReceipt>;
+    getTransactionReceipt(hash: HexString): Promise<TransactionReceipt>;
+}
+
 /**
  * Type representing an ISMP message.
  */
-type IIsmpMessage = IRequestMessage | ITimeoutPostRequestMessage | IGetResponseMessage | IGetRequestMessage;
+type IIsmpMessage = IRequestMessage | ITimeoutPostRequestMessage | IGetResponseMessage | IGetRequestMessage | IConsensusMessage | IBatchConsensusAndPostRequestMessage | IBatchConsensusAndGetResponseMessage;
+interface IConsensusMessage {
+    kind: "Consensus";
+    consensusProof: HexString;
+}
 interface IRequestMessage {
     /**
      * The kind of message.
@@ -1699,6 +1868,20 @@ interface ITimeoutPostRequestMessage {
      */
     proof: IProof;
 }
+interface IBatchConsensusAndPostRequestMessage {
+    kind: "BatchConsensusAndPostRequest";
+    consensusProofs: HexString[];
+    requests: IPostRequest[];
+    proof: IProof;
+    signer: HexString;
+}
+interface IBatchConsensusAndGetResponseMessage {
+    kind: "BatchConsensusAndGetResponse";
+    consensusProofs: HexString[];
+    responses: IGetResponse[];
+    proof: IProof;
+    signer: HexString;
+}
 interface IProof {
     /**
      * The height of the proof.
@@ -1724,7 +1907,7 @@ interface IChain {
     /**
      * Returns the configuration for this chain
      */
-    get config(): IEvmConfig | ISubstrateConfig | IPolkadotHubConfig;
+    get config(): IEvmConfig | ISubstrateConfig | IPolkadotHubConfig | IPharosConfig;
     timestamp(): Promise<bigint>;
     /**
      * Returns the state trie key for the request-receipt storage item for the given request commitment.
@@ -1776,8 +1959,8 @@ interface IEvmChain extends IChain {
 type EstimateGasCallData = ContractFunctionArgs<typeof _default.ABI, "nonpayable" | "payable", "handlePostRequests">;
 type HexString = `0x${string}`;
 interface IConfig {
-    source: IEvmConfig | ISubstrateConfig | IPolkadotHubConfig;
-    dest: IEvmConfig | ISubstrateConfig | IPolkadotHubConfig;
+    source: IEvmConfig | ISubstrateConfig | IPolkadotHubConfig | IPharosConfig;
+    dest: IEvmConfig | ISubstrateConfig | IPolkadotHubConfig | IPharosConfig;
     hyperbridge: IHyperbridgeConfig;
     tracing?: boolean;
 }
@@ -1794,6 +1977,14 @@ interface IEvmConfig {
 interface IPolkadotHubConfig extends IEvmConfig {
     substrateRpcUrl: string;
 }
+/**
+ * Pharos EVM chain — same as {@link IEvmConfig}. Pharos uses a non-standard
+ * `eth_getProof` response format (hexary hash tree proof nodes with offsets plus
+ * SHA-256 hashing), so proof fetching is handled by the Pharos-specific chain
+ * client rather than viem's standard `getProof`.
+ */
+interface IPharosConfig extends IEvmConfig {
+}
 interface ISubstrateConfig {
     wsUrl: string;
     consensusStateId: string;
@@ -2790,7 +2981,7 @@ interface SigningAccount {
         yParity: number;
     }>;
     /**
-     * Signs an EIP-712 typed-data payload (e.g. an EIP-2612 USDC permit for the Circle paymaster).
+     * Signs an EIP-712 typed-data payload (e.g. an EIP-2612 USDC permit for the Circle Paymaster).
      * The shape of `typedData` matches viem's `TypedDataDefinition` (domain + types + message).
      */
     signTypedData: (typedData: unknown, chainId?: number) => Promise<HexString>;
@@ -2843,9 +3034,9 @@ interface FillOrderEstimate {
     callGasLimit: bigint;
     verificationGasLimit: bigint;
     preVerificationGas: bigint;
-    /** Paymaster verification gas limit from bundler estimate, or Circle's cap if absent. 0n when no paymaster. */
+    /** Paymaster verification gas limit from bundler estimate. 0n when no paymaster. */
     paymasterVerificationGasLimit: bigint;
-    /** Paymaster postOp gas limit from bundler estimate, or Circle's cap if absent. 0n when no paymaster. */
+    /** Paymaster postOp gas limit from bundler estimate. 0n when no paymaster. */
     paymasterPostOpGasLimit: bigint;
     maxFeePerGas: bigint;
     maxPriorityFeePerGas: bigint;
@@ -3035,101 +3226,16 @@ type ERC7821Call = {
 };
 
 /**
- * IndexerClient provides methods for interacting with the Hyperbridge indexer.
- *
- * This client facilitates querying and tracking cross-chain requests and their status
- * through the Hyperbridge protocol. It supports:
- *
- * - Querying state machine updates by block height or timestamp
- * - Retrieving request status information by transaction hash
- * - Monitoring request status changes through streaming interfaces
- * - Handling request timeout flows and related proof generation
- * - Tracking request finalization across source and destination chains
- *
- * The client implements automatic retries with exponential backoff for network
- * resilience and provides both simple query methods and advanced streaming
- * interfaces for real-time status tracking.
- *
- * The URLs provided in the configuration must point to archive nodes to allow the client to query for storage proofs
- * of potentially much older blocks. Regular nodes only store the state for recent blocks and will not be able
- * to provide the necessary proofs for cross-chain verification, especially in timeout scenarios.
- *
- * @example
- * ```typescript
- * const sourceChain = EvmChain.fromParams({
- *   chainId: 1,
- *   rpcUrl: "https://eth-rpc.com",
- *   host: "0x87ea45..",
- *   consensusStateId: "ETH0"
- * })
- * const destChain = EvmChain.fromParams({
- *   chainId: 42161,
- *   rpcUrl: "https://arb-rpc.com",
- *   host: "0x87ea42345..",
- *   consensusStateId: "ARB0"
- * })
- * const hyperbridgeChain = await SubstrateChain.connect({
- *   stateMachineId: "POLKADOT-3367",
- *   wsUrl: "ws://localhost:9944",
- *   hasher: "Keccak",
- *   consensusStateId: "DOT0"
- * })
- *
- * const client = new IndexerClient({
- *   queryClient: queryClient,
- *   pollInterval: 2000,
- *   source: sourceChain,
- *   dest: destChain,
- *   hyperbridge: hyperbridgeChain
- * });
- *
- * // Query a request status
- * const status = await client.queryRequestWithStatus("0x1234...");
- *
- * // Stream status updates
- * for await (const update of client.postRequestStatusStream("0x1234...")) {
- *   console.log(`Request status: ${update.status}`);
- * }
- * ```
+ * Read-only indexer queries — state machine updates, post/get requests, and
+ * response lookups. Groups the thin GraphQL wrappers that other client
+ * sub-modules consume when building finality events and status streams.
  */
-declare class IndexerClient {
-    /**
-     * GraphQL client used for making requests to the indexer
-     */
-    private client;
-    /**
-     * Configuration for the IndexerClient including URLs, poll intervals, and chain-specific settings
-     */
-    private config;
-    private logger;
-    /**
-     * Default configuration for retry behavior when network requests fail
-     * - maxRetries: Maximum number of retry attempts before failing
-     * - backoffMs: Initial backoff time in milliseconds (doubles with each retry)
-     */
-    private defaultRetryConfig;
-    /**
-     * Creates a new IndexerClient instance
-     */
-    constructor(config: PartialClientConfig);
-    /**
-     * Get the source chain instance
-     */
-    get source(): IChain;
-    /**
-     * Get the destination chain instance
-     */
-    get dest(): IChain;
-    /**
-     * Get the hyperbridge chain instance
-     */
-    get hyperbridge(): IChain;
+declare class Queries {
+    private readonly ctx;
+    private readonly logger;
+    constructor(ctx: ClientContext);
     /**
      * Query for a single state machine update event greater than or equal to the given height.
-     * @params statemachineId - ID of the state machine
-     * @params height - Starting block height
-     * @params chain - The identifier for the chain where the state machine update should be queried (corresponds to a stateMachineId)
-     * @returns Closest state machine update
      */
     queryStateMachineUpdateByHeight({ statemachineId, height, chain, }: {
         statemachineId: string;
@@ -3138,10 +3244,6 @@ declare class IndexerClient {
     }): Promise<StateMachineUpdate | undefined>;
     /**
      * Query for a single state machine update event greater than or equal to the given timestamp.
-     * @params statemachineId - ID of the state machine
-     * @params timestamp - Starting block timestamp
-     * @params chain - The identifier for the chain where the state machine update should be queried (corresponds to a stateMachineId)
-     * @returns Closest state machine update
      */
     queryStateMachineUpdateByTimestamp({ statemachineId, commitmentTimestamp, chain, }: {
         statemachineId: string;
@@ -3149,271 +3251,303 @@ declare class IndexerClient {
         chain: string;
     }): Promise<StateMachineUpdate | undefined>;
     /**
-     * Query for the latest state machine update height
-     * @params statemachineId - ID of the state machine
-     * @params chain - The identifier for the chain where the state machine update should be queried (corresponds to a stateMachineId)
-     * @returns Latest height or undefined if no updates found
+     * Query for the latest state machine update height.
      */
     queryLatestStateMachineHeight({ statemachineId, chain, }: {
         statemachineId: string;
         chain: string;
     }): Promise<bigint | undefined>;
     /**
-     * Queries a request by CommitmentHash
-     *
-     * @param commitment_hash - Can be commitment
-     * @returns Latest status and block metadata of the request
+     * Queries a POST request by commitment hash.
      */
-    queryPostRequest(commitment_hash: HexString): Promise<PostRequestWithStatus | undefined>;
+    queryPostRequest(commitmentHash: HexString): Promise<PostRequestWithStatus | undefined>;
     /**
-     * Queries a request by any of its associated hashes and returns it alongside its statuses
-     * Statuses will be one of SOURCE, HYPERBRIDGE_DELIVERED and DESTINATION
-     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
-     * @returns Latest status and block metadata of the request
+     * Queries a GET request by any of its associated hashes.
      */
     queryGetRequest(hash: HexString): Promise<GetRequestWithStatus | undefined>;
     /**
-     * Queries the response associated with a specific request ID and returns its commitment
-     * @param requestId - The ID of the request to find the associated response for
-     * @returns The response associated with the given request ID, or undefined if not found
+     * Queries the response associated with a specific request ID and returns its commitment.
      */
     queryResponseByRequestId(requestId: string): Promise<ResponseCommitmentWithValues | undefined>;
+}
+
+/**
+ * GET request status tracking — snapshot + streaming flows. Responses travel
+ * back to the origin chain, so finality work happens against `source` rather
+ * than `dest`.
+ */
+declare class GetRequestClient {
+    private readonly ctx;
+    private readonly queries;
+    private readonly logger;
+    constructor(ctx: ClientContext, queries: Queries);
+    /**
+     * Enhances a GET request with finality events (`SOURCE_FINALIZED`,
+     * `HYPERBRIDGE_FINALIZED`).
+     */
+    addGetRequestFinalityEvents(request: GetRequestWithStatus): Promise<GetRequestWithStatus>;
+    /**
+     * Snapshot query with all inferred finality events sorted.
+     */
+    queryGetRequestWithStatus(hash: HexString): Promise<GetRequestWithStatus | undefined>;
+    /**
+     * Streaming status updates for a GET request. Ends when the request reaches
+     * the destination or a timeout becomes pending.
+     */
+    getRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    private streamInternal;
+    /**
+     * Snapshot helper: returns the `HYPERBRIDGE_FINALIZED` event with source-chain
+     * calldata if prerequisites are met, or `undefined` if we're still waiting
+     * for a consensus proof.
+     * Requires the matching response to already exist in the indexer.
+     */
+    private buildFinalized;
+    /**
+     * Streaming helper: waits (via `waitOrAbort`) for the consensus proof or
+     * state machine update, fetches the messaging proof, and returns the
+     * finalized event. Caller has already observed `HYPERBRIDGE_DELIVERED` and
+     * provides the index into `request.statuses` that carries it plus the
+     * indexed response (looked up separately because GET responses live in a
+     * different GraphQL entity from requests).
+     */
+    private streamFinalized;
+}
+
+/**
+ * POST request lifecycle — snapshot status, streaming status, and the full
+ * timeout flow (pending → destination-finalized → hyperbridge-finalized → timed-out).
+ * Also hosts `aggregateTransactionWithCommitment`, which relays a dispatched
+ * post request through Hyperbridge from source-chain state.
+ */
+declare class PostRequestClient {
+    private readonly ctx;
+    private readonly queries;
+    private readonly logger;
+    constructor(ctx: ClientContext, queries: Queries);
     /**
      * Enhances a request with finality events by querying state machine updates.
-     *
-     * This method augments a request object with additional inferred status events
-     * that represent chain finality confirmations. It adds:
-     * - SOURCE_FINALIZED: When the source chain has finalized the request
-     * - HYPERBRIDGE_FINALIZED: When Hyperbridge has finalized the delivery confirmation
-     *
-     * The method also generates appropriate calldata for submitting cross-chain proofs
-     * when applicable.
-     *
-     * @param request - The request to enhance with finality events
-     * @returns The request with finality events added
-     * @private
+     * Adds `SOURCE_FINALIZED` and `HYPERBRIDGE_FINALIZED` when applicable.
+     */
+    addRequestFinalityEvents(request: PostRequestWithStatus): Promise<PostRequestWithStatus>;
+    /**
+     * Snapshot query: request + all inferred finality/timeout events, sorted.
+     */
+    queryRequestWithStatus(hash: HexString): Promise<PostRequestWithStatus | undefined>;
+    /**
+     * Streaming status updates for a post request. Ends when the request reaches
+     * the destination or a timeout becomes pending.
+     */
+    postRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    private streamStatusInternal;
+    /**
+     * Populates timeout-related status events (`PENDING_TIMEOUT`,
+     * `DESTINATION_FINALIZED_TIMEOUT`, `HYPERBRIDGE_FINALIZED_TIMEOUT`) and the
+     * accompanying timeout-proof calldata.
+     */
+    addTimeoutFinalityEvents(request: PostRequestWithStatus): Promise<PostRequestWithStatus>;
+    /**
+     * Streaming status updates for a timed-out post request.
+     */
+    postRequestTimeoutStream(hash: HexString): AsyncGenerator<PostRequestTimeoutStatus, void>;
+    private streamTimeoutInternal;
+    /**
+     * Snapshot helper: returns the `HYPERBRIDGE_FINALIZED` event with relayer
+     * calldata if prerequisites are met, or `undefined` if we're still waiting
+     * for a consensus proof.
+     */
+    private buildFinalized;
+    /**
+     * Streaming helper: waits for the consensus proof, fetches the messaging
+     * proof with retry, and returns the finalized event. Caller has already
+     * observed `HYPERBRIDGE_DELIVERED` and provides the index into
+     * `request.statuses` that carries it.
+     */
+    private streamFinalized;
+    /**
+     * Retry-wrapped `hyperbridge.queryProof`. Fails after 6 retries (~2 minutes at
+     * 2s backoff) so a hung Hyperbridge node doesn't stall the stream forever.
      */
-    private addRequestFinalityEvents;
+    private fetchProofWithRetry;
+    /**
+     * Relay a post-request to Hyperbridge from source-chain state, returning
+     * the finalized Hyperbridge extrinsic receipt.
+     */
+    aggregateTransactionWithCommitment(commitment: HexString): Promise<Awaited<ReturnType<SubstrateChain["submitUnsigned"]>>>;
+}
+
+/**
+ * Shared dependencies passed to every sub-module of {@link IsmpClient}.
+ *
+ * Sub-modules read their chain configuration, GraphQL client, logger, and
+ * retry helpers off of this object rather than reaching back into the facade.
+ *
+ * Internal — not part of the public SDK surface.
+ */
+interface ClientContext {
+    /** Chain configuration + indexer poll interval. `pollInterval` is guaranteed set. */
+    config: ClientConfig & {
+        pollInterval: number;
+    };
+    /** GraphQL client used to query the Hyperbridge indexer. */
+    graphql: IndexerQueryClient;
+    /** Structured logger (tag-scoped per sub-module). */
+    logger: ConsolaInstance;
+    /** Default retry config — sub-modules may override per-call. */
+    defaultRetryConfig: RetryConfig;
+}
+/**
+ * `IsmpClient` tracks ISMP POST/GET requests and their timeout flows across
+ * source, Hyperbridge, and destination chains.
+ *
+ * The client:
+ * - queries the Hyperbridge indexer for request status,
+ * - augments status trails with derived finality events (`SOURCE_FINALIZED`,
+ *   `HYPERBRIDGE_FINALIZED`, timeout events),
+ * - streams live updates while a request is in flight, and
+ * - generates the calldata a relayer needs to finalize a request on the
+ *   counterparty chain (including the HandlerV2 batch path).
+ *
+ * The RPC URLs in {@link ClientConfig} must point to archive nodes — timeout
+ * and challenge-period flows reach back into older blocks for storage proofs.
+ *
+ * @example
+ * ```typescript
+ * const client = new IsmpClient({
+ *   queryClient,
+ *   source: sourceChain,
+ *   dest: destChain,
+ *   hyperbridge: hyperbridgeChain,
+ *   pollInterval: 2000,
+ * })
+ *
+ * const status = await client.queryRequestWithStatus("0x1234...")
+ *
+ * for await (const update of client.postRequestStatusStream("0x1234...")) {
+ *   console.log(`Request status: ${update.status}`)
+ * }
+ * ```
+ */
+declare class IsmpClient {
+    /** Shared context threaded through every sub-module. */
+    protected readonly ctx: ClientContext;
+    /** Indexer read-only queries (state machine updates, post/get requests). */
+    protected readonly queries: Queries;
+    /** POST request lifecycle: snapshot + streaming status, timeout flow, aggregation. */
+    protected readonly postRequest: PostRequestClient;
+    /** GET request snapshot + streaming status. */
+    protected readonly getRequest: GetRequestClient;
+    constructor(config: PartialClientConfig);
+    /** Source chain instance. */
+    get source(): IChain;
+    /** Destination chain instance. */
+    get dest(): IChain;
+    /** Hyperbridge chain instance. */
+    get hyperbridge(): IChain;
     /**
-     * Adds timeout finality events to a request by querying for relevant timeout proofs and
-     * chain state necessary for timeout processing.
-     *
-     * This method enhances a request object with additional status events related to the
-     * timeout flow, including:
-     * - PENDING_TIMEOUT: When a request has passed its timeout timestamp
-     * - DESTINATION_FINALIZED: When the destination chain has finalized the timeout timestamp
-     * - HYPERBRIDGE_FINALIZED_TIMEOUT: When hyperbridge has finalized the timeout state
+     * Query for the first state machine update at or after `height` for the given
+     * state machine on the indicated counterparty chain.
      *
-     * The method also generates appropriate calldata for submitting timeout proofs.
-     *
-     * @param request - Request to fill timeout events for
-     * @returns Request with timeout events filled in, including any proof calldata for timeout submissions
-     * @private
+     * @returns The matching update, or `undefined` if none has been indexed yet.
      */
-    private addTimeoutFinalityEvents;
+    queryStateMachineUpdateByHeight(args: {
+        /** State machine id whose commitment is being looked up (e.g. `EVM-1`). */
+        statemachineId: string;
+        /** Chain id where the update was applied (e.g. `POLKADOT-3367`). */
+        chain: string;
+        /** Lower bound on the update height. */
+        height: number;
+    }): Promise<StateMachineUpdate | undefined>;
     /**
-     * Queries a request returns it alongside its statuses,
-     * including any finalization events.
-     * @param hash - Commitment hash
-     * @returns Full request data with all inferred status events, including SOURCE_FINALIZED and HYPERBRIDGE_FINALIZED
-     * @remarks Unlike queryRequest(), this method adds derived finalization status events by querying state machine updates
+     * Query for the first state machine update whose commitment timestamp is at
+     * or after `commitmentTimestamp`. Used by timeout flows to find when a
+     * counterparty chain finalized a state past the request's deadline.
      */
-    queryRequestWithStatus(hash: HexString): Promise<PostRequestWithStatus | undefined>;
+    queryStateMachineUpdateByTimestamp(args: {
+        statemachineId: string;
+        commitmentTimestamp: bigint;
+        chain: string;
+    }): Promise<StateMachineUpdate | undefined>;
     /**
-     * Queries a GET request and returns it alongside its statuses,
-     * including any finalization events.
-     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
-     * @returns Full GET request data with all inferred status events, including SOURCE_FINALIZED and HYPERBRIDGE_FINALIZED
-     * @remarks Unlike queryGetRequest(), this method adds derived finalization status events by querying state machine updates
+     * Returns the latest known state machine height for a given state machine,
+     * or `undefined` if the indexer has no record yet.
      */
-    queryGetRequestWithStatus(hash: HexString): Promise<GetRequestWithStatus | undefined>;
+    queryLatestStateMachineHeight(args: {
+        statemachineId: string;
+        chain: string;
+    }): Promise<bigint | undefined>;
     /**
-     * Enhances a GET request with finality events by querying state machine updates.
-     *
-     * This method augments a GET request object with additional inferred status events
-     * that represent chain finality confirmations. It adds:
-     * - SOURCE_FINALIZED: When the source chain has finalized the request
-     * - HYPERBRIDGE_FINALIZED: When Hyperbridge has finalized the delivery confirmation and response is ready
-     *
-     * The method also generates appropriate calldata for submitting cross-chain proofs
-     * when applicable.
-     *
-     * @param request - The GET request to enhance with finality events
-     * @returns The request with finality events added
-     * @private
+     * Queries a POST request by any of its associated hashes (commitment,
+     * source/destination/hyperbridge tx hash, or timeout tx hash). Returns the
+     * raw indexed record without derived finality events.
      */
-    private addGetRequestFinalityEvents;
+    queryPostRequest(commitmentHash: HexString): Promise<PostRequestWithStatus | undefined>;
     /**
-     * Create a Stream of status updates for a post request.
-     * Stream ends when either the request reaches the destination or times out.
-     * If the stream yields TimeoutStatus.PENDING_TIMEOUT, use postRequestTimeoutStream() to begin timeout processing.
-     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
-     * @returns AsyncGenerator that emits status updates until a terminal state is reached
-     * @example
-     *
-     * let client = new IndexerClient(config)
-     * let stream = client.postRequestStatusStream(hash)
-     *
-     * // you can use a for-await-of loop
-     * for await (const status of stream) {
-     *   console.log(status)
-     * }
-     *
-     * // you can also use a while loop
-     * while (true) {
-     *   const status = await stream.next()
-     *   if (status.done) {
-     *     break
-     *   }
-     *   console.log(status.value)
-     * }
-     *
+     * Queries a GET request by any of its associated hashes. Returns the raw
+     * indexed record without derived finality events.
      */
-    postRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
-    timeoutStream(timeoutTimestamp: bigint, chain: IChain): AsyncGenerator<RequestStatusWithMetadata, void>;
+    queryGetRequest(hash: HexString): Promise<GetRequestWithStatus | undefined>;
     /**
-     * Create a Stream of status updates
-     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
-     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     * Queries the response a GET request's values come from, by the request's id.
+     * Returns the response commitment plus the indexed storage values.
      */
-    private postRequestStatusStreamInternal;
-    private sleep_for;
-    private sleep_for_interval;
+    queryResponseByRequestId(requestId: string): Promise<ResponseCommitmentWithValues | undefined>;
     /**
-     * Create a Stream of status updates for a get request.
-     * Stream ends when either the request reaches the destination or times out.
-     * If the stream yields TimeoutStatus.PENDING_TIMEOUT, use postRequestTimeoutStream() to begin timeout processing.
-     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
-     * @returns AsyncGenerator that emits status updates until a terminal state is reached
-     * @example
-     *
-     * let client = new IndexerClient(config)
-     * let stream = client.getRequestStatusStream(hash)
-     *
-     * // you can use a for-await-of loop
-     * for await (const status of stream) {
-     *   console.log(status)
-     * }
+     * Snapshot query for a POST request: returns the indexed record with all
+     * inferred finality and timeout events (`SOURCE_FINALIZED`,
+     * `HYPERBRIDGE_FINALIZED`, `PENDING_TIMEOUT`, …) sorted by progress weight.
      *
-     * // you can also use a while loop
-     * while (true) {
-     *   const status = await stream.next()
-     *   if (status.done) {
-     *     break
-     *   }
-     *   console.log(status.value)
-     * }
-     *
-     */
-    getRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
-    /**
-     * Create a Stream of status updates
-     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
-     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     * Unlike {@link postRequestStatusStream} this does not poll; each call
+     * returns a fresh snapshot based on the indexer's current state.
      */
-    private getRequestStatusStreamInternal;
+    queryRequestWithStatus(hash: HexString): Promise<PostRequestWithStatus | undefined>;
     /**
-     * Create a Stream of status updates for a timed out post request.
-     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
-     * @returns AsyncGenerator that emits status updates until a terminal state is reached
-     * @example
-     *
-     * let client = new IndexerClient(config)
-     * let stream = client.postRequestTimeoutStream(hash)
+     * Streams status updates for a POST request as it progresses through the
+     * source → Hyperbridge → destination lifecycle. Ends when the request
+     * reaches its destination or its timeout becomes pending.
      *
-     * // you can use a for-await-of loop
-     * for await (const status of stream) {
-     *   console.log(status)
-     * }
-     *
-     * // you can also use a while loop
-     * while (true) {
-     *   const status = await stream.next()
-     *   if (status.done) {
-     *     break
-     *   }
-     *   console.log(status.value)
-     * }
+     * Yields the `HYPERBRIDGE_FINALIZED` event with relayer calldata attached —
+     * this is the calldata a caller submits to the destination handler to
+     * deliver the request (bundled `handleConsensus` + `handlePostRequests` via
+     * `batchCall`).
      */
-    postRequestTimeoutStream(hash: HexString): AsyncGenerator<PostRequestTimeoutStatus, void>;
+    postRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
     /**
-     * Create a Stream of status updates for a timed out post request.
-     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
-     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     * Streams timeout status updates for a POST request past its
+     * `timeoutTimestamp`. Drives the `PENDING_TIMEOUT →
+     * DESTINATION_FINALIZED_TIMEOUT → HYPERBRIDGE_FINALIZED_TIMEOUT → TIMED_OUT`
+     * progression, submitting unsigned extrinsics to Hyperbridge where required
+     * and yielding source-chain timeout calldata at the final step.
      */
-    postRequestTimeoutStreamInternal(hash: HexString, signal: AbortSignal): AsyncGenerator<PostRequestTimeoutStatus, void>;
+    postRequestTimeoutStream(hash: HexString): AsyncGenerator<PostRequestTimeoutStatus, void>;
     /**
-     * Executes an async operation with exponential backoff retry
-     * @param operation - Async function to execute
-     * @param retryConfig - Optional retry configuration
-     * @returns Result of the operation
-     * @throws Last encountered error after all retries are exhausted
-     *
-     * @example
-     * const result = await this.withRetry(() => this.queryStatus(hash));
+     * Relays a POST request to Hyperbridge from source-chain state (when the
+     * request wasn't aggregated there yet) and returns the finalized Hyperbridge
+     * extrinsic receipt. Used to bootstrap status tracking for requests that
+     * Hyperbridge hasn't seen.
      */
-    private withRetry;
+    aggregateTransactionWithCommitment(commitment: HexString): Promise<Awaited<ReturnType<SubstrateChain["submitUnsigned"]>>>;
     /**
-     * Query for an order by its commitment hash
-     * @param commitment - The commitment hash of the order
-     * @returns The order with its status if found, undefined otherwise
+     * Snapshot query for a GET request: returns the indexed record with all
+     * inferred finality events (`SOURCE_FINALIZED`, `HYPERBRIDGE_FINALIZED`)
+     * sorted by progress weight.
      */
-    queryOrder(commitment: HexString): Promise<OrderWithStatus | undefined>;
+    queryGetRequestWithStatus(hash: HexString): Promise<GetRequestWithStatus | undefined>;
     /**
-     * Create a Stream of status updates for an order.
-     * Stream ends when the order reaches a terminal state (FILLED, REDEEMED, or REFUNDED).
-     * @param commitment - The commitment hash of the order
-     * @returns AsyncGenerator that emits status updates until a terminal state is reached
-     * @example
-     *
-     * let client = new IndexerClient(config)
-     * let stream = client.orderStatusStream(commitment)
-     *
-     * // you can use a for-await-of loop
-     * for await (const status of stream) {
-     *   console.log(status)
-     * }
-     *
-     * // you can also use a while loop
-     * while (true) {
-     *   const status = await stream.next()
-     *   if (status.done) {
-     *     break
-     *   }
-     *   console.log(status.value)
-     * }
+     * Streams status updates for a GET request. Ends when the response is
+     * delivered back to the source chain or the request's timeout elapses.
+     * Yields the `HYPERBRIDGE_FINALIZED` event with source-chain calldata for
+     * submitting the response (bundled `handleConsensus` + `handleGetResponses`
+     * via `batchCall`).
      */
-    orderStatusStream(commitment: HexString): AsyncGenerator<{
-        status: OrderStatus;
-        metadata: {
-            blockHash: string;
-            blockNumber: number;
-            transactionHash: string;
-            timestamp: bigint;
-            filler?: string;
-        };
-    }, void>;
-    tokenGatewayAssetTeleportedStatusStream(commitment: HexString): AsyncGenerator<{
-        status: TeleportStatus;
-        metadata: {
-            blockHash: string;
-            blockNumber: number;
-            transactionHash: string;
-            timestamp: bigint;
-        };
-    }, void>;
-    private queryTokenGatewayAssetTeleported;
+    getRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
     /**
-     * Aggregate transactions with commitment.
-     * @param commitment
-     * @returns an object containing the transaction hash, block hash, block number, timestamp.
+     * Low-level watcher that yields a single `PENDING_TIMEOUT` event once
+     * `chain.timestamp()` passes `timeoutTimestamp`. Used internally by the
+     * status streams; exposed for callers that want to race their own logic
+     * against a request's deadline.
      */
-    aggregateTransactionWithCommitment(commitment: HexString): Promise<Awaited<ReturnType<SubstrateChain["submitUnsigned"]>>>;
-    waitOrAbort<T>(params: {
-        signal: AbortSignal;
-        promise: () => Promise<T>;
-        predicate?: (a: T) => boolean;
-    }): Promise<NonNullable<T>>;
+    timeoutStream(timeoutTimestamp: bigint, chain: IChain): AsyncGenerator<RequestStatusWithMetadata, void>;
 }
 interface PartialClientConfig extends Omit<ClientConfig, "pollInterval"> {
     pollInterval?: number;
@@ -4078,7 +4212,7 @@ declare class IntentGateway {
      *   Defaults to `false` (source-side cancellation).
      * @yields {@link CancelEvent} objects describing each cancellation stage.
      */
-    cancelOrder(order: Order, indexerClient: IndexerClient, fromDest?: boolean): AsyncGenerator<CancelEvent>;
+    cancelOrder(order: Order, indexerClient: IsmpClient, fromDest?: boolean): AsyncGenerator<CancelEvent>;
     /**
      * Constructs a signed `PackedUserOperation` for a solver to submit as a bid.
      *
@@ -4154,6 +4288,50 @@ declare class IntentGateway {
      *   in the `_orders` mapping on the source chain.
      */
     isOrderRefunded(order: Order): Promise<boolean>;
+    /**
+     * Optional indexer context for {@link queryOrder} / {@link orderStatusStream}.
+     * Configured via {@link withQueryClient}; unset by default since not every
+     * IntentGateway caller needs indexer access.
+     */
+    private indexer?;
+    /**
+     * Attaches an indexer GraphQL client to this IntentGateway so that
+     * {@link queryOrder} and {@link orderStatusStream} become available.
+     * Returns `this` for chaining.
+     *
+     * @example
+     * ```ts
+     * const gateway = (await IntentGateway.create(source, dest)).withQueryClient(queryClient)
+     * const order = await gateway.queryOrder("0x...")
+     * ```
+     */
+    withQueryClient(queryClient: IndexerQueryClient, options?: {
+        pollInterval?: number;
+        tracing?: boolean;
+    }): this;
+    private requireIndexer;
+    /**
+     * Queries an order by its commitment hash.
+     *
+     * Requires a prior call to {@link withQueryClient}.
+     */
+    queryOrder(commitment: HexString): Promise<OrderWithStatus | undefined>;
+    /**
+     * Streams status updates for an order until it reaches a terminal state
+     * (FILLED, REDEEMED, or REFUNDED).
+     *
+     * Requires a prior call to {@link withQueryClient}.
+     */
+    orderStatusStream(commitment: HexString): AsyncGenerator<{
+        status: OrderStatus;
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp: bigint;
+            filler?: string;
+        };
+    }, void>;
 }
 
 /**
@@ -4277,6 +4455,165 @@ declare const PACKED_USEROP_TYPEHASH: `0x${string}`;
  * IntentGatewayV2 protocol.
  */
 declare const DOMAIN_TYPEHASH: `0x${string}`;
+/**
+ * Crypto and encoding utilities for IntentGatewayV2.
+ *
+ * Provides helpers for EIP-712 domain separation, UserOperation hashing,
+ * gas-limit packing/unpacking, bundler JSON-RPC calls, and ERC-7821
+ * batch-execute encoding and decoding. All methods are stateless with respect
+ * to the protocol but require the shared {@link IntentGatewayContext} for the
+ * bundler URL.
+ */
+declare class CryptoUtils {
+    private readonly ctx;
+    /**
+     * @param ctx - Shared IntentsV2 context; used to access the bundler URL for
+     *   JSON-RPC calls.
+     */
+    constructor(ctx: IntentGatewayContext);
+    /**
+     * Computes an EIP-712 domain separator for a given contract.
+     *
+     * @param contractName - Human-readable name of the contract (e.g. `"IntentGateway"`).
+     * @param version - Version string (e.g. `"2"`).
+     * @param chainId - Chain ID of the network the contract is deployed on.
+     * @param contractAddress - Address of the verifying contract.
+     * @returns The 32-byte domain separator as a hex string.
+     */
+    static getDomainSeparator(contractName: string, version: string, chainId: bigint, contractAddress: HexString): HexString;
+    /**
+     * Signs a `SelectSolver` EIP-712 message with a session key.
+     *
+     * The session key authorises the selection of a specific solver for the
+     * given order commitment. The resulting signature is appended to the
+     * solver's UserOperation signature before bundle submission.
+     *
+     * @param commitment - The order commitment (bytes32) being fulfilled.
+     * @param solverAddress - Address of the solver account selected to fill the order.
+     * @param domainSeparator - EIP-712 domain separator for the IntentGatewayV2 contract.
+     * @param privateKey - Hex-encoded private key of the session key that signs the message.
+     * @returns The ECDSA signature as a hex string, or `null` if signing fails.
+     */
+    static signSolverSelection(commitment: HexString, solverAddress: HexString, domainSeparator: HexString, privateKey: HexString): Promise<HexString | null>;
+    /**
+     * Computes the EIP-712 hash of a `PackedUserOperation` as defined by
+     * ERC-4337 EntryPoint v0.8.
+     *
+     * @param userOp - The packed UserOperation to hash.
+     * @param entryPoint - Address of the EntryPoint v0.8 contract.
+     * @param chainId - Chain ID of the network on which the operation will execute.
+     * @returns The UserOperation hash as a hex string.
+     */
+    static computeUserOpHash(userOp: PackedUserOperation, entryPoint: Hex, chainId: bigint): Hex;
+    /**
+     * Computes the EIP-712 struct hash of a `PackedUserOperation`.
+     *
+     * Hashes dynamic fields (`initCode`, `callData`, `paymasterAndData`) before
+     * ABI-encoding so the final hash is a fixed-length 32-byte value.
+     *
+     * @param userOp - The packed UserOperation to hash.
+     * @returns The struct hash as a 32-byte hex string.
+     */
+    static getPackedUserStructHash(userOp: PackedUserOperation): HexString;
+    /**
+     * Packs `verificationGasLimit` and `callGasLimit` into the ERC-4337
+     * `accountGasLimits` bytes32 field.
+     *
+     * The high 16 bytes hold `verificationGasLimit` and the low 16 bytes hold
+     * `callGasLimit`, matching the EntryPoint v0.8 packed representation.
+     *
+     * @param verificationGasLimit - Gas limit for the account verification step.
+     * @param callGasLimit - Gas limit for the main execution call.
+     * @returns A 32-byte hex string with both limits packed.
+     */
+    static packGasLimits(verificationGasLimit: bigint, callGasLimit: bigint): HexString;
+    /**
+     * Packs `maxPriorityFeePerGas` and `maxFeePerGas` into the ERC-4337
+     * `gasFees` bytes32 field.
+     *
+     * The high 16 bytes hold `maxPriorityFeePerGas` and the low 16 bytes hold
+     * `maxFeePerGas`, matching the EntryPoint v0.8 packed representation.
+     *
+     * @param maxPriorityFeePerGas - Maximum tip per gas (EIP-1559).
+     * @param maxFeePerGas - Maximum total fee per gas (EIP-1559).
+     * @returns A 32-byte hex string with both fee values packed.
+     */
+    static packGasFees(maxPriorityFeePerGas: bigint, maxFeePerGas: bigint): HexString;
+    /**
+     * Unpacks the `accountGasLimits` bytes32 field back into its constituent
+     * gas limits.
+     *
+     * @param accountGasLimits - The packed 32-byte gas limits field from a `PackedUserOperation`.
+     * @returns Object with `verificationGasLimit` and `callGasLimit` as bigints.
+     */
+    static unpackGasLimits(accountGasLimits: HexString): {
+        verificationGasLimit: bigint;
+        callGasLimit: bigint;
+    };
+    /**
+     * Unpacks the `gasFees` bytes32 field back into its constituent fee values.
+     *
+     * @param gasFees - The packed 32-byte gas fees field from a `PackedUserOperation`.
+     * @returns Object with `maxPriorityFeePerGas` and `maxFeePerGas` as bigints.
+     */
+    static unpackGasFees(gasFees: HexString): {
+        maxPriorityFeePerGas: bigint;
+        maxFeePerGas: bigint;
+    };
+    /**
+     * Converts a packed `PackedUserOperation` into the JSON object format
+     * expected by ERC-4337 bundler JSON-RPC endpoints.
+     *
+     * Unpacks `accountGasLimits` and `gasFees`, separates optional factory and
+     * paymaster fields, and converts all numeric fields to hex strings.
+     *
+     * @param userOp - The packed UserOperation to convert.
+     * @returns A plain object safe to pass as the first element of bundler RPC params.
+     */
+    static prepareBundlerCall(userOp: PackedUserOperation): Record<string, unknown>;
+    /**
+     * Sends a JSON-RPC request to the configured ERC-4337 bundler endpoint.
+     *
+     * @param method - The JSON-RPC method name (one of {@link BundlerMethod}).
+     * @param params - Array of parameters for the RPC call.
+     * @returns Resolves with the `result` field of the bundler's JSON-RPC response,
+     *   typed as `T`.
+     * @throws If the bundler URL is not configured or the bundler returns an error.
+     */
+    sendBundler<T = unknown>(method: BundlerMethod, params?: unknown[]): Promise<T>;
+    /**
+     * Sends multiple JSON-RPC requests to the bundler in a single HTTP call
+     * using JSON-RPC 2.0 batch syntax.  Results are returned in the same order
+     * as the input `requests` array.
+     *
+     * @throws If the bundler URL is not configured, the HTTP call fails, or any
+     *   individual response contains an error.
+     */
+    sendBundlerBatch<T extends unknown[]>(requests: {
+        method: BundlerMethod;
+        params: unknown[];
+    }[]): Promise<T>;
+    /**
+     * Encodes a list of calls into ERC-7821 `execute` calldata using
+     * single-batch mode (`ERC7821_BATCH_MODE`).
+     *
+     * @param calls - Ordered list of calls to batch; each specifies a `target`
+     *   address, ETH `value`, and `data`.
+     * @returns ABI-encoded calldata for the ERC-7821 `execute(bytes32,bytes)` function.
+     */
+    encodeERC7821Execute(calls: ERC7821Call[]): HexString;
+    /**
+     * Decodes ERC-7821 `execute` calldata back into its constituent calls.
+     *
+     * Returns `null` if the calldata does not match the expected `execute`
+     * function signature or cannot be decoded.
+     *
+     * @param callData - Hex-encoded calldata previously produced by
+     *   {@link encodeERC7821Execute} or an equivalent encoder.
+     * @returns Array of decoded {@link ERC7821Call} objects, or `null` on failure.
+     */
+    decodeERC7821Execute(callData: HexString): ERC7821Call[] | null;
+}
 
 declare const ABI$1: readonly [{
     readonly type: "constructor";
@@ -7787,6 +8124,41 @@ declare class TokenGateway {
      * @private
      */
     private convertNativeToFeeToken;
+    /**
+     * Optional indexer context for {@link queryAssetTeleported} /
+     * {@link assetTeleportedStatusStream}. Configured via {@link withQueryClient}.
+     */
+    private indexer?;
+    /**
+     * Attaches an indexer GraphQL client so {@link queryAssetTeleported} and
+     * {@link assetTeleportedStatusStream} become available. Returns `this` for chaining.
+     */
+    withQueryClient(queryClient: IndexerQueryClient, options?: {
+        pollInterval?: number;
+        tracing?: boolean;
+    }): this;
+    private requireIndexer;
+    /**
+     * Queries a token gateway asset-teleported event by commitment hash.
+     *
+     * Requires a prior call to {@link withQueryClient}.
+     */
+    queryAssetTeleported(commitment: HexString): Promise<TokenGatewayAssetTeleportedWithStatus | undefined>;
+    /**
+     * Streams status updates for an asset-teleported event until a terminal
+     * state (`RECEIVED` or `REFUNDED`).
+     *
+     * Requires a prior call to {@link withQueryClient}.
+     */
+    assetTeleportedStatusStream(commitment: HexString): AsyncGenerator<{
+        status: TeleportStatus;
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp: bigint;
+        };
+    }, void>;
 }
 
 /**
@@ -8006,7 +8378,9 @@ declare enum Chains {
     POLYGON_AMOY = "EVM-80002",
     POLKADOT_ASSET_HUB_PASEO = "EVM-420420417",
     TRON_MAINNET = "EVM-728126428",
-    TRON_NILE = "EVM-3448148188"
+    TRON_NILE = "EVM-3448148188",
+    PHAROS_MAINNET = "EVM-688600",
+    PHAROS_ATLANTIC = "EVM-688689"
 }
 /** Polkadot Asset Hub Paseo testnet (chain ID 420420417) — not in viem/chains */
 declare const polkadotAssetHubPaseo: {
@@ -8056,6 +8430,114 @@ declare const polkadotAssetHubPaseo: {
     serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
     verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
 };
+/** Pharos Mainnet (chain ID 688600) — not in viem/chains */
+declare const pharosMainnet: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 688600;
+    name: "Pharos Mainnet";
+    nativeCurrency: {
+        readonly name: "PHRS";
+        readonly symbol: "PHRS";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://atlantic.dplabs-internal.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
+/** Pharos Atlantic Testnet (chain ID 688689) — not in viem/chains */
+declare const pharosAtlantic: {
+    blockExplorers?: {
+        [key: string]: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+        default: {
+            name: string;
+            url: string;
+            apiUrl?: string | undefined;
+        };
+    } | undefined | undefined;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 688689;
+    name: "Pharos Atlantic Testnet";
+    nativeCurrency: {
+        readonly name: "PHRS";
+        readonly symbol: "PHRS";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://atlantic.dplabs-internal.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
 /** Tron Nile Testnet (chain ID 3448148188) — not in viem/chains */
 declare const tronNile: {
     blockExplorers: {
@@ -8169,8 +8651,8 @@ interface ChainConfigData {
         UniswapV4PoolManager?: `0x${string}`;
         /** Uniswap V4 StateView (canonical CREATE2 address) for pool state reads via extsload */
         UniswapV4StateView?: `0x${string}`;
-        /** Circle Paymaster v0.8 contract address (ERC-4337 onchain USDC paymaster) */
-        CirclePaymasterV08?: `0x${string}`;
+        /** Circle Paymaster contract address (USDC-based ERC-4337 paymaster) */
+        CirclePaymaster?: `0x${string}`;
     };
     rpcEnvKey?: string;
     defaultRpcUrl?: string;
@@ -8186,4 +8668,4 @@ declare const getChainId: (stateMachineId: string) => number | undefined;
 declare const getViemChain: (chainId: number) => Chain | undefined;
 declare const hyperbridgeAddress = "";
 
-export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BundlerGasEstimate, BundlerMethod, type CancelEvent, type CancelOptions, type CancelQuote, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type DispatchGet, type DispatchInfo, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, 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, type HostParams, HyperClientStatus, type HyperbridgeTxEvents, type IChain, type IConfig, type IEvmChain, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, type IPolkadotHubConfig, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, IndexerClient, type IndexerQueryClient, IntentGateway, type IntentGatewayContext, type IntentGatewayParams, ABI$1 as IntentGatewayV2ABI, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, IntentsCoprocessor, type IsmpRequest, MOCK_ADDRESS, type NewDeployment, ORDER_V2_PARAM_TYPE, type Order, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, PolkadotHubChain, type PolkadotHubChainParams, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, type QuoteNativeResult, 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 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 XcmGatewayParams, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, orderCommitment, parseStateMachineId, polkadotAssetHubPaseo, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };
+export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BundlerGasEstimate, BundlerMethod, type CancelEvent, type CancelOptions, type CancelQuote, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, CryptoUtils, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type DispatchGet, type DispatchInfo, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, 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, type HostParams, HyperClientStatus, 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, type IntentGatewayContext, type IntentGatewayParams, ABI$1 as IntentGatewayV2ABI, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusUpdate, IntentsCoprocessor, IsmpClient, type IsmpRequest, MOCK_ADDRESS, type NewDeployment, ORDER_V2_PARAM_TYPE, type Order, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, PharosChain, type PharosChainParams, PolkadotHubChain, type PolkadotHubChainParams, type PostRequestStatus, type PostRequestTimeoutStatus, type PostRequestWithStatus, type QuoteNativeResult, 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 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 XcmGatewayParams, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };