@hyperlane-xyz/rebalancer 27.2.14 → 27.3.1

package/src/utils/blockTag.test.ts

@@ -0,0 +1,70 @@
+import { expect } from 'chai';
+import { providers } from 'ethers';
+import Sinon from 'sinon';
+
+import { MultiProtocolProvider } from '@hyperlane-xyz/sdk';
+import { ProtocolType } from '@hyperlane-xyz/utils';
+
+import { getConfirmedBlockTag } from './blockTag.js';
+
+describe('getConfirmedBlockTag', () => {
+  let mpp: Sinon.SinonStubbedInstance<MultiProtocolProvider>;
+
+  beforeEach(() => {
+    mpp = Sinon.createStubInstance(MultiProtocolProvider);
+  });
+
+  afterEach(() => {
+    Sinon.restore();
+  });
+
+  it('returns a confirmed block number for Tron chain (EVM-like)', async () => {
+    mpp.getChainMetadata.returns({
+      protocol: ProtocolType.Tron,
+      name: 'tron',
+      chainId: 728126428,
+      blocks: { reorgPeriod: 20 },
+    } as any);
+
+    const mockProvider = {
+      send: Sinon.stub().resolves('0x64'), // 100 in hex
+      getBlockNumber: Sinon.stub().resolves(100),
+    };
+    // Make instanceof check pass
+    Object.setPrototypeOf(mockProvider, providers.JsonRpcProvider.prototype);
+    mpp.getEthersV5Provider.returns(mockProvider as any);
+
+    const result = await getConfirmedBlockTag(mpp, 'tron');
+    // 100 - 20 = 80
+    expect(result).to.equal(80);
+  });
+
+  it('returns undefined for Sealevel chain (non-EVM-like)', async () => {
+    mpp.getChainMetadata.returns({
+      protocol: ProtocolType.Sealevel,
+      name: 'solana',
+      chainId: 1399811149,
+    } as any);
+
+    const result = await getConfirmedBlockTag(mpp, 'solana');
+    expect(result).to.be.undefined;
+  });
+
+  it('returns undefined for Tron chain with string reorgPeriod (named block tags not supported)', async () => {
+    const logger = { warn: Sinon.stub() };
+    mpp.getChainMetadata.returns({
+      protocol: ProtocolType.Tron,
+      name: 'tron',
+      chainId: 728126428,
+      blocks: { reorgPeriod: 'finalized' },
+    } as any);
+
+    const result = await getConfirmedBlockTag(mpp, 'tron', logger as any);
+    expect(result).to.be.undefined;
+    expect(logger.warn.calledOnce).to.be.true;
+    const warnCall = logger.warn.getCall(0);
+    expect(warnCall.args[1]).to.include(
+      'Tron does not support named block tags',
+    );
+  });
+});

package/src/utils/blockTag.ts

@@ -6,7 +6,7 @@ import {
   EthJsonRpcBlockParameterTag,
   type MultiProtocolProvider,
 } from '@hyperlane-xyz/sdk';
-import { ProtocolType } from '@hyperlane-xyz/utils';
+import { isEVMLike, ProtocolType } from '@hyperlane-xyz/utils';
 import type { ConfirmedBlockTag } from '../interfaces/IMonitor.js';
 
 /**
@@ -29,13 +29,21 @@ export async function getConfirmedBlockTag(
   try {
     const metadata = multiProvider.getChainMetadata(chainName);
 
-    // Only EVM chains support block tag queries
-    if (metadata.protocol !== ProtocolType.Ethereum) {
+    // Only EVM-like chains support block tag queries (e.g., Ethereum, Tron).
+    // Tron uses TronJsonRpcProvider which supports eth_blockNumber
+    if (!isEVMLike(metadata.protocol)) {
       return undefined;
     }
 
     const reorgPeriod = metadata.blocks?.reorgPeriod ?? 32;
     if (typeof reorgPeriod === 'string') {
+      if (metadata.protocol === ProtocolType.Tron) {
+        logger?.warn(
+          { chain: chainName, reorgPeriod },
+          'Tron does not support named block tags — ignoring string reorgPeriod, using latest block',
+        );
+        return undefined;
+      }
       return reorgPeriod as EthJsonRpcBlockParameterTag;
     }
 

package/src/utils/gasEstimation.test.ts

@@ -0,0 +1,99 @@
+import { expect } from 'chai';
+import { BigNumber } from 'ethers';
+import { pino } from 'pino';
+import Sinon from 'sinon';
+
+import type { ChainName, MultiProvider, Token } from '@hyperlane-xyz/sdk';
+import { TokenStandard } from '@hyperlane-xyz/sdk';
+import { ProtocolType } from '@hyperlane-xyz/utils';
+
+import { calculateTransferCosts } from './gasEstimation.js';
+
+const testLogger = pino({ level: 'silent' });
+
+describe('calculateTransferCosts — Tron vs Sealevel protocol path', () => {
+  afterEach(() => {
+    Sinon.restore();
+  });
+
+  function createMockDeps(protocol: ProtocolType) {
+    const mockAdapter = {
+      quoteTransferRemoteGas: Sinon.stub().resolves({
+        igpQuote: { amount: 1000n },
+        tokenFeeQuote: { amount: 0n, addressOrDenom: '' },
+      }),
+      populateTransferRemoteTx: Sinon.stub().resolves({
+        to: '0xRouter',
+        data: '0x',
+        value: 1000n,
+      }),
+    };
+
+    const mockToken = {
+      standard: TokenStandard.EvmHypNative, // Native so we reach the isEVMLike check
+      getHypAdapter: Sinon.stub().returns(mockAdapter),
+    } as unknown as Token;
+
+    const multiProvider = {
+      getDomainId: Sinon.stub().returns(42161),
+      getProtocol: Sinon.stub().returns(protocol),
+      getProvider: Sinon.stub().returns({
+        estimateGas: Sinon.stub().resolves(BigNumber.from(200000)),
+        getFeeData: Sinon.stub().resolves({
+          maxFeePerGas: BigNumber.from(10_000_000_000n),
+          gasPrice: BigNumber.from(10_000_000_000n),
+        }),
+      }),
+    } as unknown as MultiProvider;
+
+    const getTokenForChain = Sinon.stub().returns(mockToken);
+    const isNativeTokenStandard = Sinon.stub().returns(true);
+
+    return { multiProvider, getTokenForChain, isNativeTokenStandard };
+  }
+
+  it('Tron origin (EVM-like) produces non-zero gasCost for native tokens', async () => {
+    const { multiProvider, getTokenForChain, isNativeTokenStandard } =
+      createMockDeps(ProtocolType.Tron);
+
+    const result = await calculateTransferCosts(
+      'tron' as ChainName,
+      'arbitrum' as ChainName,
+      10000000000000000000n, // 10 ETH available
+      1000000000000000000n, // 1 ETH requested
+      multiProvider,
+      {} as any, // warpCoreMultiProvider
+      getTokenForChain,
+      '0xInventorySigner',
+      isNativeTokenStandard,
+      testLogger,
+    );
+
+    // Tron is EVM-like — gas estimation runs, producing gasCost > 0
+    expect(result.gasCost > 0n).to.be.true;
+    expect(result.igpCost).to.equal(1000n);
+    expect(result.maxTransferable > 0n).to.be.true;
+  });
+
+  it('Sealevel origin (non-EVM) returns gasCost = 0 for native tokens', async () => {
+    const { multiProvider, getTokenForChain, isNativeTokenStandard } =
+      createMockDeps(ProtocolType.Sealevel);
+
+    const result = await calculateTransferCosts(
+      'solana' as ChainName,
+      'arbitrum' as ChainName,
+      200000000000n,
+      100000000000n,
+      multiProvider,
+      {} as any,
+      getTokenForChain,
+      '0xInventorySigner',
+      isNativeTokenStandard,
+      testLogger,
+    );
+
+    // Sealevel is non-EVM — gasCost is 0 (skips gas estimation)
+    expect(result.gasCost).to.equal(0n);
+    expect(result.igpCost).to.equal(1000n);
+  });
+});

package/src/utils/gasEstimation.ts

@@ -11,8 +11,8 @@ import {
 } from '@hyperlane-xyz/sdk';
 import {
   addBufferToGasLimit,
+  isEVMLike,
   isZeroishAddress,
-  ProtocolType,
 } from '@hyperlane-xyz/utils';
 
 /**
@@ -211,13 +211,13 @@ export async function calculateTransferCosts(
       ? (gasQuote.tokenFeeQuote?.amount ?? 0n)
       : 0n;
 
-  // Skip gas estimation for non-EVM chains (e.g., Solana).
+  // Skip gas estimation for non-EVM-like chains (e.g., Solana).
   // Non-EVM chains have negligible base fees (~5000 lamports ~$0.0001 on Solana)
   // compared to EVM gas costs ($0.50-$50/tx). The IGP (Interchain Gas Paymaster)
   // reservation dominates the cost, not chain-specific gas. Thus gasCost=0 is a
-  // safe approximation for non-EVM origin chains.
+  // safe approximation for non-EVM-like origin chains.
   const originProtocol = multiProvider.getProtocol(originChain);
-  if (originProtocol !== ProtocolType.Ethereum) {
+  if (!isEVMLike(originProtocol)) {
     const totalCost = igpCost + tokenFeeCost;
     let maxTransferable: bigint;
     if (availableInventory <= totalCost) {

package/src/utils/tokenUtils.ts

@@ -13,15 +13,18 @@ const REBALANCEABLE_TOKEN_COLLATERALIZED_STANDARDS = new Set<TokenStandard>([
   TokenStandard.EvmHypNative,
   TokenStandard.SealevelHypCollateral,
   TokenStandard.SealevelHypNative,
+  TokenStandard.TronHypCollateral,
+  TokenStandard.TronHypNative,
 ]);
 
-// SDK-backed native token standard check scoped to EVM and Sealevel only (2-protocol scope).
+// SDK-backed native token standard check scoped to EVM, Sealevel, and Tron (3-protocol scope).
 // NOTE: We intentionally do NOT use the full PROTOCOL_TO_HYP_NATIVE_STANDARD map (all 7 protocols)
-// because the rebalancer only supports EVM and Sealevel native token bridging.
+// because the rebalancer only supports EVM, Sealevel, and Tron native token bridging.
 // Expanding this would change gas reservation behavior for other protocols.
 const REBALANCER_NATIVE_STANDARDS = new Set([
   PROTOCOL_TO_HYP_NATIVE_STANDARD[ProtocolType.Ethereum],
   PROTOCOL_TO_HYP_NATIVE_STANDARD[ProtocolType.Sealevel],
+  PROTOCOL_TO_HYP_NATIVE_STANDARD[ProtocolType.Tron],
 ]);
 
 /**