@hyperlane-xyz/rebalancer 27.2.14 → 27.3.0

package/src/config/RebalancerConfig.test.ts

@@ -572,6 +572,141 @@ describe('RebalancerConfig', () => {
   });
 });
 
+describe('Tron inventorySigners validation', () => {
+  const TEST_CONFIG_PATH_TRON = join(tmpdir(), 'rebalancer-tron-test.yaml');
+
+  afterEach(() => {
+    rmSync(TEST_CONFIG_PATH_TRON, { force: true });
+  });
+
+  it('should reject Tron T-prefix base58 address in inventorySigners', () => {
+    const data: RebalancerConfigFileInput = {
+      warpRouteId: 'test-tron-route',
+      strategy: [
+        {
+          rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+          chains: {
+            tron: {
+              weighted: { weight: 50, tolerance: 5 },
+              executionType: ExecutionType.Inventory,
+              externalBridge: ExternalBridgeType.LiFi,
+            },
+            ethereum: {
+              weighted: { weight: 50, tolerance: 5 },
+              executionType: ExecutionType.Inventory,
+              externalBridge: ExternalBridgeType.LiFi,
+            },
+          },
+        },
+      ],
+      inventorySigners: {
+        tron: {
+          address: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
+          key: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+        },
+        ethereum: {
+          address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+          key: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+        },
+      },
+      externalBridges: {
+        lifi: {
+          integrator: 'test-app',
+        },
+      },
+    };
+
+    writeYamlOrJson(TEST_CONFIG_PATH_TRON, data);
+    expect(() => RebalancerConfig.load(TEST_CONFIG_PATH_TRON)).to.throw(
+      /must be a valid 0x hex address/,
+    );
+  });
+
+  it('should accept valid 0x hex address for Tron inventorySigners', () => {
+    const data: RebalancerConfigFileInput = {
+      warpRouteId: 'test-tron-route',
+      strategy: [
+        {
+          rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+          chains: {
+            tron: {
+              weighted: { weight: 50, tolerance: 5 },
+              executionType: ExecutionType.Inventory,
+              externalBridge: ExternalBridgeType.LiFi,
+            },
+            ethereum: {
+              weighted: { weight: 50, tolerance: 5 },
+              executionType: ExecutionType.Inventory,
+              externalBridge: ExternalBridgeType.LiFi,
+            },
+          },
+        },
+      ],
+      inventorySigners: {
+        tron: {
+          address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+          key: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+        },
+        ethereum: {
+          address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+          key: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+        },
+      },
+      externalBridges: {
+        lifi: {
+          integrator: 'test-app',
+        },
+      },
+    };
+
+    writeYamlOrJson(TEST_CONFIG_PATH_TRON, data);
+    expect(() => RebalancerConfig.load(TEST_CONFIG_PATH_TRON)).to.not.throw();
+  });
+
+  it('should reject invalid Tron address in inventorySigners', () => {
+    const data: RebalancerConfigFileInput = {
+      warpRouteId: 'test-tron-route',
+      strategy: [
+        {
+          rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+          chains: {
+            tron: {
+              weighted: { weight: 50, tolerance: 5 },
+              executionType: ExecutionType.Inventory,
+              externalBridge: ExternalBridgeType.LiFi,
+            },
+            ethereum: {
+              weighted: { weight: 50, tolerance: 5 },
+              executionType: ExecutionType.Inventory,
+              externalBridge: ExternalBridgeType.LiFi,
+            },
+          },
+        },
+      ],
+      inventorySigners: {
+        tron: {
+          address: 'INVALID_TRON_ADDRESS',
+          key: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+        },
+        ethereum: {
+          address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+          key: '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+        },
+      },
+      externalBridges: {
+        lifi: {
+          integrator: 'test-app',
+        },
+      },
+    };
+
+    writeYamlOrJson(TEST_CONFIG_PATH_TRON, data);
+    expect(() => RebalancerConfig.load(TEST_CONFIG_PATH_TRON)).to.throw(
+      /must be a valid 0x hex address/,
+    );
+  });
+});
+
 describe('per-chain bridge configuration', () => {
   const TEST_CONFIG_PATH_BRIDGE = join(tmpdir(), 'rebalancer-bridge-test.yaml');
 

package/src/config/types.ts

@@ -361,6 +361,14 @@ export const RebalancerConfigSchema = z
                 path: ['inventorySigners', protocol],
               });
             }
+          } else if (protocol === ProtocolType.Tron) {
+            if (!isAddressEvm(signerConfig.address)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `inventorySigners.${protocol} must be a valid 0x hex address, got: ${signerConfig.address}`,
+                path: ['inventorySigners', protocol],
+              });
+            }
           }
           // Other protocols: accept any non-empty string (future-proof)
         }

package/src/core/InventoryRebalancer.test.ts

@@ -7,6 +7,7 @@ import Sinon, { type SinonStubbedInstance } from 'sinon';
 
 import {
   type ChainName,
+  HyperlaneCore,
   type MultiProvider,
   ProviderType,
   TokenStandard,
@@ -444,6 +445,165 @@ describe('InventoryRebalancer E2E', () => {
     });
   });
 
+  it('sendAndConfirmInventoryTx uses the EVM-like signer path for Tron txs', async () => {
+    const TRON_CHAIN = 'tron' as ChainName;
+    config.inventorySigners[ProtocolType.Tron] = {
+      address: INVENTORY_SIGNER,
+      key: TEST_PRIVATE_KEY,
+    };
+
+    const getChainMetadata = (chain: ChainName) => ({
+      name: chain,
+      protocol:
+        chain === TRON_CHAIN ? ProtocolType.Tron : ProtocolType.Ethereum,
+      blocks: { reorgPeriod: 2 },
+      rpcUrls: [{ http: 'http://127.0.0.1:9090/jsonrpc' }],
+    });
+    warpCore.multiProvider.getChainMetadata.callsFake(getChainMetadata);
+    multiProvider.getChainMetadata.callsFake(getChainMetadata);
+    warpCore.multiProvider.toMultiProvider =
+      Sinon.stub().returns(multiProvider);
+
+    const sendFn = (inventoryRebalancer as any).sendAndConfirmInventoryTx.bind(
+      inventoryRebalancer,
+    );
+    const result = await sendFn(TRON_CHAIN, {
+      category: WarpTxCategory.Transfer,
+      type: ProviderType.Tron,
+      transaction: {
+        to: '0xRouterAddress',
+        data: '0xTransferRemoteData',
+        value: 1000000n,
+      },
+    });
+
+    expect(result).to.deep.equal({ txHash: '0xTransferRemoteTxHash' });
+    expect(multiProvider.setSigner.calledOnce).to.be.true;
+    expect(
+      multiProvider.sendTransaction.calledOnceWithExactly(
+        TRON_CHAIN,
+        {
+          to: '0xRouterAddress',
+          data: '0xTransferRemoteData',
+          value: 1000000n,
+        },
+        { waitConfirmations: 2 },
+      ),
+    ).to.be.true;
+  });
+
+  it('buildSignerAccountConfig returns correct config for Tron protocol', () => {
+    config.inventorySigners[ProtocolType.Tron] = {
+      address: INVENTORY_SIGNER,
+      key: TEST_PRIVATE_KEY,
+    };
+
+    const buildFn = (inventoryRebalancer as any).buildSignerAccountConfig.bind(
+      inventoryRebalancer,
+    );
+    const result = buildFn(
+      ProtocolType.Tron,
+      TEST_PRIVATE_KEY,
+      'tron' as ChainName,
+    );
+
+    expect(result.protocol).to.equal(ProtocolType.Tron);
+    expect(result.privateKey).to.equal(TEST_PRIVATE_KEY);
+    // Tron uses same 0x-prefixed hex key format as Ethereum
+    expect(result.privateKey.startsWith('0x')).to.be.true;
+  });
+
+  it('getTransactionReceipt returns EthersV5 type for Tron chain', async () => {
+    const TRON_CHAIN = 'tron' as ChainName;
+    const mockReceipt = {
+      transactionHash: '0xTronReceipt',
+      logs: [],
+    };
+
+    warpCore.multiProvider.getChainMetadata.callsFake((chain: ChainName) => ({
+      name: chain,
+      protocol:
+        chain === TRON_CHAIN ? ProtocolType.Tron : ProtocolType.Ethereum,
+    }));
+
+    warpCore.multiProvider.getEthersV5Provider.returns({
+      getTransactionReceipt: Sinon.stub().resolves(mockReceipt),
+    });
+
+    const getReceiptFn = (
+      inventoryRebalancer as any
+    ).getTransactionReceipt.bind(inventoryRebalancer);
+    const receipt = await getReceiptFn(TRON_CHAIN, '0xTronTxHash');
+
+    expect(receipt).to.not.be.undefined;
+    expect(receipt.type).to.equal(ProviderType.EthersV5);
+    expect(receipt.receipt).to.deep.equal(mockReceipt);
+  });
+
+  it('extractDispatchedMessageId returns Tron message ids via the EthersV5 path', async () => {
+    const TRON_CHAIN = 'tron' as ChainName;
+    const expectedMessageId =
+      '0x1111111111111111111111111111111111111111111111111111111111111111';
+    const mockReceipt = {
+      transactionHash: '0xTronTx',
+      logs: [{}],
+    };
+
+    warpCore.multiProvider.getChainMetadata.callsFake((chain: ChainName) => ({
+      name: chain,
+      protocol:
+        chain === TRON_CHAIN ? ProtocolType.Tron : ProtocolType.Ethereum,
+    }));
+
+    const getDispatchedMessagesStub = Sinon.stub(
+      HyperlaneCore,
+      'getDispatchedMessages',
+    ).returns([{ id: expectedMessageId }] as any);
+    warpCore.multiProvider.getEthersV5Provider.returns({
+      getTransactionReceipt: Sinon.stub().resolves(mockReceipt),
+    });
+
+    const extractFn = (
+      inventoryRebalancer as any
+    ).extractDispatchedMessageId.bind(inventoryRebalancer);
+    const messageId = await extractFn(TRON_CHAIN, '0xTronTx');
+    expect(messageId).to.equal(expectedMessageId);
+    expect(getDispatchedMessagesStub.calledOnce).to.be.true;
+    expect(getDispatchedMessagesStub.firstCall.firstArg).to.equal(mockReceipt);
+  });
+
+  it('selects the Tron signer address from a mixed multi-protocol config', () => {
+    config.inventorySigners[ProtocolType.Tron] = {
+      address: INVENTORY_SIGNER,
+      key: TEST_PRIVATE_KEY,
+    };
+    config.inventorySigners[ProtocolType.Sealevel] = {
+      address: 'SoLANAAddReSs1234567890123456789012345678',
+      key: '1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32',
+    };
+
+    warpCore.multiProvider.getChainMetadata.callsFake((chain: ChainName) => ({
+      name: chain,
+      protocol:
+        chain === 'tron'
+          ? ProtocolType.Tron
+          : chain === SOLANA_CHAIN
+            ? ProtocolType.Sealevel
+            : ProtocolType.Ethereum,
+    }));
+
+    const getInventorySignerAddress = (
+      inventoryRebalancer as any
+    ).getInventorySignerAddress.bind(inventoryRebalancer);
+
+    expect(getInventorySignerAddress('tron' as ChainName)).to.equal(
+      INVENTORY_SIGNER,
+    );
+    expect(getInventorySignerAddress(SOLANA_CHAIN)).to.equal(
+      'SoLANAAddReSs1234567890123456789012345678',
+    );
+  });
+
   describe('Partial Fulfillment (Insufficient Inventory)', () => {
     // Partial transfers happen when maxTransferable >= minViableTransfer.
     // For non-native tokens (EvmHypCollateral), minViableTransfer = 0, so any

package/src/core/InventoryRebalancer.ts

@@ -15,7 +15,13 @@ import {
   getSignerForChain,
   type TypedTransactionReceipt,
 } from '@hyperlane-xyz/sdk';
-import { ProtocolType, assert, ensure0x, fromWei } from '@hyperlane-xyz/utils';
+import {
+  ProtocolType,
+  assert,
+  ensure0x,
+  fromWei,
+  isEVMLike,
+} from '@hyperlane-xyz/utils';
 
 import type { ExternalBridgeType } from '../config/types.js';
 import type {
@@ -89,7 +95,6 @@ type InventoryMovementExecutionResult =
       success: false;
       error: string;
     };
-
 const RECOVERABLE_MAX_TRANSFER_ERROR_MESSAGES = [
   'balance may be insufficient',
   'transfer amount exceeds balance',
@@ -1221,6 +1226,7 @@ export class InventoryRebalancer implements IInventoryRebalancer {
   ): MultiProtocolSignerSignerAccountInfo {
     void chain;
     switch (protocol) {
+      case ProtocolType.Tron:
       case ProtocolType.Ethereum:
         return { protocol, privateKey: ensure0x(key) };
       case ProtocolType.Sealevel:
@@ -1260,7 +1266,7 @@ export class InventoryRebalancer implements IInventoryRebalancer {
     try {
       const protocol = this.getProtocolForChain(origin);
 
-      if (protocol === ProtocolType.Ethereum) {
+      if (isEVMLike(protocol)) {
         const provider =
           this.warpCore.multiProvider.getEthersV5Provider(origin);
         const receipt = await provider.getTransactionReceipt(txHash);

package/src/factories/RebalancerContextFactory.test.ts

@@ -218,6 +218,36 @@ describe('RebalancerContextFactory', () => {
       expect(multiProvider.getProvider.firstCall.args[0]).to.equal('ethereum');
     });
 
+    it('should initialize providers for Tron chains (EVM-like)', async () => {
+      const { multiProvider } = createMockMultiProvider([
+        { name: 'ethereum', protocol: ProtocolType.Ethereum },
+        { name: 'tron', protocol: ProtocolType.Tron },
+      ]);
+
+      await callCreate(multiProvider, {
+        tokens: [
+          createToken(
+            'ethereum',
+            TEST_ADDRESSES.ethereum,
+            TokenStandard.EvmHypCollateral,
+          ),
+          createToken(
+            'tron',
+            '0xTronToken1234567890',
+            TokenStandard.TronHypCollateral,
+          ),
+        ],
+      });
+
+      // Tron is EVM-like, so getProvider should be called for both chains
+      expect(multiProvider.getProvider.callCount).to.equal(2);
+      const providerChains = multiProvider.getProvider
+        .getCalls()
+        .map((c) => c.args[0]);
+      expect(providerChains).to.include('ethereum');
+      expect(providerChains).to.include('tron');
+    });
+
     it('should call getProvider for all chains when all are EVM', async () => {
       const { multiProvider } = createMockMultiProvider([
         { name: 'ethereum', protocol: ProtocolType.Ethereum },
@@ -363,7 +393,7 @@ describe('RebalancerContextFactory', () => {
           createToken(
             evmChain,
             TEST_ADDRESSES.ethereum,
-            TokenStandard.EvmHypSynthetic,
+            TokenStandard.EvmHypCollateral,
           ),
           createToken(
             sealevelChain,
@@ -446,6 +476,91 @@ describe('RebalancerContextFactory', () => {
       );
     });
 
+    it('should accept Tron as a supported inventory protocol', async () => {
+      const tronChain = 'tron';
+      const evmChain = 'ethereum';
+      const { multiProvider } = createMockMultiProvider([
+        { name: evmChain, protocol: ProtocolType.Ethereum },
+        { name: tronChain, protocol: ProtocolType.Tron },
+      ]);
+
+      const config = {
+        warpRouteId: 'USDC/tron-route',
+        strategyConfig: [
+          {
+            rebalanceStrategy: RebalancerStrategyOptions.Weighted,
+            chains: {
+              [tronChain]: {
+                bridge: TEST_ADDRESSES.bridge,
+                weighted: { weight: 50n, tolerance: 10n },
+                override: {
+                  [evmChain]: {
+                    executionType: ExecutionType.Inventory,
+                  },
+                },
+              },
+              [evmChain]: {
+                bridge: TEST_ADDRESSES.bridge,
+                weighted: { weight: 50n, tolerance: 10n },
+              },
+            },
+          },
+        ],
+        inventorySigners: {
+          [ProtocolType.Ethereum]: {
+            address: TEST_ADDRESSES.ethereum,
+            key: '0xabc123',
+          },
+          [ProtocolType.Tron]: {
+            address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+            key: '0xdef456',
+          },
+        },
+        intentTTL: DEFAULT_INTENT_TTL_MS,
+      } as RebalancerConfig;
+
+      const factory = await createFactory(config, multiProvider, {
+        tokens: [
+          createToken(
+            evmChain,
+            TEST_ADDRESSES.ethereum,
+            TokenStandard.EvmHypCollateral,
+          ),
+          createToken(
+            tronChain,
+            '0xTronToken123',
+            TokenStandard.TronHypCollateral,
+          ),
+        ],
+      });
+
+      const getChainMetadataStub = factory.getWarpCore().multiProvider
+        .getChainMetadata as Sinon.SinonStub;
+      getChainMetadataStub.callsFake((chainName: string) => ({
+        protocol:
+          chainName === tronChain ? ProtocolType.Tron : ProtocolType.Ethereum,
+      }));
+
+      const result = await (factory as any).createInventoryRebalancerAndConfig(
+        {} as any,
+        {},
+      );
+
+      assert(
+        result,
+        'Expected inventory config to be created for Tron support',
+      );
+      expect(result.inventoryConfig.inventoryAddresses).to.deep.equal({
+        [ProtocolType.Ethereum]: TEST_ADDRESSES.ethereum,
+        [ProtocolType.Tron]: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+      });
+      expect(result.inventoryConfig.chains).to.include.members([
+        evmChain,
+        tronChain,
+      ]);
+      expect(result.inventoryRebalancer).to.exist;
+    });
+
     it('should fail early when inventory chain uses unsupported protocol', async () => {
       const cosmosChain = 'cosmoshub';
       const evmChain = 'ethereum';

package/src/factories/RebalancerContextFactory.ts

@@ -11,7 +11,13 @@ import {
   WarpCore,
   type WarpCoreConfig,
 } from '@hyperlane-xyz/sdk';
-import { Address, assert, ProtocolType, objMap } from '@hyperlane-xyz/utils';
+import {
+  Address,
+  assert,
+  isEVMLike,
+  ProtocolType,
+  objMap,
+} from '@hyperlane-xyz/utils';
 
 import { LiFiBridge } from '../bridges/LiFiBridge.js';
 import { type RebalancerConfig } from '../config/RebalancerConfig.js';
@@ -137,7 +143,7 @@ export class RebalancerContextFactory {
       ...new Set(warpCoreConfig.tokens.map((t) => t.chainName)),
     ];
     for (const chain of warpChains) {
-      if (multiProvider.getProtocol(chain) !== ProtocolType.Ethereum) {
+      if (!isEVMLike(multiProvider.getProtocol(chain))) {
         logger.debug({ chain }, 'Skipping provider init for non-EVM chain');
         continue;
       }
@@ -373,11 +379,12 @@ export class RebalancerContextFactory {
       bridges,
       rebalancerAddress,
       inventorySignerAddresses: this.config.inventorySigners
-        ? (Object.entries(this.config.inventorySigners)
-            .filter(([protocol]) => protocol === ProtocolType.Ethereum)
-            .map(([, signerConfig]) => signerConfig)
-            .map((s) => s.address)
-            .filter(Boolean) as Address[])
+        ? Object.values(ProtocolType)
+            .filter((protocol) => isEVMLike(protocol))
+            .map(
+              (protocol) => this.config.inventorySigners?.[protocol]?.address,
+            )
+            .filter((address): address is Address => Boolean(address))
         : undefined,
       intentTTL: this.config.intentTTL,
     };
@@ -481,6 +488,7 @@ export class RebalancerContextFactory {
     const SUPPORTED_INVENTORY_PROTOCOLS = new Set([
       ProtocolType.Ethereum,
       ProtocolType.Sealevel,
+      ProtocolType.Tron,
     ]);
     for (const protocol of requiredProtocols) {
       const chainsForProtocol = allRelevantChains.filter(
@@ -490,7 +498,7 @@ export class RebalancerContextFactory {
       );
       assert(
         SUPPORTED_INVENTORY_PROTOCOLS.has(protocol),
-        `Inventory rebalancing does not support protocol '${protocol}' (chains: ${chainsForProtocol.join(', ')}). Supported: ethereum, sealevel`,
+        `Inventory rebalancing does not support protocol '${protocol}' (chains: ${chainsForProtocol.join(', ')}). Supported: ethereum, sealevel, tron`,
       );
     }
     for (const protocol of requiredProtocols) {
@@ -532,12 +540,12 @@ export class RebalancerContextFactory {
           'No external bridges configured, skipping inventory components',
         );
       }
-      const inventoryAddresses = Object.fromEntries(
-        Object.entries(inventorySigners).map(([protocol, cfg]) => [
-          protocol,
-          cfg.address,
-        ]),
-      ) as Partial<Record<ProtocolType, Address>>;
+      const inventoryAddresses: Partial<Record<ProtocolType, Address>> = {};
+      for (const protocol of Object.values(ProtocolType)) {
+        const cfg = inventorySigners[protocol];
+        if (!cfg) continue;
+        inventoryAddresses[protocol] = cfg.address;
+      }
       const inventoryConfig: InventoryMonitorConfig = {
         inventoryAddresses,
         chains: allRelevantChains,
@@ -546,11 +554,12 @@ export class RebalancerContextFactory {
       const mergedSigners: Partial<
         Record<ProtocolType, InventorySignerConfig>
       > = {};
-      for (const [protocol, cfg] of Object.entries(inventorySigners)) {
-        const protocolKey = protocol as ProtocolType;
-        mergedSigners[protocolKey] = {
+      for (const protocol of Object.values(ProtocolType)) {
+        const cfg = inventorySigners[protocol];
+        if (!cfg) continue;
+        mergedSigners[protocol] = {
           address: cfg.address,
-          key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocolKey],
+          key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocol],
         };
       }
       const inventoryRebalancer = new InventoryRebalancer(
@@ -572,12 +581,12 @@ export class RebalancerContextFactory {
     }
 
     // 3. Build inventory config
-    const inventoryAddresses = Object.fromEntries(
-      Object.entries(inventorySigners).map(([protocol, cfg]) => [
-        protocol,
-        cfg.address,
-      ]),
-    ) as Partial<Record<ProtocolType, Address>>;
+    const inventoryAddresses: Partial<Record<ProtocolType, Address>> = {};
+    for (const protocol of Object.values(ProtocolType)) {
+      const cfg = inventorySigners[protocol];
+      if (!cfg) continue;
+      inventoryAddresses[protocol] = cfg.address;
+    }
     const inventoryConfig: InventoryMonitorConfig = {
       inventoryAddresses,
       chains: allRelevantChains,
@@ -587,11 +596,12 @@ export class RebalancerContextFactory {
     // Merge config addresses with runtime keys
     const mergedSigners: Partial<Record<ProtocolType, InventorySignerConfig>> =
       {};
-    for (const [protocol, cfg] of Object.entries(inventorySigners)) {
-      const protocolKey = protocol as ProtocolType;
-      mergedSigners[protocolKey] = {
+    for (const protocol of Object.values(ProtocolType)) {
+      const cfg = inventorySigners[protocol];
+      if (!cfg) continue;
+      mergedSigners[protocol] = {
         address: cfg.address,
-        key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocolKey],
+        key: cfg.key ?? this.inventorySignerKeysByProtocol?.[protocol],
       };
     }
     const inventoryRebalancer = new InventoryRebalancer(

package/src/service.ts

@@ -33,6 +33,7 @@ import { MultiProvider } from '@hyperlane-xyz/sdk';
 import {
   applyRpcUrlOverridesFromEnv,
   createServiceLogger,
+  isEVMLike,
   ProtocolType,
   rootLogger,
 } from '@hyperlane-xyz/utils';
@@ -151,12 +152,15 @@ async function main(): Promise<void> {
       Record<ProtocolType, InventorySignerConfig>
     > = {};
 
-    for (const [protocol, privateKey] of Object.entries(inventoryPrivateKeys)) {
+    for (const protocol of Object.values(ProtocolType)) {
+      const privateKey = inventoryPrivateKeys[protocol];
       if (!privateKey) continue;
 
       let derivedAddress: string;
 
-      if (protocol === ProtocolType.Ethereum) {
+      if (isEVMLike(protocol)) {
+        // Tron uses same hex private key format as Ethereum.
+        // Derive 0x-prefixed hex address via ethers Wallet (TronWallet extends Wallet).
         derivedAddress = new Wallet(privateKey).address;
       } else if (protocol === ProtocolType.Sealevel) {
         const keyBytes = parseSolanaPrivateKey(privateKey);
@@ -172,12 +176,11 @@ async function main(): Promise<void> {
 
       // Validate against config if present
       const configuredAddress =
-        rebalancerConfig.inventorySigners?.[protocol as ProtocolType]?.address;
+        rebalancerConfig.inventorySigners?.[protocol]?.address;
       if (configuredAddress) {
-        const mismatch =
-          protocol === ProtocolType.Ethereum
-            ? configuredAddress.toLowerCase() !== derivedAddress.toLowerCase()
-            : configuredAddress !== derivedAddress;
+        const mismatch = isEVMLike(protocol)
+          ? configuredAddress.toLowerCase() !== derivedAddress.toLowerCase()
+          : configuredAddress !== derivedAddress;
         if (mismatch) {
           throw new Error(
             `inventorySigners.${protocol} mismatch: config has ${configuredAddress} but HYP_INVENTORY_KEY_${protocol.toUpperCase()} derives to ${derivedAddress}`,
@@ -185,7 +188,7 @@ async function main(): Promise<void> {
         }
       }
 
-      inventorySigners[protocol as ProtocolType] = {
+      inventorySigners[protocol] = {
         address: derivedAddress,
         key: privateKey,
       };