@across-protocol/sdk 4.4.0-alpha.5 → 4.4.0-alpha.7

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/caching/Arweave/ArweaveClient.ts

@@ -1,10 +1,10 @@
 import Arweave from "arweave";
 import { JWKInterface } from "arweave/node/lib/wallet";
-import axios from "axios";
+
 import { Struct, create } from "superstruct";
 import winston from "winston";
 import { ARWEAVE_TAG_APP_NAME, ARWEAVE_TAG_APP_VERSION, DEFAULT_ARWEAVE_STORAGE_ADDRESS } from "../../constants";
-import { BigNumber, delay, isDefined, jsonReplacerWithBigNumbers, toBN } from "../../utils";
+import { BigNumber, delay, fetchWithTimeout, isDefined, jsonReplacerWithBigNumbers, toBN } from "../../utils";
 
 export class ArweaveClient {
   private client: Arweave;
@@ -103,8 +103,7 @@ export class ArweaveClient {
     // that the Arweave SDK's `getData` method is too slow and does not provide a way to set a timeout.
     // Therefore, something that could take milliseconds to complete could take tens of minutes.
     const request = async () => {
-      const { data: requestData } = await axios.get(transactionUrl);
-      return requestData;
+      return await fetchWithTimeout(transactionUrl, {}, {}, 20_000);
     };
     const data = await this._retryRequest(request, 0);
     try {
@@ -137,31 +136,30 @@ export class ArweaveClient {
     validator: Struct<T>,
     originQueryAddress = DEFAULT_ARWEAVE_STORAGE_ADDRESS
   ): Promise<{ data: T; hash: string }[]> {
-    const transactions = await this.client.api.post<{
-      data: {
-        transactions: {
-          edges: {
-            node: {
-              id: string;
-            };
-          }[];
-        };
-      };
-    }>("/graphql", {
-      query: `
-        { 
-          transactions (
-            owners: ["${originQueryAddress}"]
-            tags: [
-              { name: "App-Name", values: ["${ARWEAVE_TAG_APP_NAME}"] },
-              { name: "Content-Type", values: ["application/json"] },
-              { name: "App-Version", values: ["${ARWEAVE_TAG_APP_VERSION}"] },
-              ${tag ? `{ name: "Topic", values: ["${tag}"] } ` : ""}
-            ]
-          ) { edges { node { id } } } 
-        }`,
-    });
-    const entries = transactions?.data?.data?.transactions?.edges ?? [];
+    const topicFilter = tag ? `{ name: "Topic", values: ["${tag}"] }` : "";
+    const query = `{
+      transactions (
+        owners: ["${originQueryAddress}"]
+        tags: [
+          { name: "App-Name", values: ["${ARWEAVE_TAG_APP_NAME}"] },
+          { name: "Content-Type", values: ["application/json"] },
+          { name: "App-Version", values: ["${ARWEAVE_TAG_APP_VERSION}"] },
+          ${topicFilter}
+        ]
+      ) { edges { node { id } } }
+    }`;
+
+    const response = await this._retryRequest(async () => {
+      const response = await this.client.api.post<{
+        data: { transactions: { edges: { node: { id: string } }[] } };
+      }>("/graphql", { query });
+      if (!response.ok) {
+        throw new Error(`Arweave GraphQL request failed with status ${response.status}`);
+      }
+      return response;
+    }, 0);
+
+    const entries = response?.data?.data?.transactions?.edges ?? [];
     this.logger.debug({
       at: "ArweaveClient:getByTopic",
       message: `Retrieved ${entries.length} matching transactions from Arweave`,
@@ -227,7 +225,7 @@ export class ArweaveClient {
 
   private async _retryRequest<T>(request: () => Promise<T>, retryCount: number): Promise<T> {
     try {
-      return request();
+      return await request();
     } catch (e) {
       if (retryCount < this.retries) {
         // Implement a slightly aggressive exponential backoff to account for fierce parallelism.

package/src/caching/index.ts

@@ -1,3 +1,2 @@
-export * from "./IPFS";
 export * from "./Arweave";
 export * from "./Memory";

package/src/clients/AcrossConfigStoreClient/AcrossConfigStoreClient.ts

@@ -510,7 +510,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
           }
           // If all else passes, we can add this update.
           this.chainIdIndicesUpdates.push({ ...args, value: chainIndices });
-        } catch (e) {
+        } catch {
           this.logger.warn({ at: "ConfigStore::update", message: `Failed to parse chain ID indices: ${args.value}` });
         }
       } else if (args.key === utf8ToHex(GLOBAL_CONFIG_STORE_KEYS.MAX_POOL_REBALANCE_LEAF_SIZE)) {
@@ -544,7 +544,7 @@ export class AcrossConfigStoreClient extends BaseAbstractClient {
         try {
           const chainIds = this.filterDisabledChains(JSON.parse(args.value) as number[]);
           this.cumulativeDisabledChainUpdates.push({ ...args, chainIds });
-        } catch (err) {
+        } catch {
           // Can't parse list, skip.
         }
       } else {

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/BundleDataClient/utils/SuperstructUtils.ts

@@ -24,7 +24,7 @@ const BigNumberType = coerce(instance(BigNumber), union([string(), number()]), (
   try {
     // Attempt to convert the string to a BigNumber
     return BigNumber.from(value);
-  } catch (error) {
+  } catch {
     // In case of any error during conversion, return the original value
     // This will lead to a validation error, as the resulting value won't match the expected BigNumber type
     return value;

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/coingecko/Coingecko.ts

@@ -1,7 +1,5 @@
-import axios, { AxiosError } from "axios";
 import assert from "assert";
-import get from "lodash.get";
-import { getCoingeckoTokenIdByAddress, retry } from "../utils";
+import { fetchWithTimeout, getCoingeckoTokenIdByAddress, retry } from "../utils";
 import { Logger } from "../relayFeeCalculator";
 
 export function msToS(ms: number) {
@@ -151,7 +149,7 @@ export class Coingecko {
       id = getCoingeckoTokenIdByAddress(address, chainId);
 
       return id;
-    } catch (error) {
+    } catch {
       this.logger.warn({
         at: "Coingecko#getCoingeckoTokenIdByAddress",
         message: `Token with address ${address} not found in constants. Attempting to fetch ID from coingecko API...`,
@@ -386,19 +384,19 @@ export class Coingecko {
 
       // If no pro api key, only send basic request:
       if (this.apiKey === undefined) {
-        return (await this._callBasic(path)) as T;
+        return await this._callBasic<T>(path);
       }
 
       // If pro api key, try basic and use pro as fallback.
       try {
-        return (await this._callBasic(path, this.basicApiTimeout)) as T;
+        return await this._callBasic<T>(path, this.basicApiTimeout);
       } catch (err) {
         this.logger.debug({
           at: "sdk/coingecko",
           message: `Basic CG url request failed, falling back to CG PRO host ${proHost}`,
-          errMessage: (err as AxiosError).message,
+          errMessage: (err as Error).message,
         });
-        return await this._callPro(path);
+        return await this._callPro<T>(path);
       }
     };
 
@@ -502,29 +500,15 @@ export class Coingecko {
     }
   }
 
-  private async _callBasic(path: string, timeout?: number) {
+  private async _callBasic<T>(path: string, timeout?: number): Promise<T> {
     const url = `${this.host}/${path}`;
 
-    try {
-      // Don't use timeout if there is no pro API to fallback to.
-      const result = await axios(url, { timeout });
-      return result.data;
-    } catch (err) {
-      const msg = get(err, "response.data.error", get(err, "response.statusText", (err as AxiosError).message));
-      throw new Error(msg);
-    }
+    // Don't use timeout if there is no pro API to fallback to.
+    return await fetchWithTimeout<T>(url, {}, {}, timeout);
   }
 
-  private async _callPro(path: string) {
+  private async _callPro<T>(path: string): Promise<T> {
     const url = `${this.proHost}/${path}`;
-
-    try {
-      // Don't use timeout if there is no pro API to fallback to.
-      const result = await axios(url, { params: { x_cg_pro_api_key: this.apiKey } });
-      return result.data;
-    } catch (err) {
-      const msg = get(err, "response.data.error", get(err, "response.statusText", (err as AxiosError).message));
-      throw new Error(msg);
-    }
+    return await fetchWithTimeout<T>(url, { x_cg_pro_api_key: this.apiKey });
   }
 }

package/src/gasPriceOracle/adapters/polygon.ts

@@ -116,7 +116,7 @@ export async function gasStation(
     const scaledPriorityFee = maxPriorityFeePerGas.mul(priorityFeeMultiplier).div(fixedPointAdjustment);
     maxFeePerGas = scaledBaseFee.add(scaledPriorityFee);
     maxPriorityFeePerGas = scaledPriorityFee;
-  } catch (err) {
+  } catch {
     // Fall back to the RPC provider. May be less accurate.
     ({ maxPriorityFeePerGas, maxFeePerGas } = await eip1559(provider, opts));
 

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/priceClient/adapters/baseAdapter.ts

@@ -1,5 +1,5 @@
+import { fetchWithTimeout, FetchQueryParams } from "../../utils";
 import assert from "assert";
-import axios from "axios";
 
 export type BaseHTTPAdapterArgs = {
   timeout?: number;
@@ -37,21 +37,21 @@ export class BaseHTTPAdapter {
     this.timeout = timeout; // ms
   }
 
-  protected async query(path: string, urlArgs?: object): Promise<unknown> {
+  protected async query(path: string, urlArgs?: FetchQueryParams): Promise<unknown> {
     const url = `https://${this.host}/${path ?? ""}`;
-    const args = {
-      headers: { "User-Agent": process.env.ACROSS_USER_AGENT ?? "across-protocol" },
-      timeout: this.timeout,
-      params: urlArgs ?? {},
-    };
 
     const errs: string[] = [];
     let tries = 0;
     do {
       try {
-        return (await axios(url, args)).data;
+        return await fetchWithTimeout<unknown>(
+          url,
+          urlArgs ?? {},
+          { "User-Agent": process.env.ACROSS_USER_AGENT ?? "across-protocol" },
+          this.timeout
+        );
       } catch (err) {
-        const errMsg = axios.isAxiosError(err) || err instanceof Error ? err.message : "unknown error";
+        const errMsg = err instanceof Error ? err.message : "unknown error";
         errs.push(errMsg);
         if (++tries <= this.retries) await this.sleep(Math.pow(1.5, tries) * 1000); // simple backoff
       }

package/src/providers/solana/cachedRpcFactory.ts

@@ -84,7 +84,7 @@ export class CachedSolanaRpcFactory extends SolanaClusterRpcFactory {
       if (getSignatureStatusesResponse.value[0]?.confirmationStatus !== "finalized") {
         return this.retryTransport<TResponse>(...args);
       }
-    } catch (error) {
+    } catch {
       return this.retryTransport<TResponse>(...args);
     }
 

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 },