[SDK] Does create2address function work properly in Go?

[EricYoo-n]

Environment

Testnet

Acknowledgement

• I understand that issues are expected with the Go SDK as they are being updated.

Issue Description

The test was conducted using hardhat.
We deployed AA factory and used it to deploy sc.
The deployed address matched the address of the create2Address function.

However, in tests using the Go language, the create2address function did not work properly.
Deploy of SC in Go language was successful. However, the create2address function returned an incorrect address.
Even if I used the same values ​​as hard hat, strange results were obtained.

If I'm using it wrong, please tell me how to use it properly.
If the create2Address function of Go SDK is incorrect, please correct it.

Expected Behavior

Expected return

• 0x8CFa678918b1687d3c5A661fb6B78a3cd1B1c122
  Actual return
• 0xc74ebF920d693291068640602807F6De6F83F332

Code Example

hexString := "0000000000000000000000000000000000000000000000000000000000000009"

salt, err := hex.DecodeString(hexString)
if err != nil {
	panic(err)
}

var salt32 [32]byte
copy(salt32[:], salt)

// sender = factory address
sender := common.HexToAddress("0xB45cc5C800411C41282BFb189dA4fD2eADD2eFd9")
bytecode := common.Hex2Bytes("01000601c107b05af8b86d8e014b9660adb741d1176acdfe44ff529360064b59")
contructor := common.Hex2Bytes("00000000000000000000000036615cf349d7f6344891b1e7ca7c72883f5dc049")

address, err := zkUtils.Create2Address(sender, bytecode, contructor, salt)

Repo Link (Optional)

No response

[bxpana]

Will check on the status of the GO SDK for you

[dutterbutter]

To confirm the same Hardhat values using zkSync HH plugins? Can you share a link to that just so I may get the full picture?.

create2 should work as expected in the go sdk but of course we do have different address derivation, this means that the same bytecode deployed on Ethereum and zkSync will have different addresses.

[EricYoo-n]

const hre = require("hardhat");
const { Wallet, Provider, utils} = require("zksync-ethers");
const ethers = require("ethers");
const { Deployer } = require("@matterlabs/hardhat-zksync-deploy");

const env = hre.config.networks.local
const provider = new Provider(env.url)
const ethProvider = ethers.getDefaultProvider(env.ethNetwork)
const owner = new Wallet(env.accounts[0], provider, ethProvider)
const deployer = new Deployer(hre, owner);


async function main() {
    const factoryArtifact = await deployer.loadArtifact("Factory");
    const aaArtifact = await deployer.loadArtifact("Account");
  
    // Factory contract deploy
    const factory = await deployer.deploy(factoryArtifact, [utils.hashBytecode(aaArtifact.bytecode)], undefined, [aaArtifact.bytecode])
    const factoryAddress = await factory.getAddress()
    console.log("Factory address : ", factoryAddress)
    const factoryContract = new ethers.Contract(factoryAddress, factoryArtifact.abi, owner)
  
    // deploy SC account
    const salt = "0x0000000000000000000000000000000000000000000000000000000000000001"
    var tx = await factoryContract.deployAccount(salt, owner.address)
    await tx.wait()
    console.log("tx hash : ", tx.hash)
  
    factoryByteCodeHash = await factoryContract.aaBytecodeHash()
  
    const abiCoder = new ethers.AbiCoder()
    const constructor = abiCoder.encode(["address"], [owner.address])
    const accountAddress = utils.create2Address(factoryAddress, factoryByteCodeHash, salt, constructor)
    console.log("New SC account address : ", accountAddress)
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

This is my full hard hat code.
Factory contract deployment, AA account deployment, address verification using Create2Address everything works fine.

Values such as factoryByteCodeHash, salt, and constructor have been used in the Go SDK create2Address function.
But the result is different from the hard hat.

AA deployment works well using Factory contract deployed by hard hat in Go SDK.
However, the address value of Go SDK's create2Address is an odd value.

If you apply bytecode, constructor, and salt, such as the value used in Go SDK, to the hard hat's create2address, the value comes out properly.
Only Go SDK's create2address returns a strange value.
@dutterbutter

[dutterbutter]

@EricYoo-n thanks for the follow-up. Will investigate.

[danijelTxFusion]

In the Go SDK, Create2Address accepts bytecode as a parameter, not bytecode hash, unlike Hardhat (zksync-ethers), which accepts bytecode hash.