@hyperbridge/sdk 1.4.9 → 1.5.0-rc0000000001

package/README.md

@@ -141,6 +141,104 @@ const hyperbridge = new SubstrateChain({
 const proof = await hyperbridge.queryStateProof(blockNumber, keys)
 ```
 
+### TokenGateway - Cross-Chain Token Transfers
+
+The TokenGateway class provides methods for estimating fees and managing cross-chain token teleports via Hyperbridge. Supports both EVM and Substrate chains as destination.
+
+```ts
+import { TokenGateway, EvmChain, SubstrateChain } from "@hyperbridge/sdk"
+import { keccak256, toHex, pad, parseEther } from "viem"
+
+// Create chain instances
+const sourceChain = new EvmChain({
+	chainId: 97, // BSC Testnet
+	rpcUrl: "https://data-seed-prebsc-1-s1.binance.org:8545",
+	host: "0x...", // IsmpHost contract address
+	consensusStateId: "BSC0"
+})
+
+const destChain = new EvmChain({
+	chainId: 10200, // Gnosis Chiado
+	rpcUrl: "https://rpc.chiadochain.net",
+	host: "0x...", // IsmpHost contract address
+	consensusStateId: "GNO0"
+})
+
+// Initialize TokenGateway (destination can be EvmChain or SubstrateChain)
+const tokenGateway = new TokenGateway({
+	source: sourceChain,
+	dest: destChain // EvmChain or SubstrateChain
+})
+
+// Estimate fees for a teleport
+const assetId = keccak256(toHex("USDC")) // Asset identifier
+const recipientAddress = pad("0xRecipientAddress", { size: 32 })
+
+const teleportParams = {
+	amount: parseEther("100"), // Amount to teleport
+	assetId: assetId,
+	redeem: true, // Redeem as ERC20 on destination
+	to: recipientAddress,
+	dest: "EVM-10200", // Destination chain
+	timeout: 3600n, // Timeout in seconds
+	data: "0x" // Optional call data
+}
+
+// Get native cost estimate (protocol + relayer fees)
+// For EVM destination chains, the relayer fee is automatically estimated by:
+// 1. Creating a dummy post request with 191 bytes of random data
+// 2. Estimating gas for delivery on the destination chain
+// 3. Converting gas cost to native tokens and adding 1% buffer
+// 4. Converting relayer fee to source fee token using getAmountsOut
+// For Substrate destination chains, relayer fee is set to zero
+// Returns: totalNativeCost (protocol fee with 1% buffer) and relayerFeeInSourceFeeToken
+const { totalNativeCost, relayerFeeInSourceFeeToken } = await tokenGateway.quoteNative(teleportParams)
+console.log(`Total native cost: ${totalNativeCost} wei`)
+console.log(`Relayer fee in fee token: ${relayerFeeInSourceFeeToken}`)
+
+// Example with Substrate destination
+const substrateDestChain = new SubstrateChain({
+	stateMachineId: "KUSAMA-4009",
+	wsUrl: "wss://gargantua.polytope.technology",
+	hasher: "Keccak",
+	consensusStateId: "PAS0"
+})
+
+const tokenGatewayToSubstrate = new TokenGateway({
+	source: sourceChain,
+	dest: substrateDestChain // SubstrateChain destination
+})
+
+// For Substrate destinations, relayer fee will be 0
+const { totalNativeCost: substrateCost, relayerFeeInSourceFeeToken: substrateRelayerFee } = 
+	await tokenGatewayToSubstrate.quoteNative({
+		amount: parseEther("100"),
+		assetId: assetId,
+		redeem: true,
+		to: recipientAddress,
+		dest: "KUSAMA-4009",
+		timeout: 3600n
+	})
+console.log(`Substrate destination - Native cost: ${substrateCost} wei`)
+console.log(`Substrate destination - Relayer fee: ${substrateRelayerFee}`) // Will be 0
+
+// Get token addresses
+const erc20Address = await tokenGateway.getErc20Address(assetId)
+const erc6160Address = await tokenGateway.getErc6160Address(assetId)
+
+// Get gateway parameters
+const params = await tokenGateway.getParams()
+console.log(`Host: ${params.host}, Dispatcher: ${params.dispatcher}`)
+```
+
+**TokenGateway Methods:**
+
+- `quoteNative(params)` - Estimate native token cost for a teleport operation. For EVM destination chains, the relayer fee is automatically estimated by generating a dummy post request with 191 bytes of random data, estimating gas on the destination chain, converting to native tokens, and adding a 1% buffer to the relayer fee. The relayer fee is then converted to source chain fee token using Uniswap V2's `getAmountsOut`. For Substrate destinations, relayer fee is set to zero. Returns an object with `totalNativeCost` (relayer fee + protocol fee, both with 1% buffers) and `relayerFeeInSourceFeeToken` (relayer fee converted to source chain fee token).
+- `getErc20Address(assetId)` - Get the ERC20 contract address for an asset
+- `getErc6160Address(assetId)` - Get the ERC6160 (hyper-fungible) contract address for an asset
+- `getInstanceAddress(destination)` - Get the TokenGateway address on the destination chain
+- `getParams()` - Get the TokenGateway contract parameters (host and dispatcher addresses)
+
 ## Vite Integration
 
 If you're using Vite in your project, Hyperbridge SDK includes a plugin to handle WebAssembly dependencies correctly.
@@ -169,9 +267,10 @@ The plugin automatically copies the necessary WebAssembly files to the correct l
 
 ### Classes
 
-- IndexerClient - Main client for interacting with the indexer
-- EvmChain - Utilities for EVM chain interaction
-- SubstrateChain - Utilities for Substrate chain interaction
+- **IndexerClient** - Main client for interacting with the indexer
+- **EvmChain** - Utilities for EVM chain interaction
+- **SubstrateChain** - Utilities for Substrate chain interaction
+- **TokenGateway** - Utilities for cross-chain token transfers and fee estimation
 
 ### Types
 

package/dist/browser/index.d.ts

@@ -2,7 +2,8 @@ import { ConsolaInstance } from 'consola';
 import { GraphQLClient } from 'graphql-request';
 import { PublicClient, Hex, ContractFunctionArgs, Log } from 'viem';
 import { ApiPromise } from '@polkadot/api';
-import { SignerOptions } from '@polkadot/api/types';
+import { SignerOptions, SubmittableExtrinsic } from '@polkadot/api/types';
+import { ISubmittableResult } from '@polkadot/types/types';
 import { Chain } from 'viem/chains';
 
 declare const _default: {
@@ -590,6 +591,7 @@ declare class ChainConfigService {
     constructor(env?: NodeJS.ProcessEnv);
     getChainConfig(chain: string): ChainConfig;
     getIntentGatewayAddress(chain: string): `0x${string}`;
+    getTokenGatewayAddress(chain: string): `0x${string}`;
     getHostAddress(chain: string): `0x${string}`;
     getWrappedNativeAssetWithDecimals(chain: string): {
         asset: HexString;
@@ -3079,6 +3081,15 @@ declare class IntentGateway {
      * @returns True if the order has been filled, false otherwise
      */
     isOrderFilled(order: Order): Promise<boolean>;
+    /**
+     * Checks if an order has been refunded by verifying the escrowed token amounts on-chain.
+     * Reads the storage slots for the `_orders` mapping on the source chain (where the escrow is held).
+     * An order is considered refunded when all input token amounts in the `_orders` mapping are 0.
+     *
+     * @param order - The order to check
+     * @returns True if the order has been refunded (all token amounts are 0), false otherwise
+     */
+    isOrderRefunded(order: Order): Promise<boolean>;
     private submitAndConfirmReceipt;
     /**
      * Returns the native token amount required to dispatch a cancellation GET request for the given order.
@@ -3170,6 +3181,124 @@ type CancelEvent = {
     };
 }[keyof CancelEventMap];
 
+/**
+ * Result of the quoteNative fee estimation
+ */
+interface QuoteNativeResult {
+    /** Total native token cost including relayer fee and protocol fee with 1% buffer */
+    totalNativeCost: bigint;
+    /** Relayer fee converted to source chain fee token */
+    relayerFeeInSourceFeeToken: bigint;
+}
+/**
+ * Parameters for token gateway teleport operations
+ */
+interface TeleportParams {
+    /** Amount to be sent */
+    amount: bigint;
+    /** The token identifier to send */
+    assetId: HexString;
+    /** Redeem ERC20 on the destination? */
+    redeem: boolean;
+    /** Recipient address */
+    to: HexString;
+    /** Recipient state machine */
+    dest: string | Uint8Array;
+    /** Request timeout in seconds */
+    timeout: bigint;
+    /** Destination contract call data */
+    data?: HexString | Uint8Array;
+}
+/**
+ * TokenGateway class for managing cross-chain token transfers via Hyperbridge
+ *
+ * This class provides methods to interact with the TokenGateway contract, including
+ * estimating fees for cross-chain token teleports.
+ *
+ * Supports both EVM and Substrate chains as destination.
+ *
+ * @example
+ * ```typescript
+ * const tokenGateway = new TokenGateway({
+ *   source: sourceChain,
+ *   dest: destChain // Can be EvmChain or SubstrateChain
+ * })
+ *
+ * const teleportParams: TeleportParams = {
+ *   amount: parseEther("1.0"),
+ *   assetId: keccak256(toHex("USDC")),
+ *   redeem: true,
+ *   to: pad("0xRecipientAddress", { size: 32 }),
+ *   dest: "EVM-1",
+ *   timeout: 3600n,
+ * }
+ *
+ * // Estimate native cost (relayer fee + protocol fee with 1% buffer)
+ * const { totalNativeCost, relayerFeeInSourceFeeToken } = await tokenGateway.quoteNative(teleportParams)
+ * console.log(`Total native cost: ${formatEther(totalNativeCost)} ETH`)
+ * console.log(`Relayer fee in fee token: ${relayerFeeInSourceFeeToken}`)
+ * ```
+ */
+declare class TokenGateway {
+    private readonly source;
+    private readonly dest;
+    constructor(params: {
+        source: EvmChain;
+        dest: EvmChain | SubstrateChain;
+    });
+    /**
+     * Get the TokenGateway contract address for a given chain
+     *
+     * @param chain - The chain identifier (e.g., "EVM-1", "EVM-56")
+     * @returns The TokenGateway contract address
+     */
+    private getTokenGatewayAddress;
+    /**
+     * Estimate the native token cost for a token gateway teleport operation.
+     * This includes both relayer fees and protocol fees for cross-chain delivery.
+     *
+     * The relayer fee is automatically estimated for EVM destination chains by:
+     * 1. Creating a dummy post request with 191 bytes of random data in the body
+     * 2. Estimating gas for delivery on the destination chain
+     * 3. Converting the gas estimate to native tokens
+     * 4. Adding a 1% buffer to the relayer fee for safety margin
+     *
+     * For non-EVM destination chains, the relayer fee is set to zero.
+     *
+     * The function then constructs a proper post request and calls quoteNative on the
+     * source chain to get protocol fees (with 1% buffer), converts the relayer fee to
+     * source chain fee token using Uniswap V2's getAmountsOut, and returns both values.
+     *
+     * @param params - The teleport parameters
+     * @returns Object containing totalNativeCost (with 1% buffer) and relayerFeeInSourceFeeToken
+     *
+     * @throws Will throw an error if the contract call fails
+     *
+     * @example
+     * ```typescript
+     * const params: TeleportParams = {
+     *   amount: parseEther("1.0"),
+     *   assetId: keccak256(toHex("USDC")),
+     *   redeem: true,
+     *   to: pad("0xRecipientAddress", { size: 32 }),
+     *   dest: "EVM-1",
+     *   timeout: 3600n,
+     *   data: "0x"
+     * }
+     *
+     * const { totalNativeCost, relayerFeeInSourceFeeToken } = await tokenGateway.quoteNative(params)
+     * console.log(`Total native cost: ${formatEther(totalNativeCost)} ETH`)
+     * console.log(`Relayer fee in fee token: ${relayerFeeInSourceFeeToken}`)
+     * ```
+     */
+    quoteNative(params: TeleportParams): Promise<QuoteNativeResult>;
+    /**
+     * Convert native token amount to fee token amount using Uniswap V2 router
+     * @private
+     */
+    private convertNativeToFeeToken;
+}
+
 /**
  * Extracts the IntentGateway OrderPlaced event from a transaction hash.
  * @param client - A viem PublicClient-compatible instance
@@ -3364,6 +3493,44 @@ declare function teleport(teleport_param: {
     apiPromise: ApiPromise;
     options: Partial<SignerOptions>;
 }): Promise<ReadableStream<HyperbridgeTxEvents>>;
+/**
+ * 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 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
+ * @yields {HyperbridgeTxEvents} Stream of events indicating transaction status
+ * @throws Error when asset ID is unknown or transaction fails
+ */
+declare function makeTeleportExtrinsics(teleport_param: {
+    params: Params;
+    apiPromise: ApiPromise;
+}): Promise<SubmittableExtrinsic<"promise", ISubmittableResult>>;
+/**
+ *
+ * @param extrinsic - SubmittableExtrinsic
+ * @param who - SS58Address
+ * @param options - Signer options
+ * @returns
+ */
+declare function submitExtrinsics({ extrinsics: tx, who, options, apiPromise, }: {
+    extrinsics: SubmittableExtrinsic<"promise", any>;
+    apiPromise: ApiPromise;
+    who: string;
+    options: Partial<SignerOptions>;
+}): ReadableStream<HyperbridgeTxEvents>;
 
 declare enum Chains {
     BSC_CHAPEL = "EVM-97",
@@ -3502,4 +3669,4 @@ declare const popularTokens: {
     "EVM-130": string[];
 };
 
-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, 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, TeleportStatus, TimeoutStatus, type TimeoutStatusKey, 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 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, makeTeleportExtrinsics, maxBigInt, orderCommitment, popularTokens, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, retryPromise, submitExtrinsics, teleport, teleportDot, viemChains };

package/dist/browser/index.js

@@ -3471,6 +3471,17 @@ var addresses = {
     ["EVM-137" /* POLYGON_MAINNET */]: "0x1a4ee689a004b10210a1df9f24a387ea13359acf",
     ["EVM-130" /* UNICHAIN_MAINNET */]: "0x1a4ee689a004b10210a1df9f24a387ea13359acf"
   },
+  TokenGateway: {
+    ["EVM-97" /* BSC_CHAPEL */]: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
+    ["EVM-10200" /* GNOSIS_CHIADO */]: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
+    ["EVM-11155111" /* SEPOLIA */]: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
+    ["EVM-1" /* MAINNET */]: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
+    ["EVM-56" /* BSC_MAINNET */]: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
+    ["EVM-42161" /* ARBITRUM_MAINNET */]: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
+    ["EVM-8453" /* BASE_MAINNET */]: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
+    ["EVM-137" /* POLYGON_MAINNET */]: "0x8b536105b6Fae2aE9199f5146D3C57Dfe53b614E",
+    ["EVM-130" /* UNICHAIN_MAINNET */]: "0x8b536105b6Fae2aE9199f5146D3C57Dfe53b614E"
+  },
   Host: {
     ["EVM-97" /* BSC_CHAPEL */]: "0x8Aa0Dea6D675d785A882967Bf38183f6117C09b7",
     ["EVM-10200" /* GNOSIS_CHIADO */]: "0x58a41b89f4871725e5d898d98ef4bf917601c5eb",
@@ -3662,6 +3673,9 @@ var ChainConfigService = class {
   getIntentGatewayAddress(chain) {
     return addresses.IntentGateway[chain];
   }
+  getTokenGatewayAddress(chain) {
+    return addresses.TokenGateway[chain];
+  }
   getHostAddress(chain) {
     return addresses.Host[chain];
   }
@@ -12883,6 +12897,40 @@ var IntentGateway = class {
     });
     return filledStatus !== "0x0000000000000000000000000000000000000000000000000000000000000000";
   }
+  /**
+   * Checks if an order has been refunded by verifying the escrowed token amounts on-chain.
+   * Reads the storage slots for the `_orders` mapping on the source chain (where the escrow is held).
+   * An order is considered refunded when all input token amounts in the `_orders` mapping are 0.
+   *
+   * @param order - The order to check
+   * @returns True if the order has been refunded (all token amounts are 0), false otherwise
+   */
+  async isOrderRefunded(order) {
+    order = transformOrder(order);
+    const intentGatewayAddress = this.destIntentGatewayAddress ?? this.source.configService.getIntentGatewayAddress(order.sourceChain);
+    const commitment = order.id;
+    const ORDERS_MAPPING_SLOT = 4n;
+    const firstLevelSlot = keccak256(
+      encodeAbiParameters([{ type: "bytes32" }, { type: "uint256" }], [commitment, ORDERS_MAPPING_SLOT])
+    );
+    for (const input of order.inputs) {
+      const tokenAddress = bytes32ToBytes20(input.token);
+      const storageSlot = keccak256(
+        encodeAbiParameters(
+          [{ type: "address" }, { type: "bytes32" }],
+          [tokenAddress, firstLevelSlot]
+        )
+      );
+      const escrowedAmount = await this.source.client.getStorageAt({
+        address: intentGatewayAddress,
+        slot: storageSlot
+      });
+      if (escrowedAmount !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
+        return false;
+      }
+    }
+    return true;
+  }
   async submitAndConfirmReceipt(hyperbridge, commitment, message) {
     let storageValue = await hyperbridge.queryRequestReceipt(commitment);
     if (!storageValue) {
@@ -13163,6 +13211,140 @@ async function fetchSourceProof(commitment, source, sourceStateMachine, sourceCo
     proof: proofHex
   };
 }
+var TokenGateway = class {
+  source;
+  dest;
+  constructor(params) {
+    this.source = params.source;
+    this.dest = params.dest;
+  }
+  /**
+   * Get the TokenGateway contract address for a given chain
+   *
+   * @param chain - The chain identifier (e.g., "EVM-1", "EVM-56")
+   * @returns The TokenGateway contract address
+   */
+  getTokenGatewayAddress(chain) {
+    const chainStr = typeof chain === "string" ? chain : new TextDecoder().decode(chain);
+    return this.source.configService.getTokenGatewayAddress(chainStr);
+  }
+  /**
+   * Estimate the native token cost for a token gateway teleport operation.
+   * This includes both relayer fees and protocol fees for cross-chain delivery.
+   *
+   * The relayer fee is automatically estimated for EVM destination chains by:
+   * 1. Creating a dummy post request with 191 bytes of random data in the body
+   * 2. Estimating gas for delivery on the destination chain
+   * 3. Converting the gas estimate to native tokens
+   * 4. Adding a 1% buffer to the relayer fee for safety margin
+   *
+   * For non-EVM destination chains, the relayer fee is set to zero.
+   *
+   * The function then constructs a proper post request and calls quoteNative on the
+   * source chain to get protocol fees (with 1% buffer), converts the relayer fee to
+   * source chain fee token using Uniswap V2's getAmountsOut, and returns both values.
+   *
+   * @param params - The teleport parameters
+   * @returns Object containing totalNativeCost (with 1% buffer) and relayerFeeInSourceFeeToken
+   *
+   * @throws Will throw an error if the contract call fails
+   *
+   * @example
+   * ```typescript
+   * const params: TeleportParams = {
+   *   amount: parseEther("1.0"),
+   *   assetId: keccak256(toHex("USDC")),
+   *   redeem: true,
+   *   to: pad("0xRecipientAddress", { size: 32 }),
+   *   dest: "EVM-1",
+   *   timeout: 3600n,
+   *   data: "0x"
+   * }
+   *
+   * const { totalNativeCost, relayerFeeInSourceFeeToken } = await tokenGateway.quoteNative(params)
+   * console.log(`Total native cost: ${formatEther(totalNativeCost)} ETH`)
+   * console.log(`Relayer fee in fee token: ${relayerFeeInSourceFeeToken}`)
+   * ```
+   */
+  async quoteNative(params) {
+    const dataHex = params.data ? typeof params.data === "string" ? params.data : toHex(params.data) : "0x";
+    const sourceTokenGatewayAddress = this.getTokenGatewayAddress(this.source.config.stateMachineId);
+    const destTokenGatewayAddress = this.getTokenGatewayAddress(params.dest);
+    let relayerFee = 0n;
+    const destChainId = typeof params.dest === "string" ? params.dest : new TextDecoder().decode(params.dest);
+    const isEvmDest = destChainId.startsWith("EVM-") && this.dest instanceof EvmChain;
+    if (isEvmDest) {
+      const randomHex = "0x" + Array.from({ length: 191 * 2 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+      const randomBody = randomHex;
+      const dummyPostRequest = {
+        source: this.source.config.stateMachineId,
+        dest: destChainId,
+        from: sourceTokenGatewayAddress,
+        to: destTokenGatewayAddress,
+        nonce: 0n,
+        body: randomBody,
+        timeoutTimestamp: params.timeout
+      };
+      const { gas } = await this.dest.estimateGas(dummyPostRequest);
+      const gasPrice = await this.dest.client.getGasPrice();
+      const gasCostInNative = gas * gasPrice;
+      relayerFee = gasCostInNative * 101n / 100n;
+    }
+    const teleportBody = encodeAbiParameters(
+      parseAbiParameters("uint256, uint256, bytes32, bool, bytes32, bytes"),
+      [
+        params.amount,
+        relayerFee,
+        // Use the calculated relayer fee (0 for non-EVM destinations)
+        params.assetId,
+        params.redeem,
+        params.to,
+        dataHex
+      ]
+    );
+    const postRequest = {
+      source: this.source.config.stateMachineId,
+      dest: destChainId,
+      from: sourceTokenGatewayAddress,
+      to: destTokenGatewayAddress,
+      nonce: 0n,
+      body: teleportBody,
+      timeoutTimestamp: params.timeout
+    };
+    const protocolFeeInNative = await this.source.quoteNative(postRequest, relayerFee);
+    const protocolFeeWithBuffer = protocolFeeInNative * 101n / 100n;
+    let relayerFeeInSourceFeeToken = 0n;
+    if (relayerFee > 0n) {
+      const feeToken = await this.source.getFeeTokenWithDecimals();
+      relayerFeeInSourceFeeToken = await this.convertNativeToFeeToken(
+        relayerFee,
+        feeToken.address,
+        this.source.config.stateMachineId
+      );
+    }
+    return {
+      totalNativeCost: protocolFeeWithBuffer,
+      relayerFeeInSourceFeeToken
+    };
+  }
+  /**
+   * Convert native token amount to fee token amount using Uniswap V2 router
+   * @private
+   */
+  async convertNativeToFeeToken(nativeAmount, feeTokenAddress, chain) {
+    const v2Router = this.source.configService.getUniswapRouterV2Address(chain);
+    const WETH = this.source.configService.getWrappedNativeAssetWithDecimals(chain).asset;
+    const v2AmountOut = await this.source.client.simulateContract({
+      address: v2Router,
+      abi: uniswapRouterV2_default.ABI,
+      // @ts-ignore
+      functionName: "getAmountsOut",
+      // @ts-ignore
+      args: [nativeAmount, [WETH, feeTokenAddress]]
+    });
+    return v2AmountOut.result[1];
+  }
+};
 async function getOrderPlacedFromTx(client, txHash) {
   const receipt = await client.getTransactionReceipt({ hash: txHash });
   const events = parseEventLogs({
@@ -13318,6 +13500,107 @@ function readIsmpCommitmentHash(events) {
     }
   }
 }
+async function makeTeleportExtrinsics(teleport_param) {
+  const { params, apiPromise } = teleport_param;
+  const substrateComplianceAddr = (address, stateMachine) => {
+    if (stateMachine.startsWith("EVM-")) return pad(address, { size: 32, dir: "left" });
+    return address;
+  };
+  const assetId = keccakAsU8a(params.symbol);
+  const scaleEncodedAssetId = await fetchLocalAssetId({ api: apiPromise, assetId });
+  if (scaleEncodedAssetId === null) {
+    throw new Error("Unknown asset id provided");
+  }
+  const destination = convertStateMachineIdToEnum(params.destination);
+  const recipient = hexToBytes(substrateComplianceAddr(params.recipient, params.destination));
+  const teleportParams = {
+    destination,
+    recepient: Array.from(recipient),
+    amount: params.amount,
+    timeout: BigInt(params.timeout),
+    tokenGatewayAddress: Array.from(params.tokenGatewayAddress),
+    relayerFee: BigInt(params.relayerFee),
+    redeem: params.redeem,
+    callData: params.callData ? Array.from(params.callData) : void 0
+  };
+  const encoded = TeleportParams.enc(teleportParams);
+  const fullCallData = new Uint8Array([...scaleEncodedAssetId, ...encoded]);
+  return apiPromise.tx.tokenGateway.teleport(fullCallData);
+}
+function submitExtrinsics({
+  extrinsics: tx,
+  who,
+  options,
+  apiPromise
+}) {
+  let unsub = () => {
+  };
+  let closed = false;
+  const stream = new ReadableStream(
+    {
+      async start(controller) {
+        unsub = await tx.signAndSend(who, options, async (result) => {
+          try {
+            const { isInBlock, isError, dispatchError, txHash, isFinalized, status } = result;
+            const events = result.events;
+            if (isError) {
+              console.error("Transaction failed: ", dispatchError);
+              controller.enqueue({ kind: "Error", error: dispatchError });
+              unsub?.();
+              controller.close();
+              closed = true;
+              return;
+            }
+            if (status.type === "Ready") {
+              controller.enqueue({
+                kind: "Ready",
+                transaction_hash: txHash.toHex()
+              });
+            }
+            if (isInBlock || isFinalized) {
+              const commitment_hash = readIsmpCommitmentHash(events);
+              const blockHash = isInBlock ? status.asInBlock.toHex() : status.asFinalized.toHex();
+              if (!commitment_hash) {
+                controller.enqueue({
+                  kind: "Error",
+                  error: new Error("Commitment Hash missing")
+                });
+                return controller.close();
+              }
+              const header = await apiPromise.rpc.chain.getHeader(blockHash);
+              controller.enqueue({
+                kind: isInBlock ? "Dispatched" : "Finalized",
+                transaction_hash: txHash.toHex(),
+                block_number: header.number.toBigInt(),
+                commitment: commitment_hash
+              });
+              if (isFinalized) {
+                unsub?.();
+                controller.close();
+                closed = true;
+                return;
+              }
+            }
+          } catch (err) {
+            if (closed) {
+              return;
+            }
+            controller.enqueue({
+              kind: "Error",
+              error: String(err)
+            });
+          }
+        });
+      },
+      cancel: () => unsub?.()
+    },
+    {
+      highWaterMark: 3,
+      size: () => 1
+    }
+  );
+  return stream;
+}
 var MultiAccount = Struct({
   substrate_account: Bytes(32),
   evm_account: Bytes(20),
@@ -13478,6 +13761,6 @@ async function teleportDot(param_) {
   return stream;
 }
 
-export { ADDRESS_ZERO, ChainConfigService, Chains, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DUMMY_PRIVATE_KEY, ERC20Method, EvmChain, HyperClientStatus, IndexerClient, IntentGateway, OrderStatus, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, STATE_COMMITMENTS_SLOT, SubstrateChain, TESTNET_CHAINS, TeleportStatus, TimeoutStatus, USE_ETHERSCAN_CHAINS, WrappedNativeDecimals, __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, ChainConfigService, Chains, DEFAULT_ADDRESS, DEFAULT_GRAFFITI, DUMMY_PRIVATE_KEY, ERC20Method, EvmChain, HyperClientStatus, IndexerClient, IntentGateway, OrderStatus, REQUEST_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, RESPONSE_COMMITMENTS_SLOT, RESPONSE_RECEIPTS_SLOT, RequestKind, RequestStatus, STATE_COMMITMENTS_SLOT, SubstrateChain, TESTNET_CHAINS, TeleportStatus, TimeoutStatus, TokenGateway, USE_ETHERSCAN_CHAINS, WrappedNativeDecimals, __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, makeTeleportExtrinsics, maxBigInt, orderCommitment, popularTokens, postRequestCommitment, queryAssetTeleported, queryGetRequest, queryPostRequest, requestCommitmentKey, retryPromise, submitExtrinsics, teleport, teleportDot, viemChains };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map