@hyperbridge/sdk 1.6.2 → 1.6.3

package/dist/browser/index.d.ts

@@ -1,12 +1,14 @@
 import { ConsolaInstance } from 'consola';
 import { GraphQLClient } from 'graphql-request';
 import * as viem from 'viem';
-import { PublicClient, Hex, Log, ContractFunctionArgs } from 'viem';
+import { PublicClient, TransactionReceipt, Hex, Log, ContractFunctionArgs } from 'viem';
 import { ApiPromise } from '@polkadot/api';
 import { KeyringPair } from '@polkadot/keyring/types';
+import * as unstorage from 'unstorage';
 import { SignerOptions, SubmittableExtrinsic } from '@polkadot/api/types';
 import { ISubmittableResult } from '@polkadot/types/types';
 import { Chain } from 'viem/chains';
+import { TronWeb } from 'tronweb';
 
 declare const _default: {
     ABI: readonly [{
@@ -588,263 +590,6 @@ declare const _default: {
     }];
 };
 
-declare class ChainConfigService {
-    private rpcUrls;
-    constructor(env?: NodeJS.ProcessEnv);
-    private getConfig;
-    getChainConfig(chain: string): ChainConfig;
-    getIntentGatewayAddress(chain: string): HexString;
-    getTokenGatewayAddress(chain: string): HexString;
-    getHostAddress(chain: string): HexString;
-    getWrappedNativeAssetWithDecimals(chain: string): {
-        asset: HexString;
-        decimals: number;
-    };
-    getDaiAsset(chain: string): HexString;
-    getUsdtAsset(chain: string): HexString;
-    getUsdcAsset(chain: string): HexString;
-    getUsdcDecimals(chain: string): number;
-    getUsdtDecimals(chain: string): number;
-    getChainId(chain: string): number;
-    getConsensusStateId(chain: string): HexString;
-    getHyperbridgeChainId(): number;
-    getRpcUrl(chain: string): string;
-    getUniswapRouterV2Address(chain: string): HexString;
-    getUniswapV2FactoryAddress(chain: string): HexString;
-    getUniswapV3FactoryAddress(chain: string): HexString;
-    getUniversalRouterAddress(chain: string): HexString;
-    getUniswapV3QuoterAddress(chain: string): HexString;
-    getUniswapV4QuoterAddress(chain: string): HexString;
-    getPermit2Address(chain: string): HexString;
-    getCoingeckoId(chain: string): string | undefined;
-    getEtherscanApiKey(): string | undefined;
-    getCalldispatcherAddress(chain: string): HexString;
-    getTokenStorageSlots(chain: string, tokenAddress: string): {
-        balanceSlot: number;
-        allowanceSlot: number;
-    } | undefined;
-    getPopularTokens(chain: string): string[];
-    getIntentGatewayV2Address(chain: string): HexString;
-    getEntryPointV08Address(chain: string): HexString;
-    getHyperbridgeAddress(): string;
-    /**
-     * Get the LayerZero Endpoint ID for the chain
-     * Used for USDT0 cross-chain transfers via LayerZero OFT
-     */
-    getLayerZeroEid(chain: string): number | undefined;
-    /**
-     * Get the USDT0 OFT contract address for the chain
-     * On Ethereum: OFT Adapter (locks/unlocks USDT)
-     * On other chains: OFT contract (mints/burns USDT0)
-     */
-    getUsdt0OftAddress(chain: string): HexString | undefined;
-}
-
-/**
- * The default address used as fallback when no address is provided.
- * This represents the zero address in EVM chains.
- */
-declare const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
-/**
- * Parameters for an EVM chain.
- */
-interface EvmChainParams {
-    /**
-     * The chain ID of the EVM chain
-     */
-    chainId: number;
-    /**
-     * The RPC URL of the EVM chain
-     */
-    rpcUrl: string;
-    /**
-     * The host address of the EVM chain (IsmpHost contract address)
-     */
-    host: HexString;
-    /**
-     * Consensus state identifier of this chain on hyperbridge
-     */
-    consensusStateId?: string;
-}
-/**
- * Encapsulates an EVM chain.
- */
-declare class EvmChain implements IChain {
-    private readonly params;
-    private publicClient;
-    private chainConfigService;
-    constructor(params: EvmChainParams);
-    get client(): PublicClient;
-    get host(): HexString;
-    get config(): IEvmConfig;
-    get configService(): ChainConfigService;
-    /**
-     * Derives the key for the request receipt.
-     * @param {HexString} commitment - The commitment to derive the key from.
-     * @returns {HexString} The derived key.
-     */
-    requestReceiptKey(commitment: HexString): HexString;
-    /**
-     * Queries the request receipt.
-     * @param {HexString} commitment - The commitment to query.
-     * @returns {Promise<HexString | undefined>} The relayer address responsible for delivering the request.
-     */
-    queryRequestReceipt(commitment: HexString): Promise<HexString | undefined>;
-    /**
-     * Queries the proof of the commitments.
-     * @param {IMessage} message - The message to query.
-     * @param {string} counterparty - The counterparty address.
-     * @param {bigint} [at] - The block number to query at.
-     * @returns {Promise<HexString>} The proof.
-     */
-    queryProof(message: IMessage, counterparty: string, at?: bigint): Promise<HexString>;
-    /**
-     * Query and return the encoded storage proof for the provided keys at the given height.
-     * @param {bigint} at - The block height at which to query the storage proof.
-     * @param {HexString[]} keys - The keys for which to query the storage proof.
-     * @param {HexString} address - Optional contract address to fetch storage proof else default to host contract
-     * @returns {Promise<HexString>} The encoded storage proof.
-     */
-    queryStateProof(at: bigint, keys: HexString[], address?: HexString): Promise<HexString>;
-    /**
-     * Returns the current timestamp of the chain.
-     * @returns {Promise<bigint>} The current timestamp.
-     */
-    timestamp(): Promise<bigint>;
-    /**
-     * Get the latest state machine height for a given state machine ID.
-     * @param {StateMachineIdParams} stateMachineId - The state machine ID.
-     * @returns {Promise<bigint>} The latest state machine height.
-     */
-    latestStateMachineHeight(stateMachineId: StateMachineIdParams): Promise<bigint>;
-    /**
-     * Get the state machine update time for a given state machine height.
-     * @param {StateMachineHeight} stateMachineHeight - The state machine height.
-     * @returns {Promise<bigint>} The statemachine update time in seconds.
-     */
-    stateMachineUpdateTime(stateMachineHeight: StateMachineHeight): Promise<bigint>;
-    /**
-     * Get the challenge period for a given state machine id.
-     * @param {StateMachineIdParams} stateMachineId - The state machine ID.
-     * @returns {Promise<bigint>} The challenge period in seconds.
-     */
-    challengePeriod(stateMachineId: StateMachineIdParams): Promise<bigint>;
-    /**
-     * Encodes an ISMP message for the EVM chain.
-     * @param {IIsmpMessage} message The ISMP message to encode.
-     * @returns {HexString} The encoded calldata.
-     */
-    encode(message: IIsmpMessage): HexString;
-    /**
-     * Calculates the fee required to send a post request to the destination chain.
-     * The fee is calculated based on the per-byte fee for the destination chain
-     * multiplied by the size of the request body.
-     *
-     * @param request - The post request to calculate the fee for
-     * @returns The total fee in wei required to send the post request
-     */
-    quote(request: IPostRequest | IGetRequest): Promise<bigint>;
-    quoteNative(request: IPostRequest | IGetRequest, fee: bigint): Promise<bigint>;
-    private getAmountsIn;
-    /**
-     * Estimates the gas required for a post request execution on this chain.
-     * This function generates mock proofs for the post request, creates a state override
-     * with the necessary overlay root, and estimates the gas cost for executing the
-     * handlePostRequests transaction on the handler contract.
-     *
-     * @param request - The post request to estimate gas for
-     * @param paraId - The ID of the parachain (Hyperbridge) that will process the request
-     * @returns The estimated gas amount in gas units and the generated calldata
-     */
-    estimateGas(request: IPostRequest): Promise<{
-        gas: bigint;
-        postRequestCalldata: HexString;
-    }>;
-    /**
-     * Gets the fee token address and decimals for the chain.
-     * This function gets the fee token address and decimals for the chain.
-     *
-     * @returns The fee token address and decimals
-     */
-    getFeeTokenWithDecimals(): Promise<{
-        address: HexString;
-        decimals: number;
-    }>;
-    /**
-     * Gets the nonce of the host.
-     * This function gets the nonce of the host.
-     *
-     * @returns The nonce of the host
-     */
-    getHostNonce(): Promise<bigint>;
-}
-/**
- * Factory function for creating EVM chain instances with common defaults
- *
- * @param chainId - The EVM chain ID
- * @param host - The IsmpHost contract address
- * @param options - Optional configuration overrides
- * @returns A new EvmChain instance
- *
- * @example
- * ```typescript
- * // Create with minimal config
- * const ethChain = createEvmChain(1, "0x87ea45..", {
- *   rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"
- * })
- *
- * // Create with custom consensus state ID
- * const arbChain = createEvmChain(42161, "0x87ea42345..", {
- *   rpcUrl: "https://arb-mainnet.g.alchemy.com/v2/YOUR_KEY",
- *   consensusStateId: "ARB_CUSTOM"
- * })
- * ```
- */
-declare function createEvmChain(chainId: number, host: HexString, options: {
-    rpcUrl: string;
-    consensusStateId?: string;
-}): EvmChain;
-/**
- * Slot for storing request commitments.
- */
-declare const REQUEST_COMMITMENTS_SLOT = 0n;
-/**
- * Slot index for response commitments map
- */
-declare const RESPONSE_COMMITMENTS_SLOT = 1n;
-/**
- * Slot index for requests receipts map
- */
-declare const REQUEST_RECEIPTS_SLOT = 2n;
-/**
- * Slot index for response receipts map
- */
-declare const RESPONSE_RECEIPTS_SLOT = 3n;
-/**
- * Slot index for state commitment map
- */
-declare const STATE_COMMITMENTS_SLOT = 5n;
-declare function requestCommitmentKey(key: Hex): {
-    slot1: Hex;
-    slot2: Hex;
-};
-/**
- * Derives the storage slot for a specific field in the StateCommitment struct
- *
- * struct StateCommitment {
- *   uint256 timestamp;     // slot + 0
- *   bytes32 overlayRoot;   // slot + 1
- *   bytes32 stateRoot;     // slot + 2
- * }
- *
- * @param stateMachineId - The state machine ID
- * @param height - The block height
- * @param field - The field index in the struct (0 for timestamp, 1 for overlayRoot, 2 for stateRoot)
- * @returns The storage slot for the specific field
- */
-declare function getStateCommitmentFieldSlot(stateMachineId: bigint, height: bigint, field: 0 | 1 | 2): HexString;
-declare function getStateCommitmentSlot(stateMachineId: bigint, height: bigint): HexString;
-
 /**
  * Generates a Merkle Mountain Range (MMR) root hash and proof for a post request.
  *
@@ -970,154 +715,446 @@ declare function estimateGasForPost(params: {
     call_data: EstimateGasCallData;
 }>;
 /**
- * Constructs the request body for a redeem escrow operation.
- * This function encodes the order commitment, beneficiary address, and token inputs
- * to match the format expected by the IntentGateway contract.
+ * ABI-encodes a WithdrawalRequest (commitment + beneficiary + tokens).
+ * Used as the GET-request context for cancel-from-source, and as the inner
+ * payload (after the RequestKind prefix) for POST-based escrow operations.
+ */
+declare function encodeWithdrawalRequest(order: Order | OrderV2, beneficiary: HexString): HexString;
+/**
+ * Constructs the request body for a redeem escrow operation.
+ * This function encodes the order commitment, beneficiary address, and token inputs
+ * to match the format expected by the IntentGateway contract.
+ */
+declare function constructRedeemEscrowRequestBody(order: Order | OrderV2, beneficiary: HexString): HexString;
+/**
+ * Constructs the request body for a refund escrow operation (cancel from destination).
+ * Uses RequestKind.RefundEscrow to match the IntentGatewayV2 contract's _cancelFromDest.
+ */
+declare function constructRefundEscrowRequestBody(order: Order | OrderV2, beneficiary: HexString): HexString;
+declare function fetchPrice(identifier: string | undefined, chainId?: number, apiKey?: string): Promise<number>;
+/**
+ * Fetches the current network gas price from an Etherscan-family explorer API.
+ * Returns the ProposeGasPrice (in gwei) converted to wei as bigint.
+ */
+declare function getGasPriceFromEtherscan(chainId: string, apiKey?: string): Promise<bigint>;
+/**
+ * ERC20 method signatures used for storage slot detection
+ */
+declare enum ERC20Method {
+    /** ERC20 balanceOf(address) method signature */
+    BALANCE_OF = "0x70a08231",
+    /** ERC20 allowance(address,address) method signature */
+    ALLOWANCE = "0xdd62ed3e"
+}
+declare enum EvmLanguage {
+    Solidity = 0,
+    Vyper = 1
+}
+/**
+ * Retrieves the storage slot for a contract call using debug_traceCall
+ *
+ * This function uses the Ethereum debug API to trace contract execution and identify
+ * the storage slot accessed during the call. It's commonly used for ERC20 token state
+ * mappings like balanceOf and allowance, but can work with any contract call that
+ * performs SLOAD operations.
+ *
+ * @param client - The viem PublicClient instance connected to an RPC node with debug API enabled
+ * @param tokenAddress - The address of the contract to trace
+ * @param data - The full encoded function call data (method signature + encoded parameters)
+ * @returns The storage slot as a hex string
+ * @throws Error if the storage slot cannot be found or if debug API is not available
+ *
+ * @example
+ * ```ts
+ * import { ERC20Method, bytes20ToBytes32 } from '@hyperbridge/sdk'
+ *
+ * // Get balance storage slot for ERC20
+ * const balanceData = ERC20Method.BALANCE_OF + bytes20ToBytes32(userAddress).slice(2)
+ * const balanceSlot = await getStorageSlot(
+ *   client,
+ *   tokenAddress,
+ *   balanceData as HexString
+ * )
+ *
+ * // Get allowance storage slot for ERC20
+ * const allowanceData = ERC20Method.ALLOWANCE +
+ *   bytes20ToBytes32(ownerAddress).slice(2) +
+ *   bytes20ToBytes32(spenderAddress).slice(2)
+ * const allowanceSlot = await getStorageSlot(
+ *   client,
+ *   tokenAddress,
+ *   allowanceData as HexString
+ * )
+ * ```
+ */
+declare function getStorageSlot(client: PublicClient, contractAddress: HexString, data: HexString): Promise<string>;
+/**
+ * Returns the storage slot for an ERC20 `balanceOf` or `allowance` call,
+ * first checking the recorded slot cache and falling back to an RPC trace
+ * call via `getStorageSlot` when no cached slot is available.
+ *
+ * @param client - The viem PublicClient to use for the RPC trace fallback
+ * @param chain - The chain identifier (e.g. "EVM-1")
+ * @param contractAddress - The ERC20 token contract address
+ * @param data - The ABI-encoded call data (method selector + padded args)
+ * @returns The storage slot as a hex string, or undefined if not found
+ */
+declare function getOrFetchStorageSlot(client: PublicClient, chain: string, contractAddress: HexString, data: HexString): Promise<HexString | undefined>;
+/**
+ * Adjusts fee amounts between different decimal precisions.
+ * Handles scaling up or down based on the decimal difference.
+ *
+ * @param feeInFeeToken - The fee amount to adjust
+ * @param fromDecimals - The current decimal precision
+ * @param toDecimals - The target decimal precision
+ * @returns The adjusted fee amount with the target decimal precision
+ */
+declare function adjustDecimals(feeInFeeToken: bigint, fromDecimals: number, toDecimals: number): bigint;
+/**
+ * Chains that should prefer the Etherscan API for gas price lookup
+ */
+declare const USE_ETHERSCAN_CHAINS: Set<string>;
+/**
+ * Testnet chains
+ */
+declare const TESTNET_CHAINS: Set<string>;
+/**
+ * Retrieves the calldata used to call a target contract within a transaction using debug_traceTransaction
+ * with the callTracer. Unlike the indexer helper, this returns the calldata whether the target is called
+ * directly by the transaction or via nested calls.
+ *
+ * @param client - viem PublicClient connected to an RPC node with debug API enabled
+ * @param txHash - The transaction hash
+ * @param targetContractAddress - The target contract address to find the call for
+ * @returns The input (calldata) as a hex string, or null if the target is not found in the trace
+ * @throws Error if the RPC call fails or returns an unexpected response
+ */
+declare function getContractCallInput(client: PublicClient, txHash: HexString, targetContractAddress: string): Promise<HexString | null>;
+/**
+ * Calculates the balance mapping location for a given slot and holder address.
+ * This function handles the different encoding formats used by Solidity and Vyper.
+ *
+ * @param slot - The slot number to calculate the mapping location for.
+ * @param holder - The address of the holder to calculate the mapping location for.
+ * @param language - The language of the contract.
+ * @returns The balance mapping location as a HexString.
+ */
+declare function calculateBalanceMappingLocation(slot: bigint, holder: string, language: EvmLanguage): HexString;
+/**
+ * Calculates the allowance mapping location for a given slot, owner, and spender.
+ * ERC20 allowance is a nested mapping: mapping(address owner => mapping(address spender => uint256))
+ *
+ * @param slot - The base slot number for the allowance mapping
+ * @param owner - The address of the token owner (first parameter in allowance(owner, spender))
+ * @param spender - The address approved to spend tokens (second parameter)
+ * @param language - The language of the contract (Solidity or Vyper)
+ * @returns The allowance mapping location as a HexString
+ */
+declare function calculateAllowanceMappingLocation(slot: bigint, owner: string, spender: string, language: EvmLanguage): HexString;
+
+declare class SubstrateChain implements IChain {
+    private readonly params;
+    api?: ApiPromise;
+    private rpcClient;
+    constructor(params: ISubstrateConfig);
+    get config(): ISubstrateConfig;
+    /**
+     * Connects to the Substrate chain using the provided WebSocket URL.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnects the Substrate chain connection.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Returns the storage key for a request receipt in the child trie
+     * The request commitment is the key
+     * @param key - The H256 hash key (as a 0x-prefixed hex string)
+     * @returns The storage key as a hex string
+     */
+    requestReceiptKey(key: HexString): HexString;
+    /**
+     * Returns the storage key for a request commitment in the child trie
+     * The request commitment is the key
+     * @param key - The H256 hash key (as a 0x-prefixed hex string)
+     * @returns The storage key as a hex string
+     */
+    requestCommitmentKey(key: HexString): HexString;
+    /**
+     * Queries a request commitment from the ISMP child trie storage.
+     * @param {HexString} commitment - The commitment hash to look up.
+     * @returns {Promise<HexString | undefined>} The commitment data if found, undefined otherwise.
+     */
+    queryRequestCommitment(commitment: HexString): Promise<HexString | undefined>;
+    /**
+     * Queries the request receipt.
+     * @param {HexString} commitment - The commitment to query.
+     * @returns {Promise<HexString | undefined>} The relayer address responsible for delivering the request.
+     */
+    queryRequestReceipt(commitment: HexString): Promise<HexString | undefined>;
+    /**
+     * Returns the current timestamp of the chain.
+     * @returns {Promise<bigint>} The current timestamp.
+     */
+    timestamp(): Promise<bigint>;
+    /**
+     * Queries the proof of the commitments.
+     * @param {IMessage} message - The message to query.
+     * @param {string} counterparty - The counterparty address.
+     * @param {bigint} [at] - The block number to query at.
+     * @returns {Promise<HexString>} The proof.
+     */
+    queryProof(message: IMessage, counterparty: string, at?: bigint): Promise<HexString>;
+    /**
+     * Submit an unsigned ISMP transaction to the chain. Resolves when the transaction is finalized.
+     * @param message - The message to be submitted.
+     * @returns A promise that resolves to an object containing the transaction hash, block hash, and block number.
+     */
+    submitUnsigned(message: IIsmpMessage): Promise<{
+        transactionHash: string;
+        blockHash: string;
+        blockNumber: number;
+        timestamp: number;
+    }>;
+    /**
+     * Query the state proof for a given set of keys at a specific block height.
+     * @param at The block height to query the state proof at.
+     * @param keys The keys to query the state proof for.
+     * @param _address - Optional address (ignored for Substrate; present for IChain compatibility).
+     * @returns The state proof as a hexadecimal string.
+     */
+    queryStateProof(at: bigint, keys: HexString[], _address?: HexString): Promise<HexString>;
+    /**
+     * Get the latest state machine height for a given state machine ID.
+     * @param {StateMachineIdParams} stateMachineId - The state machine ID.
+     * @returns {Promise<bigint>} The latest state machine height.
+     */
+    latestStateMachineHeight(stateMachineId: StateMachineIdParams): Promise<bigint>;
+    /**
+     * Get the state machine update time for a given state machine height.
+     * @param {StateMachineHeight} stateMachineHeight - The state machine height.
+     * @returns {Promise<bigint>} The statemachine update time in seconds.
+     */
+    stateMachineUpdateTime(stateMachineHeight: StateMachineHeight): Promise<bigint>;
+    /**
+     * Get the challenge period for a given state machine id.
+     * @param {StateMachineIdParams} stateMachineId - The state machine ID.
+     * @returns {Promise<bigint>} The challenge period in seconds.
+     */
+    challengePeriod(stateMachineId: StateMachineIdParams): Promise<bigint>;
+    /**
+     * Encode an ISMP calldata for a substrate chain.
+     * @param message The ISMP message to encode.
+     * @returns The encoded message as a hexadecimal string.
+     */
+    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.
+     */
+    private getPalletIndex;
+}
+/**
+ * Converts a state machine ID string to an enum value.
+ * @param {string} id - The state machine ID string.
+ * @returns {IStateMachine} The corresponding enum value.
  */
-declare function constructRedeemEscrowRequestBody(order: Order | OrderV2, beneficiary: HexString): HexString;
-declare function fetchPrice(identifier: string, chainId?: number, apiKey?: string): Promise<number>;
+declare function convertStateMachineIdToEnum(id: string): IStateMachine;
 /**
- * Fetches the current network gas price from an Etherscan-family explorer API.
- * Returns the ProposeGasPrice (in gwei) converted to wei as bigint.
+ * Converts a state machine enum representation to a string.
+ * @param {IStateMachine} stateMachine - The state machine enum object.
+ * @returns {string} The state machine ID string like "EVM-97" or "SUBSTRATE-cere".
  */
-declare function getGasPriceFromEtherscan(chainId: string, apiKey?: string): Promise<bigint>;
+declare function convertStateMachineEnumToString(stateMachine: {
+    tag: string;
+    value: number | number[];
+}): string;
 /**
- * ERC20 method signatures used for storage slot detection
+ * Converts a stateId object back to the state_id format used by the RPC.
+ * @param stateId - The stateId object from StateMachineIdParams
+ * @returns The string representation like "EVM-11155111" or "SUBSTRATE-cere"
  */
-declare enum ERC20Method {
-    /** ERC20 balanceOf(address) method signature */
-    BALANCE_OF = "0x70a08231",
-    /** ERC20 allowance(address,address) method signature */
-    ALLOWANCE = "0xdd62ed3e"
-}
-declare enum EvmLanguage {
-    Solidity = 0,
-    Vyper = 1
-}
+declare function convertStateIdToStateMachineId(stateId: {
+    Evm?: number;
+    Substrate?: HexString;
+    Polkadot?: number;
+    Kusama?: number;
+}): string;
 /**
- * Retrieves the storage slot for a contract call using debug_traceCall
- *
- * This function uses the Ethereum debug API to trace contract execution and identify
- * the storage slot accessed during the call. It's commonly used for ERC20 token state
- * mappings like balanceOf and allowance, but can work with any contract call that
- * performs SLOAD operations.
- *
- * @param client - The viem PublicClient instance connected to an RPC node with debug API enabled
- * @param tokenAddress - The address of the contract to trace
- * @param data - The full encoded function call data (method signature + encoded parameters)
- * @returns The storage slot as a hex string
- * @throws Error if the storage slot cannot be found or if debug API is not available
- *
- * @example
- * ```ts
- * import { ERC20Method, bytes20ToBytes32 } from '@hyperbridge/sdk'
- *
- * // Get balance storage slot for ERC20
- * const balanceData = ERC20Method.BALANCE_OF + bytes20ToBytes32(userAddress).slice(2)
- * const balanceSlot = await getStorageSlot(
- *   client,
- *   tokenAddress,
- *   balanceData as HexString
- * )
- *
- * // Get allowance storage slot for ERC20
- * const allowanceData = ERC20Method.ALLOWANCE +
- *   bytes20ToBytes32(ownerAddress).slice(2) +
- *   bytes20ToBytes32(spenderAddress).slice(2)
- * const allowanceSlot = await getStorageSlot(
- *   client,
- *   tokenAddress,
- *   allowanceData as HexString
- * )
- * ```
+ * Converts an IGetRequest object to a codec representation.
+ * @param {IGetRequest} request - The IGetRequest object.
+ * @returns The codec representation of the request.
  */
-declare function getStorageSlot(client: PublicClient, contractAddress: HexString, data: HexString): Promise<string>;
+declare function convertIGetRequestToCodec(request: IGetRequest): {
+    readonly source: IStateMachine;
+    readonly dest: IStateMachine;
+    readonly from: number[];
+    readonly nonce: bigint;
+    readonly keys: number[][];
+    readonly context: number[];
+    readonly timeoutTimestamp: bigint;
+    readonly height: bigint;
+};
 /**
- * Adjusts fee amounts between different decimal precisions.
- * Handles scaling up or down based on the decimal difference.
- *
- * @param feeInFeeToken - The fee amount to adjust
- * @param fromDecimals - The current decimal precision
- * @param toDecimals - The target decimal precision
- * @returns The adjusted fee amount with the target decimal precision
+ * Convert codec representation back to IGetRequest
  */
-declare function adjustDecimals(feeInFeeToken: bigint, fromDecimals: number, toDecimals: number): bigint;
+declare function convertCodecToIGetRequest(codec: {
+    source: {
+        tag: string;
+        value: number | number[];
+    };
+    dest: {
+        tag: string;
+        value: number | number[];
+    };
+    from: number[];
+    nonce: bigint;
+    keys: number[][];
+    height: bigint;
+    context: number[];
+    timeoutTimestamp: bigint;
+}): IGetRequest;
 /**
- * Chains that should prefer the Etherscan API for gas price lookup
+ * Converts an IProof object to a codec representation.
+ * @param {IProof} proof - The IProof object.
+ * @returns The codec representation of the proof.
  */
-declare const USE_ETHERSCAN_CHAINS: Set<string>;
+declare function convertIProofToCodec(proof: IProof): {
+    readonly height: {
+        readonly height: bigint;
+        readonly id: {
+            readonly consensusStateId: number[];
+            readonly id: IStateMachine;
+        };
+    };
+    readonly proof: number[];
+};
 /**
- * Testnet chains
+ * Converts a codec representation back to an IProof object.
+ * @param {any} codec - The codec representation of the proof.
+ * @returns {IProof} The IProof object.
  */
-declare const TESTNET_CHAINS: Set<string>;
-/**
- * Retrieves the calldata used to call a target contract within a transaction using debug_traceTransaction
- * with the callTracer. Unlike the indexer helper, this returns the calldata whether the target is called
- * directly by the transaction or via nested calls.
- *
- * @param client - viem PublicClient connected to an RPC node with debug API enabled
- * @param txHash - The transaction hash
- * @param targetContractAddress - The target contract address to find the call for
- * @returns The input (calldata) as a hex string, or null if the target is not found in the trace
- * @throws Error if the RPC call fails or returns an unexpected response
+declare function convertCodecToIProof(codec: {
+    height: {
+        height: bigint;
+        id: {
+            consensusStateId: number[];
+            id: {
+                tag: string;
+                value: number | number[];
+            };
+        };
+    };
+    proof: number[];
+}): IProof;
+declare function encodeISMPMessage(message: IIsmpMessage): Uint8Array;
+
+declare class ChainConfigService {
+    private rpcUrls;
+    constructor(env?: NodeJS.ProcessEnv);
+    private getConfig;
+    getChainConfig(chain: string): ChainConfig;
+    getIntentGatewayAddress(chain: string): HexString;
+    getTokenGatewayAddress(chain: string): HexString;
+    getHostAddress(chain: string): HexString;
+    getWrappedNativeAssetWithDecimals(chain: string): {
+        asset: HexString;
+        decimals: number;
+    };
+    getDaiAsset(chain: string): HexString;
+    getUsdtAsset(chain: string): HexString;
+    getUsdcAsset(chain: string): HexString;
+    getUsdcDecimals(chain: string): number;
+    getUsdtDecimals(chain: string): number;
+    getCNgnAsset(chain: string): HexString | undefined;
+    getCNgnDecimals(chain: string): number | undefined;
+    getChainId(chain: string): number;
+    getConsensusStateId(chain: string): HexString;
+    getHyperbridgeChainId(): number;
+    getRpcUrl(chain: string): string;
+    getUniswapRouterV2Address(chain: string): HexString;
+    getUniswapV2FactoryAddress(chain: string): HexString;
+    getUniswapV3FactoryAddress(chain: string): HexString;
+    getUniversalRouterAddress(chain: string): HexString;
+    getUniswapV3QuoterAddress(chain: string): HexString;
+    getUniswapV4QuoterAddress(chain: string): HexString;
+    getPermit2Address(chain: string): HexString;
+    getSolverAccountAddress(chain: string): HexString | undefined;
+    getCoingeckoId(chain: string): string | undefined;
+    getEtherscanApiKey(): string | undefined;
+    getCalldispatcherAddress(chain: string): HexString;
+    getTokenStorageSlots(chain: string, tokenAddress: string): {
+        balanceSlot: number;
+        allowanceSlot: number;
+    } | undefined;
+    getPopularTokens(chain: string): string[];
+    getIntentGatewayV2Address(chain: string): HexString;
+    getEntryPointV08Address(chain: string): HexString;
+    getHyperbridgeAddress(): string;
+    /**
+     * Get the LayerZero Endpoint ID for the chain
+     * Used for USDT0 cross-chain transfers via LayerZero OFT
+     */
+    getLayerZeroEid(chain: string): number | undefined;
+    /**
+     * Get the USDT0 OFT contract address for the chain
+     * On Ethereum: OFT Adapter (locks/unlocks USDT)
+     * On other chains: OFT contract (mints/burns USDT0)
+     */
+    getUsdt0OftAddress(chain: string): HexString | undefined;
+}
+
+/**
+ * The default address used as fallback when no address is provided.
+ * This represents the zero address in EVM chains.
  */
-declare function getContractCallInput(client: PublicClient, txHash: HexString, targetContractAddress: string): Promise<HexString | null>;
+declare const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
 /**
- * Calculates the balance mapping location for a given slot and holder address.
- * This function handles the different encoding formats used by Solidity and Vyper.
- *
- * @param slot - The slot number to calculate the mapping location for.
- * @param holder - The address of the holder to calculate the mapping location for.
- * @param language - The language of the contract.
- * @returns The balance mapping location as a HexString.
+ * Parameters for an EVM chain.
  */
-declare function calculateBalanceMappingLocation(slot: bigint, holder: string, language: EvmLanguage): HexString;
-
-declare class SubstrateChain implements IChain {
-    private readonly params;
-    api?: ApiPromise;
-    private rpcClient;
-    constructor(params: ISubstrateConfig);
-    get config(): ISubstrateConfig;
+interface EvmChainParams {
     /**
-     * Connects to the Substrate chain using the provided WebSocket URL.
+     * The chain ID of the EVM chain
      */
-    connect(): Promise<void>;
+    chainId: number;
     /**
-     * Disconnects the Substrate chain connection.
+     * The RPC URL of the EVM chain
      */
-    disconnect(): Promise<void>;
+    rpcUrl: string;
     /**
-     * Returns the storage key for a request receipt in the child trie
-     * The request commitment is the key
-     * @param key - The H256 hash key (as a 0x-prefixed hex string)
-     * @returns The storage key as a hex string
+     * The host address of the EVM chain (IsmpHost contract address)
      */
-    requestReceiptKey(key: HexString): HexString;
+    host: HexString;
     /**
-     * Returns the storage key for a request commitment in the child trie
-     * The request commitment is the key
-     * @param key - The H256 hash key (as a 0x-prefixed hex string)
-     * @returns The storage key as a hex string
+     * Consensus state identifier of this chain on hyperbridge
      */
-    requestCommitmentKey(key: HexString): HexString;
+    consensusStateId?: string;
+}
+/**
+ * Encapsulates an EVM chain.
+ */
+declare class EvmChain implements IChain {
+    private readonly params;
+    private publicClient;
+    private chainConfigService;
+    constructor(params: EvmChainParams);
+    get client(): PublicClient;
+    get host(): HexString;
+    get config(): IEvmConfig;
+    get configService(): ChainConfigService;
     /**
-     * Queries a request commitment from the ISMP child trie storage.
-     * @param {HexString} commitment - The commitment hash to look up.
-     * @returns {Promise<HexString | undefined>} The commitment data if found, undefined otherwise.
+     * Derives the key for the request receipt.
+     * @param {HexString} commitment - The commitment to derive the key from.
+     * @returns {HexString} The derived key.
      */
-    queryRequestCommitment(commitment: HexString): Promise<HexString | undefined>;
+    requestReceiptKey(commitment: HexString): HexString;
     /**
      * Queries the request receipt.
      * @param {HexString} commitment - The commitment to query.
      * @returns {Promise<HexString | undefined>} The relayer address responsible for delivering the request.
      */
     queryRequestReceipt(commitment: HexString): Promise<HexString | undefined>;
-    /**
-     * Returns the current timestamp of the chain.
-     * @returns {Promise<bigint>} The current timestamp.
-     */
-    timestamp(): Promise<bigint>;
     /**
      * Queries the proof of the commitments.
      * @param {IMessage} message - The message to query.
@@ -1127,23 +1164,18 @@ declare class SubstrateChain implements IChain {
      */
     queryProof(message: IMessage, counterparty: string, at?: bigint): Promise<HexString>;
     /**
-     * Submit an unsigned ISMP transaction to the chain. Resolves when the transaction is finalized.
-     * @param message - The message to be submitted.
-     * @returns A promise that resolves to an object containing the transaction hash, block hash, and block number.
+     * Query and return the encoded storage proof for the provided keys at the given height.
+     * @param {bigint} at - The block height at which to query the storage proof.
+     * @param {HexString[]} keys - The keys for which to query the storage proof.
+     * @param {HexString} address - Optional contract address to fetch storage proof else default to host contract
+     * @returns {Promise<HexString>} The encoded storage proof.
      */
-    submitUnsigned(message: IIsmpMessage): Promise<{
-        transactionHash: string;
-        blockHash: string;
-        blockNumber: number;
-        timestamp: number;
-    }>;
+    queryStateProof(at: bigint, keys: HexString[], address?: HexString): Promise<HexString>;
     /**
-     * Query the state proof for a given set of keys at a specific block height.
-     * @param at The block height to query the state proof at.
-     * @param keys The keys to query the state proof for.
-     * @returns The state proof as a hexadecimal string.
+     * Returns the current timestamp of the chain.
+     * @returns {Promise<bigint>} The current timestamp.
      */
-    queryStateProof(at: bigint, keys: HexString[]): Promise<HexString>;
+    timestamp(): Promise<bigint>;
     /**
      * Get the latest state machine height for a given state machine ID.
      * @param {StateMachineIdParams} stateMachineId - The state machine ID.
@@ -1156,6 +1188,10 @@ declare class SubstrateChain implements IChain {
      * @returns {Promise<bigint>} The statemachine update time in seconds.
      */
     stateMachineUpdateTime(stateMachineHeight: StateMachineHeight): Promise<bigint>;
+    /**
+     * Retrieves the placeOrder calldata from a transaction using debug_traceTransaction.
+     */
+    getPlaceOrderCalldata(txHash: string, intentGatewayAddress: string): Promise<HexString>;
     /**
      * Get the challenge period for a given state machine id.
      * @param {StateMachineIdParams} stateMachineId - The state machine ID.
@@ -1163,112 +1199,121 @@ declare class SubstrateChain implements IChain {
      */
     challengePeriod(stateMachineId: StateMachineIdParams): Promise<bigint>;
     /**
-     * Encode an ISMP calldata for a substrate chain.
-     * @param message The ISMP message to encode.
-     * @returns The encoded message as a hexadecimal string.
+     * Encodes an ISMP message for the EVM chain.
+     * @param {IIsmpMessage} message The ISMP message to encode.
+     * @returns {HexString} The encoded calldata.
      */
     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.
+     * Calculates the fee required to send a post request to the destination chain.
+     * The fee is calculated based on the per-byte fee for the destination chain
+     * multiplied by the size of the request body.
+     *
+     * @param request - The post request to calculate the fee for
+     * @returns The total fee in wei required to send the post request
      */
-    private getPalletIndex;
+    quote(request: IPostRequest | IGetRequest): Promise<bigint>;
+    quoteNative(request: IPostRequest | IGetRequest, fee: bigint): Promise<bigint>;
+    private getAmountsIn;
+    /**
+     * Estimates the gas required for a post request execution on this chain.
+     * This function generates mock proofs for the post request, creates a state override
+     * with the necessary overlay root, and estimates the gas cost for executing the
+     * handlePostRequests transaction on the handler contract.
+     *
+     * @param request - The post request to estimate gas for
+     * @param paraId - The ID of the parachain (Hyperbridge) that will process the request
+     * @returns The estimated gas amount in gas units and the generated calldata
+     */
+    estimateGas(request: IPostRequest): Promise<{
+        gas: bigint;
+        postRequestCalldata: HexString;
+    }>;
+    /**
+     * Gets the fee token address and decimals for the chain.
+     * This function gets the fee token address and decimals for the chain.
+     *
+     * @returns The fee token address and decimals
+     */
+    getFeeTokenWithDecimals(): Promise<{
+        address: HexString;
+        decimals: number;
+    }>;
+    /**
+     * Gets the nonce of the host.
+     * This function gets the nonce of the host.
+     *
+     * @returns The nonce of the host
+     */
+    getHostNonce(): Promise<bigint>;
+    broadcastTransaction(signedTransaction: any): Promise<TransactionReceipt>;
 }
 /**
- * Converts a state machine ID string to an enum value.
- * @param {string} id - The state machine ID string.
- * @returns {IStateMachine} The corresponding enum value.
+ * Factory function for creating EVM chain instances with common defaults
+ *
+ * @param chainId - The EVM chain ID
+ * @param host - The IsmpHost contract address
+ * @param options - Optional configuration overrides
+ * @returns A new EvmChain instance
+ *
+ * @example
+ * ```typescript
+ * // Create with minimal config
+ * const ethChain = createEvmChain(1, "0x87ea45..", {
+ *   rpcUrl: "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"
+ * })
+ *
+ * // Create with custom consensus state ID
+ * const arbChain = createEvmChain(42161, "0x87ea42345..", {
+ *   rpcUrl: "https://arb-mainnet.g.alchemy.com/v2/YOUR_KEY",
+ *   consensusStateId: "ARB_CUSTOM"
+ * })
+ * ```
  */
-declare function convertStateMachineIdToEnum(id: string): IStateMachine;
+declare function createEvmChain(chainId: number, host: HexString, options: {
+    rpcUrl: string;
+    consensusStateId?: string;
+}): EvmChain;
 /**
- * Converts a state machine enum representation to a string.
- * @param {IStateMachine} stateMachine - The state machine enum object.
- * @returns {string} The state machine ID string like "EVM-97" or "SUBSTRATE-cere".
+ * Slot for storing request commitments.
  */
-declare function convertStateMachineEnumToString(stateMachine: {
-    tag: string;
-    value: number | number[];
-}): string;
+declare const REQUEST_COMMITMENTS_SLOT = 0n;
 /**
- * Converts a stateId object back to the state_id format used by the RPC.
- * @param stateId - The stateId object from StateMachineIdParams
- * @returns The string representation like "EVM-11155111" or "SUBSTRATE-cere"
+ * Slot index for response commitments map
  */
-declare function convertStateIdToStateMachineId(stateId: {
-    Evm?: number;
-    Substrate?: HexString;
-    Polkadot?: number;
-    Kusama?: number;
-}): string;
+declare const RESPONSE_COMMITMENTS_SLOT = 1n;
 /**
- * Converts an IGetRequest object to a codec representation.
- * @param {IGetRequest} request - The IGetRequest object.
- * @returns The codec representation of the request.
+ * Slot index for requests receipts map
  */
-declare function convertIGetRequestToCodec(request: IGetRequest): {
-    readonly source: IStateMachine;
-    readonly dest: IStateMachine;
-    readonly from: number[];
-    readonly nonce: bigint;
-    readonly keys: number[][];
-    readonly context: number[];
-    readonly timeoutTimestamp: bigint;
-    readonly height: bigint;
-};
+declare const REQUEST_RECEIPTS_SLOT = 2n;
 /**
- * Convert codec representation back to IGetRequest
+ * Slot index for response receipts map
  */
-declare function convertCodecToIGetRequest(codec: {
-    source: {
-        tag: string;
-        value: number | number[];
-    };
-    dest: {
-        tag: string;
-        value: number | number[];
-    };
-    from: number[];
-    nonce: bigint;
-    keys: number[][];
-    height: bigint;
-    context: number[];
-    timeoutTimestamp: bigint;
-}): IGetRequest;
+declare const RESPONSE_RECEIPTS_SLOT = 3n;
 /**
- * Converts an IProof object to a codec representation.
- * @param {IProof} proof - The IProof object.
- * @returns The codec representation of the proof.
+ * Slot index for state commitment map
  */
-declare function convertIProofToCodec(proof: IProof): {
-    readonly height: {
-        readonly height: bigint;
-        readonly id: {
-            readonly consensusStateId: number[];
-            readonly id: IStateMachine;
-        };
-    };
-    readonly proof: number[];
+declare const STATE_COMMITMENTS_SLOT = 5n;
+declare function requestCommitmentKey(key: Hex): {
+    slot1: Hex;
+    slot2: Hex;
 };
 /**
- * Converts a codec representation back to an IProof object.
- * @param {any} codec - The codec representation of the proof.
- * @returns {IProof} The IProof object.
+ * Derives the storage slot for a specific field in the StateCommitment struct
+ *
+ * struct StateCommitment {
+ *   uint256 timestamp;     // slot + 0
+ *   bytes32 overlayRoot;   // slot + 1
+ *   bytes32 stateRoot;     // slot + 2
+ * }
+ *
+ * @param stateMachineId - The state machine ID
+ * @param height - The block height
+ * @param field - The field index in the struct (0 for timestamp, 1 for overlayRoot, 2 for stateRoot)
+ * @returns The storage slot for the specific field
  */
-declare function convertCodecToIProof(codec: {
-    height: {
-        height: bigint;
-        id: {
-            consensusStateId: number[];
-            id: {
-                tag: string;
-                value: number | number[];
-            };
-        };
-    };
-    proof: number[];
-}): IProof;
-declare function encodeISMPMessage(message: IIsmpMessage): Uint8Array;
+declare function getStateCommitmentFieldSlot(stateMachineId: bigint, height: bigint, field: 0 | 1 | 2): HexString;
+declare function getStateCommitmentSlot(stateMachineId: bigint, height: bigint): HexString;
 
 /**
  * Encodes a PackedUserOperation using SCALE codec for submission to Hyperbridge.
@@ -1377,6 +1422,64 @@ declare class IntentsCoprocessor {
     private buildOffchainBidKey;
 }
 
+/**
+ * Parameters for a Tron-backed chain.
+ * TronWeb is constructed internally from `rpcUrl`.
+ */
+type TronChainParams = EvmChainParams;
+declare class TronChain implements IChain {
+    private readonly params;
+    private readonly evm;
+    private readonly tronWebInstance;
+    constructor(params: TronChainParams);
+    /** Underlying viem public client (delegated from the internal EvmChain) */
+    get client(): PublicClient;
+    /** Host contract address for this chain (delegated from the internal EvmChain) */
+    get host(): HexString;
+    /** Chain configuration (delegated from the internal EvmChain) */
+    get config(): IEvmConfig;
+    /** Chain configuration service (delegated from the internal EvmChain) */
+    get configService(): ChainConfigService;
+    /** TronWeb instance for this Tron chain (constructed from rpcUrl) */
+    get tronWeb(): InstanceType<typeof TronWeb>;
+    timestamp(): Promise<bigint>;
+    requestReceiptKey(commitment: HexString): HexString;
+    queryRequestReceipt(commitment: HexString): Promise<HexString | undefined>;
+    queryStateProof(at: bigint, keys: HexString[], address?: HexString): Promise<HexString>;
+    queryProof(message: IMessage, counterparty: string, at?: bigint): Promise<HexString>;
+    encode(message: IIsmpMessage): HexString;
+    latestStateMachineHeight(stateMachineId: StateMachineIdParams): Promise<bigint>;
+    challengePeriod(stateMachineId: StateMachineIdParams): Promise<bigint>;
+    stateMachineUpdateTime(stateMachineHeight: StateMachineHeight): Promise<bigint>;
+    /**
+     * Retrieves top-level calldata from a Tron transaction via TronWeb.
+     * Only works for direct calls to IntentGateway (not nested/multicall).
+     * Tron does not support debug_traceTransaction.
+     */
+    getPlaceOrderCalldata(txHash: string, _intentGatewayAddress: string): Promise<HexString>;
+    /**
+     * Broadcasts a signed Tron transaction and waits for confirmation,
+     * returning a 0x-prefixed transaction hash compatible with viem.
+     *
+     * This mirrors the behavior used in IntentGatewayV2 for Tron chains.
+     */
+    broadcastTransaction(signedTransaction: any): Promise<TransactionReceipt>;
+    /** Gets the fee token address and decimals for the chain. */
+    getFeeTokenWithDecimals(): Promise<{
+        address: HexString;
+        decimals: number;
+    }>;
+    /** Gets the nonce of the host contract on this chain. */
+    getHostNonce(): Promise<bigint>;
+    /** Quotes the fee (in native token) required for the given ISMP request. */
+    quoteNative(request: IPostRequest | IGetRequest, fee: bigint): Promise<bigint>;
+    /** Estimates gas for executing a post request on this chain. */
+    estimateGas(request: IPostRequest): Promise<{
+        gas: bigint;
+        postRequestCalldata: HexString;
+    }>;
+}
+
 /**
  * Type representing an ISMP message.
  */
@@ -1500,8 +1603,9 @@ interface IChain {
     queryRequestReceipt(commitment: HexString): Promise<HexString | undefined>;
     /**
      * Query and return the encoded storage proof for the provided keys at the given height.
+     * @param address - Optional contract address for EVM chains; defaults to host contract when omitted.
      */
-    queryStateProof(at: bigint, keys: HexString[]): Promise<HexString>;
+    queryStateProof(at: bigint, keys: HexString[], address?: HexString): Promise<HexString>;
     queryProof(message: IMessage, counterparty: string, at?: bigint): Promise<HexString>;
     encode(message: IIsmpMessage): HexString;
     /**
@@ -1518,11 +1622,36 @@ interface IChain {
     stateMachineUpdateTime(stateMachineHeight: StateMachineHeight): Promise<bigint>;
 }
 /**
- * Returns the chain interface for a given state machine identifier
+ * Interface for EVM-compatible chains (EVM and Tron).
+ * Extends IChain with methods required by IntentGatewayV2 and other EVM-specific protocols.
+ */
+interface IEvmChain extends IChain {
+    readonly configService: ChainConfigService;
+    readonly client: PublicClient;
+    getHostNonce(): Promise<bigint>;
+    quoteNative(request: IPostRequest | IGetRequest, fee: bigint): Promise<bigint>;
+    getFeeTokenWithDecimals(): Promise<{
+        address: HexString;
+        decimals: number;
+    }>;
+    getPlaceOrderCalldata(txHash: string, intentGatewayAddress: string): Promise<HexString>;
+    broadcastTransaction(signedTransaction: any): Promise<TransactionReceipt>;
+}
+/**
+ * Returns the chain interface for a given state machine identifier.
+ *
+ * - For standard EVM chains, returns an `EvmChain`.
+ * - For Substrate chains, returns a connected `SubstrateChain`.
+ * - For Tron chains (identified by chain ID), constructs a `TronChain`
+ *   that delegates EVM behavior to an internal `EvmChain` and manages
+ *   its own TronWeb instance using the provided RPC URL.
+ *
  * @param chainConfig - Chain configuration
  * @returns Chain interface
  */
 declare function getChain(chainConfig: IEvmConfig | ISubstrateConfig): Promise<IChain>;
+declare function getEvmChain(chainConfig: IEvmConfig): IChain;
+declare function getSubstrateChain(chainConfig: ISubstrateConfig): Promise<SubstrateChain>;
 
 type EstimateGasCallData = ContractFunctionArgs<typeof _default.ABI, "nonpayable" | "payable", "handlePostRequests">;
 type HexString = `0x${string}`;
@@ -2186,7 +2315,15 @@ declare enum RequestKind {
     /**
      * Identifies a request for updating parameters
      */
-    UpdateParams = 2
+    UpdateParams = 2,
+    /**
+     * Identifies a request for sweeping accumulated protocol dust
+     */
+    SweepDust = 3,
+    /**
+     * Identifies a request for refunding escrowed tokens after cancellation
+     */
+    RefundEscrow = 4
 }
 /**
  * Configuration for the IntentFiller
@@ -2602,8 +2739,8 @@ interface DispatchInfoV2 {
 interface OrderV2 {
     id?: string;
     user: HexString;
-    source: string;
-    destination: string;
+    source: HexString;
+    destination: HexString;
     deadline: bigint;
     nonce: bigint;
     fees: bigint;
@@ -2641,10 +2778,11 @@ interface SubmitBidOptions {
     preVerificationGas: bigint;
     maxFeePerGas: bigint;
     maxPriorityFeePerGas: bigint;
+    /** Pre-built ERC-7821 calldata encoding the UserOp execution (approvals + fillOrder). */
+    callData: HexString;
 }
 interface EstimateFillOrderV2Params {
     order: OrderV2;
-    solverPrivateKey: HexString;
     /**
      * Optional percentage to bump maxPriorityFeePerGas.
      * This is added on top of the base gasPrice.
@@ -2667,7 +2805,6 @@ interface FillOrderEstimateV2 {
     maxPriorityFeePerGas: bigint;
     totalGasCostWei: bigint;
     totalGasInFeeToken: bigint;
-    nonce: bigint;
 }
 /**
  * Result of submitting a bid to Hyperbridge
@@ -2733,6 +2870,8 @@ declare const IntentOrderStatus: Readonly<{
     BIDS_RECEIVED: "BIDS_RECEIVED";
     BID_SELECTED: "BID_SELECTED";
     USEROP_SUBMITTED: "USEROP_SUBMITTED";
+    FILLED: "FILLED";
+    PARTIAL_FILL: "PARTIAL_FILL";
     FAILED: "FAILED";
 }>;
 type IntentOrderStatus = typeof IntentOrderStatus;
@@ -2762,6 +2901,7 @@ interface SelectBidResult {
     solverAddress: HexString;
     commitment: HexString;
     txnHash?: HexString;
+    fillStatus?: "full" | "partial";
 }
 /** Options for executing an intent order */
 interface ExecuteIntentOrderOptions {
@@ -3586,8 +3726,160 @@ type CancelEvent$1 = {
     };
 }[keyof CancelEventMap$1];
 
+type StorageDriverKey = "node" | "localstorage" | "indexeddb" | "memory";
+interface CancellationStorageOptions {
+    env?: StorageDriverKey;
+    basePath?: string;
+}
+interface SessionKeyStorageOptions {
+    env?: StorageDriverKey;
+    basePath?: string;
+}
+
+declare function createCancellationStorage(options?: CancellationStorageOptions): Readonly<{
+    getItem: <T>(key: string) => Promise<T | null>;
+    setItem: (key: string, value: unknown) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+    hasItem<U extends never, K extends keyof (U extends {
+        [key: string]: unknown;
+        items: unknown;
+    } ? U["items"] : U)>(key: K, opts?: unstorage.TransactionOptions): Promise<boolean>;
+    hasItem(key: string, opts?: unstorage.TransactionOptions): Promise<boolean>;
+    getItems: <U extends unstorage.StorageValue>(items: (string | {
+        key: string;
+        options?: unstorage.TransactionOptions;
+    })[], commonOptions?: unstorage.TransactionOptions) => Promise<{
+        key: string;
+        value: U;
+    }[]>;
+    getItemRaw: <T = any>(key: string, opts?: unstorage.TransactionOptions) => Promise<(T extends any ? T : any) | null>;
+    setItems: <U extends unstorage.StorageValue>(items: {
+        key: string;
+        value: U;
+        options?: unstorage.TransactionOptions;
+    }[], commonOptions?: unstorage.TransactionOptions) => Promise<void>;
+    setItemRaw: <T = any>(key: string, value: T extends any ? T : any, opts?: unstorage.TransactionOptions) => Promise<void>;
+    getMeta: (key: string, opts?: (unstorage.TransactionOptions & {
+        nativeOnly?: boolean;
+    }) | boolean) => unstorage.StorageMeta | Promise<unstorage.StorageMeta>;
+    setMeta: (key: string, value: unstorage.StorageMeta, opts?: unstorage.TransactionOptions) => Promise<void>;
+    removeMeta: (key: string, opts?: unstorage.TransactionOptions) => Promise<void>;
+    getKeys: (base?: string, opts?: unstorage.GetKeysOptions) => Promise<string[]>;
+    clear: (base?: string, opts?: unstorage.TransactionOptions) => Promise<void>;
+    dispose: () => Promise<void>;
+    watch: (callback: unstorage.WatchCallback) => Promise<unstorage.Unwatch>;
+    unwatch: () => Promise<void>;
+    mount: (base: string, driver: unstorage.Driver) => unstorage.Storage;
+    unmount: (base: string, dispose?: boolean) => Promise<void>;
+    getMount: (key?: string) => {
+        base: string;
+        driver: unstorage.Driver;
+    };
+    getMounts: (base?: string, options?: {
+        parents?: boolean;
+    }) => {
+        base: string;
+        driver: unstorage.Driver;
+    }[];
+    keys: unstorage.Storage["getKeys"];
+    get: {
+        <U extends never, K extends string & keyof (U extends {
+            [key: string]: unknown;
+            items: unknown;
+        } ? U["items"] : U)>(key: K, ops?: unstorage.TransactionOptions): Promise<(K extends never ? unstorage.StorageValue[K] : unstorage.StorageValue) | null>;
+        <R = unstorage.StorageValue>(key: string, opts?: unstorage.TransactionOptions): Promise<R | null>;
+    };
+    set: {
+        <U extends never, K extends keyof (U extends {
+            [key: string]: unknown;
+            items: unknown;
+        } ? U["items"] : U)>(key: K, value: K extends never ? unstorage.StorageValue[K] : unstorage.StorageValue, opts?: unstorage.TransactionOptions): Promise<void>;
+        <U extends unstorage.StorageValue>(key: string, value: U, opts?: unstorage.TransactionOptions): Promise<void>;
+    };
+    has: {
+        <U extends never, K extends keyof (U extends {
+            [key: string]: unknown;
+            items: unknown;
+        } ? U["items"] : U)>(key: K, opts?: unstorage.TransactionOptions): Promise<boolean>;
+        (key: string, opts?: unstorage.TransactionOptions): Promise<boolean>;
+    };
+    del: {
+        <U extends never, K extends keyof (U extends {
+            [key: string]: unknown;
+            items: unknown;
+        } ? U["items"] : U)>(key: K, opts?: (unstorage.TransactionOptions & {
+            removeMeta?: boolean;
+        }) | boolean): Promise<void>;
+        (key: string, opts?: (unstorage.TransactionOptions & {
+            removeMeta?: boolean;
+        }) | boolean): Promise<void>;
+    };
+    remove: {
+        <U extends never, K extends keyof (U extends {
+            [key: string]: unknown;
+            items: unknown;
+        } ? U["items"] : U)>(key: K, opts?: (unstorage.TransactionOptions & {
+            removeMeta?: boolean;
+        }) | boolean): Promise<void>;
+        (key: string, opts?: (unstorage.TransactionOptions & {
+            removeMeta?: boolean;
+        }) | boolean): Promise<void>;
+    };
+}>;
+/**
+ * Session key data stored for each order
+ */
+interface SessionKeyData {
+    /**
+     * The private key as a hex string
+     */
+    privateKey: HexString;
+    /**
+     * The derived public address
+     */
+    address: HexString;
+    /**
+     * The order commitment this session key is associated with.
+     * This may be undefined for session keys that were created
+     * but whose corresponding order has not been finalized yet.
+     */
+    commitment?: HexString;
+    /**
+     * Timestamp when the session key was created
+     */
+    createdAt: number;
+}
+/**
+ * Creates a session key storage instance for IntentGatewayV2 orders.
+ * The storage is used to persist session key private keys so they can be
+ * used later to sign solver selection messages.
+ *
+ * @param options - Optional configuration for the storage driver
+ * @returns A storage instance with methods to get, set, and remove session keys
+ */
+declare function createSessionKeyStorage(options?: SessionKeyStorageOptions): Readonly<{
+    getSessionKey: (commitment: HexString) => Promise<SessionKeyData | null>;
+    getSessionKeyByAddress: (address: HexString) => Promise<SessionKeyData | null>;
+    setSessionKey: (commitment: HexString, data: SessionKeyData) => Promise<void>;
+    setSessionKeyByAddress: (address: HexString, data: SessionKeyData) => Promise<void>;
+    removeSessionKey: (commitment: HexString) => Promise<void>;
+    removeSessionKeyByAddress: (address: HexString) => Promise<void>;
+    listSessionKeys: () => Promise<SessionKeyData[]>;
+}>;
+
+/** placeOrder function selector */
+declare const PLACE_ORDER_SELECTOR = "placeOrder((bytes32,bytes,bytes,uint256,uint256,uint256,address,((bytes32,uint256)[],bytes),(bytes32,uint256)[],(bytes32,(bytes32,uint256)[],bytes)),bytes32)";
+/** placeOrder function parameter type */
+declare const ORDER_V2_PARAM_TYPE = "(bytes32,bytes,bytes,uint256,uint256,uint256,address,((bytes32,uint256)[],bytes),(bytes32,uint256)[],(bytes32,(bytes32,uint256)[],bytes))";
 /** ERC-7821 single batch execution mode */
 declare const ERC7821_BATCH_MODE: HexString;
+/** Bundler RPC method names for ERC-4337 operations */
+declare const BundlerMethod: {
+    readonly ETH_SEND_USER_OPERATION: "eth_sendUserOperation";
+    readonly ETH_GET_USER_OPERATION_RECEIPT: "eth_getUserOperationReceipt";
+    readonly ETH_ESTIMATE_USER_OPERATION_GAS: "eth_estimateUserOperationGas";
+};
+type BundlerMethod = (typeof BundlerMethod)[keyof typeof BundlerMethod];
 /** Response from bundler's eth_estimateUserOperationGas */
 interface BundlerGasEstimate {
     preVerificationGas: HexString;
@@ -3596,22 +3888,16 @@ interface BundlerGasEstimate {
     paymasterVerificationGasLimit?: HexString;
     paymasterPostOpGasLimit?: HexString;
 }
-/** Bundler RPC method names for ERC-4337 operations */
-declare const BundlerMethod: {
-    /** Submit a user operation to the bundler */
-    readonly ETH_SEND_USER_OPERATION: "eth_sendUserOperation";
-    /** Get the receipt of a user operation */
-    readonly ETH_GET_USER_OPERATION_RECEIPT: "eth_getUserOperationReceipt";
-    /** Estimate gas for a user operation */
-    readonly ETH_ESTIMATE_USER_OPERATION_GAS: "eth_estimateUserOperationGas";
-};
-type BundlerMethod = (typeof BundlerMethod)[keyof typeof BundlerMethod];
 /** Event map for cancellation status updates */
 interface CancelEventMap {
     DESTINATION_FINALIZED: {
         proof: IProof;
     };
     AWAITING_GET_REQUEST: undefined;
+    AWAITING_CANCEL_TRANSACTION: {
+        calldata: HexString;
+        to: HexString;
+    };
     SOURCE_FINALIZED: {
         metadata: {
             blockNumber: number;
@@ -3620,6 +3906,11 @@ interface CancelEventMap {
     HYPERBRIDGE_DELIVERED: RequestStatusWithMetadata;
     HYPERBRIDGE_FINALIZED: RequestStatusWithMetadata;
     SOURCE_PROOF_RECEIVED: IProof;
+    CANCELLATION_COMPLETE: {
+        metadata: {
+            blockNumber: number;
+        };
+    };
 }
 type CancelEvent = {
     [K in keyof CancelEventMap]: {
@@ -3627,400 +3918,129 @@ type CancelEvent = {
         data: CancelEventMap[K];
     };
 }[keyof CancelEventMap];
-/** IntentGatewayV2 contract initialization parameters */
-interface IntentGatewayV2Params {
-    host: HexString;
-    dispatcher: HexString;
-    solverSelection: boolean;
-    surplusShareBps: bigint;
-    protocolFeeBps: bigint;
-    priceOracle: HexString;
+
+/** Shared context for IntentsV2 sub-modules */
+interface IntentsV2Context {
+    source: IEvmChain;
+    dest: IEvmChain;
+    intentsCoprocessor?: IntentsCoprocessor;
+    bundlerUrl?: string;
+    feeTokenCache: Map<string, {
+        address: HexString;
+        decimals: number;
+        cachedAt: number;
+    }>;
+    solverCodeCache: Map<string, string>;
+    sessionKeyStorage: ReturnType<typeof createSessionKeyStorage>;
+    cancellationStorage: ReturnType<typeof createCancellationStorage>;
+    swap: Swap;
 }
+
 /**
- * IntentGatewayV2 utilities for placing orders, submitting bids, and managing the intent lifecycle.
+ * IntentsV2 utilities for placing orders, submitting bids, and managing the intent lifecycle.
  *
- * This class provides a complete SDK for interacting with the IntentGatewayV2 protocol:
- * - **Order Placement**: Generate session keys and prepare order transactions
- * - **Bid Management**: Validate, sort, and select optimal bids from solvers
- * - **Execution Flow**: Full lifecycle management from order to completion
- * - **Cancellation**: Handle order cancellation with cross-chain proofs
- *
- * Session keys are automatically managed with environment-appropriate storage
- * (Node.js filesystem, browser localStorage/IndexedDB, or in-memory fallback).
- *
- * @example
- * ```typescript
- * const gateway = new IntentGatewayV2(sourceChain, destChain, coprocessor, bundlerUrl)
- *
- * // Place an order
- * const gen = gateway.preparePlaceOrder(order)
- * const { value: { calldata } } = await gen.next()
- * const txHash = await wallet.sendTransaction({ to: gatewayAddr, data: calldata })
- * const { value: finalOrder } = await gen.next(txHash)
- *
- * // Execute and track
- * for await (const status of gateway.executeIntentOrder({ order: finalOrder })) {
- *   console.log(status.status)
- * }
- * ```
+ * Use `IntentsV2.create()` to obtain an initialized instance.
  */
-declare class IntentGatewayV2 {
-    readonly source: EvmChain;
-    readonly dest: EvmChain;
-    readonly intentsCoprocessor?: IntentsCoprocessor | undefined;
-    readonly bundlerUrl?: string | undefined;
-    /** EIP-712 type hash for SelectSolver message */
-    static readonly SELECT_SOLVER_TYPEHASH: `0x${string}`;
-    /** EIP-712 type hash for PackedUserOperation */
-    static readonly PACKED_USEROP_TYPEHASH: `0x${string}`;
-    /** EIP-712 type hash for EIP712Domain */
-    static readonly DOMAIN_TYPEHASH: `0x${string}`;
-    private readonly sessionKeyStorage;
-    private readonly cancellationStorage;
-    private readonly swap;
-    private readonly feeTokenCache;
-    private initPromise;
-    /**
-     * Creates a new IntentGatewayV2 instance.
+declare class IntentsV2 {
+    readonly source: IEvmChain;
+    readonly dest: IEvmChain;
+    readonly intentsCoprocessor?: IntentsCoprocessor;
+    readonly bundlerUrl?: string;
+    private readonly ctx;
+    private readonly _crypto;
+    private readonly orderPlacer;
+    private readonly orderExecutor;
+    private readonly orderCanceller;
+    private readonly orderStatusChecker;
+    private readonly bidManager;
+    private readonly gasEstimator;
+    private constructor();
+    /**
+     * Creates an initialized IntentsV2 instance.
      *
      * @param source - Source chain for order placement
      * @param dest - Destination chain for order fulfillment
      * @param intentsCoprocessor - Optional coprocessor for bid fetching and order execution
-     * @param bundlerUrl - Optional ERC-4337 bundler URL for gas estimation and UserOp submission.
-     *
-     */
-    constructor(source: EvmChain, dest: EvmChain, intentsCoprocessor?: IntentsCoprocessor | undefined, bundlerUrl?: string | undefined);
-    /**
-     * Ensures the fee token cache is initialized before use.
-     * Called automatically by methods that need the cache.
-     */
-    ensureInitialized(): Promise<void>;
-    /**
-     * Generator function that prepares and places an order.
-     *
-     * Flow:
-     * 1. Generates a session key and sets `order.session`
-     * 2. Encodes the placeOrder calldata and yields `{ calldata, sessionPrivateKey }`
-     * 3. Waits for the user/frontend to submit the transaction and provide the txHash via `next(txHash)`
-     * 4. Fetches the transaction receipt and extracts the OrderPlaced event
-     * 5. Updates `order.nonce` and `order.inputs` from the actual event data
-     * 6. Computes the commitment and sets `order.id`
-     * 7. Stores the session key and returns the finalized order
-     *
-     * @param order - The order to prepare and place
-     * @yields `{ calldata, sessionPrivateKey }` - Encoded placeOrder calldata and session private key
-     * @returns The finalized order with correct nonce, inputs, and commitment from on-chain event
-     *
-     * @example
-     * ```typescript
-     * const generator = gateway.preparePlaceOrder(order)
-     *
-     * // Step 1: Get calldata and private key
-     * const { value: { calldata, sessionPrivateKey } } = await generator.next()
-     *
-     * // Step 2: Submit transaction using the calldata
-     * const txHash = await walletClient.sendTransaction({
-     *   to: intentGatewayV2Address,
-     *   data: calldata,
-     * })
-     *
-     * // Step 3: Pass txHash back to generator and get finalized order
-     * const { value: finalizedOrder } = await generator.next(txHash)
-     * ```
-     */
-    preparePlaceOrder(order: OrderV2): AsyncGenerator<{
+     * @param bundlerUrl - Optional ERC-4337 bundler URL for gas estimation and UserOp submission
+     * @returns Initialized IntentsV2 instance
+     */
+    static create(source: IEvmChain, dest: IEvmChain, intentsCoprocessor?: IntentsCoprocessor, bundlerUrl?: string): Promise<IntentsV2>;
+    private init;
+    execute(order: OrderV2, graffiti?: HexString, options?: {
+        maxPriorityFeePerGasBumpPercent?: number;
+        maxFeePerGasBumpPercent?: number;
+        minBids?: number;
+        bidTimeoutMs?: number;
+        pollIntervalMs?: number;
+    }): AsyncGenerator<{
         calldata: HexString;
         sessionPrivateKey: HexString;
-    }, OrderV2, HexString>;
-    /**
-     * Generator function that orchestrates the full intent order execution flow.
-     *
-     * Flow: AWAITING_BIDS → BIDS_RECEIVED → BID_SELECTED → USEROP_SUBMITTED
-     *
-     * Requires `intentsCoprocessor` and `bundlerUrl` to be set in the constructor.
-     *
-     * @param options - Execution options including the order and optional parameters
-     * @yields Status updates throughout the execution flow
-     *
-     * @example
-     * ```typescript
-     * for await (const status of gateway.executeIntentOrder({ order, orderTxHash: txHash })) {
-     *   switch (status.status) {
-     *     case 'AWAITING_BIDS':
-     *       console.log('Waiting for solver bids...')
-     *       break
-     *     case 'BIDS_RECEIVED':
-     *       console.log(`Received ${status.metadata.bidCount} bids`)
-     *       break
-     *     case 'BID_SELECTED':
-     *       console.log(`Selected solver: ${status.metadata.selectedSolver}`)
-     *       break
-     *     case 'USEROP_SUBMITTED':
-     *       console.log(`UserOp submitted: ${status.metadata.userOpHash}`)
-     *       break
-     *   }
-     * }
-     * ```
-     */
+    } | IntentOrderStatusUpdate, void, HexString>;
+    placeOrder(order: OrderV2, graffiti?: HexString): AsyncGenerator<{
+        calldata: HexString;
+        sessionPrivateKey: HexString;
+    }, OrderV2, any>;
     executeIntentOrder(options: ExecuteIntentOrderOptions): AsyncGenerator<IntentOrderStatusUpdate, void>;
-    /**
-     * Returns the native token amount required to dispatch a cancellation GET request.
-     *
-     * @param order - The order to get the cancellation quote for
-     * @returns Native token amount required for the cancellation GET request
-     */
-    quoteCancelNative(order: OrderV2): Promise<bigint>;
-    /**
-     * Generator function that handles the full order cancellation flow.
-     *
-     * This allows users to cancel orders that haven't been filled by the deadline.
-     *
-     * Flow:
-     * 1. Fetch proof that the order wasn't filled on the destination chain
-     * 2. Submit a GET request to read the unfilled order state
-     * 3. Wait for the GET request to be processed through Hyperbridge
-     * 4. Finalize the cancellation on Hyperbridge
-     *
-     * @param order - The order to cancel
-     * @param indexerClient - Client for querying the indexer
-     * @yields Status updates throughout the cancellation process
-     *
-     * @example
-     * ```typescript
-     * const cancelStream = gateway.cancelOrder(order, indexerClient)
-     *
-     * for await (const event of cancelStream) {
-     *   switch (event.status) {
-     *     case 'DESTINATION_FINALIZED':
-     *       console.log('Got destination proof')
-     *       break
-     *     case 'AWAITING_GET_REQUEST':
-     *       const txHash = await submitCancelTx()
-     *       cancelStream.next(txHash)
-     *       break
-     *     case 'SOURCE_FINALIZED':
-     *       console.log('Source finalized')
-     *       break
-     *     case 'HYPERBRIDGE_DELIVERED':
-     *       console.log('Delivered to Hyperbridge')
-     *       break
-     *     case 'HYPERBRIDGE_FINALIZED':
-     *       console.log('Cancellation complete')
-     *       break
-     *   }
-     * }
-     * ```
-     */
-    cancelOrder(order: OrderV2, indexerClient: IndexerClient): AsyncGenerator<CancelEvent>;
-    /**
-     * Prepares a bid UserOperation for submitting to Hyperbridge (used by fillers/solvers).
-     *
-     * The callData is encoded using ERC-7821 batch executor format since SolverAccount
-     * extends ERC7821. Format: `execute(bytes32 mode, bytes executionData)`
-     * where executionData contains the fillOrder call to IntentGatewayV2.
-     *
-     * @param options - Bid submission options including order, fillOptions, and gas parameters
-     * @returns PackedUserOperation ready for submission to Hyperbridge
-     */
+    quoteCancelNative(order: OrderV2, from?: "source" | "dest"): Promise<bigint>;
+    cancelOrder(order: OrderV2, indexerClient: IndexerClient, from?: "source" | "dest"): AsyncGenerator<CancelEvent>;
     prepareSubmitBid(options: SubmitBidOptions): Promise<PackedUserOperation>;
-    /**
-     * Selects the best bid from Hyperbridge and submits to the bundler.
-     *
-     * Flow:
-     * 1. Fetches bids from Hyperbridge
-     * 2. Validates and sorts bids by USD value (WETH price fetched via swap, USDC/USDT at $1)
-     * 3. Tries each bid (best to worst) until one passes simulation
-     * 4. Signs and submits the winning bid to the bundler
-     *
-     * Requires `bundlerUrl` and `intentsCoprocessor` to be set in the constructor.
-     *
-     * @param order - The order to select a bid for
-     * @param bids - Array of filler bids to evaluate
-     * @param sessionPrivateKey - Optional session private key (retrieved from storage if not provided)
-     * @returns Result containing the selected bid, userOp, and transaction details
-     */
     selectBid(order: OrderV2, bids: FillerBid[], sessionPrivateKey?: HexString): Promise<SelectBidResult>;
-    /**
-     * Estimates gas costs for fillOrder execution via ERC-4337.
-     *
-     * Calculates all gas parameters needed for UserOperation submission:
-     * - `callGasLimit`: Gas for fillOrder execution
-     * - `verificationGasLimit`: Gas for SolverAccount.validateUserOp
-     * - `preVerificationGas`: Bundler overhead for calldata
-     * - Gas prices based on current network conditions
-     *
-     * Uses the bundler's eth_estimateUserOperationGas method for accurate gas estimation
-     * when a bundler URL is configured.
-     *
-     * @param params - Estimation parameters including order and solver account
-     * @returns Complete gas estimate with all ERC-4337 parameters
-     */
     estimateFillOrderV2(params: EstimateFillOrderV2Params): Promise<FillOrderEstimateV2>;
-    /**
-     * Computes the EIP-712 domain separator for a contract.
-     *
-     * @param contractName - Contract name (e.g., "IntentGateway", "ERC4337")
-     * @param version - Contract version
-     * @param chainId - Chain ID
-     * @param contractAddress - Contract address
-     * @returns The domain separator hash
-     */
-    getDomainSeparator(contractName: string, version: string, chainId: bigint, contractAddress: HexString): HexString;
-    /**
-     * Signs a solver selection message using the session key (EIP-712).
-     *
-     * @param commitment - Order commitment hash
-     * @param solverAddress - Address of the selected solver
-     * @param domainSeparator - EIP-712 domain separator
-     * @param privateKey - Session private key
-     * @returns The signature or null if signing fails
-     */
-    signSolverSelection(commitment: HexString, solverAddress: HexString, domainSeparator: HexString, privateKey: HexString): Promise<HexString | null>;
-    /**
-     * Computes the EIP-4337 UserOperation hash.
-     *
-     * @param userOp - The packed user operation
-     * @param entryPoint - EntryPoint contract address
-     * @param chainId - Chain ID
-     * @returns The UserOperation hash
-     */
-    computeUserOpHash(userOp: PackedUserOperation, entryPoint: Hex, chainId: bigint): Hex;
-    /**
-     * Gets the packed user struct hash for a UserOperation.
-     *
-     * @param userOp - The UserOperation to hash
-     * @returns The struct hash
-     */
-    getPackedUserStructHash(userOp: PackedUserOperation): HexString;
-    /** Packs verificationGasLimit and callGasLimit into bytes32 */
-    packGasLimits(verificationGasLimit: bigint, callGasLimit: bigint): HexString;
-    /** Packs maxPriorityFeePerGas and maxFeePerGas into bytes32 */
-    packGasFees(maxPriorityFeePerGas: bigint, maxFeePerGas: bigint): HexString;
-    /** Unpacks accountGasLimits (bytes32) into verificationGasLimit and callGasLimit */
-    unpackGasLimits(accountGasLimits: HexString): {
-        verificationGasLimit: bigint;
-        callGasLimit: bigint;
-    };
-    /** Unpacks gasFees (bytes32) into maxPriorityFeePerGas and maxFeePerGas */
-    unpackGasFees(gasFees: HexString): {
-        maxPriorityFeePerGas: bigint;
-        maxFeePerGas: bigint;
-    };
-    /**
-     * Converts a PackedUserOperation to bundler-compatible v0.7/v0.8 format.
-     * Unpacks gas limits and fees, extracts factory/paymaster data from packed fields.
-     *
-     * @param userOp - The packed user operation to convert
-     * @returns Bundler-compatible user operation object
-     */
-    prepareBundlerCall(userOp: PackedUserOperation): Record<string, unknown>;
-    /**
-     * Sends a JSON-RPC request to the bundler endpoint.
-     *
-     * @param method - The bundler method to call
-     * @param params - Parameters array for the RPC call
-     * @returns The result from the bundler
-     * @throws Error if bundler URL not configured or bundler returns an error
-     */
-    sendBundler<T = unknown>(method: BundlerMethod, params?: unknown[]): Promise<T>;
-    /**
-     * Encodes calls into ERC-7821 execute function calldata.
-     *
-     * Format: `execute(bytes32 mode, bytes executionData)`
-     * Where executionData = abi.encode(calls) and calls = (address target, uint256 value, bytes data)[]
-     *
-     * @param calls - Array of calls to encode
-     * @returns Encoded calldata for execute function
-     */
     encodeERC7821Execute(calls: ERC7821Call[]): HexString;
-    /**
-     * Decodes ERC-7821 execute function calldata back into individual calls.
-     *
-     * @param callData - The execute function calldata to decode
-     * @returns Array of decoded calls, or null if decoding fails
-     */
     decodeERC7821Execute(callData: HexString): ERC7821Call[] | null;
-    /** Initializes the fee token cache for source and destination chains */
-    private initFeeTokenCache;
+    isOrderFilled(order: OrderV2): Promise<boolean>;
+    isOrderRefunded(order: OrderV2): Promise<boolean>;
+}
+
+declare class OrderStatusChecker {
+    private readonly ctx;
+    constructor(ctx: IntentsV2Context);
     /**
-     * Validates bids and sorts them by USD value (best to worst).
+     * Checks if a V2 order has been filled by reading the commitment storage slot on the destination chain.
      *
-     * A bid is valid if `fillOptions.outputs[i].amount >= order.output.assets[i].amount` for all i.
-     * USD value is calculated using USDC/USDT at $1 and WETH price fetched via swap.
-     */
-    private validateAndSortBids;
-    /**
-     * Simulates select + fillOrder to verify execution will succeed.
+     * Reads the storage slot returned by `calculateCommitmentSlotHash` on the IntentGatewayV2 contract.
+     * A non-zero value at that slot means the solver has called `fillOrder` and the order is complete
+     * from the user's perspective (the beneficiary has received their tokens).
      *
-     * No state overrides are used - the solver should already have tokens and approvals.
-     * The contract validates that outputs >= order.output.assets.
+     * @param order - The V2 order to check. `order.id` is used as the commitment; if not set it is computed.
+     * @returns True if the order has been filled on the destination chain, false otherwise.
      */
-    private simulateAndValidate;
+    isOrderFilled(order: OrderV2): Promise<boolean>;
     /**
-     * Unified state override builder for gas estimation.
+     * Checks if a V2 order has been refunded by reading the `_orders` mapping on the source chain.
      *
-     * Builds state overrides for:
-     * - EntryPoint deposit (for ERC-4337 UserOps)
-     * - Native balance
-     * - Token balances and allowances
-     * - IntentGatewayV2 params (solverSelection disabled)
+     * Calls `_orders(commitment, tokenAddress)` for each input token. When the order is placed the
+     * escrowed amounts are stored there. After a successful refund the contract zeroes them out.
+     * An order is considered refunded when all escrowed input amounts have been returned (i.e. are 0).
      *
-     * Returns both viem format (for estimateContractGas) and bundler format (for eth_estimateUserOperationGas).
-     *
-     * @param params - Configuration for state overrides
-     * @returns Object with both viem and bundler format state overrides
-     */
-    buildStateOverride(params: {
-        accountAddress: HexString;
-        chain: string;
-        outputAssets: {
-            token: HexString;
-            amount: bigint;
-        }[];
-        spenderAddress: HexString;
-        intentGatewayV2Address?: HexString;
-        entryPointAddress?: HexString;
-    }): {
-        viem: {
-            address: HexString;
-            balance?: bigint;
-            stateDiff?: {
-                slot: HexString;
-                value: HexString;
-            }[];
-        }[];
-        bundler: Record<string, {
-            balance?: string;
-            stateDiff?: Record<string, string>;
-        }>;
-    };
-    /**
-     * Converts gas costs to the equivalent amount in the fee token (DAI).
-     * Uses USD pricing to convert between native token gas costs and fee token amounts.
+     * @param order - The V2 order to check. `order.id` is used as the commitment; if not set it is computed.
+     * @returns True if all escrowed inputs have been returned to the user on the source chain, false otherwise.
      */
-    private convertGasToFeeToken;
-    /** Gets a quote for the native token cost of dispatching a post request */
-    private quoteNative;
-    /** Fetches proof for the destination chain that the order hasn't been filled */
-    private fetchDestinationProof;
-    /** Submits a GET request message to Hyperbridge and confirms receipt */
-    private submitAndConfirmReceipt;
+    isOrderRefunded(order: OrderV2): Promise<boolean>;
 }
+
 /**
- * Transforms an OrderV2 (SDK type) to the Order struct expected by the contract.
- *
- * Removes SDK-specific fields (`id`, `transactionHash`) and converts
- * source/destination to hex if not already.
+ * Standalone utility to encode calls into ERC-7821 execute function calldata.
+ * Can be used outside of the IntentGatewayV2 class (e.g., by filler strategies
+ * that need to build custom batch calldata for swap+fill operations).
+ */
+declare function encodeERC7821ExecuteBatch(calls: ERC7821Call[]): HexString;
+/**
+ * Fetches proof for the source chain.
  *
- * @param order - The SDK order to transform
- * @returns Contract-compatible order struct
+ * @internal
+ */
+declare function fetchSourceProof(commitment: HexString, source: IEvmChain, sourceStateMachine: string, sourceConsensusStateId: string, sourceHeight: bigint): Promise<IProof>;
+/**
+ * Transforms an OrderV2 (SDK type) to the Order struct expected by the contract.
  */
 declare function transformOrderForContract(order: OrderV2): Omit<OrderV2, "id" | "transactionHash">;
-/** @deprecated Use `IntentGatewayV2.SELECT_SOLVER_TYPEHASH` instead */
+
+/** EIP-712 type hash for SelectSolver message */
 declare const SELECT_SOLVER_TYPEHASH: `0x${string}`;
-/** @deprecated Use `IntentGatewayV2.PACKED_USEROP_TYPEHASH` instead */
+/** EIP-712 type hash for PackedUserOperation */
 declare const PACKED_USEROP_TYPEHASH: `0x${string}`;
-/** @deprecated Use `IntentGatewayV2.DOMAIN_TYPEHASH` instead */
+/** EIP-712 type hash for EIP712Domain */
 declare const DOMAIN_TYPEHASH: `0x${string}`;
 
 /**
@@ -4401,6 +4421,7 @@ declare const tronNile: {
     serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
     verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
 };
+declare const tronChainIds: Set<number>;
 interface ChainConfigData {
     chainId: number;
     stateMachineId: Chains;
@@ -4411,10 +4432,12 @@ interface ChainConfigData {
         DAI: string;
         USDC: string;
         USDT: string;
+        cNGN?: string;
     };
     tokenDecimals?: {
         USDC: number;
         USDT: number;
+        cNGN?: number;
     };
     tokenStorageSlots?: {
         USDT?: {
@@ -4451,6 +4474,8 @@ interface ChainConfigData {
         EntryPointV08?: `0x${string}`;
         /** USDT0 OFT contract address (OFT Adapter on Ethereum, OFT on other chains) */
         Usdt0Oft?: `0x${string}`;
+        /** SolverAccount contract address used for EIP-7702 delegation */
+        SolverAccount?: `0x${string}`;
     };
     rpcEnvKey?: string;
     defaultRpcUrl?: string;
@@ -4466,4 +4491,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 CancelEventMap, type CancelOptions, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedOrderV2PlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type DispatchGet, type DispatchInfoV2, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, type EstimateFillOrderV2Params, type EstimateGasCallData, EvmChain, type EvmChainParams, EvmLanguage, type ExecuteIntentOrderOptions, type ExecutionResult, type FillOptions, type FillOptionsV2, type FillOrderEstimateV2, type FillerBid, type FillerConfig, type GetRequestResponse, type GetRequestWithStatus, type GetResponseByRequestIdResponse, type GetResponseStorageValues, type HexString, type HostParams, HyperClientStatus, type HyperbridgeTxEvents, type IChain, type IConfig, type IEvmConfig, type IGetRequest, type IGetRequestMessage, type IGetResponse, type IGetResponseMessage, type IHyperbridgeConfig, type IIsmpMessage, type IMessage, type IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, IndexerClient, type IndexerQueryClient, IntentGateway, type IntentGatewayParams, IntentGatewayV2, type IntentGatewayV2Params, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusMetadata, type IntentOrderStatusUpdate, IntentsCoprocessor, type IsmpRequest, MOCK_ADDRESS, type NewDeployment, type Order, type OrderResponse, OrderStatus, type OrderStatusMetadata, type OrderV2, type OrderWithStatus, PACKED_USEROP_TYPEHASH, type PackedUserOperation, type Params, type PaymentInfo, type PaymentInfoV2, 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 RetryConfig, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, type SelectBidResult, type SelectOptions, type StateMachineHeight, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, type StorageFacade, type SubmitBidOptions, SubstrateChain, TESTNET_CHAINS, type TeleportParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, TokenGateway, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenInfoV2, type TokenPrice, type TokenPricesResponse, type TokenRegistry, type TokenRegistryResponse, type Transaction, USE_ETHERSCAN_CHAINS, type XcmGatewayParams, __test, adjustDecimals, bytes20ToBytes32, bytes32ToBytes20, calculateBalanceMappingLocation, chainConfigs, constructRedeemEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createChain, createEvmChain, createIndexerClient, createQueryClient, decodeUserOpScale, encodeISMPMessage, encodeUserOpScale, estimateGasForPost, fetchPrice, generateRootWithProof, getChain, getChainId, getConfigByStateMachineId, getContractCallInput, getGasPriceFromEtherscan, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, orderCommitment, orderV2Commitment, parseStateMachineId, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronNile };
+export { ADDRESS_ZERO, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type BidStorageEntry, type BidSubmissionResult, type BlockMetadata, type BundlerGasEstimate, BundlerMethod, type CancelEvent, type CancelEventMap, type CancelOptions, type ChainConfig, type ChainConfigData, ChainConfigService, Chains, type ClientConfig, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DOMAIN_TYPEHASH, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedOrderV2PlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type DispatchGet, type DispatchInfoV2, type DispatchPost, ERC20Method, type ERC7821Call, ERC7821_BATCH_MODE, type EstimateFillOrderV2Params, type EstimateGasCallData, EvmChain, type EvmChainParams, EvmLanguage, type ExecuteIntentOrderOptions, type ExecutionResult, type FillOptions, type FillOptionsV2, type FillOrderEstimateV2, 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 IPostRequest, type IPostResponse, type IProof, type IRequestMessage, type ISubstrateConfig, type ITimeoutPostRequestMessage, IndexerClient, type IndexerQueryClient, IntentGateway, type IntentGatewayParams, IntentOrderStatus, type IntentOrderStatusKey, type IntentOrderStatusMetadata, type IntentOrderStatusUpdate, IntentsCoprocessor, IntentsV2, type IntentsV2Context, type IsmpRequest, MOCK_ADDRESS, type NewDeployment, ORDER_V2_PARAM_TYPE, type Order, type OrderResponse, OrderStatus, OrderStatusChecker, type OrderStatusMetadata, type OrderV2, type OrderWithStatus, PACKED_USEROP_TYPEHASH, PLACE_ORDER_SELECTOR, type PackedUserOperation, type Params, type PaymentInfo, type PaymentInfoV2, 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 RetryConfig, SELECT_SOLVER_TYPEHASH, STATE_COMMITMENTS_SLOT, type SelectBidResult, type SelectOptions, 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 TokenInfoV2, type TokenPrice, type TokenPricesResponse, type TokenRegistry, type TokenRegistryResponse, 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, createChain, createEvmChain, createIndexerClient, createQueryClient, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeISMPMessage, encodeUserOpScale, encodeWithdrawalRequest, estimateGasForPost, fetchPrice, fetchSourceProof, generateRootWithProof, getChain, getChainId, getConfigByStateMachineId, getContractCallInput, getEvmChain, getGasPriceFromEtherscan, getOrFetchStorageSlot, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, getSubstrateChain, getViemChain, hexToString, hyperbridgeAddress, maxBigInt, orderCommitment, orderV2Commitment, parseStateMachineId, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, retryPromise, teleport, teleportDot, transformOrderForContract, tronChainIds, tronNile };