@across-protocol/sdk 4.3.136 → 4.3.137-alpha.0

package/src/clients/SpokePoolClient/TVMSpokePoolClient.ts

@@ -0,0 +1,65 @@
+import {
+  findDepositBlock,
+  getMaxFillDeadlineInRange as getMaxFillDeadline,
+  getTimeAt as _getTimeAt,
+  relayFillStatus,
+} from "../../arch/tvm";
+import { FillStatus, RelayData } from "../../interfaces";
+import { BigNumber } from "../../utils";
+import { EVMSpokePoolClient } from "./EVMSpokePoolClient";
+import { TVM_SPOKE_POOL_CLIENT_TYPE } from "./types";
+
+/**
+ * A TVM-specific SpokePoolClient for TRON.
+ *
+ * TRON is EVM-compatible for reads and event queries, but diverges in three areas:
+ * 1. No historical `eth_call` — only "latest" blockTag is accepted.
+ * 2. No `eth_sendRawTransaction` — TRON uses Protobuf-encoded transactions via TronWeb.
+ * 3. Energy/bandwidth fee model instead of gas.
+ *
+ * This client extends EVMSpokePoolClient, overriding only the methods affected by (1).
+ * Transaction submission (2) and fee estimation (3) are handled by the arch/tvm utilities.
+ */
+export class TVMSpokePoolClient extends EVMSpokePoolClient {
+  // @ts-expect-error: Narrowing the base class literal type from "EVM" to "TVM".
+  override readonly type = TVM_SPOKE_POOL_CLIENT_TYPE;
+
+  public override relayFillStatus(relayData: RelayData, atHeight?: number): Promise<FillStatus> {
+    return relayFillStatus(this.spokePool, relayData, atHeight, this.chainId);
+  }
+
+  public override getMaxFillDeadlineInRange(startBlock: number, endBlock: number): Promise<number> {
+    return getMaxFillDeadline(this.spokePool, startBlock, endBlock);
+  }
+
+  public override getTimeAt(blockNumber: number): Promise<number> {
+    return _getTimeAt(this.spokePool, blockNumber);
+  }
+
+  /**
+   * Override to use TVM's event-based findDepositBlock
+   * instead of EVM's binary-search over historical numberOfDeposits().
+   */
+  protected override _findDepositBlock(
+    depositId: BigNumber,
+    lowBlock: number,
+    highBlock?: number
+  ): Promise<number | undefined> {
+    return findDepositBlock(this.spokePool, depositId, lowBlock, highBlock);
+  }
+
+  /**
+   * Override to avoid historical eth_call for getCurrentTime.
+   * TRON does not support eth_call with historical blockTags, so we
+   * use the block timestamp from provider.getBlock() instead of
+   * SpokePool.getCurrentTime({ blockTag }).
+   */
+  protected override async _getCurrentTime(blockNumber: number): Promise<number> {
+    const block = await this.spokePool.provider.getBlock(blockNumber);
+    const currentTime = block.timestamp;
+    if (currentTime < this.currentTime) {
+      throw new Error(`TVMSpokePoolClient::update: currentTime: ${currentTime} < ${this.currentTime}`);
+    }
+    return currentTime;
+  }
+}

package/src/clients/SpokePoolClient/index.ts

@@ -1,11 +1,13 @@
 import { EVMSpokePoolClient } from "./EVMSpokePoolClient";
 import { SVMSpokePoolClient } from "./SVMSpokePoolClient";
+import { TVMSpokePoolClient } from "./TVMSpokePoolClient";
 import { SpokePoolClient } from "./SpokePoolClient";
-import { EVM_SPOKE_POOL_CLIENT_TYPE, SVM_SPOKE_POOL_CLIENT_TYPE } from "./types";
+import { EVM_SPOKE_POOL_CLIENT_TYPE, SVM_SPOKE_POOL_CLIENT_TYPE, TVM_SPOKE_POOL_CLIENT_TYPE } from "./types";
 
 export { EVMSpokePoolClient } from "./EVMSpokePoolClient";
 export { SpokePoolClient, SpokePoolUpdate } from "./SpokePoolClient";
 export { SVMSpokePoolClient } from "./SVMSpokePoolClient";
+export { TVMSpokePoolClient } from "./TVMSpokePoolClient";
 export { SpokePoolManager } from "./SpokePoolClientManager";
 
 /**
@@ -27,3 +29,12 @@ export function isSVMSpokePoolClient(spokePoolClient: SpokePoolClient): spokePoo
   // @TODO: Should we handle the case where spokePoolClient is undefined?
   return spokePoolClient?.type === SVM_SPOKE_POOL_CLIENT_TYPE;
 }
+
+/**
+ * Checks if a SpokePoolClient is a TVMSpokePoolClient.
+ * @param spokePoolClient The SpokePoolClient to check.
+ * @returns True if the SpokePoolClient is a TVMSpokePoolClient, false otherwise.
+ */
+export function isTVMSpokePoolClient(spokePoolClient: SpokePoolClient): spokePoolClient is TVMSpokePoolClient {
+  return spokePoolClient?.type === TVM_SPOKE_POOL_CLIENT_TYPE;
+}

package/src/clients/SpokePoolClient/types.ts

@@ -1,2 +1,3 @@
 export const EVM_SPOKE_POOL_CLIENT_TYPE = "EVM";
 export const SVM_SPOKE_POOL_CLIENT_TYPE = "SVM";
+export const TVM_SPOKE_POOL_CLIENT_TYPE = "TVM";

package/src/gasPriceOracle/adapters/tron.ts

@@ -0,0 +1,50 @@
+import { TronWeb } from "tronweb";
+import { toBN } from "../../utils";
+import { TvmGasPriceEstimate } from "../types";
+import { GasPriceEstimateOptions } from "../oracle";
+
+/**
+ * @notice Returns energy and bandwidth prices for the TRON network.
+ * @param provider A TronWeb instance.
+ * @param _opts Gas price estimate options (unused, kept for interface consistency).
+ * @returns TvmGasPriceEstimate with energyPrice and bandwidthPrice in SUN per unit.
+ */
+export async function gasPrices(provider: TronWeb, _opts: GasPriceEstimateOptions): Promise<TvmGasPriceEstimate> {
+  const [energyPrice, bandwidthPrice] = await Promise.all([getEnergyPrice(provider), getBandwidthPrice(provider)]);
+
+  return {
+    energyPrice: toBN(energyPrice),
+    bandwidthPrice: toBN(bandwidthPrice),
+  };
+}
+
+/**
+ * Query the current energy price in SUN per unit of energy.
+ * Parses the last entry from the comma-separated "timestamp:price" string.
+ */
+async function getEnergyPrice(tronWeb: TronWeb): Promise<number> {
+  const pricesStr = await tronWeb.trx.getEnergyPrices();
+  const entries = pricesStr.split(",");
+  const lastEntry = entries[entries.length - 1];
+  const price = Number(lastEntry.split(":")[1]);
+
+  if (!Number.isFinite(price) || price <= 0) {
+    throw new Error(`getEnergyPrice: unexpected energy price: ${lastEntry}`);
+  }
+
+  return price;
+}
+
+/**
+ * Query the current bandwidth price (getTransactionFee) from chain parameters.
+ */
+async function getBandwidthPrice(tronWeb: TronWeb): Promise<number> {
+  const params = await tronWeb.trx.getChainParameters();
+  const entry = params.find((p: { key: string; value: number }) => p.key === "getTransactionFee");
+
+  if (!entry) {
+    throw new Error("getBandwidthPrice: getTransactionFee not found in chain parameters");
+  }
+
+  return entry.value;
+}

package/src/gasPriceOracle/index.ts

@@ -1,2 +1,2 @@
 export { getGasPriceEstimate, GasPriceEstimateOptions } from "./oracle";
-export { GasPriceEstimate, EvmGasPriceEstimate, SvmGasPriceEstimate } from "./types";
+export { GasPriceEstimate, EvmGasPriceEstimate, SvmGasPriceEstimate, TvmGasPriceEstimate } from "./types";

package/src/gasPriceOracle/oracle.ts

@@ -2,15 +2,17 @@ import assert from "assert";
 import { Transport } from "viem";
 import { providers } from "ethers";
 import { CHAIN_IDs } from "../constants";
-import { BigNumber, fixedPointAdjustment, isEvmProvider, toBNWei, isDefined } from "../utils";
+import { BigNumber, fixedPointAdjustment, isEvmProvider, isTvmProvider, toBNWei, isDefined } from "../utils";
 import { SVMProvider as SolanaProvider } from "../arch/svm";
-import { EvmGasPriceEstimate, GasPriceEstimate, SvmGasPriceEstimate } from "./types";
+import { TronWeb } from "tronweb";
+import { EvmGasPriceEstimate, GasPriceEstimate, SvmGasPriceEstimate, TvmGasPriceEstimate } from "./types";
 import { getPublicClient } from "./util";
 import * as arbitrum from "./adapters/arbitrum";
 import * as ethereum from "./adapters/ethereum";
 import * as polygon from "./adapters/polygon";
 import * as lineaViem from "./adapters/linea-viem";
 import * as solana from "./adapters/solana";
+import * as tron from "./adapters/tron";
 import { EvmProvider } from "../arch/evm/types";
 
 export interface GasPriceEstimateOptions {
@@ -56,6 +58,12 @@ export async function getGasPriceEstimate(
   opts?: Partial<GasPriceEstimateOptions>
 ): Promise<SvmGasPriceEstimate>;
 
+// Overload For TVM providers
+export async function getGasPriceEstimate(
+  provider: TronWeb,
+  opts?: Partial<GasPriceEstimateOptions>
+): Promise<TvmGasPriceEstimate>;
+
 /**
  * Provide an estimate for the current gas price for a particular chain.
  * @param provider A valid ethers provider.
@@ -63,12 +71,24 @@ export async function getGasPriceEstimate(
  * @returns An  object of type GasPriceEstimate.
  */
 export async function getGasPriceEstimate(
-  provider: EvmProvider | SolanaProvider,
+  provider: EvmProvider | SolanaProvider | TronWeb,
   opts: Partial<GasPriceEstimateOptions> = {}
 ): Promise<GasPriceEstimate> {
   const baseFeeMultiplier = opts.baseFeeMultiplier ?? toBNWei("1");
   const priorityFeeMultiplier = opts.priorityFeeMultiplier ?? toBNWei("1");
 
+  // Exit here if we need to estimate on TRON.
+  if (isTvmProvider(provider)) {
+    const optsWithDefaults: GasPriceEstimateOptions = {
+      ...GAS_PRICE_ESTIMATE_DEFAULTS,
+      baseFeeMultiplier,
+      priorityFeeMultiplier,
+      ...opts,
+      chainId: opts.chainId ?? CHAIN_IDs.TRON,
+    };
+    return tron.gasPrices(provider, optsWithDefaults);
+  }
+
   // Exit here if we need to estimate on Solana.
   if (!isEvmProvider(provider)) {
     const optsWithDefaults: GasPriceEstimateOptions = {

package/src/gasPriceOracle/types.ts

@@ -2,7 +2,7 @@ import { type Chain, type Transport, PublicClient, FeeValuesEIP1559 } from "viem
 import { BigNumber, bnZero, isDefined } from "../utils";
 
 export type InternalGasPriceEstimate = FeeValuesEIP1559;
-export type GasPriceEstimate = EvmGasPriceEstimate | SvmGasPriceEstimate;
+export type GasPriceEstimate = EvmGasPriceEstimate | SvmGasPriceEstimate | TvmGasPriceEstimate;
 
 export type EvmGasPriceEstimate = {
   maxFeePerGas: BigNumber;
@@ -14,6 +14,11 @@ export type SvmGasPriceEstimate = {
   microLamportsPerComputeUnit: BigNumber;
 };
 
+export type TvmGasPriceEstimate = {
+  energyPrice: BigNumber;
+  bandwidthPrice: BigNumber;
+};
+
 export interface GasPriceFeed {
   (provider: PublicClient<Transport, Chain>, chainId: number): Promise<InternalGasPriceEstimate>;
 }
@@ -35,3 +40,8 @@ export function isSVMGasPrice(gasPrice: GasPriceEstimate): gasPrice is SvmGasPri
   const { baseFee, microLamportsPerComputeUnit } = gasPrice as SvmGasPriceEstimate;
   return isDefined(baseFee) && isDefined(microLamportsPerComputeUnit);
 }
+
+export function isTVMGasPrice(gasPrice: GasPriceEstimate): gasPrice is TvmGasPriceEstimate {
+  const { energyPrice, bandwidthPrice } = gasPrice as TvmGasPriceEstimate;
+  return isDefined(energyPrice) && isDefined(bandwidthPrice);
+}

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

@@ -3,13 +3,15 @@ import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "@across-protocol/constants";
 import { getDeployedAddress } from "@across-protocol/contracts";
 import { asL2Provider } from "@eth-optimism/sdk";
 import { providers } from "ethers";
+import { TronWeb } from "tronweb";
 import { CUSTOM_GAS_TOKENS } from "../../constants";
-import { chainIsEvm, chainIsOPStack, isDefined, chainIsSvm, SvmAddress } from "../../utils";
+import { chainIsEvm, chainIsOPStack, isDefined, chainIsSvm, chainIsTvm, SvmAddress } from "../../utils";
 import { QueryBase } from "./baseQuery";
 import { SVMProvider as svmProvider } from "../../arch/svm";
 import { DEFAULT_LOGGER, getDefaultRelayer, Logger } from "../relayFeeCalculator";
 import { CustomGasTokenQueries } from "./customGasToken";
 import { SvmQuery } from "./svmQuery";
+import { TvmQuery } from "./tvmQuery";
 
 /**
  * Some chains have a fixed gas price that is applied to the gas estimates. We should override
@@ -22,14 +24,14 @@ const fixedGasPrice = {
 export class QueryBase__factory {
   static create(
     chainId: number,
-    provider: providers.Provider | svmProvider,
+    provider: providers.Provider | svmProvider | TronWeb,
     symbolMapping = TOKEN_SYMBOLS_MAP,
     spokePoolAddress = getDeployedAddress("SpokePool", chainId),
     relayerAddress = getDefaultRelayer(chainId),
     coingeckoProApiKey?: string,
     logger: Logger = DEFAULT_LOGGER,
     coingeckoBaseCurrency = "eth"
-  ): QueryBase | SvmQuery {
+  ): QueryBase | SvmQuery | TvmQuery {
     assert(isDefined(spokePoolAddress));
 
     const customGasTokenSymbol = CUSTOM_GAS_TOKENS[chainId];
@@ -62,6 +64,19 @@ export class QueryBase__factory {
         coingeckoBaseCurrency
       );
     }
+    if (chainIsTvm(chainId)) {
+      assert(relayerAddress.isEVM());
+      return new TvmQuery(
+        provider as TronWeb,
+        symbolMapping,
+        spokePoolAddress,
+        relayerAddress,
+        logger,
+        coingeckoProApiKey,
+        fixedGasPrice[chainId],
+        coingeckoBaseCurrency
+      );
+    }
 
     // For OPStack chains, we need to wrap the provider in an L2Provider
     provider = chainIsOPStack(chainId)

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

@@ -2,3 +2,4 @@ export * from "./baseQuery";
 export * from "./factory";
 export * from "./customGasToken";
 export * from "./svmQuery";
+export * from "./tvmQuery";

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

@@ -0,0 +1,88 @@
+import assert from "assert";
+import { PopulatedTransaction, providers, VoidSigner } from "ethers";
+import { TronWeb } from "tronweb";
+import { getGasPriceEstimate, GasPriceEstimateOptions } from "../../gasPriceOracle";
+import { TvmGasPriceEstimate } from "../../gasPriceOracle/types";
+import { RelayData } from "../../interfaces";
+import { Address, BigNumber, BigNumberish, bnZero, EvmAddress, TransactionCostEstimate } from "../../utils";
+import { arch } from "../..";
+import { Logger } from "../relayFeeCalculator";
+import { QueryBase, SymbolMappingType } from "./baseQuery";
+
+/**
+ * A TVM-specific query implementation for TRON.
+ *
+ * TRON's JSON-RPC is EVM-compatible for reads and gas estimation, so this
+ * class extends QueryBase and overrides only the gas price oracle dispatch
+ * to use TronWeb (energy/bandwidth pricing) instead of the EVM oracle.
+ *
+ * The ethers provider is derived from the TronWeb instance's fullNode URL.
+ */
+export class TvmQuery extends QueryBase {
+  readonly tronWeb: TronWeb;
+
+  constructor(
+    tronWeb: TronWeb,
+    symbolMapping: SymbolMappingType,
+    spokePoolAddress: string,
+    simulatedRelayerAddress: EvmAddress,
+    logger: Logger,
+    coingeckoProApiKey?: string,
+    fixedGasPrice?: BigNumberish,
+    coingeckoBaseCurrency: string = "eth"
+  ) {
+    const provider = new providers.StaticJsonRpcProvider(tronWeb.fullNode.host);
+    super(
+      provider,
+      symbolMapping,
+      spokePoolAddress,
+      simulatedRelayerAddress,
+      logger,
+      coingeckoProApiKey,
+      fixedGasPrice,
+      coingeckoBaseCurrency
+    );
+    this.tronWeb = tronWeb;
+  }
+
+  /**
+   * Estimate the gas cost of a transaction using TVM energy pricing.
+   *
+   * Gas units (energy) are estimated via the ethers provider (TRON's JSON-RPC
+   * returns energy units for eth_estimateGas). The energy price is queried
+   * from TronWeb's gas price oracle.
+   */
+  override async estimateGas(
+    unsignedTx: PopulatedTransaction,
+    senderAddress: Address,
+    provider: providers.Provider,
+    options: Partial<
+      GasPriceEstimateOptions & {
+        gasPrice: BigNumberish;
+        gasUnits: BigNumberish;
+      }
+    > = {}
+  ): Promise<TransactionCostEstimate> {
+    const { gasPrice: _gasPrice, gasUnits } = options;
+
+    const voidSigner = new VoidSigner(senderAddress.toEvmAddress(), provider);
+
+    const [nativeGasCost, gasPriceEstimate] = await Promise.all([
+      gasUnits ? Promise.resolve(BigNumber.from(gasUnits)) : voidSigner.estimateGas(unsignedTx),
+      _gasPrice
+        ? Promise.resolve({ energyPrice: BigNumber.from(_gasPrice.toString()), bandwidthPrice: bnZero })
+        : getGasPriceEstimate(this.tronWeb),
+    ]);
+
+    assert(nativeGasCost.gt(bnZero), "Gas cost should not be 0");
+
+    const gasPrice = (gasPriceEstimate as TvmGasPriceEstimate).energyPrice;
+    const tokenGasCost = nativeGasCost.mul(gasPrice);
+
+    return { nativeGasCost, tokenGasCost, gasPrice };
+  }
+
+  override getAuxiliaryNativeTokenCost(deposit: RelayData): BigNumber {
+    return arch.tvm.getAuxiliaryNativeTokenCost(deposit);
+  }
+}

package/src/utils/Multicall.ts

@@ -21,6 +21,7 @@ const MULTICALL_DEPLOYER = "0x05f32B3cC3888453ff71B01135B34FF8e41263F2";
 
 const NON_DETERMINISTIC_MULTICALL_ADDRESSES = {
   [CHAIN_IDs.LENS]: "0x6b6dEa4D80e3077D076733A04c48F63c3BA49320",
+  [CHAIN_IDs.TRON]: "0x32a4f47a74a6810bd0bf861cabab99656a75de9e", // @todo: Base58?
   [CHAIN_IDs.ZK_SYNC]: "0xF9cda624FBC7e059355ce98a31693d299FACd963",
   [CHAIN_IDs.LENS_SEPOLIA]: "0x8A44EDE8a6843a997bC0Cc4659e4dB1Da8f91116",
 };

package/src/utils/NetworkUtils.ts

@@ -134,6 +134,15 @@ export function chainIsSvm(chainId: number): boolean {
   return PUBLIC_NETWORKS[chainId]?.family === ChainFamily.SVM;
 }
 
+/**
+ * Determines whether a chain ID runs on a TVM-like execution layer (e.g. TRON).
+ * @param chainId Chain ID to evaluate.
+ * @returns True if chain corresponding to chainId has a TVM-like execution layer.
+ */
+export function chainIsTvm(chainId: number): boolean {
+  return PUBLIC_NETWORKS[chainId]?.family === ChainFamily.TVM;
+}
+
 /**
  * Determines whether a chain ID has a native gas token.
  * @param chainId Chain ID to evaluate.
@@ -166,13 +175,14 @@ export function chainIsOFTEnabled(chainId: number): boolean {
   // This is backwards vs. CCTP logic because Across support for OFTs is limited vs. OFT deployments.
   const oftEnabled = [
     CHAIN_IDs.ARBITRUM,
-    CHAIN_IDs.POLYGON,
     CHAIN_IDs.HYPEREVM,
+    CHAIN_IDs.INK,
+    CHAIN_IDs.MEGAETH,
     CHAIN_IDs.MONAD,
     CHAIN_IDs.PLASMA,
-    CHAIN_IDs.MEGAETH,
+    CHAIN_IDs.POLYGON,
+    CHAIN_IDs.TRON, // tbd!!!
     CHAIN_IDs.UNICHAIN,
-    CHAIN_IDs.INK,
   ];
   return oftEnabled.includes(chainId) && PRODUCTION_NETWORKS[chainId]?.oftEid !== OFT_NO_EID;
 }

package/src/utils/TypeGuards.ts

@@ -1,6 +1,7 @@
 import { SVMProvider } from "../arch/svm/types";
 import { EvmProvider } from "../arch/evm/types";
 import { providers } from "ethers";
+import { TronWeb } from "tronweb";
 
 export function isPromiseFulfilled<T>(
   promiseSettledResult: PromiseSettledResult<T>
@@ -18,6 +19,10 @@ export function isDefined<T>(input: T | null | undefined): input is T {
   return input !== null && input !== undefined;
 }
 
-export function isEvmProvider(provider: EvmProvider | SVMProvider): provider is EvmProvider {
+export function isTvmProvider(provider: EvmProvider | SVMProvider | TronWeb): provider is TronWeb {
+  return typeof (provider as TronWeb)?.trx?.getEnergyPrices === "function";
+}
+
+export function isEvmProvider(provider: EvmProvider | SVMProvider | TronWeb): provider is EvmProvider {
   return provider instanceof providers.Provider;
 }