feat: zksync compatibility checks [ZK-004]

.changeset/honest-readers-lick.md

@@ -0,0 +1,5 @@
+---
+'@hyperlane-xyz/sdk': minor
+---
+
+Check for ZKSync contracts and functionalities support

typescript/sdk/src/core/EvmCoreModule.ts

@@ -35,12 +35,16 @@ import {
   proxyFactoryFactories,
 } from '../deploy/contracts.js';
 import { proxyAdminUpdateTxs } from '../deploy/proxy.js';
+import { createDefaultProxyFactoryFactories } from '../deploy/proxyFactoryUtils.js';
+import { ProxyFactoryFactoriesAddresses } from '../deploy/types.js';
 import { ContractVerifier } from '../deploy/verify/ContractVerifier.js';
 import { HookFactories } from '../hook/contracts.js';
 import { EvmIsmModule } from '../ism/EvmIsmModule.js';
 import { DerivedIsmConfig } from '../ism/EvmIsmReader.js';
 import { HyperlaneIsmFactory } from '../ism/HyperlaneIsmFactory.js';
 import { IsmConfig } from '../ism/types.js';
+import { isStaticDeploymentSupported } from '../ism/utils.js';
+import { ChainTechnicalStack } from '../metadata/chainMetadataTypes.js';
 import { MultiProvider } from '../providers/MultiProvider.js';
 import { AnnotatedEV5Transaction } from '../providers/ProviderType.js';
 import { ChainName, ChainNameOrId } from '../types.js';
@@ -280,14 +284,16 @@ export class EvmCoreModule extends HyperlaneModule<
     contractVerifier?: ContractVerifier;
   }): Promise<DeployedCoreAddresses> {
     const { config, multiProvider, chain, contractVerifier } = params;
-    const chainName = multiProvider.getChainName(chain);
+    const { name: chainName, technicalStack } =
+      multiProvider.getChainMetadata(chain);
 
-    const ismFactoryFactories = await EvmCoreModule.deployIsmFactories({
-      chainName,
-      config,
-      multiProvider,
-      contractVerifier,
-    });
+    const ismFactoryFactories: ProxyFactoryFactoriesAddresses =
+      await this.getIsmFactoryFactories(technicalStack, {
+        chainName,
+        config,
+        multiProvider,
+        contractVerifier,
+      });
 
     const ismFactory = new HyperlaneIsmFactory(
       attachContractsMap(
@@ -382,7 +388,6 @@ export class EvmCoreModule extends HyperlaneModule<
     // Set Core & extra addresses
     return {
       ...ismFactoryFactories,
-
       proxyAdmin: proxyAdmin.address,
       mailbox: mailbox.address,
       interchainAccountRouter,
@@ -487,4 +492,31 @@ export class EvmCoreModule extends HyperlaneModule<
     );
     return mailbox;
   }
+
+  /**
+   * Retrieves the ISM factory factories based on the provided protocol and parameters.
+   *
+   * @param protocol - The protocol type to determine if static address set deployment should be skipped.
+   * @param params - An object containing the parameters needed for ISM factory deployment.
+   * @param params.chainName - The name of the chain for which the ISM factories are being deployed.
+   * @param params.config - The core configuration to be used during deployment.
+   * @param params.multiProvider - The multi-provider instance for interacting with the blockchain.
+   * @param params.contractVerifier - An optional contract verifier for validating contracts during deployment.
+   * @returns A promise that resolves to the addresses of the deployed ISM factory factories.
+   */
+  private static async getIsmFactoryFactories(
+    technicalStack: ChainTechnicalStack | undefined,
+    params: {
+      chainName: string;
+      config: CoreConfig;
+      multiProvider: MultiProvider;
+      contractVerifier?: ContractVerifier;
+    },
+  ): Promise<ProxyFactoryFactoriesAddresses> {
+    // Check if we should skip static address set deployment
+    if (!isStaticDeploymentSupported(technicalStack)) {
+      return createDefaultProxyFactoryFactories();
+    }
+    return EvmCoreModule.deployIsmFactories(params);
+  }
 }

typescript/sdk/src/core/HyperlaneCore.ts

@@ -33,6 +33,7 @@ import {
 } from '../contracts/types.js';
 import { DerivedHookConfig, EvmHookReader } from '../hook/EvmHookReader.js';
 import { DerivedIsmConfig, EvmIsmReader } from '../ism/EvmIsmReader.js';
+import { ChainTechnicalStack } from '../metadata/chainMetadataTypes.js';
 import { MultiProvider } from '../providers/MultiProvider.js';
 import { RouterConfig } from '../router/types.js';
 import { ChainMap, ChainName, OwnableConfig } from '../types.js';
@@ -252,6 +253,13 @@ export class HyperlaneCore extends HyperlaneApp<CoreFactories> {
   }
 
   async estimateHandle(message: DispatchedMessage): Promise<string> {
+    // This estimation is not possible on zksync as it is overriding transaction.from
+    // transaction.from must be a signer on zksync
+    if (
+      this.multiProvider.getChainMetadata(this.getDestination(message))
+        .technicalStack === ChainTechnicalStack.ZkSync
+    )
+      return '0';
     return (
       await this.getRecipient(message).estimateGas.handle(
         message.parsed.origin,

typescript/sdk/src/ism/HyperlaneIsmFactory.ts

@@ -68,7 +68,7 @@ import {
   RoutingIsmDelta,
   WeightedMultisigIsmConfig,
 } from './types.js';
-import { routingModuleDelta } from './utils.js';
+import { isIsmCompatible, routingModuleDelta } from './utils.js';
 
 const ismFactories = {
   [IsmType.PAUSABLE]: new PausableIsm__factory(),
@@ -149,6 +149,14 @@ export class HyperlaneIsmFactory extends HyperlaneApp<ProxyFactoryFactories> {
       }`,
     );
 
+    const { technicalStack } = this.multiProvider.getChainMetadata(destination);
+
+    // For static ISM types it checks whether the technical stack supports static contract deployment
+    assert(
+      isIsmCompatible({ chainTechnicalStack: technicalStack, ismType }),
+      `Technical stack ${technicalStack} is not compatible with ${ismType}`,
+    );
+
     let contract: DeployedIsmType[typeof ismType];
     switch (ismType) {
       case IsmType.MESSAGE_ID_MULTISIG: