feat: zksync compatibility checks (#6329)

### Description
This PR enhances ISM deployments and transaction estimation with:

Technical stack compatibility verification for ISM types
Static address support in ISM factory deployments
Gas estimation skip for zkSync deployments
txfusion#23

### Drive-by changes
Added isIsmCompatible utility function import
Added technical stack validation checks
Related issues
https://linear.app/hyperlane-xyz/issue/ENG-1153

Previously was here:
#5213

### Backward compatibility
Yes

### Testing
Build passing

---------

Co-authored-by: Le Yu <6251863+ltyu@users.noreply.github.com>
Co-authored-by: ljankovic-txfusion <lazar@txfusion.io>
Co-authored-by: ljankovic-txfusion <131957285+ljankovic-txfusion@users.noreply.github.com>
Co-authored-by: Morteza Shojaei <31728528+mortezashojaei@users.noreply.github.com>
Co-authored-by: Paul Balaji <10051819+paulbalaji@users.noreply.github.com>
Co-authored-by: graphite-app[bot] <96075541+graphite-app[bot]@users.noreply.github.com>

Author: 6 people

.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,11 +35,15 @@ 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 { HyperlaneIsmFactory } from '../ism/HyperlaneIsmFactory.js';
 import { DerivedIsmConfig, 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';
@@ -279,14 +283,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(
@@ -381,7 +387,6 @@ export class EvmCoreModule extends HyperlaneModule<
     // Set Core & extra addresses
     return {
       ...ismFactoryFactories,
-
       proxyAdmin: proxyAdmin.address,
       mailbox: mailbox.address,
       interchainAccountRouter,
@@ -486,4 +491,31 @@ export class EvmCoreModule extends HyperlaneModule<
     );
     return mailbox;
   }
+
+  /**
+   * Retrieves the ISM factory factories based on the provided technicalStack and parameters.
+   *
+   * @param technicalStack - The technicalStack 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

@@ -35,6 +35,7 @@ import { EvmHookReader } from '../hook/EvmHookReader.js';
 import { DerivedHookConfig } from '../hook/types.js';
 import { EvmIsmReader } from '../ism/EvmIsmReader.js';
 import { DerivedIsmConfig } from '../ism/types.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';
@@ -254,6 +255,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/hook/utils.ts

@@ -0,0 +1,22 @@
+import { ChainTechnicalStack } from '../metadata/chainMetadataTypes.js';
+
+import { HookType } from './types.js';
+
+/**
+ * Checks if the given hook type is compatible with the chain's technical stack.
+ *
+ * @param {HookType} params.hookType - The type of hook
+ * @param {ChainTechnicalStack | undefined} params.chainTechnicalStack - The technical stack of the chain
+ * @returns {boolean} True if the hook type is compatible with the chain, false otherwise
+ */
+export const isHookCompatible = ({
+  hookType,
+  chainTechnicalStack,
+}: {
+  hookType: HookType;
+  chainTechnicalStack?: ChainTechnicalStack;
+}): boolean =>
+  !(
+    hookType === HookType.AGGREGATION &&
+    chainTechnicalStack === ChainTechnicalStack.ZkSync
+  );

typescript/sdk/src/index.ts

@@ -223,10 +223,12 @@ export {
 } from './ism/types.js';
 export {
   collectValidators,
-  moduleCanCertainlyVerify,
-  isStaticDeploymentSupported,
   isIsmCompatible,
+  isStaticDeploymentSupported,
+  isStaticIsm,
+  moduleCanCertainlyVerify,
 } from './ism/utils.js';
+export { isHookCompatible } from './hook/utils.js';
 export {
   AgentChainMetadata,
   AgentChainMetadataSchema,

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({ ismType, chainTechnicalStack: technicalStack }),
+      `Technical stack ${technicalStack} is not compatible with ${ismType}`,
+    );
+
     let contract: DeployedIsmType[typeof ismType];
     switch (ismType) {
       case IsmType.MESSAGE_ID_MULTISIG:

typescript/sdk/src/ism/utils.ts

@@ -587,6 +587,16 @@ export function collectValidators(
   return new Set(validators);
 }
 
+/**
+ * Checks if the given ISM type requires static deployment
+ *
+ * @param {IsmType} ismType - The type of Interchain Security Module (ISM)
+ * @returns {boolean} True if the ISM type requires static deployment, false otherwise
+ */
+export function isStaticIsm(ismType: IsmType): boolean {
+  return STATIC_ISM_TYPES.includes(ismType);
+}
+
 /**
  * Determines if static ISM deployment is supported on a given chain's technical stack
  * @dev Currently, only ZkSync does not support static deployments
@@ -602,9 +612,8 @@ export function isStaticDeploymentSupported(
 /**
  * Checks if the given ISM type is compatible with the chain's technical stack.
  *
- * @param {Object} params - The parameters object
- * @param {ChainTechnicalStack | undefined} params.chainTechnicalStack - The technical stack of the chain
  * @param {IsmType} params.ismType - The type of Interchain Security Module (ISM)
+ * @param {ChainTechnicalStack | undefined} params.chainTechnicalStack - The technical stack of the chain
  * @returns {boolean} True if the ISM type is compatible with the chain, false otherwise
  */
 export function isIsmCompatible({
@@ -615,7 +624,6 @@ export function isIsmCompatible({
   ismType: IsmType;
 }): boolean {
   // Skip compatibility check for non-static ISMs as they're always supported
-  if (!STATIC_ISM_TYPES.includes(ismType)) return true;
-
+  if (!isStaticIsm(ismType)) return true;
   return isStaticDeploymentSupported(chainTechnicalStack);
 }