feat: implement HyperlaneCCIPDeployer (#5429)

Author: paulbalaji

.changeset/late-clouds-flash.md

@@ -0,0 +1,5 @@
+---
+'@hyperlane-xyz/sdk': minor
+---
+
+Implement HyperlaneCCIPDeployer and CCIPContractCache, for deploying and initializing CCIP ISMs/Hooks for supported pairs of CCIP chains.

.changeset/sweet-coins-appear.md

@@ -0,0 +1,5 @@
+---
+'@hyperlane-xyz/utils': minor
+---
+
+Add ZERO_ADDRESS_HEX_32 constant.

typescript/infra/config/environments/mainnet3/ccip.ts

@@ -0,0 +1,15 @@
+import { ChainMap, ChainName, getCCIPChains } from '@hyperlane-xyz/sdk';
+
+export function getCCIPDeployConfig(
+  targetNetworks: ChainName[],
+): ChainMap<Set<ChainName>> {
+  const chains = getCCIPChains().filter((chain) =>
+    targetNetworks.includes(chain),
+  );
+  return Object.fromEntries(
+    chains.map((origin) => [
+      origin,
+      new Set(chains.filter((chain) => chain !== origin)),
+    ]),
+  );
+}

typescript/infra/scripts/agent-utils.ts

@@ -72,6 +72,7 @@ export enum Modules {
   HELLO_WORLD = 'helloworld',
   WARP = 'warp',
   HAAS = 'haas',
+  CCIP = 'ccip',
 }
 
 export const REGISTRY_MODULES = [
@@ -82,6 +83,7 @@ export const REGISTRY_MODULES = [
   Modules.INTERCHAIN_QUERY_SYSTEM,
   Modules.TEST_RECIPIENT,
   Modules.HOOK,
+  Modules.CCIP,
 ];
 
 export function getArgs() {

typescript/infra/scripts/deploy.ts

@@ -9,6 +9,7 @@ import {
   ContractVerifier,
   ExplorerLicenseType,
   HypERC20Deployer,
+  HyperlaneCCIPDeployer,
   HyperlaneCoreDeployer,
   HyperlaneDeployer,
   HyperlaneHookDeployer,
@@ -24,6 +25,7 @@ import {
 import { objFilter, objMap } from '@hyperlane-xyz/utils';
 
 import { Contexts } from '../config/contexts.js';
+import { getCCIPDeployConfig } from '../config/environments/mainnet3/ccip.js';
 import { core as coreConfig } from '../config/environments/mainnet3/core.js';
 import { getEnvAddresses } from '../config/registry.js';
 import { getWarpConfig } from '../config/warp.js';
@@ -79,6 +81,13 @@ async function main() {
     chains,
   );
 
+  const targetNetworks =
+    chains && chains.length > 0 ? chains : !fork ? [] : [fork];
+
+  const filteredTargetNetworks = targetNetworks.filter(
+    (chain) => !chainsToSkip.includes(chain),
+  );
+
   if (fork) {
     multiProvider = multiProvider.extendChainMetadata({
       [fork]: { blocks: { confirmations: 0 } },
@@ -241,6 +250,16 @@ async function main() {
     config = {
       ethereum: coreConfig.ethereum.defaultHook,
     };
+  } else if (module === Modules.CCIP) {
+    if (environment !== 'mainnet3') {
+      throw new Error('CCIP is only supported on mainnet3');
+    }
+    config = getCCIPDeployConfig(filteredTargetNetworks);
+    deployer = new HyperlaneCCIPDeployer(
+      multiProvider,
+      getEnvAddresses(environment),
+      contractVerifier,
+    );
   } else {
     console.log(`Skipping ${module}, deployer unimplemented`);
     return;
@@ -284,12 +303,6 @@ async function main() {
     }
   }
 
-  const targetNetworks =
-    chains && chains.length > 0 ? chains : !fork ? [] : [fork];
-
-  const filteredTargetNetworks = targetNetworks.filter(
-    (chain) => !chainsToSkip.includes(chain),
-  );
   chainsToSkip.forEach((chain) => delete config[chain]);
 
   await deployWithArtifacts({

typescript/sdk/src/ccip/HyperlaneCCIPDeployer.ts

@@ -0,0 +1,237 @@
+import { CCIPHook__factory, CCIPIsm__factory } from '@hyperlane-xyz/core';
+import {
+  ZERO_ADDRESS_HEX_32,
+  addressToBytes32,
+  assert,
+  rootLogger,
+} from '@hyperlane-xyz/utils';
+
+import {
+  HyperlaneAddressesMap,
+  HyperlaneContracts,
+} from '../contracts/types.js';
+import { CoreAddresses } from '../core/contracts.js';
+import { HyperlaneDeployer } from '../deploy/HyperlaneDeployer.js';
+import { ContractVerifier } from '../deploy/verify/ContractVerifier.js';
+import { MultiProvider } from '../providers/MultiProvider.js';
+import { ChainMap, ChainName } from '../types.js';
+
+import {
+  CCIPContractCache,
+  getCCIPChainSelector,
+  getCCIPRouterAddress,
+} from './utils.js';
+
+export class HyperlaneCCIPDeployer extends HyperlaneDeployer<
+  Set<ChainName>,
+  {}
+> {
+  private ccipContractCache: CCIPContractCache = new CCIPContractCache();
+
+  constructor(
+    multiProvider: MultiProvider,
+    readonly core: ChainMap<Partial<CoreAddresses>>,
+    contractVerifier?: ContractVerifier,
+  ) {
+    super(
+      multiProvider,
+      {},
+      {
+        logger: rootLogger.child({ module: 'HyperlaneCCIPDeployer' }),
+        contractVerifier,
+      },
+    );
+  }
+
+  cacheAddressesMap(addressesMap: HyperlaneAddressesMap<any>): void {
+    super.cacheAddressesMap(addressesMap);
+    this.ccipContractCache.cacheAddressesMap(addressesMap);
+  }
+
+  async deployContracts(
+    origin: ChainName,
+    config: Set<ChainName>,
+  ): Promise<HyperlaneContracts<{}>> {
+    // Deploy ISMs from chain to each destination chain concurrently.
+    // This is done in parallel since the ISM is deployed on discrete destination chains.
+    await Promise.all(
+      Array.from(config).map(async (destination) => {
+        // Deploy CCIP ISM for this origin->destination pair
+        await this.deployCCIPIsm(origin, destination);
+      }),
+    );
+
+    // On the origin chain, deploy hooks for each destination chain in series.
+    // This is done in series to avoid nonce contention on the origin chain.
+    for (const destination of config) {
+      await this.deployCCIPHook(origin, destination);
+    }
+
+    // Authorize hooks for each destination chain concurrently.
+    // This is done in parallel since the ISM is deployed on discrete destination chains.
+    await Promise.all(
+      Array.from(config).map(async (destination) => {
+        await this.authorizeHook(origin, destination);
+      }),
+    );
+
+    this.ccipContractCache.writeBack(this.cachedAddresses);
+    return {};
+  }
+
+  private async authorizeHook(origin: ChainName, destination: ChainName) {
+    const ccipIsmAddress = this.ccipContractCache.getIsm(origin, destination);
+    assert(
+      ccipIsmAddress,
+      `CCIP ISM not found for ${origin} -> ${destination}`,
+    );
+
+    const ccipHookAddress = this.ccipContractCache.getHook(origin, destination);
+    assert(
+      ccipHookAddress,
+      `CCIP Hook not found for ${origin} -> ${destination}`,
+    );
+
+    const bytes32HookAddress = addressToBytes32(ccipHookAddress);
+    const ccipIsm = CCIPIsm__factory.connect(
+      ccipIsmAddress,
+      this.multiProvider.getSigner(destination),
+    );
+
+    const authorizedHook = await ccipIsm.authorizedHook();
+    this.logger.debug(
+      'Authorized hook on ism %s: %s',
+      ccipIsm.address,
+      authorizedHook,
+    );
+
+    // If the hook is already set, return
+    if (authorizedHook === bytes32HookAddress) {
+      this.logger.info(
+        'Authorized hook already set on ism %s',
+        ccipIsm.address,
+      );
+      return;
+    }
+
+    // If not already set, must not be initialised yet
+    if (authorizedHook !== ZERO_ADDRESS_HEX_32) {
+      this.logger.error(
+        'Authorized hook mismatch on ism %s, expected %s, got %s',
+        ccipIsm.address,
+        bytes32HookAddress,
+        authorizedHook,
+      );
+      throw new Error('Authorized hook mismatch');
+    }
+
+    // If not initialised, set the hook
+    this.logger.info(
+      'Setting authorized hook %s on ism %s on destination %s',
+      ccipHookAddress,
+      ccipIsm.address,
+      destination,
+    );
+    await this.multiProvider.handleTx(
+      destination,
+      ccipIsm.setAuthorizedHook(
+        bytes32HookAddress,
+        this.multiProvider.getTransactionOverrides(destination),
+      ),
+    );
+  }
+
+  protected async deployCCIPIsm(
+    origin: ChainName,
+    destination: ChainName,
+  ): Promise<void> {
+    const cachedIsm = this.ccipContractCache.getIsm(origin, destination);
+    if (cachedIsm) {
+      this.logger.debug(
+        'CCIP ISM already deployed for %s -> %s: %s',
+        origin,
+        destination,
+        cachedIsm,
+      );
+      return;
+    }
+
+    const ccipOriginChainSelector = getCCIPChainSelector(origin);
+    const ccipIsmChainRouterAddress = getCCIPRouterAddress(destination);
+    assert(
+      ccipOriginChainSelector,
+      `CCIP chain selector not found for ${origin}`,
+    );
+    assert(
+      ccipIsmChainRouterAddress,
+      `CCIP router address not found for ${origin}`,
+    );
+
+    const ccipIsm = await this.deployContractFromFactory(
+      destination,
+      new CCIPIsm__factory(),
+      'CCIPIsm',
+      [ccipIsmChainRouterAddress, ccipOriginChainSelector],
+      undefined,
+      false,
+    );
+
+    this.ccipContractCache.setIsm(origin, destination, ccipIsm);
+  }
+
+  protected async deployCCIPHook(
+    origin: ChainName,
+    destination: ChainName,
+  ): Promise<void> {
+    // Grab the ISM from the cache
+    const ccipIsmAddress = this.ccipContractCache.getIsm(origin, destination);
+    assert(
+      ccipIsmAddress,
+      `CCIP ISM not found for ${origin} -> ${destination}`,
+    );
+
+    const cachedHook = this.ccipContractCache.getHook(origin, destination);
+    if (cachedHook) {
+      this.logger.debug(
+        'CCIP Hook already deployed for %s -> %s: %s',
+        origin,
+        destination,
+        cachedHook,
+      );
+      return;
+    }
+
+    const mailbox = this.core[origin].mailbox;
+    assert(mailbox, `Mailbox address is required for ${origin}`);
+
+    const ccipDestinationChainSelector = getCCIPChainSelector(destination);
+    const ccipOriginChainRouterAddress = getCCIPRouterAddress(origin);
+    assert(
+      ccipDestinationChainSelector,
+      `CCIP chain selector not found for ${destination}`,
+    );
+    assert(
+      ccipOriginChainRouterAddress,
+      `CCIP router address not found for ${destination}`,
+    );
+
+    const destinationDomain = this.multiProvider.getDomainId(destination);
+
+    const ccipHook = await this.deployContractFromFactory(
+      origin,
+      new CCIPHook__factory(),
+      'CCIPHook',
+      [
+        ccipOriginChainRouterAddress,
+        ccipDestinationChainSelector,
+        mailbox,
+        destinationDomain,
+        addressToBytes32(ccipIsmAddress),
+      ],
+      undefined,
+      false,
+    );
+
+    this.ccipContractCache.setHook(origin, destination, ccipHook);
+  }
+}