Merkle Tree Hook Deployer changes

typescript/infra/config/environments/test/interceptor.ts

@@ -1,21 +1,25 @@
-import {
-  ChainMap,
-  InterceptorConfig,
-  InterceptorType,
-} from '@hyperlane-xyz/sdk';
+import { ChainMap, InterceptorConfig } from '@hyperlane-xyz/sdk';
+import { HookType } from '@hyperlane-xyz/sdk/src/hook/types';
 import { objMap } from '@hyperlane-xyz/utils';
 
-import { chainToValidator, merkleRootMultisig } from './multisigIsm';
+import {
+  chainToValidator,
+  merkleRootMultisig,
+  messageIdMultisig,
+} from './multisigIsm';
 import { owners } from './owners';
 
 export const merkleRoot: ChainMap<InterceptorConfig> = objMap(
   owners,
   (chain, _) => {
     const config: InterceptorConfig = {
       hook: {
-        type: InterceptorType.HOOK,
+        type: HookType.MERKLE_ROOT_HOOK,
       },
-      ism: merkleRootMultisig(chainToValidator[chain]),
+      ism:
+        Math.random() < 0.5
+          ? merkleRootMultisig(chainToValidator[chain])
+          : messageIdMultisig(chainToValidator[chain]),
     };
     return config;
   },

typescript/infra/config/environments/test/multisigIsm.ts

@@ -27,7 +27,7 @@ export const messageIdMultisig = (validatorKey: string): MultisigIsmConfig => {
 // the addresses here must line up with the e2e test's validator addresses
 export const multisigIsm: ChainMap<MultisigIsmConfig> = {
   // Validators are anvil accounts 4-6
-  test1: messageIdMultisig('test1'),
-  test2: merkleRootMultisig('test2'),
-  test3: messageIdMultisig('test3'),
+  test1: messageIdMultisig(chainToValidator['test1']),
+  test2: merkleRootMultisig(chainToValidator['test2']),
+  test3: messageIdMultisig(chainToValidator['test3']),
 };

typescript/sdk/src/hook/MerkleRootInterceptorDeployer.ts

@@ -1,18 +1,22 @@
 import debug from 'debug';
 
+import {
+  StaticMerkleRootMultisigIsm,
+  StaticMessageIdMultisigIsm,
+} from '@hyperlane-xyz/core';
 import { Address } from '@hyperlane-xyz/utils';
 
 import { HyperlaneContracts } from '../contracts/types';
 import { HyperlaneDeployer } from '../deploy/HyperlaneDeployer';
 import { HyperlaneIsmFactory } from '../ism/HyperlaneIsmFactory';
-import { MultisigIsmConfig } from '../ism/types';
+import { ModuleType, MultisigIsmConfig } from '../ism/types';
 import { MultiProvider } from '../providers/MultiProvider';
 import { ChainMap, ChainName } from '../types';
 
 import {
   MerkleRootHookFactories,
   MerkleRootInterceptorFactories,
-  MerkleRootIsmFactories,
+  MultisigIsmFactories,
   merkleRootHookFactories,
   merkleRootIsmFactories,
 } from './contracts';
@@ -64,14 +68,22 @@ export class MerkleRootInterceptorDeployer extends HyperlaneDeployer<
   async deployIsmContracts(
     chain: ChainName,
     config: MultisigIsmConfig,
-  ): Promise<HyperlaneContracts<MerkleRootIsmFactories>> {
-    this.logger(`Deploying MerkleRootMultisigIsm to ${chain}`);
-    const ism = await this.ismFactory.deployMerkleRootMultisigIsm(
-      chain,
-      config,
-    );
-    return {
-      ism: ism,
-    };
+  ): Promise<HyperlaneContracts<MultisigIsmFactories>> {
+    const ism = await this.ismFactory.deploy(chain, config);
+    if (config.type === ModuleType.MERKLE_ROOT_MULTISIG) {
+      this.logger(`Deploying StaticMerkleRootMultisigIsm to ${chain}`);
+      return {
+        ism: ism as StaticMerkleRootMultisigIsm,
+      };
+    } else if (config.type === ModuleType.MESSAGE_ID_MULTISIG) {
+      this.logger(`Deploying StaticMessageIdMultisigIsm to ${chain}`);
+      return {
+        ism: ism as StaticMessageIdMultisigIsm,
+      };
+    } else {
+      throw new Error(
+        `Unexpected ISM type ${config.type} for MerkleRootInterceptorDeployer`,
+      );
+    }
   }
 }

typescript/sdk/src/hook/contracts.ts

@@ -1,23 +1,30 @@
 import {
   MerkleTreeHook__factory,
   StaticMerkleRootMultisigIsm__factory,
+  StaticMessageIdMultisigIsm__factory,
 } from '@hyperlane-xyz/core';
 
 export const merkleRootHookFactories = {
   hook: new MerkleTreeHook__factory(),
 };
 
+export const messageIdMultisigIsmFactory = {
+  ism: new StaticMessageIdMultisigIsm__factory(),
+};
+
 export type MerkleRootHookFactories = typeof merkleRootHookFactories;
-export type MerkleRootIsmFactories = typeof merkleRootIsmFactories;
+export type MultisigIsmFactories =
+  | typeof merkleRootIsmFactories
+  | typeof messageIdMultisigIsmFactory;
 
 export const merkleRootIsmFactories = {
   ism: new StaticMerkleRootMultisigIsm__factory(),
 };
 
 export type MerkleRootInterceptorFactories = MerkleRootHookFactories &
-  MerkleRootIsmFactories;
+  MultisigIsmFactories;
 
 export type HookFactories = MerkleRootHookFactories;
-export type IsmFactories = MerkleRootIsmFactories;
+export type IsmFactories = MultisigIsmFactories;
 
 export type InterceptorFactories = HookFactories & IsmFactories;

typescript/sdk/src/hook/types.ts

@@ -1,43 +1,18 @@
-import { BigNumber } from 'ethers';
-
-import type { Address } from '@hyperlane-xyz/utils';
-
 import type { MultisigIsmConfig } from '../ism/types';
-import { ChainName } from '../types';
 
-export enum InterceptorType {
-  HOOK = 'hook',
-  ISM = 'ism',
+export enum HookType {
+  MERKLE_ROOT_HOOK = 'merkleRootHook',
 }
 
-export type OpStackHookConfig = {
-  type: InterceptorType.HOOK;
-  nativeBridge: Address;
-  remoteIsm?: Address;
-  destinationDomain: BigNumber;
-  destination: ChainName;
-};
-
 export type MerkleRootHookConfig = {
-  type: InterceptorType.HOOK;
+  type: HookType.MERKLE_ROOT_HOOK;
 };
 
 export type MerkleRootInterceptorConfig = {
   hook: MerkleRootHookConfig;
   ism: MultisigIsmConfig;
 };
 
-export type OpStackInterceptorConfig = {
-  hook: OpStackHookConfig;
-  ism: OPStackIsmConfig;
-};
-
-export type HookConfig = OpStackHookConfig | MerkleRootHookConfig;
-
-export type OPStackIsmConfig = {
-  type: InterceptorType.ISM;
-  origin: ChainName;
-  nativeBridge: Address;
-};
+export type HookConfig = MerkleRootHookConfig;
 
 export type InterceptorConfig = MerkleRootInterceptorConfig;

typescript/sdk/src/index.ts

@@ -111,11 +111,9 @@ export {
 export { MerkleRootInterceptorDeployer } from './hook/MerkleRootInterceptorDeployer';
 export {
   HookConfig,
+  HookType,
   InterceptorConfig,
-  InterceptorType,
   MerkleRootHookConfig,
-  OPStackIsmConfig,
-  OpStackHookConfig,
 } from './hook/types';
 export {
   HyperlaneIsmFactory,

typescript/sdk/src/ism/HyperlaneIsmFactory.ts

@@ -9,8 +9,6 @@ import {
   IRoutingIsm__factory,
   StaticAggregationIsm__factory,
   StaticMOfNAddressSetFactory,
-  StaticMerkleRootMultisigIsm,
-  StaticMerkleRootMultisigIsm__factory,
 } from '@hyperlane-xyz/core';
 import { Address, eqAddress, formatMessage, warn } from '@hyperlane-xyz/utils';
 
@@ -124,24 +122,6 @@ export class HyperlaneIsmFactory extends HyperlaneApp<IsmFactoryFactories> {
     return IMultisigIsm__factory.connect(address, signer);
   }
 
-  public async deployMerkleRootMultisigIsm(
-    chain: ChainName,
-    config: MultisigIsmConfig,
-  ): Promise<StaticMerkleRootMultisigIsm> {
-    this.logger(`Deploying Merkle Root Multisig ISM to ${chain}`);
-    const signer = this.multiProvider.getSigner(chain);
-    const multisigIsmFactory =
-      this.getContracts(chain).merkleRootMultisigIsmFactory;
-    const address = await this.deployMOfNFactory(
-      chain,
-      multisigIsmFactory,
-      config.validators,
-      config.threshold,
-    );
-
-    return StaticMerkleRootMultisigIsm__factory.connect(address, signer);
-  }
-
   private async deployRoutingIsm(chain: ChainName, config: RoutingIsmConfig) {
     const signer = this.multiProvider.getSigner(chain);
     const routingIsmFactory = this.getContracts(chain).routingIsmFactory;

typescript/sdk/src/ism/types.ts

@@ -3,24 +3,26 @@ import {
   IInterchainSecurityModule,
   IMultisigIsm,
   IRoutingIsm,
+  StaticMerkleRootMultisigIsm,
+  StaticMessageIdMultisigIsm,
 } from '@hyperlane-xyz/core';
 import type { Address } from '@hyperlane-xyz/utils';
 
-import { OPStackIsmConfig } from '../hook/types';
 import { ChainMap } from '../types';
 
 export type DeployedIsm =
   | IInterchainSecurityModule
   | IMultisigIsm
   | IAggregationIsm
-  | IRoutingIsm;
+  | IRoutingIsm
+  | StaticMessageIdMultisigIsm
+  | StaticMerkleRootMultisigIsm;
 
 export enum ModuleType {
   UNUSED,
   ROUTING,
   AGGREGATION,
-  // DEPRECATED
-  LEGACY_MULTISIG,
+  LEGACY_MULTISIG, // DEPRECATED
   MERKLE_ROOT_MULTISIG,
   MESSAGE_ID_MULTISIG,
 }
@@ -50,5 +52,4 @@ export type IsmConfig =
   | Address
   | RoutingIsmConfig
   | MultisigIsmConfig
-  | AggregationIsmConfig
-  | OPStackIsmConfig;
+  | AggregationIsmConfig;