[Deployment] Cannot deploy and initialize a Contract in Mainnet: Hash code not known

[jpreciadom]

Team or Project

No response

Environment

Mainnet

L2 block number

No response

zkSolc Version

latest

zksync-ethers Version

@matterlabs/hardhat-zksync-ethers 1.2.1

Minimal Reproducible Code or Repo Link

Issue

We are trying to deploy 3 contracts to the zkSync Mainnet Network. The deployment of the three contracts worked but when I call the "factoryContract.initialize(controllerAddress, collateralAddress)contract method it throw an error with the messageexecution reverted: The code hash is not known`. The same code worked for zkSync Sepolia.

Hardhat config

import dotenv from "dotenv";
import { HardhatUserConfig } from "hardhat/config";
import "@typechain/hardhat";
import "@matterlabs/hardhat-zksync";
import "@matterlabs/hardhat-zksync-solc"
import "@matterlabs/hardhat-zksync-deploy"
import "@matterlabs/hardhat-zksync-verify"
import "@matterlabs/hardhat-zksync-ethers"

... additional imports

const config: HardhatUserConfig = {
  solidity: {
    version: '0.8.17',
    eraVersion: '1.0.0',
  },
  zksolc: {
    version: "latest",
    settings: {
      optimizer: {
        enabled: true, // optional. True by default
        mode: 'z', // optional. 3 by default, z to optimize bytecode size
        fallback_to_optimizing_for_size: false, // optional. Try to recompile with optimizer mode "z" if the bytecode is too large
      },
      suppressedErrors: ["sendtransfer"],
      libraries: {
              "lib/blockchainManager/contracts/Spigot/utils/LineLib.sol": {
                "LineLib": "0xC3a5309C5CE4358da3C3249929eb8b8d86433bCd"
              },
              "lib/blockchainManager/contracts/Spigot/utils/CreditListLib.sol": {
                "CreditListLib": "0x34e9380234C4a9d43d5667779a167BE69574da38"
              },
              "lib/blockchainManager/contracts/Spigot/utils/CreditLib.sol": {
                "CreditLib": "0x234B99F9c53dFbeB01Fbe2929F005249142Eb2B9"
              },
              "lib/blockchainManager/contracts/Spigot/utils/SpigotedLineLib.sol": {
                "SpigotedLineLib": "0x93de1598B188318Ab25B5578C050bE8f4e63cF37"
              },
              "lib/blockchainManager/contracts/Spigot/utils/EscrowLib.sol": {
                "EscrowLib": "0x8d086B1Db9E13A7C30C69D2a8A212a9710cc1c35"
              },
              "lib/blockchainManager/contracts/Spigot/utils/LineFactoryLib.sol": {
                "LineFactoryLib": "0xdBfC3Cd5aA50d05D9e78504ec96629cf57994f95"
              },
              "lib/blockchainManager/contracts/Spigot/utils/SpigotLib.sol": {
                "SpigotLib": "0x29ed4e2Ad26B121d5ba980b5e0fB0af8E92A9aAf"
              }
            },
    },
  },
  networks: {
    zkSyncMainnet: {
      url: `https://mainnet.era.zksync.io`,
      ethNetwork: "mainnet",
      zksync: true,
      verifyURL: "https://zksync2-mainnet-explorer.zksync.io/contract_verification",
      accounts: [DEPLOYER_PRIVATE_KEY as string]
    },
    zkSyncSepoliaTestnet: {
      url: "https://sepolia.era.zksync.dev",
      chainId: 0x12c,
      ethNetwork: "sepolia",
      zksync: true,
      verifyURL: "https://explorer.sepolia.era.zksync.dev/contract_verification",
      accounts: [DEPLOYER_PRIVATE_KEY as string]
    },
  },
};

export default config;

Deployment task in hardhat

task('contractsDeployment', 'Deploy all admin contracts')
  .addParam("treasuryAddress", "Treasury address that will receive funds")
  .setAction(async (taskArgs, hre) => {
    // Get params
    const { treasuryAddress } = taskArgs

    const adminAddress = KMS_BLOCKCHAIN_ADMIN_ADDRESS as string
    const [deployer] = await hre.zksyncEthers.getSigners()

    // Deploy the Controller Contract
    console.log('Deploying Controller...')
    const controllerFactory = await hre.zksyncEthers.getContractFactory('RainCollateralController')
    const controller = await controllerFactory.deploy(adminAddress, treasuryAddress)
    await controller.waitForDeployment()

    const controllerAddress = await controller.getAddress()
    await hre.run('verify:verify', {
      address: controllerAddress,
      constructorArguments: [adminAddress, treasuryAddress]
    })
    console.log(`Controller deployed at ${controllerAddress}\n`)

    // Deploy the Collateral Contract
    console.log('Deploying Collateral....')
    const collateralFactory = await hre.zksyncEthers.getContractFactory('RainCollateral')
    const collateral = await collateralFactory.deploy()
    await collateral.waitForDeployment()

    const collateralAddress = await collateral.getAddress()
    await hre.run('verify:verify', {
      address: collateralAddress,
      constructorArguments: []
    })
    console.log(`Collateral deployed at ${collateralAddress}\n`)

    // Deploy the Collateral Factory Contract
    const factoryFactory = await hre.zksyncEthers.getContractFactory('RainCollateralFactory')
    const factory = await factoryFactory.deploy()
    await factory.waitForDeployment()

    const factoryAddress = await factory.getAddress()
    await hre.run('verify:verify', {
      address: factoryAddress,
      constructorArguments: []
    })
    console.log(`Factory deployed at ${factoryAddress}\n`)

    // Initialize the Factory
    const factoryContract = await hre.zksyncEthers.getContractAt('RainCollateralFactory', factoryAddress)
    const initializationTx = await factoryContract.initialize(controllerAddress, collateralAddress, {})
    await initializationTx.wait()
    console.log(`Factory initialized at tx: ${initializationTx.hash}`)
  })

Does this work on other EVMs? (If yes, please list at least 1 of them)

Yes. Ethereum, Polygon, Optimism

Description of What Your Contract Does

Factory Contract Code

import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
import "./RainCollateralBeacon.sol";
import "./RainCollateral.sol";

contract RainCollateralFactory is OwnableUpgradeable {
  ...
}

Additional Details

No response

[gleenai[bot]]

The error message execution reverted: The code hash is not known typically indicates that the contract you are trying to interact with has not been properly deployed or recognized on the network. This can happen due to several reasons, such as incorrect contract deployment, issues with the contract's bytecode, or the network not properly syncing with the contract's state.

Given that your deployment works on the zkSync Sepolia but not on the zkSync Mainnet, here are a few steps you can consider:

1. Verify Contract Deployment: Ensure that all contracts are deployed correctly on the zkSync Mainnet. You can use the verifyURL provided in your hardhat configuration to check if the contracts are verified.

2. Check Contract Addresses: Double-check the addresses used during the initialization call. Make sure that the controllerAddress and collateralAddress are correct and point to the right deployed contracts on the zkSync Mainnet.

3. Network Sync Issues: Sometimes, there might be a delay in the network syncing up with the latest state. Ensure that the network has fully recognized the deployed contracts before calling the initialize function.

4. Bytecode and Compiler Settings: Since the same code works on another network, review any network-specific settings or optimizations in your compiler configuration that might affect the deployment on the Mainnet.

5. Library and External Contract Dependencies: Ensure that all linked libraries and external contracts are correctly deployed and verified on the Mainnet. Any mismatch in the library addresses or their deployment state can cause issues.

If these steps do not resolve the issue, you might want to consider redeploying the contracts or reaching out for more specific support through the zkSync developer community or support channels.

Your feedback helps us serve you better. If this fully addresses your question, please give it a thumbs up. If it doesn't, please give it a thumbs down. This will inform the community and team so we can improve our support.

[kaymomin]

Hey @jpreciadom, could you share the smart contracts with us so we can reproduce the error?

[jpreciadom]

Unfortunately I cannot share the smart contracts code because it is private

[gleenai[bot]]

Thank you for your question! I’m unable to provide an answer at this moment, but I have forwarded your inquiry to our team. Someone will be with you shortly to assist further. Your patience is appreciated!

[kaymomin]

@jpreciadom It looks like a similar issue was discussed and resolved in this thread.

tldr: You will need to provide the preimage (full bytecode) in the dependency for it to work properly.

Could you check it out and see if the solution works for you? If not, feel free to follow up here, and we’ll dig deeper.

[jpreciadom]

I was able to deploy and initialize the contracts using the project generated by zksync-cli npm package but not using the hardhat-zksync dependencies and using the generated utils by zksync-cli create liek this:

import {Deployer} from "@matterlabs/hardhat-zksync";
import dotenv from "dotenv";
import {ethers} from "ethers";
import * as hre from "hardhat";
import {Provider, Wallet} from "zksync-ethers";

import "@matterlabs/hardhat-zksync-node/dist/type-extensions";
import "@matterlabs/hardhat-zksync-verify/dist/src/type-extensions";

// Load env file
dotenv.config();

export const getProvider = () => {
  const rpcUrl = hre.network.config.url;
  if (!rpcUrl) throw `⛔️ RPC URL wasn't found in "${hre.network.name}"! Please add a "url" field to the network config in hardhat.config.ts`;

  // Initialize ZKsync Provider
  const provider = new Provider(rpcUrl);

  return provider;
}

export const getWallet = (privateKey?: string) => {
  if (!privateKey) {
    // Get wallet private key from .env file
    if (!process.env.WALLET_PRIVATE_KEY) throw "⛔️ Wallet private key wasn't found in .env file!";
  }

  const provider = getProvider();

  // Initialize ZKsync Wallet
  const wallet = new Wallet(privateKey ?? process.env.WALLET_PRIVATE_KEY!, provider);

  return wallet;
}

export const verifyEnoughBalance = async (wallet: Wallet, amount: bigint) => {
  // Check if the wallet has enough balance
  const balance = await wallet.getBalance();
  if (balance < amount) throw `⛔️ Wallet balance is too low! Required ${ethers.formatEther(amount)} ETH, but current ${wallet.address} balance is ${ethers.formatEther(balance)} ETH`;
}

/**
 * @param {string} data.contract The contract's path and name. E.g., "/Greeter.sol:Greeter"
 */
export const verifyContract = async (data: {
  address: string,
  contract: string,
  constructorArguments: string,
  bytecode: string
}) => {
  const verificationRequestId: number = await hre.run("verify:verify", {
    ...data,
    noCompile: true,
  });
  return verificationRequestId;
}

type DeployContractOptions = {
  /**
   * If true, the deployment process will not print any logs
   */
  silent?: boolean
  /**
   * If true, the contract will not be verified on Block Explorer
   */
  noVerify?: boolean
  /**
   * If specified, the contract will be deployed using this wallet
   */
  wallet?: Wallet
}
export const deployContract = async (contractArtifactName: string, constructorArguments?: any[], options?: DeployContractOptions) => {
  const log = (message: string) => {
    if (!options?.silent) console.log(message);
  };

  log(`\nStarting deployment process of "${contractArtifactName}"...`);

  const wallet = options?.wallet ?? getWallet();
  const deployer = new Deployer(hre, wallet);
  const artifact = await deployer
    .loadArtifact(contractArtifactName)
    .catch((error) => {
      if (
        error?.message?.includes(
          `Artifact for contract "${contractArtifactName}" not found.`
        )
      ) {
        console.error(error.message);
        throw `⛔️ Please make sure you have compiled your  or specified the correct contract name!`;
      } else {
        throw error;
      }
    });

  // Estimate contract deployment fee
  const deploymentFee = await deployer.estimateDeployFee(
    artifact,
    constructorArguments || []
  );
  log(`Estimated deployment cost: ${ethers.formatEther(deploymentFee)} ETH`);

  // Check if the wallet has enough balance
  await verifyEnoughBalance(wallet, deploymentFee);

  // Deploy the contract to ZKsync
  const contract = await deployer.deploy(artifact, constructorArguments);
  const address = await contract.getAddress();
  const constructorArgs = contract.interface.encodeDeploy(constructorArguments);
  const fullource = `${artifact.sourceName}:${artifact.contractName}`;

  // Display contract deployment info
  log(`\n"${artifact.contractName}" was successfully deployed:`);
  log(` - Contract address: ${address}`);
  log(` - Contract source: ${fullource}`);
  log(` - Encoded constructor arguments: ${constructorArgs}\n`);

  if (!options?.noVerify && hre.network.config.verifyURL) {
    log(`Requesting contract verification...`);
    await verifyContract({
      address,
      contract: fullource,
      constructorArguments: constructorArgs,
      bytecode: artifact.bytecode,
    });
  }

  return contract;
}

[uF4No]

hey @jpreciadom you mentioned this issue is not happening on testnet. Do you remember if when compiling the contracts the first time and before the testnet deployment you got a warning with the message: zksolc compiler detected missing libraries! For more details, visit... and then you ran npx hardhat deploy-zksync:libraries.

Also, are the library addresses in your hardhat.config.ts file the ones from testnet or mainnet?