@humanode-hyperlane/rebalancer 27.2.2 → 1029.1.1

package/src/utils/gasEstimation.test.ts

@@ -0,0 +1,192 @@
+import { expect } from 'chai';
+import { BigNumber } from 'ethers';
+import { pino } from 'pino';
+import Sinon from 'sinon';
+
+import type { ChainName, MultiProvider, Token } from '@humanode-hyperlane/sdk';
+import { TokenStandard } from '@humanode-hyperlane/sdk';
+import { ProtocolType } from '@humanode-hyperlane/utils';
+
+import {
+  calculateTransferCosts,
+  estimateTransferRemoteGas,
+} 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 mockProvider = {
+      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),
+      }),
+    };
+    const multiProvider = {
+      getDomainId: Sinon.stub().returns(42161),
+      getProtocol: Sinon.stub().returns(protocol),
+      getProvider: Sinon.stub().returns(mockProvider),
+    } as unknown as MultiProvider;
+
+    const getTokenForChain = Sinon.stub().returns(mockToken);
+    const isNativeTokenStandard = Sinon.stub().returns(true);
+
+    return {
+      multiProvider,
+      getTokenForChain,
+      isNativeTokenStandard,
+      mockAdapter,
+      mockProvider,
+    };
+  }
+
+  it('uses one quote consistently for EVM-native reservation and estimation', async () => {
+    const {
+      multiProvider,
+      getTokenForChain,
+      isNativeTokenStandard,
+      mockAdapter,
+    } = createMockDeps(ProtocolType.Ethereum);
+    mockAdapter.quoteTransferRemoteGas
+      .onSecondCall()
+      .rejects(new Error('duplicate quote'));
+    const result = await calculateTransferCosts(
+      'ethereum',
+      'arbitrum',
+      3_000_000_000_000_000n,
+      3_000_000_000_000_000n,
+      multiProvider,
+      {},
+      getTokenForChain,
+      '0xInventorySigner',
+      isNativeTokenStandard,
+      testLogger,
+    );
+    expect(mockAdapter.quoteTransferRemoteGas.callCount).to.equal(1);
+    expect(
+      mockAdapter.populateTransferRemoteTx.firstCall.args[0].interchainGas,
+    ).to.equal(result.gasQuote);
+    expect(result.igpCost).to.equal(1000n);
+    expect(result.gasCost).to.equal(2_200_000_000_000_000n);
+    expect(result.totalCost).to.equal(2_200_000_000_001_000n);
+    expect(result.maxTransferable).to.equal(799_999_999_999_000n);
+    expect(result.minViableTransfer).to.equal(4_400_000_000_002_000n);
+  });
+
+  it('retains the fallback gas reserve when estimation fails', async () => {
+    const {
+      multiProvider,
+      getTokenForChain,
+      isNativeTokenStandard,
+      mockAdapter,
+      mockProvider,
+    } = createMockDeps(ProtocolType.Ethereum);
+    mockProvider.estimateGas.rejects(new Error('estimate unavailable'));
+    const result = await calculateTransferCosts(
+      'ethereum',
+      'arbitrum',
+      10_000_000_000_000_000n,
+      5_000_000_000_000_000n,
+      multiProvider,
+      {},
+      getTokenForChain,
+      '0xInventorySigner',
+      isNativeTokenStandard,
+      testLogger,
+    );
+    expect(mockAdapter.quoteTransferRemoteGas.callCount).to.equal(1);
+    expect(result.gasCost).to.equal(3_300_000_000_000_000n);
+    expect(result.igpCost).to.equal(1000n);
+  });
+
+  it('still obtains a quote for standalone gas estimation', async () => {
+    const { multiProvider, getTokenForChain, mockAdapter } = createMockDeps(
+      ProtocolType.Ethereum,
+    );
+    const estimate = await estimateTransferRemoteGas(
+      'ethereum',
+      'arbitrum',
+      100n,
+      multiProvider,
+      {},
+      getTokenForChain,
+      '0xInventorySigner',
+      testLogger,
+    );
+    expect(estimate).to.equal(200000n);
+    expect(mockAdapter.quoteTransferRemoteGas.callCount).to.equal(1);
+    expect(mockAdapter.quoteTransferRemoteGas.firstCall.args[0]).to.deep.equal({
+      destination: 42161,
+      sender: '0xInventorySigner',
+      recipient: '0xInventorySigner',
+      amount: 100n,
+    });
+  });
+
+  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 '@humanode-hyperlane/sdk';
 import {
   addBufferToGasLimit,
+  isEVMLike,
   isZeroishAddress,
-  ProtocolType,
 } from '@humanode-hyperlane/utils';
 
 /**
@@ -60,6 +60,7 @@ export interface TransferCostEstimate {
  * @param getTokenForChain - Function to get token for a chain
  * @param inventorySigner - Address of the inventory signer
  * @param logger - Logger instance
+ * @param providedGasQuote - Quote already obtained for this exact transfer-cost calculation
  * @returns Estimated gas limit for the transaction
  */
 export async function estimateTransferRemoteGas(
@@ -71,6 +72,7 @@ export async function estimateTransferRemoteGas(
   getTokenForChain: (chain: ChainName) => Token | undefined,
   inventorySigner: string,
   logger: Logger,
+  providedGasQuote?: InterchainGasQuote,
 ): Promise<bigint> {
   const originToken = getTokenForChain(originChain);
   if (!originToken) {
@@ -85,13 +87,16 @@ export async function estimateTransferRemoteGas(
     const destinationDomain = multiProvider.getDomainId(destinationChain);
     const adapter = originToken.getHypAdapter(warpCoreMultiProvider);
 
-    // Quote the IGP gas first (needed for the full transaction)
-    const gasQuote = await adapter.quoteTransferRemoteGas({
-      destination: destinationDomain,
-      sender: inventorySigner,
-      recipient: inventorySigner,
-      amount,
-    });
+    // Reuse the quote from this cost calculation when supplied; standalone
+    // estimation still obtains a fresh quote for its own transfer parameters.
+    const gasQuote =
+      providedGasQuote ??
+      (await adapter.quoteTransferRemoteGas({
+        destination: destinationDomain,
+        sender: inventorySigner,
+        recipient: inventorySigner,
+        amount,
+      }));
 
     // Populate with minimal amount for gas estimation
     // Gas cost is independent of transfer size (just a require check in _transferFromSender),
@@ -211,13 +216,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) {
@@ -251,6 +256,7 @@ export async function calculateTransferCosts(
     getTokenForChain,
     inventorySigner,
     logger,
+    gasQuote,
   );
   const bufferedGasLimit = addBufferToGasLimit(
     BigNumber.from(estimatedGasLimit.toString()),

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],
 ]);
 
 /**