@hyperbridge/sdk 1.9.6 → 2.0.1

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;
 }>;
@@ -989,6 +1055,14 @@ declare function postRequestCommitment(post: IPostRequest): {
 declare function bytes32ToBytes20(bytes32Address: string): HexString;
 declare function bytes20ToBytes32(bytes20Address: string): HexString;
 declare function hexToString(hex: string): string;
+declare function normalizeStateMachineId(stateMachineId: string): string;
+declare function normalizeEvmChainId(chainId: number | string): {
+    chainId: number;
+    stateMachineId: string;
+};
+declare function encodeStateMachineId(stateMachineId: string): HexString;
+declare function normalizeAddressForEvmBytes32(address: string): HexString;
+declare function normalizeAddressForStateMachine(address: string, stateMachineId: string): HexString;
 /**
  * Retries a promise-returning operation with exponential backoff.
  * This function will attempt to execute the operation up to maxRetries times,
@@ -1264,10 +1338,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;
 }
 /**
@@ -1704,7 +1789,11 @@ declare class PharosChain implements IChain {
 /**
  * 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.
@@ -1787,6 +1876,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.
@@ -1863,6 +1966,8 @@ interface IEvmChain extends IChain {
 
 type EstimateGasCallData = ContractFunctionArgs<typeof _default.ABI, "nonpayable" | "payable", "handlePostRequests">;
 type HexString = `0x${string}`;
+type StateMachineId = string;
+type BytesLikeHex = HexString;
 interface IConfig {
     source: IEvmConfig | ISubstrateConfig | IPolkadotHubConfig | IPharosConfig;
     dest: IEvmConfig | ISubstrateConfig | IPolkadotHubConfig | IPharosConfig;
@@ -2317,10 +2422,13 @@ interface ChainConfig {
  */
 interface TokenInfo {
     /**
-     * The address of the ERC20 token
-     * address(0) is used as a sentinel for the native token
+     * The token identifier as either:
+     * - a standard 20-byte EVM address (`0xabc...`)
+     * - an already padded 32-byte value (`0x000...abc...`)
+     *
+     * `address(0)` / `bytes32(0)` is used as a sentinel for the native token.
      */
-    token: HexString;
+    token: BytesLikeHex;
     /**
      * The amount of the token
      */
@@ -2839,7 +2947,8 @@ interface StorageFacade {
     delete(key: string): Promise<void>;
 }
 interface PaymentInfo {
-    beneficiary: HexString;
+    /** Accepts a standard 20-byte address; the SDK pads to bytes32 internally when needed. */
+    beneficiary: BytesLikeHex;
     assets: TokenInfo[];
     call: HexString;
 }
@@ -2850,8 +2959,10 @@ interface DispatchInfo {
 interface Order {
     id?: string;
     user: HexString;
-    source: HexString;
-    destination: HexString;
+    /** Accepts either `"EVM-1"` style IDs or their hex-encoded form. */
+    source: StateMachineId;
+    /** Accepts either `"EVM-42161"` style IDs or their hex-encoded form. */
+    destination: StateMachineId;
     deadline: bigint;
     nonce: bigint;
     fees: bigint;
@@ -2860,6 +2971,10 @@ interface Order {
     inputs: TokenInfo[];
     output: PaymentInfo;
 }
+interface CancelOrderOptions {
+    /** Where to initiate the cancel from. Defaults to `"source"`. */
+    from?: "source" | "destination";
+}
 interface FillOptions {
     relayerFee: bigint;
     nativeDispatchFee: bigint;
@@ -2886,7 +3001,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>;
@@ -2939,9 +3054,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;
@@ -3131,101 +3246,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;
@@ -3234,10 +3264,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;
@@ -3245,271 +3271,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 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
+     * Enhances a GET request with finality events (`SOURCE_FINALIZED`,
+     * `HYPERBRIDGE_FINALIZED`).
      */
-    private addRequestFinalityEvents;
+    addGetRequestFinalityEvents(request: GetRequestWithStatus): Promise<GetRequestWithStatus>;
     /**
-     * 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
-     *
-     * 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
+     * Snapshot query with all inferred finality events sorted.
      */
-    private addTimeoutFinalityEvents;
+    queryGetRequestWithStatus(hash: HexString): Promise<GetRequestWithStatus | 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
+     * Streaming status updates for a GET request. Ends when the request reaches
+     * the destination or a timeout becomes pending.
      */
-    queryRequestWithStatus(hash: HexString): Promise<PostRequestWithStatus | undefined>;
+    getRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    private streamInternal;
     /**
-     * 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
+     * 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.
      */
-    queryGetRequestWithStatus(hash: HexString): Promise<GetRequestWithStatus | undefined>;
+    private buildFinalized;
     /**
-     * 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
+     * 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 addGetRequestFinalityEvents;
+    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);
     /**
-     * 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)
-     * }
-     *
+     * Enhances a request with finality events by querying state machine updates.
+     * Adds `SOURCE_FINALIZED` and `HYPERBRIDGE_FINALIZED` when applicable.
      */
-    postRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
-    timeoutStream(timeoutTimestamp: bigint, chain: IChain): AsyncGenerator<RequestStatusWithMetadata, void>;
+    addRequestFinalityEvents(request: PostRequestWithStatus): Promise<PostRequestWithStatus>;
     /**
-     * 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
+     * Snapshot query: request + all inferred finality/timeout events, sorted.
      */
-    private postRequestStatusStreamInternal;
-    private sleep_for;
-    private sleep_for_interval;
+    queryRequestWithStatus(hash: HexString): Promise<PostRequestWithStatus | 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)
-     * }
-     *
-     * // you can also use a while loop
-     * while (true) {
-     *   const status = await stream.next()
-     *   if (status.done) {
-     *     break
-     *   }
-     *   console.log(status.value)
-     * }
-     *
+     * Streaming status updates for a post request. Ends when the request reaches
+     * the destination or a timeout becomes pending.
      */
-    getRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    postRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    private streamStatusInternal;
     /**
-     * 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
+     * Populates timeout-related status events (`PENDING_TIMEOUT`,
+     * `DESTINATION_FINALIZED_TIMEOUT`, `HYPERBRIDGE_FINALIZED_TIMEOUT`) and the
+     * accompanying timeout-proof calldata.
      */
-    private getRequestStatusStreamInternal;
+    addTimeoutFinalityEvents(request: PostRequestWithStatus): Promise<PostRequestWithStatus>;
     /**
-     * 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)
-     *
-     * // 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)
-     * }
+     * Streaming status updates for a timed-out post request.
      */
     postRequestTimeoutStream(hash: HexString): AsyncGenerator<PostRequestTimeoutStatus, void>;
+    private streamTimeoutInternal;
     /**
-     * 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
+     * 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.
      */
-    postRequestTimeoutStreamInternal(hash: HexString, signal: AbortSignal): AsyncGenerator<PostRequestTimeoutStatus, void>;
+    private buildFinalized;
     /**
-     * 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));
+     * 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 withRetry;
+    private streamFinalized;
     /**
-     * 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
+     * Retry-wrapped `hyperbridge.queryProof`. Fails after 6 retries (~2 minutes at
+     * 2s backoff) so a hung Hyperbridge node doesn't stall the stream forever.
      */
-    queryOrder(commitment: HexString): Promise<OrderWithStatus | undefined>;
+    private fetchProofWithRetry;
     /**
-     * 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
+     * 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;
+    /**
+     * Query for the first state machine update at or after `height` for the given
+     * state machine on the indicated counterparty chain.
      *
-     * let client = new IndexerClient(config)
-     * let stream = client.orderStatusStream(commitment)
+     * @returns The matching update, or `undefined` if none has been indexed yet.
+     */
+    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>;
+    /**
+     * 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.
+     */
+    queryStateMachineUpdateByTimestamp(args: {
+        statemachineId: string;
+        commitmentTimestamp: bigint;
+        chain: string;
+    }): Promise<StateMachineUpdate | undefined>;
+    /**
+     * Returns the latest known state machine height for a given state machine,
+     * or `undefined` if the indexer has no record yet.
+     */
+    queryLatestStateMachineHeight(args: {
+        statemachineId: string;
+        chain: string;
+    }): Promise<bigint | undefined>;
+    /**
+     * 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.
+     */
+    queryPostRequest(commitmentHash: HexString): Promise<PostRequestWithStatus | undefined>;
+    /**
+     * Queries a GET request by any of its associated hashes. Returns the raw
+     * indexed record without derived finality events.
+     */
+    queryGetRequest(hash: HexString): Promise<GetRequestWithStatus | undefined>;
+    /**
+     * Queries the response a GET request's values come from, by the request's id.
+     * Returns the response commitment plus the indexed storage values.
+     */
+    queryResponseByRequestId(requestId: string): Promise<ResponseCommitmentWithValues | undefined>;
+    /**
+     * 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 use a for-await-of loop
-     * for await (const status of stream) {
-     *   console.log(status)
-     * }
+     * Unlike {@link postRequestStatusStream} this does not poll; each call
+     * returns a fresh snapshot based on the indexer's current state.
+     */
+    queryRequestWithStatus(hash: HexString): Promise<PostRequestWithStatus | undefined>;
+    /**
+     * 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 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`).
      */
-    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;
+    postRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    /**
+     * 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.
+     */
+    postRequestTimeoutStream(hash: HexString): AsyncGenerator<PostRequestTimeoutStatus, void>;
     /**
-     * Aggregate transactions with commitment.
-     * @param commitment
-     * @returns an object containing the transaction hash, block hash, block number, timestamp.
+     * 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.
      */
     aggregateTransactionWithCommitment(commitment: HexString): Promise<Awaited<ReturnType<SubstrateChain["submitUnsigned"]>>>;
-    waitOrAbort<T>(params: {
-        signal: AbortSignal;
-        promise: () => Promise<T>;
-        predicate?: (a: T) => boolean;
-    }): Promise<NonNullable<T>>;
+    /**
+     * Snapshot query for a GET request: returns the indexed record with all
+     * inferred finality events (`SOURCE_FINALIZED`, `HYPERBRIDGE_FINALIZED`)
+     * sorted by progress weight.
+     */
+    queryGetRequestWithStatus(hash: HexString): Promise<GetRequestWithStatus | undefined>;
+    /**
+     * 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`).
+     */
+    getRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    /**
+     * 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.
+     */
+    timeoutStream(timeoutTimestamp: bigint, chain: IChain): AsyncGenerator<RequestStatusWithMetadata, void>;
 }
 interface PartialClientConfig extends Omit<ClientConfig, "pollInterval"> {
     pollInterval?: number;
@@ -3560,9 +3618,89 @@ declare function queryGetRequest(params: {
     queryClient: IndexerQueryClient;
 }): Promise<GetRequestWithStatus | undefined>;
 
+type UniswapProtocol = "v2" | "v3" | "v4";
+type UniswapTradeType = "EXACT_INPUT" | "EXACT_OUTPUT";
+/**
+ * Token metadata required for Uniswap quoting.
+ */
+interface UniswapQuoteToken {
+    /** Token contract address. Use ADDRESS_ZERO for the native asset. */
+    address: HexString;
+    /** Token decimals used by the integrating app when formatting quote amounts. */
+    decimals: number;
+    /** Optional display symbol, returned unchanged in quote responses. */
+    symbol?: string;
+    /** EVM chain ID where this token exists. */
+    chainId: number;
+}
+/**
+ * Parameters for quoting a Uniswap swap through the SDK.
+ *
+ * Provide `amountIn` when `tradeType` is `EXACT_INPUT`, or `amountOut` when
+ * `tradeType` is `EXACT_OUTPUT`. RPC clients are derived from SDK chain config.
+ */
+interface QuoteUniswapParams {
+    /** Numeric EVM chain ID or state machine ID, for example `8453` or `EVM-8453`. */
+    chainId: number | string;
+    /** Token the user pays with. */
+    tokenIn: UniswapQuoteToken;
+    /** Token the user receives. */
+    tokenOut: UniswapQuoteToken;
+    /** Exact input amount, required for `EXACT_INPUT`. */
+    amountIn?: bigint;
+    /** Exact output amount, required for `EXACT_OUTPUT`. */
+    amountOut?: bigint;
+    /** Whether to quote by fixed input or fixed output. */
+    tradeType: UniswapTradeType;
+    /** Protocols to check. Defaults to all supported protocols: v2, v3, and v4. */
+    protocols?: UniswapProtocol[];
+    /** Slippage tolerance in basis points, only used when `recipient` is provided. */
+    slippageBps?: number;
+    /** Optional recipient. When set, executable transaction calldata is included. */
+    recipient?: HexString;
+}
+/**
+ * Normalized quote returned by every Uniswap protocol adapter.
+ */
+interface UniswapQuote {
+    /** Protocol that produced this quote. */
+    protocol: UniswapProtocol;
+    /** Quote direction used to calculate the amounts. */
+    tradeType: UniswapTradeType;
+    /** Numeric EVM chain ID. */
+    chainId: number;
+    /** Token the user pays with. */
+    tokenIn: UniswapQuoteToken;
+    /** Token the user receives. */
+    tokenOut: UniswapQuoteToken;
+    /** Input amount required for this quote. */
+    amountIn: bigint;
+    /** Output amount returned by this quote. */
+    amountOut: bigint;
+    /** Winning fee tier for concentrated-liquidity protocols. */
+    fee?: number;
+    /** Token path used by the quote. */
+    route: {
+        tokens: HexString[];
+    };
+    /** Executable transactions, included only when `recipient` is supplied. */
+    transactions?: Transaction[];
+}
+/**
+ * Quote result containing the best quote and all successful protocol candidates.
+ */
+interface QuoteUniswapResult {
+    /** Best quote by highest output for exact input, or lowest input for exact output. */
+    bestQuote: UniswapQuote | null;
+    /** All successful protocol quotes considered by the SDK. */
+    quotes: UniswapQuote[];
+}
+
 declare class Swap {
     private chainConfigService;
+    private uniswapQuoteEngine;
     constructor();
+    quoteUniswap(params: QuoteUniswapParams): Promise<QuoteUniswapResult>;
     /**
      * Gets V2 quote for exact output swap.
      */
@@ -3712,6 +3850,7 @@ declare class Swap {
      */
     private getTickSpacing;
 }
+declare function quoteUniswap(params: QuoteUniswapParams): Promise<QuoteUniswapResult>;
 
 type StorageDriverKey = "node" | "localstorage" | "indexeddb" | "memory";
 interface CancellationStorageOptions {
@@ -4157,11 +4296,13 @@ declare class IntentGateway {
      * Delegates to {@link OrderCanceller.quoteCancelOrder}.
      *
      * @param order - The order to quote cancellation for.
-     * @param fromDest - If `true`, quotes the destination-initiated cancellation fee.
+     * @param options - Choose the initiation side. Defaults to source-side cancellation.
      * @returns `{ nativeValue }` — native token amount (wei) to send as `value`;
      *   `{ relayerFee }` — relayer incentive denominated in the chain's fee token.
      */
-    quoteCancelOrder(order: Order, fromDest?: boolean): Promise<CancelQuote>;
+    quoteCancelOrder(order: Order, options?: CancelOrderOptions): Promise<CancelQuote>;
+    quoteCancelOrderFromSource(order: Order): Promise<CancelQuote>;
+    quoteCancelOrderFromDest(order: Order): Promise<CancelQuote>;
     /**
      * Async generator that cancels an order and streams status events until
      * cancellation is complete.
@@ -4170,11 +4311,12 @@ declare class IntentGateway {
      *
      * @param order - The order to cancel.
      * @param indexerClient - Indexer client used for ISMP request status streaming.
-     * @param fromDest - If `true`, initiates cancellation from the destination chain.
-     *   Defaults to `false` (source-side cancellation).
+     * @param options - Choose the initiation side. Defaults to 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, options?: CancelOrderOptions): AsyncGenerator<CancelEvent>;
+    cancelOrderFromSource(order: Order, indexerClient: IsmpClient): AsyncGenerator<CancelEvent>;
+    cancelOrderFromDest(order: Order, indexerClient: IsmpClient): AsyncGenerator<CancelEvent>;
     /**
      * Constructs a signed `PackedUserOperation` for a solver to submit as a bid.
      *
@@ -4250,6 +4392,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>;
 }
 
 /**
@@ -4289,6 +4475,10 @@ declare class OrderStatusChecker {
     isOrderRefunded(order: Order): Promise<boolean>;
 }
 
+type ContractOrder = Omit<Order, "id" | "source" | "destination"> & {
+    source: HexString;
+    destination: HexString;
+};
 /**
  * Encodes a list of calls into ERC-7821 `execute` function calldata using
  * single-batch mode.
@@ -4327,8 +4517,8 @@ declare function fetchSourceProof(commitment: HexString, source: IEvmChain, sour
  * - `id` is removed (not part of the on-chain struct).
  * - `source` and `destination` are hex-encoded if currently plain string
  *   state-machine IDs.
- * - `inputs[i].token`, `output.beneficiary`, `output.assets[i].token`, and
- *   `predispatch.assets[i].token` are left-padded from 20-byte addresses to
+ * - `user`, `inputs[i].token`, `output.beneficiary`, `output.assets[i].token`,
+ *   and `predispatch.assets[i].token` are left-padded from 20-byte addresses to
  *   32-byte values (`0x000…addr`) via {@link bytes20ToBytes32}, matching the
  *   `bytes32(uint256(uint160(addr)))` encoding the contract uses when casting
  *   these fields back to `address`. Values already at 32 bytes are unchanged.
@@ -4336,7 +4526,7 @@ declare function fetchSourceProof(commitment: HexString, source: IEvmChain, sour
  * @param order - The SDK-level order to transform.
  * @returns A contract-compatible order struct without `id`.
  */
-declare function transformOrderForContract(order: Order): Omit<Order, "id">;
+declare function transformOrderForContract(order: Order): ContractOrder;
 /**
  * Calculates the commitment hash for an order by ABI-encoding the
  * contract-normalised form of the order and hashing it.
@@ -4373,6 +4563,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";
@@ -7786,7 +8135,7 @@ interface TeleportParams {
     assetId: HexString;
     /** Redeem ERC20 on the destination? */
     redeem: boolean;
-    /** Recipient address */
+    /** Recipient address. For EVM destinations, plain 20-byte addresses are accepted and padded internally. */
     to: HexString;
     /** Recipient state machine */
     dest: string | Uint8Array;
@@ -7883,6 +8232,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>;
 }
 
 /**
@@ -8375,8 +8759,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;
@@ -8392,4 +8776,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 IPharosConfig, 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, 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 };
+export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BundlerGasEstimate, BundlerMethod, type BytesLikeHex, type CancelEvent, type CancelOptions, type CancelOrderOptions, 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, 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 XcmGatewayParams, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateAllowanceMappingLocation, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, constructRefundEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createEvmChain, createQueryClient, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeStateMachineId, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChainId, getConfigByStateMachineId, getContractCallInput, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, normalizeAddressForEvmBytes32, normalizeAddressForStateMachine, normalizeEvmChainId, normalizeStateMachineId, orderCommitment, parseStateMachineId, pharosAtlantic, pharosMainnet, polkadotAssetHubPaseo, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, quoteUniswap, requestCommitmentKey, responseCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };