@across-protocol/sdk 4.3.139 → 4.3.140-alpha.1

package/src/arch/tvm/SpokeUtils.ts

@@ -0,0 +1,225 @@
+import assert from "assert";
+import { Contract, providers } from "ethers";
+import { CHAIN_IDs } from "../../constants";
+import { FillStatus, FillWithBlock, RelayData } from "../../interfaces";
+import { get1967Upgrades } from "../evm/UpgradeUtils";
+import { relayFillStatus as evmRelayFillStatus } from "../evm/SpokeUtils";
+import {
+  BigNumber,
+  getRelayDataHash,
+  isDefined,
+  isUnsafeDepositId,
+  paginatedEventQuery,
+  spreadEventWithBlockNumber,
+  unpackFillEvent,
+} from "../../utils";
+
+type BlockTag = providers.BlockTag;
+
+// Re-export functions that work unchanged on TRON's JSON-RPC.
+export { populateV3Relay, getTimestampForBlock, fillStatusArray } from "../evm/SpokeUtils";
+
+// Local implementations for functions requiring historical eth_call,
+// which TRON does not support (only "latest" blockTag is accepted).
+
+/**
+ * @notice Retrieve the on-chain time at a specific block number.
+ * TRON does not support historical eth_call so block timestamps are used
+ * instead of SpokePool.getCurrentTime(). In production these are equivalent.
+ */
+export async function getTimeAt(spokePool: Contract, blockNumber: number): Promise<number> {
+  const block = await spokePool.provider.getBlock(blockNumber);
+  return block.timestamp;
+}
+
+// Fallback fill deadline buffer (6 hours) used when a contract upgrade is
+// detected in the query range. An upgrade implies fillDeadlineBuffer may
+// have changed and we cannot read historical state on TRON, so we use a
+// conservative upper bound.
+const FALLBACK_FILL_DEADLINE_BUFFER = 21600; // 6 hours in seconds
+
+/**
+ * @notice Return the maximum fill deadline buffer across a block range.
+ * TRON does not support historical eth_call, so we read the current value.
+ * If a contract upgrade (EIP-1967 Upgraded event) occurred within the range,
+ * the value may have changed at the upgrade boundary. In that case, return
+ * the greater of the current value and a conservative 6-hour fallback.
+ */
+export async function getMaxFillDeadlineInRange(
+  spokePool: Contract,
+  startBlock: number,
+  endBlock: number
+): Promise<number> {
+  const [fillDeadlineBuffer, upgrades] = await Promise.all([
+    spokePool.fillDeadlineBuffer(),
+    get1967Upgrades(spokePool, startBlock, endBlock),
+  ]);
+
+  const currentBuffer = Number(fillDeadlineBuffer);
+
+  if (upgrades.length > 0) {
+    return Math.max(currentBuffer, FALLBACK_FILL_DEADLINE_BUFFER);
+  }
+
+  return currentBuffer;
+}
+
+/**
+ * @notice Not supported on TVM — callers should use findDepositBlock instead.
+ */
+export function getDepositIdAtBlock(_contract: Contract, _blockTag: number): Promise<BigNumber> {
+  throw new Error("getDepositIdAtBlock: not supported on TVM");
+}
+
+/**
+ * @notice Find the block at which a deposit was created.
+ * TRON does not support historical eth_call, so event queries replace the
+ * EVM binary-search over numberOfDeposits().
+ */
+export async function findDepositBlock(
+  spokePool: Contract,
+  depositId: BigNumber,
+  lowBlock: number,
+  highBlock?: number
+): Promise<number | undefined> {
+  if (isUnsafeDepositId(depositId)) {
+    throw new Error(`Cannot search for depositId ${depositId}`);
+  }
+
+  highBlock ??= await spokePool.provider.getBlockNumber();
+  assert(highBlock > lowBlock, `Block numbers out of range (${lowBlock} >= ${highBlock})`);
+
+  const events = await paginatedEventQuery(
+    spokePool,
+    spokePool.filters.FundsDeposited(null, null, null, null, null, depositId),
+    { from: lowBlock, to: highBlock }
+  );
+
+  if (events.length === 0) {
+    return undefined;
+  }
+
+  return events[0].blockNumber;
+}
+
+/**
+ * @notice Determine the fill status of a relay at a given block.
+ * For "latest" queries, delegates to the EVM implementation (TRON's
+ * eth_call works normally for "latest"). For historical queries the
+ * status is reconstructed from on-chain events because TRON does not
+ * support eth_call with historical blockTags.
+ */
+export async function relayFillStatus(
+  spokePool: Contract,
+  relayData: RelayData,
+  blockTag: BlockTag = "latest",
+  destinationChainId?: number
+): Promise<FillStatus> {
+  if (blockTag === "latest") {
+    return evmRelayFillStatus(spokePool, relayData, blockTag, destinationChainId);
+  }
+
+  destinationChainId ??= await spokePool.chainId();
+  assert(isDefined(destinationChainId));
+
+  const hash = getRelayDataHash(relayData, destinationChainId);
+
+  // Historical blockTag: check the current state first as an optimisation.
+  // Fill status can only increase (Unfilled -> RequestedSlowFill -> Filled),
+  // so if the deposit is still Unfilled now it was Unfilled at every prior block.
+  const latestStatus = Number(await spokePool.fillStatuses(hash));
+  if (latestStatus === FillStatus.Unfilled) {
+    return FillStatus.Unfilled;
+  }
+
+  // Reconstruct from events up to the requested block.
+  const fromBlock = 0;
+  const toBlock = Number(blockTag);
+
+  const fillEvents = await paginatedEventQuery(
+    spokePool,
+    spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
+    { from: fromBlock, to: toBlock }
+  );
+
+  if (fillEvents.length > 0) {
+    return FillStatus.Filled;
+  }
+
+  // No fill before blockTag — check for slow fill requests.
+  if (latestStatus >= FillStatus.RequestedSlowFill) {
+    const slowFillEvents = await paginatedEventQuery(
+      spokePool,
+      spokePool.filters.RequestedSlowFill(null, null, null, null, relayData.originChainId, relayData.depositId),
+      { from: fromBlock, to: toBlock }
+    );
+
+    if (slowFillEvents.length > 0) {
+      return FillStatus.RequestedSlowFill;
+    }
+  }
+
+  return FillStatus.Unfilled;
+}
+
+/**
+ * @notice Find the block at which a fill was completed.
+ * TRON does not support historical eth_call, so event queries replace the
+ * EVM binary-search over fillStatuses().
+ */
+export async function findFillBlock(
+  spokePool: Contract,
+  relayData: RelayData,
+  lowBlockNumber: number,
+  highBlockNumber?: number
+): Promise<number | undefined> {
+  const { provider } = spokePool;
+  highBlockNumber ??= await provider.getBlockNumber();
+  assert(highBlockNumber > lowBlockNumber, `Block numbers out of range (${lowBlockNumber} >= ${highBlockNumber})`);
+
+  const events = await paginatedEventQuery(
+    spokePool,
+    spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
+    { from: lowBlockNumber, to: highBlockNumber }
+  );
+
+  if (events.length === 0) {
+    return undefined;
+  }
+
+  return events[0].blockNumber;
+}
+
+/**
+ * @notice Find the fill event for a deposit.
+ * Queries fill events directly rather than binary-searching then re-querying.
+ */
+export async function findFillEvent(
+  spokePool: Contract,
+  relayData: RelayData,
+  lowBlockNumber: number,
+  highBlockNumber?: number
+): Promise<FillWithBlock | undefined> {
+  const { provider } = spokePool;
+  highBlockNumber ??= await provider.getBlockNumber();
+
+  const events = await paginatedEventQuery(
+    spokePool,
+    spokePool.filters.FilledRelay(null, null, null, null, null, relayData.originChainId, relayData.depositId),
+    { from: lowBlockNumber, to: highBlockNumber }
+  );
+
+  if (events.length === 0) {
+    return undefined;
+  }
+
+  const event = events[0];
+  // In production the chainId returned from the provider matches 1:1 with the actual chainId. Querying the provider
+  // object saves an RPC query because the chainId is cached by StaticJsonRpcProvider instances. In hre, the SpokePool
+  // may be configured with a different chainId than what is returned by the provider.
+  const destinationChainId = Object.values(CHAIN_IDs).includes(relayData.originChainId)
+    ? (await spokePool.provider.getNetwork()).chainId
+    : Number(await spokePool.chainId());
+
+  return unpackFillEvent(spreadEventWithBlockNumber(event), destinationChainId);
+}

package/src/arch/tvm/TransactionUtils.ts

@@ -0,0 +1,126 @@
+import { TronWeb } from "tronweb";
+import { PopulatedTransaction } from "ethers";
+import { TvmAddress } from "../../utils";
+
+export interface TronTransactionResult {
+  txid: string;
+  result: boolean;
+}
+
+/** Result of an off-chain contract call via `triggerConstantContract` (no broadcast). */
+export interface TronSimulationResult {
+  success: boolean;
+  message?: string;
+  constantResult?: unknown;
+  energyUsed?: number;
+  energyRequired?: number;
+  energyPenalty?: number;
+}
+
+/**
+ * Submit a populated EVM transaction to TRON via TronWeb.
+ *
+ * The EVM `populateV3Relay()` already produces correct ABI-encoded calldata.
+ * This function extracts `to` and `data` from the PopulatedTransaction,
+ * converts the target address to TRON Base58 format, and uses TronWeb's
+ * `triggerSmartContract` → `sign` → `sendRawTransaction` pipeline.
+ *
+ * @param tronWeb An authenticated TronWeb instance (with private key set).
+ * @param populatedTx The populated transaction containing `to` and `data`.
+ * @param feeLimit The maximum TRX to burn for energy consumption, in SUN (1 TRX = 1,000,000 SUN).
+ * @returns The transaction ID and result status.
+ */
+export async function submitTransaction(
+  tronWeb: TronWeb,
+  populatedTx: PopulatedTransaction,
+  feeLimit: number,
+  callValue: number = 0
+): Promise<TronTransactionResult> {
+  const { to, data } = populatedTx;
+  if (!to || !data) {
+    throw new Error("submitTransaction: populatedTx must have both 'to' and 'data' fields");
+  }
+
+  const tronAddress = TvmAddress.from(to).toNative();
+  const ownerAddress = tronWeb.defaultAddress?.base58;
+  if (!ownerAddress) {
+    throw new Error("submitTransaction: TronWeb instance must have a default address configured");
+  }
+
+  // Use triggerSmartContract with the `input` option to pass pre-encoded calldata.
+  // The function selector is empty — the full calldata (selector + params) is in `input`.
+  const input = data.startsWith("0x") ? data.slice(2) : data;
+  const txWrapper = await tronWeb.transactionBuilder.triggerSmartContract(
+    tronAddress,
+    // Use empty function selector — the `input` option provides the full calldata.
+    "",
+    { feeLimit, input, callValue },
+    [],
+    ownerAddress
+  );
+
+  if (!txWrapper?.result?.result) {
+    const message = txWrapper?.result?.message ?? "Unknown error";
+    throw new Error(`submitTransaction: triggerSmartContract failed: ${message}`);
+  }
+
+  const signedTx = await tronWeb.trx.sign(txWrapper.transaction);
+  const broadcast = await tronWeb.trx.sendRawTransaction(signedTx);
+
+  return {
+    txid: broadcast.txid ?? signedTx.txID,
+    result: broadcast.result ?? false,
+  };
+}
+
+/**
+ * Simulate a populated EVM transaction against TRON via TronWeb (constant call / `eth_call`-style).
+ *
+ * Same calldata path as {@link submitTransaction}: `to` and `data` from the populated tx,
+ * EVM `to` converted to TRON Base58, empty function selector with `{ input: data }`.
+ * Does not sign or broadcast.
+ *
+ * @param tronWeb TronWeb instance with a default address (used as `caller`).
+ * @param populatedTx Must contain `to` and `data`.
+ * @param feeLimit Maximum TRX for energy, in SUN (mirrors `submitTransaction`).
+ */
+export async function simulateTransaction(
+  tronWeb: TronWeb,
+  populatedTx: PopulatedTransaction,
+  feeLimit: number,
+  callValue: number = 0
+): Promise<TronSimulationResult> {
+  const { to, data } = populatedTx;
+  if (!to || !data) {
+    throw new Error("simulateTransaction: populatedTx must have both 'to' and 'data' fields");
+  }
+
+  const tronAddress = TvmAddress.from(to).toNative();
+  const ownerAddress = tronWeb.defaultAddress?.base58;
+  if (!ownerAddress) {
+    throw new Error("simulateTransaction: TronWeb instance must have a default address configured");
+  }
+
+  // `triggerConstantContract` is used to Invoke the readonly function (modified by the view or pure modifier) of a contract for contract data query;
+  // or to Invoke the non-readonly function of a contract for predicting whether the transaction can be successfully executed
+  // and estimating the energy consumption; or to estimate the energy consumption of contract deployment
+  const input = data.startsWith("0x") ? data.slice(2) : data;
+  const txWrapper = await tronWeb.transactionBuilder.triggerConstantContract(
+    tronAddress,
+    "",
+    { feeLimit, input, callValue },
+    [],
+    ownerAddress
+  );
+
+  const success = txWrapper?.result?.result === true;
+
+  return {
+    success,
+    message: txWrapper?.result?.message,
+    constantResult: txWrapper?.constant_result,
+    energyUsed: txWrapper?.energy_used,
+    energyRequired: txWrapper?.energy_required,
+    energyPenalty: txWrapper?.energy_penalty,
+  };
+}

package/src/arch/tvm/index.ts

@@ -0,0 +1,2 @@
+export * from "./SpokeUtils";
+export * from "./TransactionUtils";

package/src/clients/BundleDataClient/BundleDataClient.ts

@@ -20,6 +20,7 @@ import {
 import { SpokePoolClient } from "..";
 import { findFillEvent as findEvmFillEvent } from "../../arch/evm";
 import { findFillEvent as findSvmFillEvent } from "../../arch/svm";
+import { findFillEvent as findTvmFillEvent } from "../../arch/tvm";
 import {
   BigNumber,
   bnZero,
@@ -40,6 +41,7 @@ import {
   toBytes32,
   convertRelayDataParamsToBytes32,
   convertFillParamsToBytes32,
+  chainIsTvm,
 } from "../../utils";
 import winston from "winston";
 import {
@@ -1308,7 +1310,8 @@ export class BundleDataClient {
         spokePoolClient.logger
       );
     } else if (isEVMSpokePoolClient(spokePoolClient)) {
-      return await findEvmFillEvent(
+      const findFillEventHandler = chainIsTvm(spokePoolClient.chainId) ? findTvmFillEvent : findEvmFillEvent;
+      return await findFillEventHandler(
         spokePoolClient.spokePool,
         deposit,
         spokePoolClient.deploymentBlock,

package/src/clients/SpokePoolClient/EVMSpokePoolClient.ts

@@ -7,6 +7,12 @@ import {
   relayFillStatus,
   getTimestampForBlock as _getTimestampForBlock,
 } from "../../arch/evm";
+import {
+  relayFillStatus as relayFillStatusTvm,
+  getMaxFillDeadlineInRange as getMaxFillDeadlineTvm,
+  getTimeAt as _getTimeAtTvm,
+  findDepositBlock as findDepositBlockTvm,
+} from "../../arch/tvm";
 import { DepositWithBlock, FillStatus, Log, RelayData } from "../../interfaces";
 import {
   BigNumber,
@@ -17,6 +23,7 @@ import {
   toBN,
   EvmAddress,
   unpackDepositEvent,
+  chainIsTvm,
 } from "../../utils";
 import {
   EventSearchConfig,
@@ -36,6 +43,8 @@ import { EVM_SPOKE_POOL_CLIENT_TYPE } from "./types";
  */
 export class EVMSpokePoolClient extends SpokePoolClient {
   readonly type = EVM_SPOKE_POOL_CLIENT_TYPE;
+  readonly tvm: boolean;
+
   constructor(
     logger: winston.Logger,
     public readonly spokePool: Contract,
@@ -46,10 +55,12 @@ export class EVMSpokePoolClient extends SpokePoolClient {
   ) {
     super(logger, hubPoolClient, chainId, deploymentBlock, eventSearchConfig);
     this.spokePoolAddress = EvmAddress.from(spokePool.address);
+    this.tvm = chainIsTvm(this.chainId);
   }
 
   public override relayFillStatus(relayData: RelayData, atHeight?: number): Promise<FillStatus> {
-    return relayFillStatus(this.spokePool, relayData, atHeight, this.chainId);
+    const fillStatusHandler = this.tvm ? relayFillStatusTvm : relayFillStatus;
+    return fillStatusHandler(this.spokePool, relayData, atHeight, this.chainId);
   }
 
   public override fillStatusArray(relayData: RelayData[], atHeight?: number): Promise<(FillStatus | undefined)[]> {
@@ -57,7 +68,8 @@ export class EVMSpokePoolClient extends SpokePoolClient {
   }
 
   public override getMaxFillDeadlineInRange(startBlock: number, endBlock: number): Promise<number> {
-    return getMaxFillDeadline(this.spokePool, startBlock, endBlock);
+    const maxFillDeadlineInRangeHandler = this.tvm ? getMaxFillDeadlineTvm : getMaxFillDeadline;
+    return maxFillDeadlineInRangeHandler(this.spokePool, startBlock, endBlock);
   }
 
   private _availableEventsOnSpoke(eventNames: string[] = knownEventNames): { [eventName: string]: EventFilter } {
@@ -72,6 +84,42 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     return Object.keys(this._availableEventsOnSpoke(knownEventNames));
   }
 
+  /**
+   * Retrieve the on-chain time at a specific block.
+   * EVM reads SpokePool.getCurrentTime() via multicall with a historical blockTag.
+   * @param blockNumber The block number to query.
+   * @returns The on-chain time as a number.
+   */
+  protected async _getCurrentTime(blockNumber: number): Promise<number> {
+    if (this.tvm) {
+      const block = await this.spokePool.provider.getBlock(blockNumber);
+      const currentTime = block.timestamp;
+      if (currentTime < this.currentTime) {
+        throw new Error(`EVMSpokePoolClient::_getCurrentTimeTvm: currentTime: ${currentTime} < ${this.currentTime}`);
+      }
+      return currentTime;
+    }
+    const { spokePool } = this;
+    const multicallFunctions = ["getCurrentTime"];
+    const multicallOutput = await spokePool.callStatic.multicall(
+      multicallFunctions.map((f) => spokePool.interface.encodeFunctionData(f)),
+      { blockTag: blockNumber }
+    );
+
+    const [currentTime] = multicallFunctions.map(
+      (fn, idx) => spokePool.interface.decodeFunctionResult(fn, multicallOutput[idx])[0]
+    );
+
+    if (!BigNumber.isBigNumber(currentTime) || currentTime.lt(this.currentTime)) {
+      const errMsg = BigNumber.isBigNumber(currentTime)
+        ? `currentTime: ${currentTime} < ${toBN(this.currentTime)}`
+        : `currentTime is not a BigNumber: ${JSON.stringify(currentTime)}`;
+      throw new Error(`EVMSpokePoolClient::update: ${errMsg}`);
+    }
+
+    return currentTime.toNumber();
+  }
+
   protected override async _update(eventsToQuery: string[]): Promise<SpokePoolUpdate> {
     const searchConfig = await this.updateSearchConfig(this.spokePool.provider);
     if (isUpdateFailureReason(searchConfig)) {
@@ -107,25 +155,14 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     });
 
     const timerStart = Date.now();
-    const multicallFunctions = ["getCurrentTime"];
-    const [multicallOutput, ...events] = await Promise.all([
-      spokePool.callStatic.multicall(
-        multicallFunctions.map((f) => spokePool.interface.encodeFunctionData(f)),
-        { blockTag: searchConfig.to }
-      ),
+    const [currentTime, ...events] = await Promise.all([
+      this._getCurrentTime(searchConfig.to),
       ...eventSearchConfigs.map((config) => paginatedEventQuery(this.spokePool, config.filter, config.searchConfig)),
     ]);
     this.log("debug", `Time to query new events from RPC for ${this.chainId}: ${Date.now() - timerStart} ms`);
 
-    const [currentTime] = multicallFunctions.map(
-      (fn, idx) => spokePool.interface.decodeFunctionResult(fn, multicallOutput[idx])[0]
-    );
-
-    if (!BigNumber.isBigNumber(currentTime) || currentTime.lt(this.currentTime)) {
-      const errMsg = BigNumber.isBigNumber(currentTime)
-        ? `currentTime: ${currentTime} < ${toBN(this.currentTime)}`
-        : `currentTime is not a BigNumber: ${JSON.stringify(currentTime)}`;
-      throw new Error(`EVMSpokePoolClient::update: ${errMsg}`);
+    if (currentTime < this.currentTime) {
+      throw new Error(`EVMSpokePoolClient::update: currentTime: ${currentTime} < ${this.currentTime}`);
     }
 
     // Sort all events to ensure they are stored in a consistent order.
@@ -138,14 +175,15 @@ export class EVMSpokePoolClient extends SpokePoolClient {
 
     return {
       success: true,
-      currentTime: currentTime.toNumber(), // uint32
+      currentTime,
       searchEndBlock: searchConfig.to,
       events: eventsWithBlockNumber,
     };
   }
 
   public override getTimeAt(blockNumber: number): Promise<number> {
-    return _getTimeAt(this.spokePool, blockNumber);
+    const getTimeAtHandler = this.tvm ? _getTimeAtTvm : _getTimeAt;
+    return getTimeAtHandler(this.spokePool, blockNumber);
   }
 
   public override async findDeposit(depositId: BigNumber): Promise<DepositSearchResult> {
@@ -190,12 +228,22 @@ export class EVMSpokePoolClient extends SpokePoolClient {
     return _getTimestampForBlock(this.spokePool.provider, blockNumber);
   }
 
-  private async queryDepositEvents(
+  /**
+   * Find the block at which a deposit was created.
+   * EVM uses a binary-search over historical numberOfDeposits().
+   * TVM overrides this with an event-based lookup.
+   */
+  protected _findDepositBlock(depositId: BigNumber, lowBlock: number, highBlock?: number): Promise<number | undefined> {
+    const findDepositBlockHandler = this.tvm ? findDepositBlockTvm : findDepositBlock;
+    return findDepositBlockHandler(this.spokePool, depositId, lowBlock, highBlock);
+  }
+
+  protected async queryDepositEvents(
     depositId: BigNumber
   ): Promise<{ event: Log; elapsedMs: number } | { reason: string }> {
     const tStart = Date.now();
     const upperBound = this.latestHeightSearched || undefined;
-    const from = await findDepositBlock(this.spokePool, depositId, this.deploymentBlock, upperBound);
+    const from = await this._findDepositBlock(depositId, this.deploymentBlock, upperBound);
     const chain = getNetworkName(this.chainId);
 
     if (!from) {

package/src/gasPriceOracle/oracle.ts

@@ -113,6 +113,7 @@ function getGasPriceEthers(provider: providers.Provider, opts: GasPriceEstimateO
     [CHAIN_IDs.POLYGON]: polygon.gasStation,
     [CHAIN_IDs.SCROLL]: ethereum.legacy,
     [CHAIN_IDs.TEMPO]: ethereum.eip1559,
+    [CHAIN_IDs.TRON]: ethereum.legacy,
     [CHAIN_IDs.ZK_SYNC]: ethereum.legacy,
     // Testnet
     [CHAIN_IDs.POLYGON_AMOY]: polygon.gasStation,

package/src/relayFeeCalculator/chain-queries/baseQuery.ts

@@ -9,6 +9,7 @@ import { populateV3Relay } from "../../arch/evm";
 import {
   BigNumberish,
   EvmAddress,
+  TvmAddress,
   TransactionCostEstimate,
   BigNumber,
   toBNWei,
@@ -85,9 +86,15 @@ export class QueryBase implements QueryInterface {
     const { gasPrice = this.fixedGasPrice, gasUnits, opStackL1GasCostMultiplier } = options;
 
     const { recipient, outputToken, exclusiveRelayer } = relayData;
-    assert(recipient.isEVM(), `getGasCosts: recipient not an EVM address (${recipient})`);
-    assert(outputToken.isEVM(), `getGasCosts: outputToken not an EVM address (${outputToken})`);
-    assert(exclusiveRelayer.isEVM(), `getGasCosts: exclusiveRelayer not an EVM address (${exclusiveRelayer})`);
+    assert(recipient.isEVM() || recipient.isTVM(), `getGasCosts: recipient not an EVM-like address (${recipient})`);
+    assert(
+      outputToken.isEVM() || outputToken.isTVM(),
+      `getGasCosts: outputToken not an EVM-like address (${outputToken})`
+    );
+    assert(
+      exclusiveRelayer.isEVM() || exclusiveRelayer.isTVM(),
+      `getGasCosts: exclusiveRelayer not an EVM-like address (${exclusiveRelayer})`
+    );
 
     const tx = await this.getUnsignedTxFromDeposit({ ...relayData, recipient, outputToken, exclusiveRelayer }, relayer);
     const {
@@ -119,8 +126,8 @@ export class QueryBase implements QueryInterface {
   getUnsignedTxFromDeposit(
     relayData: Omit<RelayData, "recipient" | "outputToken"> & {
       destinationChainId: number;
-      recipient: EvmAddress;
-      outputToken: EvmAddress;
+      recipient: EvmAddress | TvmAddress;
+      outputToken: EvmAddress | TvmAddress;
     },
     relayer = getDefaultRelayer(relayData.destinationChainId)
   ): Promise<PopulatedTransaction> {
@@ -138,9 +145,18 @@ export class QueryBase implements QueryInterface {
     relayer = getDefaultRelayer(relayData.destinationChainId)
   ): Promise<BigNumber> {
     const { recipient, outputToken, exclusiveRelayer } = relayData;
-    assert(recipient.isEVM(), `getNativeGasCost: recipient not an EVM address (${recipient})`);
-    assert(outputToken.isEVM(), `getNativeGasCost: outputToken not an EVM address (${outputToken})`);
-    assert(exclusiveRelayer.isEVM(), `getNativeGasCost: exclusiveRelayer not an EVM address (${exclusiveRelayer})`);
+    assert(
+      recipient.isEVM() || recipient.isTVM(),
+      `getNativeGasCost: recipient not an EVM-like address (${recipient})`
+    );
+    assert(
+      outputToken.isEVM() || outputToken.isTVM(),
+      `getNativeGasCost: outputToken not an EVM-like address (${outputToken})`
+    );
+    assert(
+      exclusiveRelayer.isEVM() || exclusiveRelayer.isTVM(),
+      `getNativeGasCost: exclusiveRelayer not an EVM-like address (${exclusiveRelayer})`
+    );
 
     const unsignedTx = await this.getUnsignedTxFromDeposit(
       { ...relayData, recipient, outputToken, exclusiveRelayer },