@hyperbridge/sdk 1.5.1 → 1.6.2

package/dist/node/index.d.ts

@@ -1,8 +1,11 @@
 import { ConsolaInstance } from 'consola';
 import { GraphQLClient } from 'graphql-request';
-import { PublicClient, Hex, ContractFunctionArgs, Log } from 'viem';
+import * as viem from 'viem';
+import { PublicClient, Hex, Log, ContractFunctionArgs } from 'viem';
 import { ApiPromise } from '@polkadot/api';
-import { SignerOptions } from '@polkadot/api/types';
+import { KeyringPair } from '@polkadot/keyring/types';
+import { SignerOptions, SubmittableExtrinsic } from '@polkadot/api/types';
+import { ISubmittableResult } from '@polkadot/types/types';
 import { Chain } from 'viem/chains';
 
 declare const _default: {
@@ -588,10 +591,11 @@ declare const _default: {
 declare class ChainConfigService {
     private rpcUrls;
     constructor(env?: NodeJS.ProcessEnv);
+    private getConfig;
     getChainConfig(chain: string): ChainConfig;
-    getIntentGatewayAddress(chain: string): `0x${string}`;
-    getTokenGatewayAddress(chain: string): `0x${string}`;
-    getHostAddress(chain: string): `0x${string}`;
+    getIntentGatewayAddress(chain: string): HexString;
+    getTokenGatewayAddress(chain: string): HexString;
+    getHostAddress(chain: string): HexString;
     getWrappedNativeAssetWithDecimals(chain: string): {
         asset: HexString;
         decimals: number;
@@ -599,6 +603,8 @@ declare class ChainConfigService {
     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;
@@ -613,6 +619,25 @@ declare class ChainConfigService {
     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;
 }
 
 /**
@@ -866,6 +891,7 @@ type IStateMachine = {
 };
 
 declare const ADDRESS_ZERO: HexString;
+declare const MOCK_ADDRESS: HexString;
 declare const DUMMY_PRIVATE_KEY: HexString;
 declare const DEFAULT_GRAFFITI: HexString;
 /**
@@ -875,6 +901,25 @@ declare const DEFAULT_GRAFFITI: HexString;
  * @returns The larger of the two values
  */
 declare function maxBigInt(a: bigint, b: bigint): bigint;
+/**
+ * Converts a state machine ID string to a stateId object.
+ * Handles formats like:
+ * - "EVM-97" → { Evm: 97 }
+ * - "SUBSTRATE-cere" → { Substrate: "0x63657265" } (hex encoded UTF-8 bytes)
+ * - "POLKADOT-3367" → { Polkadot: 3367 }
+ * - "KUSAMA-123" → { Kusama: 123 }
+ *
+ * @param stateMachineId The state machine ID string
+ * @returns A stateId object conforming to the StateMachineIdParams interface
+ */
+declare function parseStateMachineId(stateMachineId: string): {
+    stateId: {
+        Evm?: number;
+        Substrate?: HexString;
+        Polkadot?: number;
+        Kusama?: number;
+    };
+};
 /**
  * Calculates the commitment hash for a post request.
  * @param post The post request to calculate the commitment hash for.
@@ -885,6 +930,8 @@ declare function postRequestCommitment(post: IPostRequest): {
     encodePacked: HexString;
 };
 declare function orderCommitment(order: Order): HexString;
+/** Calculates the order commitment hash */
+declare function orderV2Commitment(order: OrderV2): HexString;
 /**
  * Converts a bytes32 token address to bytes20 format
  * This removes the extra padded zeros from the address
@@ -927,7 +974,7 @@ declare function estimateGasForPost(params: {
  * 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, beneficiary: HexString): HexString;
+declare function constructRedeemEscrowRequestBody(order: Order | OrderV2, beneficiary: HexString): HexString;
 declare function fetchPrice(identifier: string, chainId?: number, apiKey?: string): Promise<number>;
 /**
  * Fetches the current network gas price from an Etherscan-family explorer API.
@@ -943,6 +990,10 @@ declare enum ERC20Method {
     /** 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
  *
@@ -990,7 +1041,7 @@ declare function getStorageSlot(client: PublicClient, contractAddress: HexString
  * @param toDecimals - The target decimal precision
  * @returns The adjusted fee amount with the target decimal precision
  */
-declare function adjustFeeDecimals(feeInFeeToken: bigint, fromDecimals: number, toDecimals: number): bigint;
+declare function adjustDecimals(feeInFeeToken: bigint, fromDecimals: number, toDecimals: number): bigint;
 /**
  * Chains that should prefer the Etherscan API for gas price lookup
  */
@@ -999,6 +1050,28 @@ 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;
 
 declare class SubstrateChain implements IChain {
     private readonly params;
@@ -1006,6 +1079,9 @@ declare class SubstrateChain implements IChain {
     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.
@@ -1194,6 +1270,113 @@ declare function convertCodecToIProof(codec: {
 }): IProof;
 declare function encodeISMPMessage(message: IIsmpMessage): Uint8Array;
 
+/**
+ * Encodes a PackedUserOperation using SCALE codec for submission to Hyperbridge.
+ * This is the recommended way to encode UserOps for the intents coprocessor.
+ *
+ * @param userOp - The PackedUserOperation to encode
+ * @returns Hex-encoded SCALE bytes
+ */
+declare function encodeUserOpScale(userOp: PackedUserOperation): HexString;
+/**
+ * Decodes a SCALE-encoded PackedUserOperation.
+ *
+ * @param hex - The hex-encoded SCALE bytes
+ * @returns The decoded PackedUserOperation
+ */
+declare function decodeUserOpScale(hex: HexString): PackedUserOperation;
+/**
+ * Service for interacting with Hyperbridge's pallet-intents coprocessor.
+ * Handles bid submission and retrieval for the IntentGatewayV2 protocol.
+ *
+ * Can be created from an existing SubstrateChain instance to share the connection.
+ */
+declare class IntentsCoprocessor {
+    private api;
+    private substratePrivateKey?;
+    private ownsConnection;
+    /**
+     * Creates and connects an IntentsCoprocessor to a Hyperbridge node.
+     * This creates and manages its own API connection.
+     *
+     * @param wsUrl - WebSocket URL of the Hyperbridge node
+     * @param substratePrivateKey - Private key for signing extrinsics (optional for read-only operations)
+     * @returns Promise resolving to a connected IntentsCoprocessor
+     */
+    static connect(wsUrl: string, substratePrivateKey?: string): Promise<IntentsCoprocessor>;
+    /**
+     * Creates an IntentsCoprocessor from an existing SubstrateChain instance.
+     * This shares the connection - the SubstrateChain must already be connected.
+     *
+     * @param chain - Connected SubstrateChain instance (typically Hyperbridge)
+     * @param substratePrivateKey - Private key for signing extrinsics (optional for read-only operations)
+     */
+    static fromSubstrateChain(chain: SubstrateChain, substratePrivateKey?: string): IntentsCoprocessor;
+    /**
+     * Creates an IntentsCoprocessor from an existing ApiPromise instance.
+     *
+     * @param api - Connected ApiPromise instance
+     * @param substratePrivateKey - Private key for signing extrinsics (optional for read-only operations)
+     */
+    static fromApi(api: ApiPromise, substratePrivateKey?: string): IntentsCoprocessor;
+    private constructor();
+    /**
+     * Disconnects the underlying API connection if this instance owns it.
+     * Only disconnects if created via `connect()`, not when using shared connections.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Creates a Substrate keypair from the configured private key
+     * Supports both hex seed (without 0x prefix) and mnemonic phrases
+     */
+    getKeyPair(): KeyringPair;
+    /**
+     * Signs and sends an extrinsic, handling status updates and errors
+     * Implements retry logic with progressive tip increases for stuck transactions
+     */
+    private signAndSendExtrinsic;
+    /**
+     * Sends an extrinsic with a timeout
+     */
+    private sendWithTimeout;
+    /**
+     * Submits a bid to Hyperbridge's pallet-intents
+     *
+     * @param commitment - The order commitment hash (bytes32)
+     * @param userOp - The encoded PackedUserOperation as hex string
+     * @returns BidSubmissionResult with success status and block/extrinsic hash
+     */
+    submitBid(commitment: HexString, userOp: HexString): Promise<BidSubmissionResult>;
+    /**
+     * Retracts a bid from Hyperbridge and reclaims the deposit
+     *
+     * Use this to remove unused quotes and claim back deposited BRIDGE tokens.
+     *
+     * @param commitment - The order commitment hash (bytes32)
+     * @returns BidSubmissionResult with success status and block/extrinsic hash
+     */
+    retractBid(commitment: HexString): Promise<BidSubmissionResult>;
+    /**
+     * Fetches all bid storage entries for a given order commitment.
+     * Returns the on-chain data only (filler addresses and deposits).
+     *
+     * @param commitment - The order commitment hash (bytes32)
+     * @returns Array of BidStorageEntry objects
+     */
+    getBidStorageEntries(commitment: HexString): Promise<BidStorageEntry[]>;
+    /**
+     * Fetches all bids for a given order commitment from Hyperbridge.
+     *
+     * @param commitment - The order commitment hash (bytes32)
+     * @returns Array of FillerBid objects containing filler address, userOp, and deposit
+     */
+    getBidsForOrder(commitment: HexString): Promise<FillerBid[]>;
+    /** Decodes SCALE-encoded Bid struct and SCALE-encoded PackedUserOperation */
+    private decodeBid;
+    /** Builds offchain storage key: "intents::bid::" + commitment + filler */
+    private buildOffchainBidKey;
+}
+
 /**
  * Type representing an ISMP message.
  */
@@ -1754,7 +1937,7 @@ interface StateMachineIdParams {
         Polkadot?: number;
         Kusama?: number;
     };
-    consensusStateId: HexString;
+    consensusStateId: string;
 }
 /**
  * Configuration for a blockchain chain
@@ -1867,6 +2050,32 @@ interface DecodedOrderPlacedLog extends Log {
     };
     transactionHash: HexString;
 }
+interface DecodedOrderV2PlacedLog extends Log {
+    eventName: string;
+    args: {
+        user: HexString;
+        source: Hex;
+        destination: Hex;
+        deadline: bigint;
+        nonce: bigint;
+        fees: bigint;
+        session: HexString;
+        beneficiary: HexString;
+        predispatch: Array<{
+            token: HexString;
+            amount: bigint;
+        }>;
+        inputs: Array<{
+            token: HexString;
+            amount: bigint;
+        }>;
+        outputs: Array<{
+            token: HexString;
+            amount: bigint;
+        }>;
+    };
+    transactionHash: HexString;
+}
 interface DecodedPostRequestEvent extends Log {
     eventName: string;
     args: {
@@ -2036,6 +2245,12 @@ interface FillerConfig {
          */
         maxRechecks?: number;
     };
+    /**
+     * Watch-only mode: per-chain configuration to monitor and log orders without executing fills
+     * Maps chainId to boolean. If a chain is not in this map, defaults to false (normal execution)
+     * Example: { 1: true, 56: false } - watch-only on Ethereum, normal execution on BSC
+     */
+    watchOnly?: Record<number, boolean>;
 }
 /**
  * Result of an order execution attempt
@@ -2160,7 +2375,7 @@ interface StateMachineHeight {
             Polkadot?: number;
             Kusama?: number;
         };
-        consensusStateId: HexString;
+        consensusStateId: string;
     };
     height: bigint;
 }
@@ -2371,6 +2586,197 @@ interface StorageFacade {
     set<T>(key: string, value: T): Promise<void>;
     delete(key: string): Promise<void>;
 }
+interface TokenInfoV2 {
+    token: HexString;
+    amount: bigint;
+}
+interface PaymentInfoV2 {
+    beneficiary: HexString;
+    assets: TokenInfoV2[];
+    call: HexString;
+}
+interface DispatchInfoV2 {
+    assets: TokenInfoV2[];
+    call: HexString;
+}
+interface OrderV2 {
+    id?: string;
+    user: HexString;
+    source: string;
+    destination: string;
+    deadline: bigint;
+    nonce: bigint;
+    fees: bigint;
+    session: HexString;
+    predispatch: DispatchInfoV2;
+    inputs: TokenInfoV2[];
+    output: PaymentInfoV2;
+    transactionHash?: HexString;
+}
+interface FillOptionsV2 {
+    relayerFee: bigint;
+    nativeDispatchFee: bigint;
+    outputs: TokenInfoV2[];
+}
+interface PackedUserOperation {
+    sender: HexString;
+    nonce: bigint;
+    initCode: HexString;
+    callData: HexString;
+    accountGasLimits: HexString;
+    preVerificationGas: bigint;
+    gasFees: HexString;
+    paymasterAndData: HexString;
+    signature: HexString;
+}
+interface SubmitBidOptions {
+    order: OrderV2;
+    fillOptions: FillOptionsV2;
+    solverAccount: HexString;
+    solverPrivateKey: HexString;
+    nonce: bigint;
+    entryPointAddress: HexString;
+    callGasLimit: bigint;
+    verificationGasLimit: bigint;
+    preVerificationGas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}
+interface EstimateFillOrderV2Params {
+    order: OrderV2;
+    solverPrivateKey: HexString;
+    /**
+     * Optional percentage to bump maxPriorityFeePerGas.
+     * This is added on top of the base gasPrice.
+     * Default: 8 (8%)
+     */
+    maxPriorityFeePerGasBumpPercent?: number;
+    /**
+     * Optional percentage to bump maxFeePerGas.
+     * This is added on top of the base gasPrice.
+     * Default: 10 (10%)
+     */
+    maxFeePerGasBumpPercent?: number;
+}
+interface FillOrderEstimateV2 {
+    fillOptions: FillOptionsV2;
+    callGasLimit: bigint;
+    verificationGasLimit: bigint;
+    preVerificationGas: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    totalGasCostWei: bigint;
+    totalGasInFeeToken: bigint;
+    nonce: bigint;
+}
+/**
+ * Result of submitting a bid to Hyperbridge
+ */
+interface BidSubmissionResult {
+    /**
+     * Whether the bid submission was successful
+     */
+    success: boolean;
+    /**
+     * Block hash where the bid was included
+     */
+    blockHash?: HexString;
+    /**
+     * Extrinsic hash of the bid transaction
+     */
+    extrinsicHash?: HexString;
+    /**
+     * Error message if submission failed
+     */
+    error?: string;
+}
+/**
+ * Represents a storage entry from pallet-intents Bids storage
+ * StorageDoubleMap<_, Blake2_128Concat, H256, Blake2_128Concat, AccountId, Balance>
+ */
+interface BidStorageEntry {
+    /** The order commitment hash (H256) */
+    commitment: HexString;
+    /** The filler's Substrate account ID (SS58 encoded) */
+    filler: string;
+    /** The deposit amount stored on-chain (BalanceOf<T> = u128) */
+    deposit: bigint;
+}
+/**
+ * Represents a bid placed by a filler for an order
+ * Matches the Rust struct: Bid<AccountId> { filler: AccountId, user_op: Vec<u8> }
+ */
+interface FillerBid {
+    /** The filler's Substrate account ID (SS58 encoded) */
+    filler: string;
+    /** The decoded PackedUserOperation */
+    userOp: PackedUserOperation;
+    /** The deposit amount stored on-chain (in plancks) */
+    deposit: bigint;
+}
+/**
+ * Options for selecting a solver in IntentGatewayV2
+ */
+interface SelectOptions {
+    /** The order commitment hash (bytes32) */
+    commitment: HexString;
+    /** The solver address to select */
+    solver: HexString;
+    /** The EIP-712 signature from the session key */
+    signature: HexString;
+}
+/** Status stages for the intent order execution flow */
+declare const IntentOrderStatus: Readonly<{
+    ORDER_SUBMITTED: "ORDER_SUBMITTED";
+    ORDER_CONFIRMED: "ORDER_CONFIRMED";
+    AWAITING_BIDS: "AWAITING_BIDS";
+    BIDS_RECEIVED: "BIDS_RECEIVED";
+    BID_SELECTED: "BID_SELECTED";
+    USEROP_SUBMITTED: "USEROP_SUBMITTED";
+    FAILED: "FAILED";
+}>;
+type IntentOrderStatus = typeof IntentOrderStatus;
+type IntentOrderStatusKey = keyof typeof IntentOrderStatus;
+/** Metadata for intent order status updates */
+interface IntentOrderStatusMetadata {
+    commitment?: HexString;
+    transactionHash?: HexString;
+    blockHash?: HexString;
+    blockNumber?: number;
+    bidCount?: number;
+    bids?: FillerBid[];
+    selectedSolver?: HexString;
+    userOpHash?: HexString;
+    userOp?: PackedUserOperation;
+    error?: string;
+}
+/** Status update yielded by the intent order stream */
+interface IntentOrderStatusUpdate {
+    status: IntentOrderStatusKey;
+    metadata: IntentOrderStatusMetadata;
+}
+/** Result of selecting a bid and submitting to the bundler */
+interface SelectBidResult {
+    userOp: PackedUserOperation;
+    userOpHash: HexString;
+    solverAddress: HexString;
+    commitment: HexString;
+    txnHash?: HexString;
+}
+/** Options for executing an intent order */
+interface ExecuteIntentOrderOptions {
+    order: OrderV2;
+    sessionPrivateKey?: HexString;
+    minBids?: number;
+    bidTimeoutMs?: number;
+    pollIntervalMs?: number;
+}
+/** Type for ERC-7821 Call struct */
+type ERC7821Call = {
+    target: `0x${string}`;
+    value: bigint;
+    data: `0x${string}`;
+};
 
 /**
  * Helper function to create chain configuration from legacy config format
@@ -3151,7 +3557,7 @@ declare class IntentGateway {
      * }
      * ```
      */
-    cancelOrder(order: Order, indexerClient: IndexerClient): AsyncGenerator<CancelEvent>;
+    cancelOrder(order: Order, indexerClient: IndexerClient): AsyncGenerator<CancelEvent$1>;
     /**
      * Fetches proof for the destination chain.
      * @param order - The order to fetch proof for
@@ -3159,6 +3565,48 @@ declare class IntentGateway {
      */
     private fetchDestinationProof;
 }
+interface CancelEventMap$1 {
+    DESTINATION_FINALIZED: {
+        proof: IProof;
+    };
+    AWAITING_GET_REQUEST: undefined;
+    SOURCE_FINALIZED: {
+        metadata: {
+            blockNumber: number;
+        };
+    };
+    HYPERBRIDGE_DELIVERED: RequestStatusWithMetadata;
+    HYPERBRIDGE_FINALIZED: RequestStatusWithMetadata;
+    SOURCE_PROOF_RECEIVED: IProof;
+}
+type CancelEvent$1 = {
+    [K in keyof CancelEventMap$1]: {
+        status: K;
+        data: CancelEventMap$1[K];
+    };
+}[keyof CancelEventMap$1];
+
+/** ERC-7821 single batch execution mode */
+declare const ERC7821_BATCH_MODE: HexString;
+/** Response from bundler's eth_estimateUserOperationGas */
+interface BundlerGasEstimate {
+    preVerificationGas: HexString;
+    verificationGasLimit: HexString;
+    callGasLimit: HexString;
+    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;
@@ -3179,6 +3627,401 @@ 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;
+}
+/**
+ * IntentGatewayV2 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)
+ * }
+ * ```
+ */
+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.
+     *
+     * @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<{
+        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
+     *   }
+     * }
+     * ```
+     */
+    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
+     */
+    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;
+    /**
+     * Validates bids and sorts them by USD value (best to worst).
+     *
+     * 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.
+     *
+     * No state overrides are used - the solver should already have tokens and approvals.
+     * The contract validates that outputs >= order.output.assets.
+     */
+    private simulateAndValidate;
+    /**
+     * Unified state override builder for gas estimation.
+     *
+     * Builds state overrides for:
+     * - EntryPoint deposit (for ERC-4337 UserOps)
+     * - Native balance
+     * - Token balances and allowances
+     * - IntentGatewayV2 params (solverSelection disabled)
+     *
+     * 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.
+     */
+    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;
+}
+/**
+ * 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.
+ *
+ * @param order - The SDK order to transform
+ * @returns Contract-compatible order struct
+ */
+declare function transformOrderForContract(order: OrderV2): Omit<OrderV2, "id" | "transactionHash">;
+/** @deprecated Use `IntentGatewayV2.SELECT_SOLVER_TYPEHASH` instead */
+declare const SELECT_SOLVER_TYPEHASH: `0x${string}`;
+/** @deprecated Use `IntentGatewayV2.PACKED_USEROP_TYPEHASH` instead */
+declare const PACKED_USEROP_TYPEHASH: `0x${string}`;
+/** @deprecated Use `IntentGatewayV2.DOMAIN_TYPEHASH` instead */
+declare const DOMAIN_TYPEHASH: `0x${string}`;
 
 /**
  * Result of the quoteNative fee estimation
@@ -3478,11 +4321,12 @@ type Params = {
  * @param params.recipient - Recipient address
  * @param params.amount - Amount to teleport
  * @param params.timeout - Operation timeout
+ * @param params.extrinsics - An array of SubmittableExtrinsic to prepend to the teleport transaction
  * @param params.tokenGatewayAddress - Gateway contract address
+ * @param options - Signer options
  * @param params.relayerFee - Fee for the relayer
  * @param params.redeem - Whether to redeem on arrival
  * @param params.callData - Optional additional call data
- * @param options - Signer options
  * @yields {HyperbridgeTxEvents} Stream of events indicating transaction status
  * @throws Error when asset ID is unknown or transaction fails
  */
@@ -3491,6 +4335,7 @@ declare function teleport(teleport_param: {
     params: Params;
     apiPromise: ApiPromise;
     options: Partial<SignerOptions>;
+    extrinsics?: Array<SubmittableExtrinsic<"promise", ISubmittableResult>>;
 }): Promise<ReadableStream<HyperbridgeTxEvents>>;
 
 declare enum Chains {
@@ -3503,131 +4348,122 @@ declare enum Chains {
     ARBITRUM_MAINNET = "EVM-42161",
     BASE_MAINNET = "EVM-8453",
     POLYGON_MAINNET = "EVM-137",
-    UNICHAIN_MAINNET = "EVM-130"
+    UNICHAIN_MAINNET = "EVM-130",
+    POLYGON_AMOY = "EVM-80002",
+    TRON_MAINNET = "EVM-728126428",
+    TRON_NILE = "EVM-3448148188"
 }
-type AddressMap = {
-    [key: string]: {
-        [K in Chains]?: `0x${string}`;
-    };
-};
-type RpcMap = Record<Chains, string>;
-declare const chainIds: {
-    readonly "EVM-97": 97;
-    readonly "EVM-10200": 10200;
-    readonly "KUSAMA-4009": 4009;
-    readonly "EVM-11155111": 11155111;
-    readonly "EVM-1": 1;
-    readonly "EVM-56": 56;
-    readonly "EVM-42161": 42161;
-    readonly "EVM-8453": 8453;
-    readonly "EVM-137": 137;
-    readonly "EVM-130": 130;
-};
-type ChainId = typeof chainIds;
-declare const viemChains: Record<string, Chain>;
-declare const WrappedNativeDecimals: {
-    "EVM-97": number;
-    "EVM-10200": number;
-    "EVM-11155111": number;
-    "EVM-1": number;
-    "EVM-56": number;
-    "EVM-42161": number;
-    "EVM-8453": number;
-    "EVM-137": number;
-    "EVM-130": number;
-};
-declare const assets: {
-    "EVM-97": {
-        WETH: string;
-        DAI: string;
-        USDC: string;
-        USDT: string;
-    };
-    "EVM-10200": {
-        WETH: string;
-        USDC: string;
-        DAI: string;
-        USDT: string;
-    };
-    "EVM-11155111": {
-        WETH: string;
-        USDC: string;
-        USDT: string;
-        DAI: string;
+/** Tron Nile Testnet (chain ID 3448148188) — not in viem/chains */
+declare const tronNile: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Nile Tronscan";
+            readonly url: "https://nile.tronscan.org";
+        };
     };
-    "EVM-1": {
-        WETH: string;
-        DAI: string;
-        USDC: string;
-        USDT: string;
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: viem.ChainContract | {
+            [sourceId: number]: viem.ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: viem.ChainContract | undefined;
+        ensUniversalResolver?: viem.ChainContract | undefined;
+        multicall3?: viem.ChainContract | undefined;
+        erc6492Verifier?: viem.ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 3448148188;
+    name: "TRON Nile Testnet";
+    nativeCurrency: {
+        readonly name: "TRX";
+        readonly symbol: "TRX";
+        readonly decimals: 6;
     };
-    "EVM-56": {
-        WETH: string;
-        DAI: string;
-        USDC: string;
-        USDT: string;
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://nile.trongrid.io/jsonrpc"];
+        };
     };
-    "EVM-42161": {
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: viem.ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+};
+interface ChainConfigData {
+    chainId: number;
+    stateMachineId: Chains;
+    viemChain?: Chain;
+    wrappedNativeDecimals?: number;
+    assets?: {
         WETH: string;
         DAI: string;
         USDC: string;
         USDT: string;
     };
-    "EVM-8453": {
-        WETH: string;
-        DAI: string;
-        USDC: string;
-        USDT: string;
+    tokenDecimals?: {
+        USDC: number;
+        USDT: number;
     };
-    "EVM-137": {
-        WETH: string;
-        DAI: string;
-        USDC: string;
-        USDT: string;
+    tokenStorageSlots?: {
+        USDT?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        USDC?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        WETH?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
+        DAI?: {
+            balanceSlot: number;
+            allowanceSlot: number;
+        };
     };
-    "EVM-130": {
-        WETH: string;
-        DAI: string;
-        USDC: string;
-        USDT: string;
+    addresses: {
+        IntentGateway?: `0x${string}`;
+        IntentGatewayV2?: `0x${string}`;
+        TokenGateway?: `0x${string}`;
+        Host?: `0x${string}`;
+        UniswapRouter02?: `0x${string}`;
+        UniswapV2Factory?: `0x${string}`;
+        UniswapV3Factory?: `0x${string}`;
+        UniversalRouter?: `0x${string}`;
+        UniswapV3Quoter?: `0x${string}`;
+        UniswapV4Quoter?: `0x${string}`;
+        Calldispatcher?: `0x${string}`;
+        Permit2?: `0x${string}`;
+        /** ERC-4337 v0.8 EntryPoint address (canonical across all EVM chains) */
+        EntryPointV08?: `0x${string}`;
+        /** USDT0 OFT contract address (OFT Adapter on Ethereum, OFT on other chains) */
+        Usdt0Oft?: `0x${string}`;
     };
-};
-declare const addresses: AddressMap;
-declare const createRpcUrls: (env: NodeJS.ProcessEnv) => RpcMap;
-declare const consensusStateIds: {
-    "EVM-97": string;
-    "EVM-10200": string;
-    "KUSAMA-4009": string;
-    "EVM-11155111": string;
-    "EVM-1": string;
-    "EVM-56": string;
-    "EVM-42161": string;
-    "EVM-8453": string;
-    "EVM-137": string;
-    "EVM-130": string;
-};
-declare const coingeckoIds: {
-    "EVM-97": string;
-    "EVM-10200": string;
-    "KUSAMA-4009": string;
-    "EVM-11155111": string;
-    "EVM-1": string;
-    "EVM-56": string;
-    "EVM-42161": string;
-    "EVM-8453": string;
-    "EVM-137": string;
-    "EVM-130": string;
-};
-declare const popularTokens: {
-    "EVM-97": string[];
-    "EVM-10200": string[];
-    "EVM-11155111": string[];
-    "EVM-1": string[];
-    "EVM-56": string[];
-    "EVM-42161": string[];
-    "EVM-8453": string[];
-    "EVM-137": string[];
-    "EVM-130": string[];
-};
+    rpcEnvKey?: string;
+    defaultRpcUrl?: string;
+    consensusStateId: string;
+    coingeckoId: string;
+    popularTokens?: string[];
+    /** LayerZero Endpoint ID for cross-chain messaging */
+    layerZeroEid?: number;
+}
+declare const chainConfigs: Record<number, ChainConfigData>;
+declare const getConfigByStateMachineId: (id: Chains) => ChainConfigData | undefined;
+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 BlockMetadata, type CancelOptions, type ChainConfig, ChainConfigService, type ChainId, Chains, type ClientConfig, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DecodedPostRequestEvent, type DecodedPostResponseEvent, type DispatchGet, type DispatchPost, ERC20Method, type EstimateGasCallData, EvmChain, type EvmChainParams, type ExecutionResult, type FillOptions, 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, type IsmpRequest, type NewDeployment, type Order, type OrderResponse, OrderStatus, type OrderStatusMetadata, type OrderWithStatus, type Params, type PaymentInfo, 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, STATE_COMMITMENTS_SLOT, type StateMachineHeight, type StateMachineIdParams, type StateMachineResponse, type StateMachineUpdate, type StorageFacade, SubstrateChain, TESTNET_CHAINS, type TeleportParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, TokenGateway, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, type TokenPrice, type TokenPricesResponse, type TokenRegistry, type TokenRegistryResponse, type Transaction, USE_ETHERSCAN_CHAINS, WrappedNativeDecimals, type XcmGatewayParams, __test, addresses, adjustFeeDecimals, assets, bytes20ToBytes32, bytes32ToBytes20, chainIds, coingeckoIds, consensusStateIds, constructRedeemEscrowRequestBody, convertCodecToIGetRequest, convertCodecToIProof, convertIGetRequestToCodec, convertIProofToCodec, convertStateIdToStateMachineId, convertStateMachineEnumToString, convertStateMachineIdToEnum, createChain, createEvmChain, createIndexerClient, createQueryClient, createRpcUrls, encodeISMPMessage, estimateGasForPost, fetchPrice, generateRootWithProof, getChain, getGasPriceFromEtherscan, getOrderPlacedFromTx, getPostRequestEventFromTx, getPostResponseEventFromTx, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, hexToString, maxBigInt, orderCommitment, popularTokens, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, retryPromise, teleport, teleportDot, viemChains };
+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 };