@hyperbridge/sdk 1.0.0 → 1.2.0

package/dist/browser/index.d.ts

@@ -0,0 +1,2190 @@
+import { ConsolaInstance } from 'consola';
+import { GraphQLClient } from 'graphql-request';
+import { Hex, Log, PublicClient } from 'viem';
+import { ApiPromise } from '@polkadot/api';
+import { SignerOptions } from '@polkadot/api/types';
+import { Chain } from 'viem/chains';
+
+type HexString = `0x${string}`;
+interface IConfig {
+    source: IEvmConfig | ISubstrateConfig;
+    dest: IEvmConfig | ISubstrateConfig;
+    hyperbridge: IHyperbridgeConfig;
+    tracing?: boolean;
+}
+interface IEvmConfig {
+    rpcUrl: string;
+    stateMachineId: string;
+    host: string;
+    consensusStateId: string;
+}
+interface ISubstrateConfig {
+    wsUrl: string;
+    consensusStateId: string;
+    hasher: "Keccak" | "Blake2";
+    stateMachineId: string;
+}
+interface IHyperbridgeConfig {
+    wsUrl: string;
+    stateMachineId: string;
+    consensusStateId: string;
+}
+interface IPostRequest {
+    source: string;
+    dest: string;
+    from: HexString;
+    to: HexString;
+    nonce: bigint;
+    body: HexString;
+    timeoutTimestamp: bigint;
+}
+interface IGetRequest {
+    source: string;
+    dest: string;
+    from: HexString;
+    nonce: bigint;
+    height: bigint;
+    keys: HexString[];
+    timeoutTimestamp: bigint;
+    context: HexString;
+}
+interface GetResponseStorageValues {
+    key: HexString;
+    value: HexString;
+}
+interface IPostResponse {
+    post: IPostRequest;
+    response: string;
+    timeoutTimestamp: bigint;
+}
+type IMessage = {
+    Requests: HexString[];
+} | {
+    Responses: HexString[];
+};
+type IndexerQueryClient = GraphQLClient;
+interface ClientConfig {
+    pollInterval: number;
+    queryClient: IndexerQueryClient;
+    tracing?: boolean;
+    source: IEvmConfig | ISubstrateConfig;
+    dest: IEvmConfig | ISubstrateConfig;
+    hyperbridge: IHyperbridgeConfig;
+}
+interface RetryConfig {
+    maxRetries: number;
+    backoffMs: number;
+    logMessage?: string;
+    logger?: ConsolaInstance;
+}
+interface IsmpRequest {
+    source: string;
+    dest: string;
+    from: string;
+    to: string;
+    nonce: bigint;
+    body: string;
+    timeoutTimestamp: bigint;
+    storage_key?: string;
+}
+declare const RequestStatus: Readonly<{
+    SOURCE: "SOURCE";
+    SOURCE_FINALIZED: "SOURCE_FINALIZED";
+    HYPERBRIDGE_DELIVERED: "HYPERBRIDGE_DELIVERED";
+    HYPERBRIDGE_FINALIZED: "HYPERBRIDGE_FINALIZED";
+    DESTINATION: "DESTINATION";
+    TIMED_OUT: "TIMED_OUT";
+    HYPERBRIDGE_TIMED_OUT: "HYPERBRIDGE_TIMED_OUT";
+}>;
+type RequestStatus = typeof RequestStatus;
+type RequestStatusKey = keyof typeof RequestStatus;
+declare const TimeoutStatus: Readonly<{
+    PENDING_TIMEOUT: "PENDING_TIMEOUT";
+    DESTINATION_FINALIZED_TIMEOUT: "DESTINATION_FINALIZED_TIMEOUT";
+    HYPERBRIDGE_TIMED_OUT: "HYPERBRIDGE_TIMED_OUT";
+    HYPERBRIDGE_FINALIZED_TIMEOUT: "HYPERBRIDGE_FINALIZED_TIMEOUT";
+    TIMED_OUT: "TIMED_OUT";
+}>;
+type TimeoutStatus = typeof TimeoutStatus;
+type TimeoutStatusKey = keyof typeof TimeoutStatus;
+type AllStatusKey = RequestStatusKey | TimeoutStatusKey;
+declare enum HyperClientStatus {
+    PENDING = "PENDING",
+    SOURCE_FINALIZED = "SOURCE_FINALIZED",
+    HYPERBRIDGE_FINALIZED = "HYPERBRIDGE_FINALIZED",
+    HYPERBRIDGE_VERIFIED = "HYPERBRIDGE_VERIFIED",
+    DESTINATION = "DESTINATION",
+    TIMED_OUT = "TIMED_OUT",
+    HYPERBRIDGE_TIMED_OUT = "HYPERBRIDGE_TIMED_OUT",
+    ERROR = "ERROR"
+}
+declare enum OrderStatus {
+    PLACED = "PLACED",
+    FILLED = "FILLED",
+    REDEEMED = "REDEEMED",
+    REFUNDED = "REFUNDED"
+}
+declare enum TeleportStatus {
+    TELEPORTED = "TELEPORTED",
+    RECEIVED = "RECEIVED",
+    REFUNDED = "REFUNDED"
+}
+interface TokenGatewayAssetTeleportedResponse {
+    tokenGatewayAssetTeleporteds: {
+        nodes: Array<{
+            id: string;
+            from: string;
+            to: string;
+            sourceChain: string;
+            destChain: string;
+            commitment: string;
+            amount: string;
+            usdValue: string;
+            assetId: string;
+            redeem: boolean;
+            status: TeleportStatus;
+            createdAt: string;
+            blockNumber: string;
+            blockTimestamp: string;
+            transactionHash: string;
+            statusMetadata: {
+                nodes: Array<{
+                    status: TeleportStatus;
+                    chain: string;
+                    timestamp: string;
+                    blockNumber: string;
+                    blockHash: string;
+                    transactionHash: string;
+                }>;
+            };
+        }>;
+    };
+}
+interface TokenGatewayAssetTeleportedWithStatus {
+    id: string;
+    from: string;
+    to: string;
+    sourceChain: string;
+    destChain: string;
+    commitment: string;
+    amount: bigint;
+    usdValue: string;
+    assetId: string;
+    redeem: boolean;
+    status: TeleportStatus;
+    createdAt: Date;
+    blockNumber: bigint;
+    blockTimestamp: bigint;
+    transactionHash: string;
+    statuses: Array<{
+        status: TeleportStatus;
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp: bigint;
+        };
+    }>;
+}
+interface BlockMetadata {
+    blockHash: string;
+    blockNumber: number;
+    transactionHash: string;
+    calldata?: string;
+    timestamp?: number;
+}
+interface PostRequestStatus {
+    status: RequestStatusKey;
+    metadata: Partial<BlockMetadata>;
+}
+interface PostRequestTimeoutStatus {
+    status: TimeoutStatusKey;
+    metadata?: Partial<BlockMetadata>;
+}
+interface StateMachineUpdate {
+    height: number;
+    chain: string;
+    blockHash: string;
+    blockNumber: number;
+    transactionHash: string;
+    transactionIndex: number;
+    stateMachineId: string;
+    timestamp: number;
+}
+interface RequestResponse {
+    requests: {
+        nodes: Array<{
+            source: string;
+            dest: string;
+            to: HexString;
+            from: HexString;
+            nonce: bigint;
+            body: HexString;
+            timeoutTimestamp: bigint;
+            statusMetadata: {
+                nodes: Array<{
+                    blockHash: string;
+                    blockNumber: string;
+                    timestamp: string;
+                    chain: string;
+                    status: string;
+                    transactionHash: string;
+                }>;
+            };
+        }>;
+    };
+}
+interface GetRequestResponse {
+    getRequests: {
+        nodes: Array<{
+            source: string;
+            dest: string;
+            to: HexString;
+            from: HexString;
+            nonce: bigint;
+            height: bigint;
+            keys: HexString[];
+            context: HexString;
+            timeoutTimestamp: bigint;
+            statusMetadata: {
+                nodes: Array<{
+                    blockHash: string;
+                    blockNumber: string;
+                    timestamp: string;
+                    chain: string;
+                    status: string;
+                    transactionHash: string;
+                }>;
+            };
+        }>;
+    };
+}
+type RequestStatusWithMetadata = {
+    status: RequestStatus["SOURCE"];
+    metadata: {
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+} | {
+    status: RequestStatus["SOURCE_FINALIZED"];
+    metadata: {
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+} | {
+    status: RequestStatus["HYPERBRIDGE_DELIVERED"];
+    metadata: {
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+} | {
+    status: RequestStatus["HYPERBRIDGE_FINALIZED"];
+    metadata: {
+        calldata: Hex;
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+} | {
+    status: RequestStatus["DESTINATION"];
+    metadata: {
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+} | {
+    status: TimeoutStatus["PENDING_TIMEOUT"];
+    metadata: {
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+    };
+} | {
+    status: TimeoutStatus["DESTINATION_FINALIZED_TIMEOUT"];
+    metadata: {
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+} | {
+    status: TimeoutStatus["HYPERBRIDGE_TIMED_OUT"];
+    metadata: {
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+} | {
+    status: TimeoutStatus["HYPERBRIDGE_FINALIZED_TIMEOUT"];
+    metadata: {
+        calldata: Hex;
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+} | {
+    status: TimeoutStatus["TIMED_OUT"];
+    metadata: {
+        blockHash: string;
+        blockNumber: number;
+        transactionHash: string;
+        timestamp?: number;
+    };
+};
+interface GenericRequestWithStatuses {
+    source: string;
+    dest: string;
+    from: HexString;
+    nonce: bigint;
+    timeoutTimestamp: bigint;
+    statuses: Array<RequestStatusWithMetadata>;
+}
+interface PostRequestWithStatus extends GenericRequestWithStatuses {
+    to: HexString;
+    body: HexString;
+}
+interface GetRequestWithStatus extends GenericRequestWithStatuses {
+    height: bigint;
+    keys: HexString[];
+    context: HexString;
+}
+interface GetResponseByRequestIdResponse {
+    getResponses: {
+        nodes: Array<{
+            id: string;
+            commitment: string;
+            responseMessage: string[];
+        }>;
+    };
+}
+interface ResponseCommitmentWithValues {
+    commitment: string;
+    values: string[];
+}
+interface RequestCommitment {
+    requests: {
+        nodes: Array<{
+            id: string;
+            commitment: string;
+        }>;
+    };
+}
+interface StateMachineResponse {
+    stateMachineUpdateEvents: {
+        nodes: {
+            height: number;
+            chain: string;
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            transactionIndex: number;
+            stateMachineId: string;
+            createdAt: string;
+        }[];
+    };
+}
+interface AssetTeleported {
+    id: string;
+    from: string;
+    to: string;
+    amount: bigint;
+    dest: string;
+    commitment: string;
+    createdAt: Date;
+    blockNumber: number;
+}
+interface AssetTeleportedResponse {
+    assetTeleporteds: {
+        nodes: AssetTeleported[];
+    };
+}
+interface StateMachineIdParams {
+    stateId: {
+        Evm?: number;
+        Substrate?: HexString;
+        Polkadot?: number;
+        Kusama?: number;
+    };
+    consensusStateId: HexString;
+}
+/**
+ * Configuration for a blockchain chain
+ */
+interface ChainConfig {
+    /**
+     * The unique identifier for the chain
+     */
+    chainId: number;
+    /**
+     * The RPC URL to connect to the chain
+     */
+    rpcUrl: string;
+    /**
+     * The address of the IntentGateway contract on this chain
+     */
+    intentGatewayAddress: string;
+}
+/**
+ * Represents token information for an order
+ */
+interface TokenInfo {
+    /**
+     * The address of the ERC20 token
+     * address(0) is used as a sentinel for the native token
+     */
+    token: HexString;
+    /**
+     * The amount of the token
+     */
+    amount: bigint;
+}
+/**
+ * Represents payment information for an order
+ */
+interface PaymentInfo extends TokenInfo {
+    /**
+     * The address to receive the output tokens
+     */
+    beneficiary: HexString;
+}
+/**
+ * Represents an order in the IntentGateway
+ */
+interface Order {
+    /**
+     * The unique identifier for the order
+     */
+    id?: string;
+    /**
+     * The address of the user who is initiating the transfer
+     */
+    user: HexString;
+    /**
+     * The state machine identifier of the origin chain
+     */
+    sourceChain: string;
+    /**
+     * The state machine identifier of the destination chain
+     */
+    destChain: string;
+    /**
+     * The block number by which the order must be filled on the destination chain
+     */
+    deadline: bigint;
+    /**
+     * The nonce of the order
+     */
+    nonce: bigint;
+    /**
+     * Represents the dispatch fees associated with the IntentGateway
+     */
+    fees: bigint;
+    /**
+     * The tokens that the filler will provide
+     */
+    outputs: PaymentInfo[];
+    /**
+     * The tokens that are escrowed for the filler
+     */
+    inputs: TokenInfo[];
+    /**
+     * A bytes array to store the calls if any
+     */
+    callData: HexString;
+    /**
+     * The transaction hash of the order
+     */
+    transactionHash?: HexString;
+}
+interface DecodedOrderPlacedLog extends Log {
+    eventName: string;
+    args: {
+        user: HexString;
+        sourceChain: Hex;
+        destChain: Hex;
+        deadline: bigint;
+        nonce: bigint;
+        fees: bigint;
+        outputs: Array<{
+            token: HexString;
+            amount: bigint;
+            beneficiary: HexString;
+        }>;
+        inputs: Array<{
+            token: HexString;
+            amount: bigint;
+        }>;
+        callData: HexString;
+    };
+    transactionHash: HexString;
+}
+/**
+ * Options for filling an order
+ */
+interface FillOptions {
+    /**
+     * The fee paid to the relayer for processing transactions
+     */
+    relayerFee: bigint;
+}
+/**
+ * Options for canceling an order
+ */
+interface CancelOptions {
+    /**
+     * The fee paid to the relayer for processing transactions
+     */
+    relayerFee: string;
+    /**
+     * Stores the height value
+     */
+    height: string;
+}
+/**
+ * Represents a new deployment of IntentGateway
+ */
+interface NewDeployment {
+    /**
+     * Identifier for the state machine
+     */
+    stateMachineId: HexString;
+    /**
+     * The gateway identifier
+     */
+    gateway: HexString;
+}
+/**
+ * Represents the body of a request
+ */
+interface RequestBody {
+    /**
+     * Represents the commitment of an order
+     */
+    commitment: HexString;
+    /**
+     * Stores the identifier for the beneficiary
+     */
+    beneficiary: HexString;
+    /**
+     * An array of token identifiers
+     */
+    tokens: TokenInfo[];
+}
+/**
+ * Represents the parameters for the IntentGateway module
+ */
+interface IntentGatewayParams {
+    /**
+     * The address of the host contract
+     */
+    host: string;
+    /**
+     * Address of the dispatcher contract responsible for handling intents
+     */
+    dispatcher: string;
+}
+/**
+ * Enum representing the different kinds of incoming requests
+ */
+declare enum RequestKind {
+    /**
+     * Identifies a request for redeeming an escrow
+     */
+    RedeemEscrow = 0,
+    /**
+     * Identifies a request for recording new contract deployments
+     */
+    NewDeployment = 1,
+    /**
+     * Identifies a request for updating parameters
+     */
+    UpdateParams = 2
+}
+/**
+ * Configuration for the IntentFiller
+ */
+interface FillerConfig {
+    /**
+     * Policy for determining confirmation requirements
+     */
+    confirmationPolicy: {
+        getConfirmationBlocks: (chainId: number, amount: bigint) => number;
+    };
+    /**
+     * Maximum number of orders to process concurrently
+     */
+    maxConcurrentOrders?: number;
+    /**
+     * Minimum profitability threshold to consider filling an order
+     * Expressed as a percentage (e.g., 0.5 = 0.5%)
+     */
+    minProfitabilityThreshold?: number;
+    /**
+     * Gas price strategy for each chain
+     * Maps chainId to a gas price strategy function
+     */
+    gasPriceStrategy?: Record<string, () => Promise<string>>;
+    /**
+     * Maximum gas price willing to pay for each chain
+     * Maps chainId to maximum gas price in wei
+     */
+    maxGasPrice?: Record<string, string>;
+    /**
+     * Retry configuration for failed transactions
+     */
+    retryConfig?: {
+        /**
+         * Maximum number of retry attempts
+         */
+        maxAttempts: number;
+        /**
+         * Initial delay between retries in ms
+         */
+        initialDelayMs: number;
+    };
+    /**
+     * Configuration for the pending queue
+     */
+    pendingQueueConfig?: {
+        /**
+         * Delay in milliseconds before rechecking an order for confirmations
+         * Default: 30000 (30 seconds)
+         */
+        recheckDelayMs?: number;
+        /**
+         * Maximum number of times to recheck an order before giving up
+         * Default: 10
+         */
+        maxRechecks?: number;
+    };
+}
+/**
+ * Result of an order execution attempt
+ */
+interface ExecutionResult {
+    /**
+     * Whether the execution was successful
+     */
+    success: boolean;
+    /**
+     * The transaction hash if successful
+     */
+    txHash?: string;
+    /**
+     * Error message if unsuccessful
+     */
+    error?: string;
+    /**
+     * Gas used by the transaction
+     */
+    gasUsed?: string;
+    /**
+     * Gas price used for the transaction
+     */
+    gasPrice?: string;
+    /**
+     * Total transaction cost in wei
+     */
+    txCost?: string;
+    /**
+     * Block number when the transaction was confirmed
+     */
+    confirmedAtBlock?: number;
+    /**
+     * Timestamp when the transaction was confirmed
+     */
+    confirmedAt?: Date;
+    /**
+     * Actual profitability achieved
+     */
+    actualProfitability?: number;
+    /**
+     * Strategy used to fill the order
+     */
+    strategyUsed?: string;
+    /**
+     * Any tokens exchanged during the fill process
+     */
+    exchanges?: Array<{
+        fromToken: HexString;
+        toToken: HexString;
+        fromAmount: string;
+        toAmount: string;
+        exchangeRate: string;
+    }>;
+    /**
+     * The time it took to fill the order
+     */
+    processingTimeMs?: number;
+}
+/**
+ * Represents a dispatch post for cross-chain communication
+ */
+interface DispatchPost {
+    /**
+     * Bytes representation of the destination state machine
+     */
+    dest: HexString;
+    /**
+     * The destination module
+     */
+    to: HexString;
+    /**
+     * The request body
+     */
+    body: HexString;
+    /**
+     * Timeout for this request in seconds
+     */
+    timeout: bigint;
+    /**
+     * The amount put up to be paid to the relayer,
+     * this is charged in `IIsmpHost.feeToken` to `msg.sender`
+     */
+    fee: bigint;
+    /**
+     * Who pays for this request?
+     */
+    payer: HexString;
+}
+interface DispatchGet {
+    /**
+     * Bytes representation of the destination state machine
+     */
+    dest: HexString;
+    /**
+     * Height at which to read the state machine
+     */
+    height: bigint;
+    /**
+     * Raw storage keys to fetch values from the counterparty
+     */
+    keys: HexString[];
+    /**
+     * Timeout for this request in seconds
+     */
+    timeout: bigint;
+    /**
+     * The amount put up to be paid to the relayer
+     */
+    fee: bigint;
+    /**
+     * Context for the request
+     */
+    context: HexString;
+}
+interface StateMachineHeight {
+    id: {
+        stateId: {
+            Evm?: number;
+            Substrate?: HexString;
+            Polkadot?: number;
+            Kusama?: number;
+        };
+        consensusStateId: HexString;
+    };
+    height: bigint;
+}
+/**
+ * The EvmHost protocol parameters
+ */
+interface HostParams {
+    /**
+     * The default timeout in seconds for messages. If messages are dispatched
+     * with a timeout value lower than this this value will be used instead
+     */
+    defaultTimeout: bigint;
+    /**
+     * The default per byte fee
+     */
+    perByteFee: bigint;
+    /**
+     * The cost for applications to access the hyperbridge state commitment.
+     * They might do so because the hyperbridge state contains the verified state commitments
+     * for all chains and they want to directly read the state of these chains state bypassing
+     * the ISMP protocol entirely.
+     */
+    stateCommitmentFee: bigint;
+    /**
+     * The fee token contract address. This will typically be DAI.
+     * but we allow it to be configurable to prevent future regrets.
+     */
+    feeToken: HexString;
+    /**
+     * The admin account, this only has the rights to freeze, or unfreeze the bridge
+     */
+    admin: HexString;
+    /**
+     * Ismp message handler contract. This performs all verification logic
+     * needed to validate cross-chain messages before they are dispatched to local modules
+     */
+    handler: HexString;
+    /**
+     * The authorized host manager contract, is itself an `IIsmpModule`
+     * which receives governance requests from the Hyperbridge chain to either
+     * withdraw revenue from the host or update its protocol parameters
+     */
+    hostManager: HexString;
+    /**
+     * The local UniswapV2Router02 contract, used for swapping the native token to the feeToken.
+     */
+    uniswapV2: HexString;
+    /**
+     * The unstaking period of Polkadot's validators. In order to prevent long-range attacks
+     */
+    unStakingPeriod: bigint;
+    /**
+     * Minimum challenge period for state commitments in seconds
+     */
+    challengePeriod: bigint;
+    /**
+     * The consensus client contract which handles consensus proof verification
+     */
+    consensusClient: HexString;
+    /**
+     * State machines whose state commitments are accepted
+     */
+    readonly stateMachines: readonly bigint[];
+    /**
+     * The state machine identifier for hyperbridge
+     */
+    hyperbridge: HexString;
+}
+interface OrderStatusMetadata {
+    status: OrderStatus;
+    chain: string;
+    timestamp: bigint;
+    blockNumber: string;
+    transactionHash: string;
+    filler?: string;
+}
+interface OrderWithStatus {
+    id: string;
+    user: string;
+    sourceChain: string;
+    destChain: string;
+    commitment: string;
+    deadline: bigint;
+    nonce: bigint;
+    fees: bigint;
+    inputTokens: string[];
+    inputAmounts: bigint[];
+    inputValuesUSD: string[];
+    inputUSD: string;
+    outputTokens: string[];
+    outputAmounts: bigint[];
+    outputBeneficiaries: string[];
+    calldata: string;
+    status: OrderStatus;
+    createdAt: Date;
+    blockNumber: bigint;
+    blockTimestamp: bigint;
+    transactionHash: string;
+    statuses: Array<{
+        status: OrderStatus;
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp: bigint;
+            filler?: string;
+        };
+    }>;
+}
+interface OrderResponse {
+    orderPlaceds: {
+        nodes: Array<{
+            id: string;
+            user: string;
+            sourceChain: string;
+            destChain: string;
+            commitment: string;
+            deadline: string;
+            nonce: string;
+            fees: string;
+            inputTokens: string[];
+            inputAmounts: string[];
+            inputValuesUSD: string[];
+            inputUSD: string;
+            outputTokens: string[];
+            outputAmounts: string[];
+            outputBeneficiaries: string[];
+            calldata: string;
+            status: OrderStatus;
+            createdAt: string;
+            blockNumber: string;
+            blockTimestamp: string;
+            transactionHash: string;
+            statusMetadata: {
+                nodes: Array<{
+                    status: OrderStatus;
+                    chain: string;
+                    timestamp: string;
+                    blockNumber: string;
+                    blockHash: string;
+                    transactionHash: string;
+                    filler?: string;
+                }>;
+            };
+        }>;
+    };
+}
+declare class AbortSignalInternal extends Error {
+    constructor(message: string);
+    static isError(error: unknown): error is AbortSignalInternal;
+}
+
+declare class ChainConfigService {
+    private rpcUrls;
+    constructor(env?: NodeJS.ProcessEnv);
+    getChainConfig(chain: string): ChainConfig;
+    getIntentGatewayAddress(chain: string): `0x${string}`;
+    getHostAddress(chain: string): `0x${string}`;
+    getWrappedNativeAssetWithDecimals(chain: string): {
+        asset: HexString;
+        decimals: number;
+    };
+    getDaiAsset(chain: string): HexString;
+    getUsdtAsset(chain: string): HexString;
+    getUsdcAsset(chain: string): HexString;
+    getChainId(chain: string): number;
+    getConsensusStateId(chain: string): HexString;
+    getHyperbridgeChainId(): number;
+    getRpcUrl(chain: string): string;
+    getUniswapRouterV2Address(chain: string): HexString;
+    getUniswapV2FactoryAddress(chain: string): HexString;
+    getBatchExecutorAddress(chain: string): HexString;
+    getUniversalRouterAddress(chain: string): HexString;
+    getUniswapV3RouterAddress(chain: string): HexString;
+    getUniswapV3FactoryAddress(chain: string): HexString;
+    getUniswapV3QuoterAddress(chain: string): HexString;
+}
+
+/**
+ * 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 host address of the EVM chain.
+     */
+    host: HexString;
+    /**
+     * The URL of the EVM chain.
+     */
+    url: 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(): 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.
+     * @returns {Promise<HexString>} The encoded storage proof.
+     */
+    queryStateProof(at: bigint, keys: 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): Promise<bigint>;
+    /**
+     * 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
+     */
+    estimateGas(request: IPostRequest): Promise<bigint>;
+    /**
+     * 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>;
+}
+/**
+ * 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;
+/**
+ * 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.
+ *
+ * This function takes a post request and tree size, encodes it according to the PostRequest format,
+ * and generates both the MMR root hash and a proof. The function builds an MMR with `treeSize` leaves,
+ * where most leaves are variations of the encoded request (XORed with their index), except for the
+ * last leaf, which is the unmodified request. The proof is generated for this unmodified leaf.
+ *
+ * @param postRequest - The post request to generate the MMR root and proof for
+ * @param treeSize - Controls how many leaves will be added to the MMR (exactly `treeSize` leaves)
+ * @returns An object containing:
+ *   - root: The MMR root hash as a hex string
+ *   - proof: An array of hex strings representing the MMR proof for the unmodified request
+ *   - index: The index of the unmodified request in the MMR
+ *   - kIndex: The k-index of the unmodified request in the MMR
+ *   - treeSize: The number of leaves in the MMR
+ *   - mmrSize: The size of the MMR in nodes
+ */
+declare function generateRootWithProof(postRequest: IPostRequest, treeSize: bigint): Promise<{
+    root: HexString;
+    proof: HexString[];
+    index: bigint;
+    kIndex: bigint;
+    treeSize: bigint;
+    mmrSize: bigint;
+}>;
+declare function __test(): Promise<string>;
+
+type IStateMachine = {
+    tag: "Evm";
+    value: number;
+} | {
+    tag: "Polkadot";
+    value: number;
+} | {
+    tag: "Kusama";
+    value: number;
+} | {
+    tag: "Substrate";
+    value: number[];
+} | {
+    tag: "Tendermint";
+    value: number[];
+};
+
+declare const ADDRESS_ZERO: HexString;
+declare const DUMMY_PRIVATE_KEY: HexString;
+/**
+ * Calculates the commitment hash for a post request.
+ * @param post The post request to calculate the commitment hash for.
+ * @returns The commitment hash and the encode packed data.
+ */
+declare function postRequestCommitment(post: IPostRequest): {
+    commitment: HexString;
+    encodePacked: HexString;
+};
+declare function orderCommitment(order: Order): HexString;
+/**
+ * Converts a bytes32 token address to bytes20 format
+ * This removes the extra padded zeros from the address
+ */
+declare function bytes32ToBytes20(bytes32Address: string): HexString;
+declare function bytes20ToBytes32(bytes20Address: string): HexString;
+declare function hexToString(hex: string): string;
+/**
+ * Calculates the commitment hash for a get request.
+ * @param get The get request to calculate the commitment hash for.
+ * @returns The commitment hash.
+ */
+declare function getRequestCommitment(get: IGetRequest): HexString;
+/**
+ * Estimates the gas required for a post request transaction on the source chain.
+ * This function constructs a post request, generates mock proofs, and estimates
+ * the gas cost for executing the transaction on the source chain.
+ */
+declare function estimateGasForPost(params: {
+    postRequest: IPostRequest;
+    sourceClient: PublicClient;
+    hostLatestStateMachineHeight: bigint;
+    hostAddress: HexString;
+}): Promise<bigint>;
+/**
+ * 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, beneficiary: HexString): HexString;
+/**
+ * Fetches the USD price of a token from CoinGecko with Defillama fallback
+ * @param identifier - The ticker symbol of the token (e.g., "BTC", "ETH", "USDC") or contract address
+ * @note This function will be replaced by internal price indexer
+ * @returns The USD price of the token as a number (preserves decimals)
+ */
+declare function fetchTokenUsdPrice(identifier: string): Promise<number>;
+/**
+ * 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>;
+
+interface SubstrateChainParams {
+    ws: string;
+    hasher: "Keccak" | "Blake2";
+}
+declare class SubstrateChain implements IChain {
+    private readonly params;
+    api?: ApiPromise;
+    constructor(params: SubstrateChainParams);
+    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.
+     * @returns The state proof as a hexadecimal string.
+     */
+    queryStateProof(at: bigint, keys: 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 convertStateMachineIdToEnum(id: string): IStateMachine;
+declare function encodeISMPMessage(message: IIsmpMessage): Uint8Array;
+
+/**
+ * Type representing an ISMP message.
+ */
+type IIsmpMessage = IRequestMessage | ITimeoutPostRequestMessage | IGetResponseMessage;
+interface IRequestMessage {
+    /**
+     * The kind of message.
+     */
+    kind: "PostRequest";
+    /**
+     * The requests to be posted.
+     */
+    requests: IPostRequest[];
+    /**
+     * The proof of the requests.
+     */
+    proof: IProof;
+    /**
+     * The signer of the message.
+     */
+    signer: HexString;
+}
+interface IGetRequestMessage {
+    /**
+     * The kind of message.
+     */
+    kind: "GetRequest";
+    /**
+     * The requests to be posted.
+     */
+    requests: IGetRequest[];
+    /**
+     * The proof of the requests.
+     */
+    proof: IProof;
+    /**
+     * The signer of the message.
+     */
+    signer: HexString;
+}
+interface IGetResponse {
+    /**
+     * The request that triggered this response.
+     */
+    get: IGetRequest;
+    /**
+     * The response message.
+     */
+    values: GetResponseStorageValues[];
+}
+interface IGetResponseMessage {
+    /**
+     * The kind of message.
+     */
+    kind: "GetResponse";
+    /**
+     * The responses to be posted.
+     */
+    responses: IGetResponse[];
+    /**
+     * The proof of the responses.
+     */
+    proof: IProof;
+    /**
+     * The signer of the message.
+     */
+    signer: HexString;
+}
+interface ITimeoutPostRequestMessage {
+    /**
+     * The kind of message.
+     */
+    kind: "TimeoutPostRequest";
+    /**
+     * The requests to be posted.
+     */
+    requests: IPostRequest[];
+    /**
+     * The proof of the requests.
+     */
+    proof: IProof;
+}
+interface IProof {
+    /**
+     * The height of the proof.
+     */
+    height: bigint;
+    /**
+     * The state machine identifier of the proof.
+     */
+    stateMachine: string;
+    /**
+     * The associated consensus state identifier of the proof.
+     */
+    consensusStateId: string;
+    /**
+     * The encoded storage proof
+     */
+    proof: HexString;
+}
+/**
+ * Interface representing a chain.
+ */
+interface IChain {
+    timestamp(): Promise<bigint>;
+    /**
+     * Returns the state trie key for the request-receipt storage item for the given request commitment.
+     */
+    requestReceiptKey(commitment: HexString): HexString;
+    /**
+     * Query and return the request-receipt for the given request commitment.
+     */
+    queryRequestReceipt(commitment: HexString): Promise<HexString | undefined>;
+    /**
+     * Query and return the encoded storage proof for the provided keys at the given height.
+     */
+    queryStateProof(at: bigint, keys: HexString[]): Promise<HexString>;
+    queryProof(message: IMessage, counterparty: string, at?: bigint): Promise<HexString>;
+    encode(message: IIsmpMessage): HexString;
+    /**
+     * Get the latest state machine height for a given state machine ID.
+     */
+    latestStateMachineHeight(stateMachineId: StateMachineIdParams): Promise<bigint>;
+    /**
+     * Get the challenge period for a given state machine ID.
+     */
+    challengePeriod(stateMachineId: StateMachineIdParams): Promise<bigint>;
+    /**
+     * Get the update time for a statemachine height.
+     */
+    stateMachineUpdateTime(stateMachineHeight: StateMachineHeight): Promise<bigint>;
+}
+/**
+ * Returns the chain interface for a given state machine identifier
+ * @param chainConfig - Chain configuration
+ * @returns Chain interface
+ */
+declare function getChain(chainConfig: IEvmConfig | ISubstrateConfig): Promise<IChain>;
+
+/**
+ * IndexerClient provides methods for interacting with the Hyperbridge indexer.
+ *
+ * This client facilitates querying and tracking cross-chain requests and their status
+ * through the Hyperbridge protocol. It supports:
+ *
+ * - Querying state machine updates by block height or timestamp
+ * - Retrieving request status information by transaction hash
+ * - Monitoring request status changes through streaming interfaces
+ * - Handling request timeout flows and related proof generation
+ * - Tracking request finalization across source and destination chains
+ *
+ * The client implements automatic retries with exponential backoff for network
+ * resilience and provides both simple query methods and advanced streaming
+ * interfaces for real-time status tracking.
+ *
+ * The URLs provided in the configuration must point to archive nodes to allow the client to query for storage proofs
+ * of potentially much older blocks. Regular nodes only store the state for recent blocks and will not be able
+ * to provide the necessary proofs for cross-chain verification, especially in timeout scenarios.
+ *
+ * @example
+ * ```typescript
+ * const client = new IndexerClient({
+ *   url: "https://indexer.hyperbridge.xyz/graphql",
+ *   pollInterval: 2000,
+ *   source: {
+ *		stateMachineId: "EVM-1",
+ * 		consensusStateId: "ETH0"
+ *		rpcUrl: "",
+ *		host: "0x87ea45..",
+ * 	},
+ *   dest: {
+ *		stateMachineId: "EVM-42161",
+ * 		consensusStateId: "ETH0"
+ *		rpcUrl: "",
+ *		host: "0x87ea42345..",
+ * 	},
+ *   hyperbridge: {
+ *     stateMachineId: "POLKADOT-3367",
+ *     consensusStateId: "DOT0"
+ *     wsUrl: "ws://localhost:9944"
+ *   }
+ * });
+ *
+ * // Query a request status
+ * const status = await client.queryRequestWithStatus("0x1234...");
+ *
+ * // Stream status updates
+ * for await (const update of client.postRequestStatusStream("0x1234...")) {
+ *   console.log(`Request status: ${update.status}`);
+ * }
+ * ```
+ */
+declare class IndexerClient {
+    /**
+     * GraphQL client used for making requests to the indexer
+     */
+    private client;
+    /**
+     * Configuration for the IndexerClient including URLs, poll intervals, and chain-specific settings
+     */
+    private config;
+    private logger;
+    /**
+     * Default configuration for retry behavior when network requests fail
+     * - maxRetries: Maximum number of retry attempts before failing
+     * - backoffMs: Initial backoff time in milliseconds (doubles with each retry)
+     */
+    private defaultRetryConfig;
+    /**
+     * Creates a new IndexerClient instance
+     */
+    constructor(config: PartialClientConfig);
+    /**
+     * Query for a single state machine update event greater than or equal to the given height.
+     * @params statemachineId - ID of the state machine
+     * @params height - Starting block height
+     * @params chain - The identifier for the chain where the state machine update should be queried (corresponds to a stateMachineId)
+     * @returns Closest state machine update
+     */
+    queryStateMachineUpdateByHeight({ statemachineId, height, chain, }: {
+        statemachineId: string;
+        chain: string;
+        height: number;
+    }): Promise<StateMachineUpdate | undefined>;
+    /**
+     * Query for a single state machine update event greater than or equal to the given timestamp.
+     * @params statemachineId - ID of the state machine
+     * @params timestamp - Starting block timestamp
+     * @params chain - The identifier for the chain where the state machine update should be queried (corresponds to a stateMachineId)
+     * @returns Closest state machine update
+     */
+    queryStateMachineUpdateByTimestamp({ statemachineId, commitmentTimestamp, chain, }: {
+        statemachineId: string;
+        commitmentTimestamp: bigint;
+        chain: string;
+    }): Promise<StateMachineUpdate | undefined>;
+    /**
+     * Queries a request by CommitmentHash
+     *
+     * @param commitment_hash - Can be commitment
+     * @returns Latest status and block metadata of the request
+     */
+    queryPostRequest(commitment_hash: string): Promise<PostRequestWithStatus | undefined>;
+    /**
+     * Queries a request by any of its associated hashes and returns it alongside its statuses
+     * Statuses will be one of SOURCE, HYPERBRIDGE_DELIVERED and DESTINATION
+     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
+     * @returns Latest status and block metadata of the request
+     */
+    queryGetRequest(hash: string): Promise<GetRequestWithStatus | undefined>;
+    /**
+     * Queries the response associated with a specific request ID and returns its commitment
+     * @param requestId - The ID of the request to find the associated response for
+     * @returns The response associated with the given request ID, or undefined if not found
+     */
+    queryResponseByRequestId(requestId: string): Promise<ResponseCommitmentWithValues | undefined>;
+    /**
+     * Enhances a request with finality events by querying state machine updates.
+     *
+     * This method augments a request object with additional inferred status events
+     * that represent chain finality confirmations. It adds:
+     * - SOURCE_FINALIZED: When the source chain has finalized the request
+     * - HYPERBRIDGE_FINALIZED: When Hyperbridge has finalized the delivery confirmation
+     *
+     * The method also generates appropriate calldata for submitting cross-chain proofs
+     * when applicable.
+     *
+     * @param request - The request to enhance with finality events
+     * @returns The request with finality events added
+     * @private
+     */
+    private addRequestFinalityEvents;
+    /**
+     * Adds timeout finality events to a request by querying for relevant timeout proofs and
+     * chain state necessary for timeout processing.
+     *
+     * This method enhances a request object with additional status events related to the
+     * timeout flow, including:
+     * - PENDING_TIMEOUT: When a request has passed its timeout timestamp
+     * - DESTINATION_FINALIZED: When the destination chain has finalized the timeout timestamp
+     * - HYPERBRIDGE_FINALIZED_TIMEOUT: When hyperbridge has finalized the timeout state
+     *
+     * The method also generates appropriate calldata for submitting timeout proofs.
+     *
+     * @param request - Request to fill timeout events for
+     * @returns Request with timeout events filled in, including any proof calldata for timeout submissions
+     * @private
+     */
+    private addTimeoutFinalityEvents;
+    /**
+     * Queries a request returns it alongside its statuses,
+     * including any finalization events.
+     * @param hash - Commitment hash
+     * @returns Full request data with all inferred status events, including SOURCE_FINALIZED and HYPERBRIDGE_FINALIZED
+     * @remarks Unlike queryRequest(), this method adds derived finalization status events by querying state machine updates
+     */
+    queryRequestWithStatus(hash: string): Promise<PostRequestWithStatus | undefined>;
+    /**
+     * Create a Stream of status updates for a post request.
+     * Stream ends when either the request reaches the destination or times out.
+     * If the stream yields TimeoutStatus.PENDING_TIMEOUT, use postRequestTimeoutStream() to begin timeout processing.
+     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
+     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     * @example
+     *
+     * let client = new IndexerClient(config)
+     * let stream = client.postRequestStatusStream(hash)
+     *
+     * // you can use a for-await-of loop
+     * for await (const status of stream) {
+     *   console.log(status)
+     * }
+     *
+     * // you can also use a while loop
+     * while (true) {
+     *   const status = await stream.next()
+     *   if (status.done) {
+     *     break
+     *   }
+     *   console.log(status.value)
+     * }
+     *
+     */
+    postRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    timeoutStream(timeoutTimestamp: bigint, chain: IChain): AsyncGenerator<RequestStatusWithMetadata, void>;
+    /**
+     * Create a Stream of status updates
+     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
+     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     */
+    private postRequestStatusStreamInternal;
+    private sleep_for;
+    private sleep_for_interval;
+    /**
+     * Create a Stream of status updates for a get request.
+     * Stream ends when either the request reaches the destination or times out.
+     * If the stream yields TimeoutStatus.PENDING_TIMEOUT, use postRequestTimeoutStream() to begin timeout processing.
+     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
+     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     * @example
+     *
+     * let client = new IndexerClient(config)
+     * let stream = client.getRequestStatusStream(hash)
+     *
+     * // you can use a for-await-of loop
+     * for await (const status of stream) {
+     *   console.log(status)
+     * }
+     *
+     * // you can also use a while loop
+     * while (true) {
+     *   const status = await stream.next()
+     *   if (status.done) {
+     *     break
+     *   }
+     *   console.log(status.value)
+     * }
+     *
+     */
+    getRequestStatusStream(hash: HexString): AsyncGenerator<RequestStatusWithMetadata, void>;
+    /**
+     * Create a Stream of status updates
+     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
+     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     */
+    private getRequestStatusStreamInternal;
+    /**
+     * Create a Stream of status updates for a timed out post request.
+     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
+     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     * @example
+     *
+     * let client = new IndexerClient(config)
+     * let stream = client.postRequestTimeoutStream(hash)
+     *
+     * // you can use a for-await-of loop
+     * for await (const status of stream) {
+     *   console.log(status)
+     * }
+     *
+     * // you can also use a while loop
+     * while (true) {
+     *   const status = await stream.next()
+     *   if (status.done) {
+     *     break
+     *   }
+     *   console.log(status.value)
+     * }
+     */
+    postRequestTimeoutStream(hash: HexString): AsyncGenerator<PostRequestTimeoutStatus, void>;
+    /**
+     * Create a Stream of status updates for a timed out post request.
+     * @param hash - Can be commitment, hyperbridge tx hash, source tx hash, destination tx hash, or timeout tx hash
+     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     */
+    postRequestTimeoutStreamInternal(hash: HexString, signal: AbortSignal): AsyncGenerator<PostRequestTimeoutStatus, void>;
+    /**
+     * Query for asset teleported events by sender, recipient, and destination chain
+     * @param from - The sender address
+     * @param to - The recipient address
+     * @param dest - The destination chain ID
+     * @returns The asset teleported event if found, undefined otherwise
+     */
+    queryAssetTeleported(from: string, to: string, dest: string, blockNumber: number): Promise<AssetTeleported | undefined>;
+    /**
+     * Executes an async operation with exponential backoff retry
+     * @param operation - Async function to execute
+     * @param retryConfig - Optional retry configuration
+     * @returns Result of the operation
+     * @throws Last encountered error after all retries are exhausted
+     *
+     * @example
+     * const result = await this.withRetry(() => this.queryStatus(hash));
+     */
+    private withRetry;
+    /**
+     * Query for an order by its commitment hash
+     * @param commitment - The commitment hash of the order
+     * @returns The order with its status if found, undefined otherwise
+     */
+    queryOrder(commitment: HexString): Promise<OrderWithStatus | undefined>;
+    /**
+     * Create a Stream of status updates for an order.
+     * Stream ends when the order reaches a terminal state (FILLED, REDEEMED, or REFUNDED).
+     * @param commitment - The commitment hash of the order
+     * @returns AsyncGenerator that emits status updates until a terminal state is reached
+     * @example
+     *
+     * let client = new IndexerClient(config)
+     * let stream = client.orderStatusStream(commitment)
+     *
+     * // you can use a for-await-of loop
+     * for await (const status of stream) {
+     *   console.log(status)
+     * }
+     *
+     * // you can also use a while loop
+     * while (true) {
+     *   const status = await stream.next()
+     *   if (status.done) {
+     *     break
+     *   }
+     *   console.log(status.value)
+     * }
+     */
+    orderStatusStream(commitment: HexString): AsyncGenerator<{
+        status: OrderStatus;
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp: bigint;
+            filler?: string;
+        };
+    }, void>;
+    tokenGatewayAssetTeleportedStatusStream(commitment: HexString): AsyncGenerator<{
+        status: TeleportStatus;
+        metadata: {
+            blockHash: string;
+            blockNumber: number;
+            transactionHash: string;
+            timestamp: bigint;
+        };
+    }, void>;
+    private queryTokenGatewayAssetTeleported;
+    /**
+     * Aggregate transactions with commitment.
+     * @param commitment
+     * @returns an object containing the transaction hash, block hash, block number, timestamp.
+     */
+    aggregateTransactionWithCommitment(commitment: HexString): Promise<Awaited<ReturnType<SubstrateChain["submitUnsigned"]>>>;
+    waitOrAbort<T>(params: {
+        signal: AbortSignal;
+        promise: () => Promise<T>;
+        predicate?: (a: T) => boolean;
+    }): Promise<NonNullable<T>>;
+}
+interface PartialClientConfig extends Omit<ClientConfig, "pollInterval"> {
+    pollInterval?: number;
+}
+
+declare function createQueryClient(config: {
+    url: string;
+}): GraphQLClient;
+/**
+ * Queries a request by CommitmentHash
+ *
+ * @example
+ * import { createQueryClient, queryRequest } from "@hyperbridge/sdk"
+ *
+ * const queryClient = createQueryClient({
+ *   url: "http://localhost:3000", // URL of the Hyperbridge indexer API
+ * })
+ * const commitmentHash = "0x...."
+ * const request = await queryPostRequest({ commitmentHash, queryClient })
+ */
+declare function queryPostRequest(params: {
+    commitmentHash: string;
+    queryClient: IndexerQueryClient;
+}): Promise<PostRequestWithStatus | undefined>;
+/**
+ * Queries a GET Request by CommitmentHash
+ *
+ * @example
+ * import { createQueryClient, queryRequest } from "@hyperbridge/sdk"
+ *
+ * const queryClient = createQueryClient({
+ *   url: "http://localhost:3000", // URL of the Hyperbridge indexer API
+ * })
+ * const commitmentHash = "0x...."
+ * const request = await queryGetRequest({ commitmentHash, queryClient })
+ */
+declare function queryGetRequest(params: {
+    commitmentHash: string;
+    queryClient: IndexerQueryClient;
+}): Promise<GetRequestWithStatus | undefined>;
+
+/**
+ * IntentGateway handles cross-chain intent operations between EVM chains.
+ * It provides functionality for estimating fill orders, finding optimal swap protocols,
+ * and checking order statuses across different chains.
+ */
+declare class IntentGateway {
+    readonly source: EvmChain;
+    readonly dest: EvmChain;
+    /**
+     * Creates a new IntentGateway instance for cross-chain operations.
+     * @param source - The source EVM chain
+     * @param dest - The destination EVM chain
+     */
+    constructor(source: EvmChain, dest: EvmChain);
+    /**
+     * Estimates the total cost required to fill an order, including gas fees, relayer fees,
+     * protocol fees, and swap operations.
+     *
+     * @param order - The order to estimate fill costs for
+     * @returns The estimated total cost in the source chain's fee token
+     */
+    estimateFillOrder(order: Order): Promise<bigint>;
+    /**
+     * Finds the best Uniswap protocol (V2 or V3) for swapping tokens given a desired output amount.
+     * Compares liquidity and pricing across different protocols and fee tiers.
+     *
+     * @param chain - The chain identifier where the swap will occur
+     * @param tokenIn - The address of the input token
+     * @param tokenOut - The address of the output token
+     * @param amountOut - The desired output amount
+     * @returns Object containing the best protocol, required input amount, fee tier (for V3), and gas estimate
+     */
+    findBestProtocolWithAmountOut(chain: string, tokenIn: HexString, tokenOut: HexString, amountOut: bigint): Promise<{
+        protocol: "v2" | "v3" | null;
+        amountIn: bigint;
+        fee?: number;
+        gasEstimate?: bigint;
+    }>;
+    /**
+     * Finds the best Uniswap protocol (V2 or V3) for swapping tokens given an input amount.
+     * Compares liquidity and pricing across different protocols and fee tiers.
+     *
+     * @param chain - The chain identifier where the swap will occur
+     * @param tokenIn - The address of the input token
+     * @param tokenOut - The address of the output token
+     * @param amountIn - The input amount to swap
+     * @returns Object containing the best protocol, expected output amount, fee tier (for V3), and gas estimate
+     */
+    findBestProtocolWithAmountIn(chain: string, tokenIn: HexString, tokenOut: HexString, amountIn: bigint): Promise<{
+        protocol: "v2" | "v3" | null;
+        amountOut: bigint;
+        fee?: number;
+        gasEstimate?: bigint;
+    }>;
+    /**
+     * 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 gasEstimate - The estimated gas units
+     * @param publicClient - The client for the chain to get gas prices
+     * @param targetDecimals - The decimal places of the target fee token
+     * @returns The gas cost converted to fee token amount
+     * @private
+     */
+    private convertGasToFeeToken;
+    /**
+     * 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
+     */
+    adjustFeeDecimals(feeInFeeToken: bigint, fromDecimals: number, toDecimals: number): bigint;
+    /**
+     * Checks if an order has been filled by verifying the commitment status on-chain.
+     * Reads the storage slot corresponding to the order's commitment hash.
+     *
+     * @param order - The order to check
+     * @returns True if the order has been filled, false otherwise
+     */
+    isOrderFilled(order: Order): Promise<boolean>;
+}
+
+type HyperbridgeTxEvents = {
+    kind: "Ready";
+    transaction_hash: HexString;
+} | {
+    kind: "Dispatched";
+    transaction_hash: HexString;
+    block_number: bigint;
+    commitment: HexString;
+} | {
+    kind: "Finalized";
+    transaction_hash: HexString;
+    block_number?: bigint;
+    commitment?: HexString;
+} | {
+    kind: "Error";
+    error: unknown;
+};
+/**
+ * Parameters for teleporting DOT from Polkadot relay chain to EVM-based destination
+ */
+type XcmGatewayParams = {
+    /**
+     * Destination state machine ID (chain ID) where assets will be teleported to
+     * This value identifies the specific EVM chain in the destination network
+     */
+    destination: number;
+    /**
+     * The recipient address on the destination chain (in hex format)
+     * This is the EVM address that will receive the teleported assets
+     */
+    recipient: HexString;
+    /**
+     * Amount of DOT to teleport
+     * This will be converted to the appropriate format internally
+     */
+    amount: number;
+    /**
+     * Request timeout value in blocks or timestamp
+     * Specifies how long the teleport request remains valid before expiring
+     */
+    timeout: bigint;
+    /**
+     * The parachain ID of the Hyperbridge
+     */
+    paraId: number;
+};
+/**
+ * Teleports DOT tokens from Polkadot relay chain to an EVM-based destination chain
+ * using XCM (Cross-Consensus Message Format) and uses the indexer client to track
+ * the transaction instead of polling hyperbridge blocks.
+ *
+ * This function initiates a teleport transaction, monitors its status through the indexer,
+ * and yields events about the transaction's progress through a ReadableStream.
+ * It handles the complete lifecycle of a teleport operation:
+ * 1. Transaction preparation and signing
+ * 2. Broadcasting to the relay chain
+ * 3. Tracking the transaction via the indexer client
+ * 4. Yielding events about transaction status
+ *
+ * Note: There is no guarantee that both Dispatched and Finalized events will be yielded.
+ * Consumers should listen for either one of these events instead of expecting both.
+ *
+ * @param relayApi - Polkadot API instance connected to the relay chain
+ * @param hyperbridge - Polkadot API instance connected to the Hyperbridge parachain
+ * @param who - Sender's SS58Address address
+ * @param options - Transaction signing options
+ * @param params - Teleport parameters including destination, recipient, and amount
+ * @param indexerClient - The indexer client to track the transaction
+ * @param pollInterval - Optional polling interval in milliseconds (default: 2000)
+ * @yields {HyperbridgeTxEvents} Stream of events indicating transaction status
+ */
+declare function teleportDot(param_: {
+    relayApi: ApiPromise;
+    hyperbridge: ApiPromise;
+    who: string;
+    xcmGatewayParams: XcmGatewayParams;
+    indexerClient: IndexerClient;
+    pollInterval?: number;
+    options: Partial<SignerOptions>;
+}): Promise<ReadableStream<HyperbridgeTxEvents>>;
+
+type Params = {
+    /** Asset symbol for the teleport operation */
+    symbol: string;
+    /**
+     * Destination state machine identifier (e.g., "EVM-1", "SUBSTRATE-cere")
+     * that specifies the target blockchain or network
+     */
+    destination: string;
+    /**
+     * Recipient address in hexadecimal format where the assets will be sent
+     * on the destination chain
+     */
+    recipient: HexString;
+    /**
+     * Amount of tokens to teleport, represented as a bigint to handle
+     * large numeric values precisely
+     */
+    amount: bigint;
+    /**
+     * Request timeout in block numbers or timestamp, after which the
+     * teleport operation will be considered failed
+     */
+    timeout: bigint;
+    /**
+     * Address of the token gateway contract on the destination chain
+     * that will process the teleported assets
+     */
+    tokenGatewayAddress: Uint8Array;
+    /**
+     * Fee paid to relayers who process the cross-chain transaction,
+     * represented as a bigint
+     */
+    relayerFee: bigint;
+    /**
+     * Optional call data to be executed on the destination chain
+     * as part of the teleport operation
+     */
+    callData?: Uint8Array;
+    /**
+     * Flag indicating whether to automatically redeem the tokens
+     * for erc20
+     */
+    redeem: boolean;
+};
+/**
+ * Teleports assets from Substrate to other chains via the token gateway
+ *
+ * Note: There is no guarantee that both Dispatched and Finalized events will be yielded.
+ * Consumers should listen for either one of these events instead of expecting both.
+ *
+ *
+ * @param apiPromise - Polkadot API instance
+ * @param who - SS58Address
+ * @param params - Teleport parameters
+ * @param params.symbol - Asset symbol
+ * @param params.destination - Target state machine ID
+ * @param params.recipient - Recipient address
+ * @param params.amount - Amount to teleport
+ * @param params.timeout - Operation timeout
+ * @param params.tokenGatewayAddress - Gateway contract address
+ * @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
+ */
+declare function teleport(teleport_param: {
+    who: string;
+    params: Params;
+    apiPromise: ApiPromise;
+    options: Partial<SignerOptions>;
+}): Promise<ReadableStream<HyperbridgeTxEvents>>;
+
+declare enum Chains {
+    BSC_CHAPEL = "EVM-97",
+    GNOSIS_CHIADO = "EVM-10200",
+    HYPERBRIDGE_GARGANTUA = "KUSAMA-4009",
+    SEPOLIA = "EVM-11155111"
+}
+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;
+};
+type ChainId = typeof chainIds;
+declare const viemChains: Record<string, Chain>;
+declare const WrappedNativeDecimals: {
+    "EVM-97": number;
+    "EVM-10200": number;
+    "EVM-11155111": number;
+};
+declare const assets: {
+    "EVM-97": {
+        WETH: string;
+        DAI: string;
+        USDC: string;
+        USDT: string;
+    };
+    "EVM-10200": {
+        WETH: string;
+        DAI: string;
+        USDC: string;
+        USDT: string;
+    };
+    "EVM-11155111": {
+        WETH: string;
+        USDC: string;
+        USDT: string;
+        DAI: 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;
+};
+
+export { ADDRESS_ZERO, AbortSignalInternal, type AllStatusKey, type AssetTeleported, type AssetTeleportedResponse, type BlockMetadata, type CancelOptions, type ChainConfig, ChainConfigService, type ChainId, Chains, type ClientConfig, DEFAULT_ADDRESS, DUMMY_PRIVATE_KEY, type DecodedOrderPlacedLog, type DispatchGet, type DispatchPost, 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, 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, SubstrateChain, type SubstrateChainParams, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, type TokenGatewayAssetTeleportedResponse, type TokenGatewayAssetTeleportedWithStatus, type TokenInfo, WrappedNativeDecimals, type XcmGatewayParams, __test, addresses, assets, bytes20ToBytes32, bytes32ToBytes20, chainIds, consensusStateIds, constructRedeemEscrowRequestBody, convertStateMachineIdToEnum, createQueryClient, createRpcUrls, encodeISMPMessage, estimateGasForPost, fetchTokenUsdPrice, generateRootWithProof, getChain, getRequestCommitment, getStateCommitmentFieldSlot, getStateCommitmentSlot, getStorageSlot, hexToString, orderCommitment, postRequestCommitment, queryGetRequest, queryPostRequest, teleport, teleportDot, viemChains };