@hyperlane-xyz/rebalancer 27.2.14 → 27.3.0

package/dist/utils/gasEstimation.test.js

@@ -0,0 +1,63 @@
+import { expect } from 'chai';
+import { BigNumber } from 'ethers';
+import { pino } from 'pino';
+import Sinon from 'sinon';
+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) {
+        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),
+        };
+        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(10000000000n),
+                    gasPrice: BigNumber.from(10000000000n),
+                }),
+            }),
+        };
+        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', 'arbitrum', 10000000000000000000n, // 10 ETH available
+        1000000000000000000n, // 1 ETH requested
+        multiProvider, {}, // 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', 'arbitrum', 200000000000n, 100000000000n, multiProvider, {}, 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);
+    });
+});
+//# sourceMappingURL=gasEstimation.test.js.map

package/dist/utils/gasEstimation.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gasEstimation.test.js","sourceRoot":"","sources":["../../src/utils/gasEstimation.test.ts"],"names":[],"mappings":"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"}

package/dist/utils/tokenUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokenUtils.d.ts","sourceRoot":"","sources":["../../src/utils/tokenUtils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,EAEL,KAAK,KAAK,EACV,aAAa,EACd,MAAM,oBAAoB,CAAC;AAkB5B;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAEtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2CAA2C,CACzD,KAAK,EAAE,KAAK,GACX,OAAO,CAKT;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,KAAK,EACZ,kBAAkB,EAAE,kBAAkB,EACtC,qBAAqB,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,MAAM,GAC1D,MAAM,CAaR"}
+{"version":3,"file":"tokenUtils.d.ts","sourceRoot":"","sources":["../../src/utils/tokenUtils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,OAAO,EAEL,KAAK,KAAK,EACV,aAAa,EACd,MAAM,oBAAoB,CAAC;AAqB5B;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAEtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2CAA2C,CACzD,KAAK,EAAE,KAAK,GACX,OAAO,CAKT;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,KAAK,EACZ,kBAAkB,EAAE,kBAAkB,EACtC,qBAAqB,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,MAAM,GAC1D,MAAM,CAaR"}

package/dist/utils/tokenUtils.js

@@ -5,14 +5,17 @@ const REBALANCEABLE_TOKEN_COLLATERALIZED_STANDARDS = new Set([
     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],
 ]);
 /**
  * Check if a token's balance is the same as native gas balance.

package/dist/utils/tokenUtils.js.map

@@ -1 +1 @@
-{"version":3,"file":"tokenUtils.js","sourceRoot":"","sources":["../../src/utils/tokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAI5D,OAAO,EACL,+BAA+B,EAE/B,aAAa,GACd,MAAM,oBAAoB,CAAC;AAE5B,MAAM,4CAA4C,GAAG,IAAI,GAAG,CAAgB;IAC1E,aAAa,CAAC,gBAAgB;IAC9B,aAAa,CAAC,YAAY;IAC1B,aAAa,CAAC,qBAAqB;IACnC,aAAa,CAAC,iBAAiB;CAChC,CAAC,CAAC;AAEH,6FAA6F;AAC7F,mGAAmG;AACnG,+EAA+E;AAC/E,4EAA4E;AAC5E,MAAM,2BAA2B,GAAG,IAAI,GAAG,CAAC;IAC1C,+BAA+B,CAAC,YAAY,CAAC,QAAQ,CAAC;IACtD,+BAA+B,CAAC,YAAY,CAAC,QAAQ,CAAC;CACvD,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAuB;IAC3D,OAAO,2BAA2B,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2CAA2C,CACzD,KAAY;IAEZ,OAAO,CACL,KAAK,CAAC,gBAAgB,EAAE;QACxB,4CAA4C,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CACjE,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,6BAA6B,CAC3C,KAAY,EACZ,kBAAsC,EACtC,qBAA2D;IAE3D,IAAI,qBAAqB,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1C,OAAO,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,KAAK,CAAC,wBAAwB;QAAE,OAAO,KAAK,CAAC,wBAAwB,CAAC;IAE1E,MAAM,CACJ,CAAC,4CAA4C,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,EACjE,gEAAgE,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,QAAQ,GAAG,CACtG,CAAC;IAEF,OAAO,KAAK,CAAC,cAAc,CAAC;AAC9B,CAAC"}
+{"version":3,"file":"tokenUtils.js","sourceRoot":"","sources":["../../src/utils/tokenUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAI5D,OAAO,EACL,+BAA+B,EAE/B,aAAa,GACd,MAAM,oBAAoB,CAAC;AAE5B,MAAM,4CAA4C,GAAG,IAAI,GAAG,CAAgB;IAC1E,aAAa,CAAC,gBAAgB;IAC9B,aAAa,CAAC,YAAY;IAC1B,aAAa,CAAC,qBAAqB;IACnC,aAAa,CAAC,iBAAiB;IAC/B,aAAa,CAAC,iBAAiB;IAC/B,aAAa,CAAC,aAAa;CAC5B,CAAC,CAAC;AAEH,+FAA+F;AAC/F,mGAAmG;AACnG,sFAAsF;AACtF,4EAA4E;AAC5E,MAAM,2BAA2B,GAAG,IAAI,GAAG,CAAC;IAC1C,+BAA+B,CAAC,YAAY,CAAC,QAAQ,CAAC;IACtD,+BAA+B,CAAC,YAAY,CAAC,QAAQ,CAAC;IACtD,+BAA+B,CAAC,YAAY,CAAC,IAAI,CAAC;CACnD,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAuB;IAC3D,OAAO,2BAA2B,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,2CAA2C,CACzD,KAAY;IAEZ,OAAO,CACL,KAAK,CAAC,gBAAgB,EAAE;QACxB,4CAA4C,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CACjE,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,6BAA6B,CAC3C,KAAY,EACZ,kBAAsC,EACtC,qBAA2D;IAE3D,IAAI,qBAAqB,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1C,OAAO,qBAAqB,CAAC,kBAAkB,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,KAAK,CAAC,wBAAwB;QAAE,OAAO,KAAK,CAAC,wBAAwB,CAAC;IAE1E,MAAM,CACJ,CAAC,4CAA4C,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,EACjE,gEAAgE,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,QAAQ,GAAG,CACtG,CAAC;IAEF,OAAO,KAAK,CAAC,cAAc,CAAC;AAC9B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperlane-xyz/rebalancer",
-  "version": "27.2.14",
+  "version": "27.3.0",
   "description": "Hyperlane Warp Route Collateral Rebalancer Service",
   "keywords": [
     "blockchain",
@@ -43,10 +43,10 @@
     "zod": "^3.21.2",
     "zod-validation-error": "^3.3.0",
     "@hyperlane-xyz/core": "11.3.1",
-    "@hyperlane-xyz/metrics": "0.2.20",
-    "@hyperlane-xyz/provider-sdk": "5.1.0",
-    "@hyperlane-xyz/sdk": "33.0.2",
-    "@hyperlane-xyz/utils": "33.0.2"
+    "@hyperlane-xyz/metrics": "0.2.21",
+    "@hyperlane-xyz/provider-sdk": "6.0.0",
+    "@hyperlane-xyz/sdk": "33.1.0",
+    "@hyperlane-xyz/utils": "33.1.0"
   },
   "devDependencies": {
     "@ethersproject/constants": "*",
@@ -66,8 +66,8 @@
     "testcontainers": "11.12.0",
     "tsx": "^4.19.1",
     "typescript": "6.0.2",
-    "@hyperlane-xyz/relayer": "1.1.27",
-    "@hyperlane-xyz/tsconfig": "^33.0.2"
+    "@hyperlane-xyz/relayer": "1.1.28",
+    "@hyperlane-xyz/tsconfig": "^33.1.0"
   },
   "engines": {
     "node": ">=18"

package/src/bridges/LiFiBridge.test.ts

@@ -15,6 +15,7 @@ const testLogger = pino({ level: 'silent' });
 
 const TEST_PRIVATE_KEY =
   '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+const OTHER_PRIVATE_KEY = `${TEST_PRIVATE_KEY.slice(0, -1)}1`;
 
 const BRIDGE_CONFIG: ExternalBridgeConfig = {
   integrator: 'test-rebalancer',
@@ -34,6 +35,58 @@ const SOLANA_CHAIN_METADATA_CONFIG: ExternalBridgeConfig = {
   },
 };
 
+const DUPLICATE_CHAIN_ID_CONFIG: ExternalBridgeConfig = {
+  integrator: 'test-rebalancer',
+  chainMetadata: {
+    ethereum: {
+      chainId: 1,
+      protocol: ProtocolType.Ethereum,
+      name: 'ethereum',
+      displayName: 'Ethereum',
+      domainId: 1,
+      rpcUrls: [{ http: 'https://ethereum-rpc.local' }],
+    },
+    radix: {
+      chainId: 1,
+      protocol: ProtocolType.Radix,
+      name: 'radix',
+      displayName: 'Radix',
+      domainId: 1001,
+      rpcUrls: [{ http: 'https://radix-rpc.local' }],
+    },
+    solanamainnet: {
+      chainId: 1399811149,
+      protocol: ProtocolType.Sealevel,
+      name: 'solanamainnet',
+      displayName: 'Solana',
+      domainId: 1399811149,
+      rpcUrls: [{ http: 'https://api.mainnet-beta.solana.com' }],
+    },
+  },
+};
+
+const NON_EVM_DOMAIN_COLLISION_CONFIG: ExternalBridgeConfig = {
+  integrator: 'test-rebalancer',
+  chainMetadata: {
+    ethereum: {
+      chainId: 1,
+      protocol: ProtocolType.Ethereum,
+      name: 'ethereum',
+      displayName: 'Ethereum',
+      domainId: 1,
+      rpcUrls: [{ http: 'https://ethereum-rpc.local' }],
+    },
+    cosmos: {
+      chainId: 999999999,
+      protocol: ProtocolType.Cosmos,
+      name: 'cosmos',
+      displayName: 'Cosmos',
+      domainId: 1,
+      rpcUrls: [{ http: 'https://rpc.cosmos.invalid' }],
+    },
+  },
+};
+
 // Use all-digit hex addresses to avoid EIP-55 checksum case mutations
 const TOKEN_ADDR = '0x1234567890123456789012345678901234567890';
 const SENDER_ADDR = '0x9876543210987654321098765432109876543210';
@@ -655,4 +708,178 @@ describe('LiFiBridge constructor chainMetadataByChainId', function () {
       expect(msg).to.include('does not match requested');
     }
   });
+
+  it('should prefer Ethereum metadata for LiFi chainId lookups when non-EVM chainIds collide', () => {
+    const bridge = new LiFiBridge(DUPLICATE_CHAIN_ID_CONFIG, testLogger);
+    const quote = createTestQuote(
+      { fromChainId: 1 },
+      {
+        fromChain: 1,
+        toChain: 1151111081099710,
+      },
+    );
+
+    return bridge
+      .execute(quote, {
+        [ProtocolType.Ethereum]: '0x1234',
+      })
+      .catch((error: unknown) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        expect(
+          isValidationError(msg),
+          `Expected non-validation error but got: ${msg}`,
+        ).to.equal(false);
+        expect(msg).to.not.include('Missing private key');
+        expect(msg).to.not.include('protocol radix');
+        expect(msg.toLowerCase()).to.include('private key');
+      });
+  });
+
+  it('should index Tron by chainId even when domainId differs', () => {
+    const TRON_CHAIN_ID = 728126428;
+    const bridge = new LiFiBridge(
+      {
+        integrator: 'test-rebalancer',
+        chainMetadata: {
+          tron: {
+            chainId: TRON_CHAIN_ID,
+            protocol: ProtocolType.Tron,
+            name: 'tron',
+            displayName: 'Tron',
+            domainId: 999000999,
+            rpcUrls: [{ http: 'https://api.trongrid.io/jsonrpc' }],
+          },
+        },
+      },
+      testLogger,
+    );
+    const getProtocolTypeForChainId = (
+      bridge as any
+    ).getProtocolTypeForChainId.bind(bridge);
+
+    expect(getProtocolTypeForChainId(TRON_CHAIN_ID)).to.equal(
+      ProtocolType.Tron,
+    );
+    expect(getProtocolTypeForChainId(999000999)).to.equal(undefined);
+  });
+
+  it('should not let non-EVM domainIds overwrite EVM chainId lookups', () => {
+    const bridge = new LiFiBridge(NON_EVM_DOMAIN_COLLISION_CONFIG, testLogger);
+    const getProtocolTypeForChainId = (
+      bridge as any
+    ).getProtocolTypeForChainId.bind(bridge);
+
+    expect(getProtocolTypeForChainId(1)).to.equal(ProtocolType.Ethereum);
+    expect(getProtocolTypeForChainId(999999999)).to.equal(ProtocolType.Cosmos);
+  });
+});
+
+describe('LiFiBridge source protocol handling', function () {
+  it('ignores unrelated Tron keys when executing an Ethereum LiFi route', async () => {
+    const bridge = new LiFiBridge(BRIDGE_CONFIG, testLogger);
+    (bridge as any).configureLiFiProvider = (
+      protocol: ProtocolType,
+      key: string,
+      fromChain: number,
+    ) => {
+      expect(protocol).to.equal(ProtocolType.Ethereum);
+      expect(key).to.equal(TEST_PRIVATE_KEY);
+      expect(fromChain).to.equal(42161);
+      throw new Error('expected downstream error');
+    };
+
+    const quote = createTestQuote();
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Ethereum]: TEST_PRIVATE_KEY,
+        [ProtocolType.Tron]: OTHER_PRIVATE_KEY,
+      });
+      expect.fail('Expected execute to throw');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.equal('expected downstream error');
+    }
+  });
+
+  it('addressesEqual keeps Sealevel base58 comparison case-sensitive', () => {
+    const bridge = new LiFiBridge(SOLANA_CHAIN_METADATA_CONFIG, testLogger);
+    const addressesEqualFn = (bridge as any).addressesEqual.bind(bridge);
+
+    expect(
+      addressesEqualFn(
+        'SoLANAAddReSs1234567890123456789012345678',
+        'solanaaddress1234567890123456789012345678',
+        1399811149,
+      ),
+    ).to.be.false;
+  });
+
+  it('throws when the route source protocol is Tron', async () => {
+    const TRON_CHAIN_ID = 728126428;
+    const bridge = new LiFiBridge(
+      {
+        integrator: 'test-rebalancer',
+        chainMetadata: {
+          tron: {
+            chainId: TRON_CHAIN_ID,
+            protocol: ProtocolType.Tron,
+            name: 'tron',
+            displayName: 'Tron',
+            domainId: TRON_CHAIN_ID,
+            rpcUrls: [{ http: 'https://api.trongrid.io/jsonrpc' }],
+          },
+        },
+      },
+      testLogger,
+    );
+    const quote = createTestQuote(
+      { fromChainId: TRON_CHAIN_ID },
+      { fromChain: TRON_CHAIN_ID },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Tron]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Should have thrown for unsupported source protocol Tron');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include("Unsupported protocol type 'tron'");
+    }
+  });
+
+  it('throws when the route source protocol is an unsupported non-Tron chain', async () => {
+    const COSMOS_CHAIN_ID = 999999999;
+    const bridge = new LiFiBridge(
+      {
+        integrator: 'test-rebalancer',
+        chainMetadata: {
+          cosmos: {
+            chainId: COSMOS_CHAIN_ID,
+            protocol: ProtocolType.Cosmos,
+            name: 'cosmos',
+            displayName: 'Cosmos',
+            domainId: COSMOS_CHAIN_ID,
+            rpcUrls: [{ http: 'https://rpc.cosmos.invalid' }],
+          },
+        },
+      },
+      testLogger,
+    );
+    const quote = createTestQuote(
+      { fromChainId: COSMOS_CHAIN_ID },
+      { fromChain: COSMOS_CHAIN_ID },
+    );
+
+    try {
+      await bridge.execute(quote, {
+        [ProtocolType.Cosmos]: TEST_PRIVATE_KEY,
+      });
+      expect.fail('Should have thrown for unsupported source protocol Cosmos');
+    } catch (error: unknown) {
+      const msg = (error as Error).message;
+      expect(msg).to.include("Unsupported protocol type 'cosmos'");
+    }
+  });
 });

package/src/bridges/LiFiBridge.ts

@@ -14,7 +14,12 @@ import {
 } from '@lifi/sdk';
 import bs58 from 'bs58';
 import type { ChainMetadata } from '@hyperlane-xyz/sdk';
-import { ProtocolType, assert, ensure0x } from '@hyperlane-xyz/utils';
+import {
+  ProtocolType,
+  assert,
+  ensure0x,
+  isEVMLike,
+} from '@hyperlane-xyz/utils';
 import type { Logger } from 'pino';
 import { type Chain, createWalletClient, http } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
@@ -133,21 +138,25 @@ export class LiFiBridge implements IExternalBridge {
   constructor(config: ExternalBridgeConfig, logger: Logger) {
     this.config = config;
     this.logger = logger;
-    // Build chainId -> metadata map for O(1) lookups
+    // Build LiFi chainId -> metadata map for O(1) lookups.
+    // Numeric chainIds are only unique for EVM chains; non-EVM chains can
+    // legitimately collide (e.g. radix and ethereum both use 1), so index
+    // non-EVM chains only through explicit Hyperlane-domain -> LiFi mappings.
     this.chainMetadataByChainId = new Map();
     if (config.chainMetadata) {
+      const metadataByDomainId = new Map<number, ChainMetadata>();
       for (const metadata of Object.values(config.chainMetadata)) {
-        if (metadata.chainId !== undefined) {
+        metadataByDomainId.set(metadata.domainId, metadata);
+        if (metadata.chainId !== undefined && isEVMLike(metadata.protocol)) {
           this.chainMetadataByChainId.set(Number(metadata.chainId), metadata);
         }
       }
-      // Also key by LiFi chain IDs so both Hyperlane domains and LiFi IDs resolve to the same metadata.
+      // Also key by LiFi chain IDs so both Hyperlane domains and LiFi IDs
+      // resolve to the same metadata for non-EVM chains like Solana.
       for (const [hyperlaneDomainId, lifiChainId] of Object.entries(
         HYPERLANE_TO_LIFI_CHAIN_IDS,
       )) {
-        const metadata = this.chainMetadataByChainId.get(
-          Number(hyperlaneDomainId),
-        );
+        const metadata = metadataByDomainId.get(Number(hyperlaneDomainId));
         if (metadata !== undefined) {
           this.chainMetadataByChainId.set(Number(lifiChainId), metadata);
         }
@@ -179,11 +188,24 @@ export class LiFiBridge implements IExternalBridge {
    * Iterates metadata to find matching chainId and returns first HTTP RPC URL.
    */
   private getRpcUrlForChainId(chainId: number): string | undefined {
-    return this.chainMetadataByChainId.get(chainId)?.rpcUrls?.[0]?.http;
+    return this.getMetadataForChainId(chainId)?.rpcUrls?.[0]?.http;
   }
 
   private getProtocolTypeForChainId(chainId: number): ProtocolType | undefined {
-    return this.chainMetadataByChainId.get(chainId)?.protocol;
+    return this.getMetadataForChainId(chainId)?.protocol;
+  }
+
+  private getMetadataForChainId(chainId: number): ChainMetadata | undefined {
+    const directMetadata = this.chainMetadataByChainId.get(chainId);
+    if (directMetadata) {
+      return directMetadata;
+    }
+
+    const matches = Object.values(this.config.chainMetadata ?? {}).filter(
+      (metadata) =>
+        metadata.chainId !== undefined && Number(metadata.chainId) === chainId,
+    );
+    return matches.length === 1 ? matches[0] : undefined;
   }
 
   private addressesEqual(a: string, b: string, chainId: number): boolean {
@@ -196,58 +218,53 @@ export class LiFiBridge implements IExternalBridge {
   }
 
   /**
-   * Configure LiFi SDK providers from the given private keys.
-   * Sets up wallet/signer for each protocol type present in the keys map.
+   * Configure the LiFi SDK provider for the route source protocol.
    */
-  private configureLiFiProviders(
-    privateKeys: Partial<Record<ProtocolType, string>>,
+  private configureLiFiProvider(
+    protocol: ProtocolType,
+    key: string,
     fromChain: number,
     fromRpcUrl: string | undefined,
   ): void {
     const providers: Parameters<typeof lifiConfig.setProviders>[0] = [];
-    for (const [protocol, key] of Object.entries(privateKeys)) {
-      switch (protocol) {
-        case ProtocolType.Ethereum: {
-          const account = privateKeyToAccount(ensure0x(key) as `0x${string}`);
-          const chain = getViemChain(fromChain, fromRpcUrl);
-          const walletClient = createWalletClient({
-            account,
-            chain,
-            transport: http(fromRpcUrl),
-          });
-          providers.push(
-            EVM({
-              getWalletClient: async () => walletClient,
-              switchChain: async (requiredChainId: number) => {
-                const switchRpcUrl = this.getRpcUrlForChainId(requiredChainId);
-                const requiredChain = getViemChain(
-                  requiredChainId,
-                  switchRpcUrl,
-                );
-                return createWalletClient({
-                  account,
-                  chain: requiredChain,
-                  transport: http(switchRpcUrl),
-                });
-              },
-            }),
-          );
-          break;
-        }
-        case ProtocolType.Sealevel: {
-          const base58Key = toBase58SolanaKey(key);
-          providers.push(
-            Solana({
-              getWalletAdapter: async () => new KeypairWalletAdapter(base58Key),
-            }),
-          );
-          break;
-        }
-        default:
-          throw new Error(
-            `Unsupported protocol type '${protocol}' for LiFi provider`,
-          );
+    switch (protocol) {
+      case ProtocolType.Ethereum: {
+        const account = privateKeyToAccount(ensure0x(key) as `0x${string}`);
+        const chain = getViemChain(fromChain, fromRpcUrl);
+        const walletClient = createWalletClient({
+          account,
+          chain,
+          transport: http(fromRpcUrl),
+        });
+        providers.push(
+          EVM({
+            getWalletClient: async () => walletClient,
+            switchChain: async (requiredChainId: number) => {
+              const switchRpcUrl = this.getRpcUrlForChainId(requiredChainId);
+              const requiredChain = getViemChain(requiredChainId, switchRpcUrl);
+              return createWalletClient({
+                account,
+                chain: requiredChain,
+                transport: http(switchRpcUrl),
+              });
+            },
+          }),
+        );
+        break;
+      }
+      case ProtocolType.Sealevel: {
+        const base58Key = toBase58SolanaKey(key);
+        providers.push(
+          Solana({
+            getWalletAdapter: async () => new KeypairWalletAdapter(base58Key),
+          }),
+        );
+        break;
       }
+      default:
+        throw new Error(
+          `Unsupported protocol type '${protocol}' for LiFi provider`,
+        );
     }
 
     lifiConfig.setProviders(providers);
@@ -255,9 +272,9 @@ export class LiFiBridge implements IExternalBridge {
     this.logger.debug(
       {
         fromChain,
-        protocols: Object.keys(privateKeys),
+        protocol,
       },
-      'Configured LiFi providers for route execution',
+      'Configured LiFi provider for route execution',
     );
   }
 
@@ -491,9 +508,10 @@ export class LiFiBridge implements IExternalBridge {
     const fromChain = route.fromChainId;
     const toChain = route.toChainId;
     const fromProtocol = this.getProtocolTypeForChainId(fromChain);
+    const sourceProtocol = fromProtocol ?? ProtocolType.Ethereum;
     assert(
-      privateKeys[fromProtocol ?? ProtocolType.Ethereum],
-      `Missing private key for source chain protocol ${fromProtocol ?? ProtocolType.Ethereum}`,
+      privateKeys[sourceProtocol],
+      `Missing private key for source chain protocol ${sourceProtocol}`,
     );
 
     this.logger.info(
@@ -521,14 +539,11 @@ export class LiFiBridge implements IExternalBridge {
     let executedRoute!: RouteExtended;
 
     try {
-      this.configureLiFiProviders(privateKeys, fromChain, fromRpcUrl);
-
-      this.logger.debug(
-        {
-          fromChain,
-          protocols: Object.keys(privateKeys),
-        },
-        'Configured LiFi providers for route execution',
+      this.configureLiFiProvider(
+        sourceProtocol,
+        privateKeys[sourceProtocol]!,
+        fromChain,
+        fromRpcUrl,
       );
 
       // Execute route with update callbacks