[Dev Tools] hardhat deploy-zksync:contract does not seem to be deterministic across wallets

[coffeexcoin]

Team or Project

Abstract

Environment

Testnet

Select the Dev Tool you are using

Hardhat Plugins

Provide the version of the tool (if applicable)

1.10

Provide a brief description of the functionality you're trying to implement and the issue you are running into.

By running the following command I would expect the deployment of the same contract address no matter what the deploying private key/transaction origin is:

npx hardhat deploy-zksync:contract --deployment-type create2 --network abstract-testnet --verify --contract-name VerifySig

Instead, create2 seems to deploy to two separate addresses depending on tx origin

Deployment tx 1

https://explorer.testnet.abs.xyz/tx/0xd2b91c3a1b296ba1d31e7ec4fafa822c10e628d7d4764a02c8bfaac90b0aa476
https://explorer.testnet.abs.xyz/address/0x35Dd57027CC736d50b91EcE32E8d02B3aaeFF754#contract

Deployment tx 2

https://explorer.testnet.abs.xyz/tx/0xc1fa188452ca18edced681f6e4dc5ee65e78d675bbddea997c5f8423a481ca6d
https://explorer.testnet.abs.xyz/address/0xfB688330379976DA81eB64Fe4BF50d7401763B9C#contract

Please note that the calldata for these is identical:

• Function selector create2(bytes32,bytes32,bytes)
• Salt: 0x0000000000000000000000000000000000000000000000000000000000000000
• BytecodeHash: 0x010000dda816e1cfbae72962e28bf9a80680a7f08779cb9256be166fb392ae54
• Input: 0x

Repo Link (Optional)

https://gist.github.com/coffeexcoin/ffdea6221ede2ea4e9191c8cf0126990

Additional Details

No response

[gleenai[bot]]

The behavior you're experiencing with the create2 deployment type resulting in different contract addresses despite using the same parameters can be attributed to the specific address derivation rules used in ZKsync. When deploying contracts using create2, the actual address of the deployed contract may differ from the expected address derived using Ethereum’s method due to differences in the underlying bytecode and the specific hashing mechanism used by ZKsync.

To ensure deterministic contract addresses across different wallets or transaction origins, you need to use ZKsync's specific hashing mechanism that includes a zksyncCreate2 prefix. This ensures that the contract addresses are correctly computed and consistent regardless of the deploying entity.

Here are some steps and considerations:

• Ensure that the salt and bytecode hash used in the deployment are consistent and correctly formatted.
• Verify that the deploying account configuration in your Hardhat setup does not influence the derived address in unexpected ways.
• Consider using the ZKsync SDK or tools that specifically cater to ZKsync's address derivation methods to precompute addresses if necessary.

For more detailed guidance on deploying contracts on ZKsync and ensuring deterministic behavior, you can refer to the ZKsync Deployment Guide.

If you continue to face issues, I recommend visiting the ZKsync developers discussions on Github for more in-depth support and community insights.

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.

[dutterbutter]

@coffeexcoin ZKsync create2 implementation is different then EVM. Specifically, CREATE2 implementation includes the deployer's address (msg.sender) in the address derivation. This means that deploying the same contract with different origins will result in distinct addresses, even if the calldata, salt, and bytecode hash are identical. You can view the implementation here

[coffeexcoin]

Gotcha - so this command is not using a "create2 factory" per-se but instead treating the deployment as if the calling EOA was in fact a contract calling the create2 opcode (speaking in EVM terms)

[dutterbutter]

Unlike Ethereum, where create/create2 are opcodes, on ZKsync these are implemented by the compiler via calls to the ContractDeployer system contract.

[coffeexcoin]

Sorry - @dutterbutter circling back to this. I just learned about the Create2Factory - this is exactly what I would expect to be used when using a create2 flag within tooling (a deterministic address being used where the contract is deployed at the same address on any chain, regardless of the deploying wallet)

Can we get some clarity on this with respect to zksync hardhat and zksync foundry? Are there plans to integrate this into tooling to better match the behavior of this tooling on other EVM chains?

[dutterbutter]

No need to apologize @coffeexcoin ! Yes, you are correct. On foundry-zksync this works as intended. That is regardless of the deploying wallet a deterministic address is used. Below you can see a forge script that uses the Create2Factory.sol via the syntax sugar of counter = new Counter{salt: salt}();. If you deploy this to abstract and zksync using different deployers it will result in the same address.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.26;

import {Script, console} from "forge-std/Script.sol";
import {Counter} from "../src/Counter.sol";

contract CounterScript is Script {
    Counter public counter;

    function setUp() public {}

    function run() public {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        vm.startBroadcast(deployerPrivateKey);
        address alice = vm.addr(deployerPrivateKey);
        console.log("Alice address: ", alice);

        bytes32 salt = keccak256(
            abi.encodePacked(
                "0x7935910912126667836566922594852029127629416664760357073852948630"
            )
        );

        counter = new Counter{salt: salt}();

        console.log("Counter address: ", address(counter));
        vm.stopBroadcast();
    }
}

As for HH, I am assuming its making use of the ContractDeployer directly hence the difference but let me investigate as to why there is a divergence. Nonetheless we will look to remedy. As always, appreciate the post sir @coffeexcoin 🙏

[dutterbutter]

You can still do this with HH btw @coffeexcoin. Below is a provided example, but understandably this should simply just work with --create2 deployment type. Still will follow up to fix but wanted to provided a workaround in the meantime.

import { HardhatRuntimeEnvironment } from "hardhat/types";
import { utils } from "zksync-ethers";
import { hexlify } from "ethers";

const deployScript = async function (hre: HardhatRuntimeEnvironment) {
  console.info(`Running deploy script for the Counter contract`);

  const artifact = await hre.deployer.loadArtifact("Counter");
  const counterBytecodeHash = hexlify(utils.hashBytecode(artifact.bytecode));
  const salt =
    "0x7935910912126667836566922594852029127629416664760357073852948630";
  const create2FactoryAddress = "0x0000000000000000000000000000000000010000";

  const deterministicAddress = utils.create2Address(
    create2FactoryAddress,
    counterBytecodeHash,
    salt,
    "0x"
  );
  console.log("Counter contract address: ", deterministicAddress);
};

export default deployScript;

[dutterbutter]

@coffeexcoin this has been fixed here: zksync-sdk/zksync-ethers#218