feat: zksync deployment logic [ZK-002]

.changeset/eleven-cows-dance.md

@@ -0,0 +1,5 @@
+---
+'@hyperlane-xyz/sdk': minor
+---
+
+Added ZKSync specific deployment logic and artifact related utils

typescript/sdk/src/deploy/proxy.ts

@@ -1,4 +1,5 @@
 import { ethers } from 'ethers';
+import { Provider as ZKSyncProvider } from 'zksync-ethers';
 
 import { ProxyAdmin__factory } from '@hyperlane-xyz/core';
 import { Address, ChainId, eqAddress } from '@hyperlane-xyz/utils';
@@ -7,6 +8,8 @@ import { transferOwnershipTransactions } from '../contracts/contracts.js';
 import { AnnotatedEV5Transaction } from '../providers/ProviderType.js';
 import { DeployedOwnableConfig } from '../types.js';
 
+type Provider = ethers.providers.Provider | ZKSyncProvider;
+
 export type UpgradeConfig = {
   timelock: {
     delay: number;
@@ -19,7 +22,7 @@ export type UpgradeConfig = {
 };
 
 export async function proxyImplementation(
-  provider: ethers.providers.Provider,
+  provider: Provider,
   proxy: Address,
 ): Promise<Address> {
   // Hardcoded storage slot for implementation per EIP-1967
@@ -31,7 +34,7 @@ export async function proxyImplementation(
 }
 
 export async function isInitialized(
-  provider: ethers.providers.Provider,
+  provider: Provider,
   contract: Address,
 ): Promise<boolean> {
   // Using OZ's Initializable 4.9 which keeps it at the 0x0 slot
@@ -43,7 +46,7 @@ export async function isInitialized(
 }
 
 export async function proxyAdmin(
-  provider: ethers.providers.Provider,
+  provider: Provider,
   proxy: Address,
 ): Promise<Address> {
   // Hardcoded storage slot for admin per EIP-1967
@@ -66,7 +69,7 @@ export function proxyConstructorArgs<C extends ethers.Contract>(
 }
 
 export async function isProxy(
-  provider: ethers.providers.Provider,
+  provider: Provider,
   proxy: Address,
 ): Promise<boolean> {
   const admin = await proxyAdmin(provider, proxy);

typescript/sdk/src/deploy/proxyFactoryUtils.ts

@@ -0,0 +1,16 @@
+import { ethers } from 'ethers';
+
+import { proxyFactoryFactories } from './contracts.js';
+import { ProxyFactoryFactoriesAddresses } from './types.js';
+
+/**
+ * Creates a default ProxyFactoryFactoriesAddresses object with all values set to ethers.constants.AddressZero.
+ * @returns {ProxyFactoryFactoriesAddresses} An object with all factory addresses set to AddressZero.
+ */
+export function createDefaultProxyFactoryFactories(): ProxyFactoryFactoriesAddresses {
+  const defaultAddress = ethers.constants.AddressZero;
+  return Object.keys(proxyFactoryFactories).reduce((acc, key) => {
+    acc[key as keyof ProxyFactoryFactoriesAddresses] = defaultAddress; // Type assertion added here
+    return acc;
+  }, {} as ProxyFactoryFactoriesAddresses);
+}

typescript/sdk/src/hook/types.ts

@@ -38,6 +38,21 @@ export enum HookType {
   ARB_L2_TO_L1 = 'arbL2ToL1Hook',
 }
 
+export const HookTypeToContractNameMap: Record<
+  Exclude<HookType, HookType.CUSTOM>,
+  string
+> = {
+  [HookType.MERKLE_TREE]: 'merkleTreeHook',
+  [HookType.INTERCHAIN_GAS_PAYMASTER]: 'interchainGasPaymaster',
+  [HookType.AGGREGATION]: 'staticAggregationHook',
+  [HookType.PROTOCOL_FEE]: 'protocolFee',
+  [HookType.OP_STACK]: 'opStackHook',
+  [HookType.ROUTING]: 'domainRoutingHook',
+  [HookType.FALLBACK_ROUTING]: 'fallbackDomainRoutingHook',
+  [HookType.PAUSABLE]: 'pausableHook',
+  [HookType.ARB_L2_TO_L1]: 'arbL2ToL1Hook',
+};
+
 export type MerkleTreeHookConfig = z.infer<typeof MerkleTreeSchema>;
 export type IgpHookConfig = z.infer<typeof IgpSchema>;
 export type ProtocolFeeHookConfig = z.infer<typeof ProtocolFeeSchema>;

typescript/sdk/src/index.ts

@@ -201,7 +201,12 @@ export {
   WeightedMultisigIsmConfig,
   WeightedMultisigIsmConfigSchema,
 } from './ism/types.js';
-export { collectValidators, moduleCanCertainlyVerify } from './ism/utils.js';
+export {
+  collectValidators,
+  moduleCanCertainlyVerify,
+  isStaticDeploymentSupported,
+  isIsmCompatible,
+} from './ism/utils.js';
 export {
   AgentChainMetadata,
   AgentChainMetadataSchema,

typescript/sdk/src/ism/types.ts

@@ -67,6 +67,16 @@ export const MUTABLE_ISM_TYPE = [
   IsmType.PAUSABLE,
 ];
 
+// ISM types that require static deployment
+export const STATIC_ISM_TYPE = [
+  IsmType.AGGREGATION,
+  IsmType.MERKLE_ROOT_MULTISIG,
+  IsmType.MESSAGE_ID_MULTISIG,
+  IsmType.WEIGHTED_MERKLE_ROOT_MULTISIG,
+  IsmType.WEIGHTED_MESSAGE_ID_MULTISIG,
+  IsmType.ICA_ROUTING,
+];
+
 // mapping between the two enums
 export function ismTypeToModuleType(ismType: IsmType): ModuleType {
   switch (ismType) {

typescript/sdk/src/ism/utils.ts

@@ -24,6 +24,7 @@ import {
 
 import { HyperlaneContracts } from '../contracts/types.js';
 import { ProxyFactoryFactories } from '../deploy/contracts.js';
+import { ChainTechnicalStack } from '../metadata/chainMetadataTypes.js';
 import { MultiProvider } from '../providers/MultiProvider.js';
 import { ChainName } from '../types.js';
 
@@ -34,6 +35,7 @@ import {
   ModuleType,
   RoutingIsmConfig,
   RoutingIsmDelta,
+  STATIC_ISM_TYPE,
   ismTypeToModuleType,
 } from './types.js';
 
@@ -534,3 +536,37 @@ export function collectValidators(
 
   return new Set(validators);
 }
+
+/**
+ * Determines if static ISM deployment is supported on a given chain's technical stack
+ * @dev Currently, only ZkSync does not support static deployments
+ * @param chainTechnicalStack - The technical stack of the target chain
+ * @returns boolean - true if static deployment is supported, false for ZkSync
+ */
+export function isStaticDeploymentSupported(
+  chainTechnicalStack: ChainTechnicalStack | undefined,
+): boolean {
+  if (chainTechnicalStack === undefined) return true;
+  return chainTechnicalStack !== ChainTechnicalStack.ZkSync;
+}
+
+/**
+ * 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)
+ * @returns {boolean} True if the ISM type is compatible with the chain, false otherwise
+ */
+export function isIsmCompatible({
+  chainTechnicalStack,
+  ismType,
+}: {
+  chainTechnicalStack: ChainTechnicalStack | undefined;
+  ismType: IsmType;
+}): boolean {
+  // Skip compatibility check for non-static ISMs as they're always supported
+  if (!STATIC_ISM_TYPE.includes(ismType)) return true;
+
+  return isStaticDeploymentSupported(chainTechnicalStack);
+}

typescript/sdk/src/metadata/chainMetadataTypes.ts

@@ -22,6 +22,7 @@ export enum ExplorerFamily {
   Etherscan = 'etherscan',
   Blockscout = 'blockscout',
   Routescan = 'routescan',
+  ZkSync = 'zksync',
   Other = 'other',
 }
 

typescript/sdk/src/utils/zksync.ts

@@ -0,0 +1,32 @@
+import { ZKSyncArtifact, loadAllZKSyncArtifacts } from '@hyperlane-xyz/core';
+
+/**
+ * @dev Retrieves a ZkSync artifact by its contract name or qualified name.
+ * @param name The name of the contract or qualified name in the format "sourceName:contractName".
+ * @return The corresponding ZKSyncArtifact if found, or undefined if not found.
+ */
+export const getZKSyncArtifactByContractName = async (
+  name: string,
+): Promise<ZKSyncArtifact | undefined> => {
+  // Load all ZkSync artifacts
+  const allArtifacts = loadAllZKSyncArtifacts();
+
+  // Find the artifact that matches the contract name or qualified name
+  const artifact = Object.values(allArtifacts).find(
+    ({ contractName, sourceName }: ZKSyncArtifact) => {
+      const lowerCaseContractName = contractName.toLowerCase();
+      const lowerCaseName = name.toLowerCase();
+
+      // Check if the contract name matches
+      if (lowerCaseContractName === lowerCaseName) {
+        return true;
+      }
+
+      // Check if the qualified name matches
+      const qualifiedName = `${sourceName}:${contractName}`;
+      return qualifiedName === name; // Return true if qualified name matches
+    },
+  );
+
+  return artifact;
+};