feat: zksync support

package.json

@@ -12,7 +12,8 @@
     "husky": "^8.0.0",
     "lint-staged": "^12.4.3",
     "prettier": "^2.8.8",
-    "tsx": "^4.7.1"
+    "tsx": "^4.7.1",
+    "zksync-ethers": "^5"
   },
   "dependencies": {
     "@changesets/cli": "^2.26.2"

solidity/.gitignore

@@ -1,6 +1,6 @@
 node_modules/
 cache/
-artifacts/
+.artifacts/
 types/
 dist/
 coverage/
@@ -15,3 +15,13 @@ docs
 flattened/
 buildArtifact.json
 fixtures/
+
+
+# zksync artifacts
+artifacts-zk
+cache-zk
+
+core-utils/zksync/artifacts/output
+
+.zksolc-libraries-cache/
+typechain-types/

solidity/contracts/Mailbox.sol

@@ -10,7 +10,7 @@ import {IInterchainSecurityModule, ISpecifiesInterchainSecurityModule} from "./i
 import {IPostDispatchHook} from "./interfaces/hooks/IPostDispatchHook.sol";
 import {IMessageRecipient} from "./interfaces/IMessageRecipient.sol";
 import {IMailbox} from "./interfaces/IMailbox.sol";
-import {PackageVersioned} from "contracts/PackageVersioned.sol";
+import {PackageVersioned} from "./PackageVersioned.sol";
 
 // ============ External Imports ============
 import {Address} from "@openzeppelin/contracts/utils/Address.sol";

solidity/contracts/interfaces/IThresholdAddressFactory.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+interface IThresholdAddressFactory {
+    function deploy(
+        address[] calldata _values,
+        uint8 _threshold
+    ) external returns (address);
+}

solidity/contracts/isms/multisig/AbstractMultisigIsm.sol

@@ -68,7 +68,7 @@ abstract contract AbstractMultisig is PackageVersioned {
  * @notice Manages per-domain m-of-n Validator sets of AbstractMultisig that are used to verify
  * interchain messages.
  */
-abstract contract AbstractMultisigIsm is AbstractMultisig {
+abstract contract AbstractMultisigIsm is AbstractMultisig, IMultisigIsm {
     // ============ Virtual Functions ============
     // ======= OVERRIDE THESE TO IMPLEMENT =======
 

solidity/contracts/isms/multisig/StorageMultisigIsm.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+// ============ Internal Imports ============
+import {AbstractMultisigIsm} from "./AbstractMultisigIsm.sol";
+import {AbstractMerkleRootMultisigIsm} from "./AbstractMerkleRootMultisigIsm.sol";
+import {AbstractMessageIdMultisigIsm} from "./AbstractMessageIdMultisigIsm.sol";
+import {IInterchainSecurityModule} from "../../interfaces/IInterchainSecurityModule.sol";
+import {IThresholdAddressFactory} from "../../interfaces/IThresholdAddressFactory.sol";
+import {MinimalProxy} from "../../libs/MinimalProxy.sol";
+import {PackageVersioned} from "../../PackageVersioned.sol";
+
+// ============ External Imports ============
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+abstract contract AbstractStorageMultisigIsm is
+    AbstractMultisigIsm,
+    OwnableUpgradeable
+{
+    address[] public validators;
+    uint8 public threshold;
+
+    event ValidatorsAndThresholdSet(address[] validators, uint8 threshold);
+
+    constructor(
+        address[] memory _validators,
+        uint8 _threshold
+    ) OwnableUpgradeable() {
+        validators = _validators;
+        threshold = _threshold;
+        _disableInitializers();
+    }
+
+    function initialize(
+        address[] memory _validators,
+        uint8 _threshold
+    ) external initializer {
+        __Ownable_init();
+        setValidatorsAndThreshold(_validators, _threshold);
+    }
+
+    function setValidatorsAndThreshold(
+        address[] memory _validators,
+        uint8 _threshold
+    ) public onlyOwner {
+        require(_threshold <= _validators.length, "Invalid threshold");
+        validators = _validators;
+        threshold = _threshold;
+        emit ValidatorsAndThresholdSet(_validators, _threshold);
+    }
+
+    function validatorsAndThreshold(
+        bytes calldata /* _message */
+    ) public view override returns (address[] memory, uint8) {
+        return (validators, threshold);
+    }
+}
+
+contract StorageMerkleRootMultisigIsm is
+    AbstractMerkleRootMultisigIsm,
+    AbstractStorageMultisigIsm
+{
+    uint8 public constant moduleType =
+        uint8(IInterchainSecurityModule.Types.MERKLE_ROOT_MULTISIG);
+
+    constructor(
+        address[] memory _validators,
+        uint8 _threshold
+    ) AbstractStorageMultisigIsm(_validators, _threshold) {}
+}
+
+contract StorageMessageIdMultisigIsm is
+    AbstractMessageIdMultisigIsm,
+    AbstractStorageMultisigIsm
+{
+    uint8 public constant moduleType =
+        uint8(IInterchainSecurityModule.Types.MESSAGE_ID_MULTISIG);
+
+    constructor(
+        address[] memory _validators,
+        uint8 _threshold
+    ) AbstractStorageMultisigIsm(_validators, _threshold) {}
+}
+
+abstract contract StorageMultisigIsmFactory is
+    IThresholdAddressFactory,
+    PackageVersioned
+{
+    /**
+     * @notice Emitted when a multisig module is deployed
+     * @param module The deployed ISM
+     */
+    event ModuleDeployed(address module);
+
+    // ============ External Functions ============
+    function deploy(
+        address[] calldata _validators,
+        uint8 _threshold
+    ) external returns (address ism) {
+        ism = MinimalProxy.create(implementation());
+        emit ModuleDeployed(ism);
+        AbstractStorageMultisigIsm(ism).initialize(_validators, _threshold);
+    }
+
+    function implementation() public view virtual returns (address);
+}
+
+contract StorageMerkleRootMultisigIsmFactory is StorageMultisigIsmFactory {
+    address internal immutable _implementation;
+
+    constructor() {
+        _implementation = address(
+            new StorageMerkleRootMultisigIsm(new address[](0), 0)
+        );
+    }
+
+    function implementation() public view override returns (address) {
+        return _implementation;
+    }
+}
+
+contract StorageMessageIdMultisigIsmFactory is StorageMultisigIsmFactory {
+    address internal immutable _implementation;
+
+    constructor() {
+        _implementation = address(
+            new StorageMessageIdMultisigIsm(new address[](0), 0)
+        );
+    }
+
+    function implementation() public view override returns (address) {
+        return _implementation;
+    }
+}

solidity/core-utils/zksync/artifacts/index.ts

@@ -0,0 +1,102 @@
+import { readdirSync } from 'fs';
+import path, { join } from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * @dev Represents a ZkSync artifact.
+ */
+export type ZkSyncArtifact = {
+  contractName: string;
+  sourceName: string;
+  abi: any;
+  bytecode: string;
+  deployedBytecode: string;
+  factoryDeps?: Record<string, string>;
+};
+
+/**
+ * @dev A mapping of artifact names to their corresponding ZkSync artifacts.
+ */
+export type ArtifactMap = {
+  [key: string]: ZkSyncArtifact; // Key is the artifact name, value is the ZkSyncArtifact
+};
+
+// Get the resolved path to the current file
+const currentFilePath = fileURLToPath(import.meta.url); // Convert the module URL to a file path
+const currentDirectory = path.dirname(currentFilePath);
+
+/**
+ * @dev Reads artifact files from the specified directory.
+ * @param directory The directory to read artifact files from.
+ * @return An array of artifact file names that end with '.js'.
+ */
+function getArtifactFiles(directory: string): string[] {
+  return readdirSync(directory).filter((file) => file.endsWith('.js')); // Filter for .js files
+}
+
+/**
+ * @dev Exports the list of artifact names without the .js extension.
+ * @return An array of artifact names without the .js extension.
+ */
+export const zksyncArtifactNames = getArtifactFiles(
+  join(currentDirectory, 'output'),
+).map((file) => file.replace('.js', ''));
+
+/**
+ * @dev Checks if a ZkSync artifact exists by its name.
+ * @param name The name of the artifact to check.
+ * @return True if the artifact exists, false otherwise.
+ */
+export function artifactExists(name: string): boolean {
+  return zksyncArtifactNames.includes(`${name}.js`); // Check if the artifact file exists
+}
+
+/**
+ * @dev Loads a ZkSync artifact by its name.
+ * @param name The name of the artifact to load.
+ * @return The loaded ZkSyncArtifact or undefined if it cannot be loaded.
+ */
+export async function loadZkArtifact(
+  name: string,
+): Promise<ZkSyncArtifact | undefined> {
+  try {
+    const artifactModule = await import(
+      join(currentDirectory, 'output', `${name}.js`)
+    ); // Dynamically import the artifact module
+    return artifactModule[name]; // Return the artifact from the artifactModule
+  } catch (error) {
+    console.error(`Error loading artifact: ${name}`, error);
+    return undefined;
+  }
+}
+
+/**
+ * @dev Loads all ZkSync artifacts into a map.
+ * @return A map of artifact names to their corresponding ZkSync artifacts.
+ */
+export async function loadAllZkArtifacts(): Promise<ArtifactMap> {
+  const zkSyncArtifactMap: ArtifactMap = {};
+
+  // Load all artifacts concurrently
+  const loadPromises = zksyncArtifactNames.map(async (artifactFileName) => {
+    const artifact = await loadZkArtifact(artifactFileName);
+    if (artifact) {
+      zkSyncArtifactMap[artifactFileName] = artifact;
+    }
+  });
+
+  await Promise.all(loadPromises);
+
+  return zkSyncArtifactMap; // Return the populated artifact map
+}
+
+/**
+ * @dev Retrieves a specific ZkSync artifact by its file name.
+ * @param name The name of the artifact to retrieve.
+ * @return The loaded ZkSyncArtifact or undefined if it cannot be loaded.
+ */
+export async function getZkArtifactByName(
+  name: string,
+): Promise<ZkSyncArtifact | undefined> {
+  return loadZkArtifact(name);
+}

solidity/exportBuildArtifact.sh

@@ -6,12 +6,12 @@ cd "$(dirname "$0")"
 # Define the artifacts directory
 artifactsDir="./artifacts/build-info"
 # Define the output file
-outputFileJson="./dist/buildArtifact.json"
-outputFileJs="./dist/buildArtifact.js"
-outputFileTsd="./dist/buildArtifact.d.ts"
+outputFileJson="./dist/evm/buildArtifact.json"
+outputFileJs="./dist/evm/buildArtifact.js"
+outputFileTsd="./dist/evm/buildArtifact.d.ts"
 
 # log that we're in the script
-echo 'Finding and processing hardhat build artifact...'
+echo 'Finding and processing hardhat build EVM artifact...'
 
 # Find most recently modified JSON build artifact
 if [ "$(uname)" = "Darwin" ]; then
@@ -37,3 +37,40 @@ else
   echo 'Failed to process build artifact with jq'
   exit 1
 fi
+
+# ZKSYNC
+
+# Define the artifacts directory
+artifactsDir="./artifacts-zk/build-info"
+# Define the output file
+outputFileJson="./dist/zksync/buildArtifact.json"
+outputFileJs="./dist/zksync/buildArtifact.js"
+outputFileTsd="./dist/zksync/buildArtifact.d.ts"
+
+# log that we're in the script
+echo 'Finding and processing hardhat build ZKSync artifact...'
+
+# Find most recently modified JSON build artifact
+if [ "$(uname)" = "Darwin" ]; then
+    # for local flow
+    jsonFiles=$(find "$artifactsDir" -type f -name "*.json" -exec stat -f "%m %N" {} \; | sort -rn | head -n 1 | cut -d' ' -f2-)
+else
+    # for CI flow
+    jsonFiles=$(find "$artifactsDir" -type f -name "*.json" -exec stat -c "%Y %n" {} \; | sort -rn | head -n 1 | cut -d' ' -f2-)
+fi
+
+if [ ! -f "$jsonFiles" ]; then
+  echo 'Failed to find build artifact'
+  exit 1
+fi
+
+# Extract required keys and write to outputFile
+if jq -c '{input, solcLongVersion, zk_version: .output.zk_version}' "$jsonFiles" > "$outputFileJson"; then
+  echo "export const buildArtifact = " > "$outputFileJs"
+  cat "$outputFileJson" >> "$outputFileJs"
+  echo "export const buildArtifact: any" > "$outputFileTsd"
+  echo 'Finished processing build artifact.'
+else
+  echo 'Failed to process build artifact with jq'
+  exit 1
+fi