fix arbitrum lazy loading in rebalancer tests

Author: Mo-Hussain

typescript/rebalancer/src/e2e/harness/MockExternalBridge.ts

@@ -6,7 +6,6 @@ import {
   HypERC20Collateral__factory,
   HypNative__factory,
 } from '@hyperlane-xyz/core';
-import { HyperlaneRelayer } from '@hyperlane-xyz/relayer';
 import { HyperlaneCore, type MultiProvider } from '@hyperlane-xyz/sdk';
 import { assert, ProtocolType } from '@hyperlane-xyz/utils';
 
@@ -31,6 +30,19 @@ type MockBridgeRoute = {
   tokenType: 'native' | 'erc20';
 };
 
+async function loadHyperlaneRelayer(): Promise<
+  (typeof import('@hyperlane-xyz/relayer'))['HyperlaneRelayer']
+> {
+  const relayerModuleUrl = new URL(
+    '../../../../relayer/dist/core/HyperlaneRelayer.js',
+    import.meta.url,
+  );
+  const relayerModule = (await import(relayerModuleUrl.href)) as {
+    HyperlaneRelayer: (typeof import('@hyperlane-xyz/relayer'))['HyperlaneRelayer'];
+  };
+  return relayerModule.HyperlaneRelayer;
+}
+
 export class MockExternalBridge implements IExternalBridge {
   readonly externalBridgeId = 'mock-bridge';
   readonly logger: Logger;
@@ -213,6 +225,7 @@ export class MockExternalBridge implements IExternalBridge {
       );
       const dispatchedMsgId = dispatchedMessages[0].id;
 
+      const HyperlaneRelayer = await loadHyperlaneRelayer();
       const relayer = new HyperlaneRelayer({ core: this.core });
       const receipts = await relayer.relayAll(dispatchTxReceipt);
 

typescript/rebalancer/src/e2e/harness/TransferHelper.ts

@@ -5,7 +5,6 @@ import {
   HypERC20Collateral__factory,
   MovableCollateralRouter__factory,
 } from '@hyperlane-xyz/core';
-import { HyperlaneRelayer } from '@hyperlane-xyz/relayer';
 import {
   HyperlaneCore,
   type MultiProvider,
@@ -14,6 +13,19 @@ import {
 } from '@hyperlane-xyz/sdk';
 import { addressToBytes32, retryAsync } from '@hyperlane-xyz/utils';
 
+async function loadHyperlaneRelayer(): Promise<
+  (typeof import('@hyperlane-xyz/relayer'))['HyperlaneRelayer']
+> {
+  const relayerModuleUrl = new URL(
+    '../../../../relayer/dist/core/HyperlaneRelayer.js',
+    import.meta.url,
+  );
+  const relayerModule = (await import(relayerModuleUrl.href)) as {
+    HyperlaneRelayer: (typeof import('@hyperlane-xyz/relayer'))['HyperlaneRelayer'];
+  };
+  return relayerModule.HyperlaneRelayer;
+}
+
 export interface WarpTransferParams {
   originChain: string;
   destinationChain: string;
@@ -115,6 +127,7 @@ export async function relayMessage(
 ): Promise<ContractReceipt> {
   return retryAsync(
     async () => {
+      const HyperlaneRelayer = await loadHyperlaneRelayer();
       const relayer = new HyperlaneRelayer({ core });
       const receipts = await relayer.relayAll(transferResult.dispatchTx);
       // relayAll keys receipts by domain ID, so look up by domain ID or chain name

typescript/rebalancer/src/factories/RebalancerContextFactory.test.ts

@@ -340,11 +340,19 @@ describe('RebalancerContextFactory', () => {
             : ProtocolType.Ethereum,
       }));
 
-      await expect(
-        (factory as any).createInventoryRebalancerAndConfig({} as any, {}),
-      ).to.be.rejectedWith(
-        `Missing inventory signer key for protocol ${ProtocolType.Sealevel}`,
-      );
+      let threw = false;
+      try {
+        await (factory as any).createInventoryRebalancerAndConfig(
+          {} as any,
+          {},
+        );
+      } catch (error) {
+        threw = true;
+        expect((error as Error).message).to.include(
+          `Missing inventory signer key for protocol ${ProtocolType.Sealevel}`,
+        );
+      }
+      expect(threw).to.equal(true);
     });
 
     it('should accept Tron as a supported inventory protocol', async () => {
@@ -492,11 +500,19 @@ describe('RebalancerContextFactory', () => {
             : ProtocolType.Ethereum,
       }));
 
-      await expect(
-        (factory as any).createInventoryRebalancerAndConfig({} as any, {}),
-      ).to.be.rejectedWith(
-        `Inventory rebalancing does not support protocol '${ProtocolType.Cosmos}'`,
-      );
+      let threw = false;
+      try {
+        await (factory as any).createInventoryRebalancerAndConfig(
+          {} as any,
+          {},
+        );
+      } catch (error) {
+        threw = true;
+        expect((error as Error).message).to.include(
+          `Inventory rebalancing does not support protocol '${ProtocolType.Cosmos}'`,
+        );
+      }
+      expect(threw).to.equal(true);
     });
   });
 });

typescript/relayer/src/metadata/builder.ts

@@ -1,4 +1,5 @@
 import {
+  ArbL2ToL1IsmConfig,
   ArbL2ToL1HookConfig,
   HookType,
   HyperlaneCore,
@@ -14,7 +15,6 @@ import {
 } from '@hyperlane-xyz/utils';
 
 import { AggregationMetadataBuilder } from './aggregation.js';
-import { ArbL2ToL1MetadataBuilder } from './arbL2ToL1.js';
 import { OffchainLookupMetadataBuilder } from './ccipread.js';
 import { decodeIsmMetadata } from './decode.js';
 import { MultisigMetadataBuilder } from './multisig.js';
@@ -27,23 +27,33 @@ import type {
   StructuredMetadata,
 } from './types.js';
 
+type ArbL2ToL1MetadataBuilderLike = {
+  build(
+    context: MetadataContext<
+      WithAddress<ArbL2ToL1IsmConfig>,
+      WithAddress<ArbL2ToL1HookConfig>
+    >,
+  ): Promise<MetadataBuildResult>;
+};
+
 export class BaseMetadataBuilder implements MetadataBuilder {
   public nullMetadataBuilder: NullMetadataBuilder;
   public multisigMetadataBuilder: MultisigMetadataBuilder;
   public aggregationMetadataBuilder: AggregationMetadataBuilder;
   public routingMetadataBuilder: DynamicRoutingMetadataBuilder;
-  public arbL2ToL1MetadataBuilder: ArbL2ToL1MetadataBuilder;
+  public arbL2ToL1MetadataBuilder?: ArbL2ToL1MetadataBuilderLike;
   public ccipReadMetadataBuilder: OffchainLookupMetadataBuilder;
 
   public multiProvider: MultiProvider;
   protected logger = rootLogger.child({ module: 'BaseMetadataBuilder' });
+  protected core: HyperlaneCore;
 
   constructor(core: HyperlaneCore) {
+    this.core = core;
     this.multisigMetadataBuilder = new MultisigMetadataBuilder(core);
     this.aggregationMetadataBuilder = new AggregationMetadataBuilder(this);
     this.routingMetadataBuilder = new DynamicRoutingMetadataBuilder(this);
     this.nullMetadataBuilder = new NullMetadataBuilder(core.multiProvider);
-    this.arbL2ToL1MetadataBuilder = new ArbL2ToL1MetadataBuilder(core);
     this.ccipReadMetadataBuilder = new OffchainLookupMetadataBuilder(core);
     this.multiProvider = core.multiProvider;
   }
@@ -108,7 +118,9 @@ export class BaseMetadataBuilder implements MetadataBuilder {
 
       case IsmType.ARB_L2_TO_L1: {
         const hookConfig = hook as WithAddress<ArbL2ToL1HookConfig>;
-        return this.arbL2ToL1MetadataBuilder.build({
+        const arbL2ToL1MetadataBuilder =
+          await this.getArbL2ToL1MetadataBuilder();
+        return arbL2ToL1MetadataBuilder.build({
           ...context,
           ism,
           hook: hookConfig,
@@ -132,4 +144,12 @@ export class BaseMetadataBuilder implements MetadataBuilder {
   ): StructuredMetadata {
     return decodeIsmMetadata(metadata, context);
   }
+
+  protected async getArbL2ToL1MetadataBuilder(): Promise<ArbL2ToL1MetadataBuilderLike> {
+    if (!this.arbL2ToL1MetadataBuilder) {
+      const { ArbL2ToL1MetadataBuilder } = await import('./arbL2ToL1.js');
+      this.arbL2ToL1MetadataBuilder = new ArbL2ToL1MetadataBuilder(this.core);
+    }
+    return this.arbL2ToL1MetadataBuilder;
+  }
 }

typescript/relayer/src/metadata/decode.ts

@@ -1,10 +1,12 @@
 import { IsmType } from '@hyperlane-xyz/sdk';
+import { IOutbox__factory } from '@hyperlane-xyz/core';
+import { utils } from 'ethers';
 
 import { AggregationMetadataBuilder } from './aggregation.js';
-import { ArbL2ToL1MetadataBuilder } from './arbL2ToL1.js';
 import { MultisigMetadataBuilder } from './multisig.js';
 import { NullMetadataBuilder } from './null.js';
 import { DynamicRoutingMetadataBuilder } from './routing.js';
+import type { ArbL2ToL1Metadata } from './arbL2ToL1.js';
 import { MetadataContext, StructuredMetadata } from './types.js';
 
 export function decodeIsmMetadata(
@@ -33,12 +35,26 @@ export function decodeIsmMetadata(
       });
 
     case IsmType.ARB_L2_TO_L1:
-      return ArbL2ToL1MetadataBuilder.decode(metadata, {
-        ...context,
-        ism,
-      });
+      return decodeArbL2ToL1Metadata(metadata);
 
     default:
       throw new Error(`Unsupported ISM type: ${ism.type}`);
   }
 }
+
+function decodeArbL2ToL1Metadata(metadata: string): ArbL2ToL1Metadata {
+  const abiCoder = new utils.AbiCoder();
+  const outboxInterface = IOutbox__factory.createInterface();
+  const executeTransactionInputs =
+    outboxInterface.functions[
+      'executeTransaction(bytes32[],uint256,address,address,uint256,uint256,uint256,uint256,bytes)'
+    ].inputs;
+  const executeTransactionTypes = executeTransactionInputs
+    .map((input) => input.type)
+    .filter((_, index, array) => index !== array.length - 2);
+  const decoded = abiCoder.decode(executeTransactionTypes, metadata);
+
+  return Object.fromEntries(
+    Object.keys({} as ArbL2ToL1Metadata).map((key, i) => [key, decoded[i]]),
+  ) as ArbL2ToL1Metadata;
+}

typescript/sdk/src/hook/EvmHookModule.ts

@@ -1,4 +1,3 @@
-import { getArbitrumNetwork } from '@arbitrum/sdk';
 import { BigNumber, ethers } from 'ethers';
 
 import {
@@ -896,7 +895,9 @@ export class EvmHookModule extends HyperlaneModule<
     }
 
     const bridge =
-      config.bridge ?? getArbitrumNetwork(destinationChainId).ethBridge.bridge;
+      config.bridge ??
+      (await import('@arbitrum/sdk')).getArbitrumNetwork(destinationChainId)
+        .ethBridge.bridge;
 
     const ismConfig: ArbL2ToL1IsmConfig = {
       type: IsmType.ARB_L2_TO_L1,