[Deployment] Proxy Deployment from a Factory making use of create2Account

[4NNNN]

Environment

Testnet

zkSolc Version

latest

zksync-ethers Version

^6.0.0

Hardhat.config.ts

const config: HardhatUserConfig = {
    zksolc: {
        version: 'latest',
        settings: {
            isSystem: true,
            optimizer: {
                fallbackToOptimizingForSize: false,
            },
        },
    },
    typechain: {
        outDir: "typechain",
        target: "ethers-v5",
    },
    defaultNetwork: 'zkSyncTestnet',
    networks: {
        hardhat: {
            zksync: true,
        },
        zkSyncTestnet,
    },
    solidity: {
        compilers: [{ version: '0.8.17' }]
}

Deployment Script (WITHOUT PRIVATE KEY)

const implementationArtifact = await deployer.loadArtifact("CharterWalletImplementation");
  const implementation = await deployer.deploy(implementationArtifact, [], undefined, [])
  const implementationaddr = await implementation.getAddress();
  console.log(`DRIPImplementation: "${implementationaddr}",`);

  //////////////////////////

  // Deploy AccountFactory
  const factoryArtifact = await deployer.loadArtifact("AccountFactory");
  const proxyArtifact = await deployer.loadArtifact("CharterWalletImplementation");
*****************************************************
Why is it aritifact of CharterWallet Implementation and not the proxy artifact is because the implementation implements UUPSupgradble contract!

*****************************************************
  const proxybytecodeHash = utils.hashBytecode(proxyArtifact.deployedBytecode);

  const factory = await deployer.deploy(factoryArtifact, [implementationaddr, proxybytecodeHash, eoawallet.address], undefined, [
    proxyArtifact.bytecode,
  ]);
  const factoryaddr = await factory.getAddress();
  console.log(`DRIPFactory: "${factoryaddr}",`);

Package.json

"zksync-ethers": "^6.0.0",
    "@matterlabs/hardhat-zksync-upgradable": "^1.5.1",
    "@matterlabs/hardhat-zksync-chai-matchers": "^1.3.0",
    "@matterlabs/hardhat-zksync-deploy": "1.1.2",
    "@matterlabs/hardhat-zksync-solc": "1.0.6",
    "@matterlabs/hardhat-zksync-toolbox": "1.2.1",
    "@matterlabs/hardhat-zksync-verify": "1.2.2",
    "@matterlabs/zksync-contracts": "^0.6.1",

Contract Code

import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";


CharterWalletImplementation is UUPSUpgradeable,Initializable{}

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

NA

Description of What Your Contract Does

1. I tried deploying a proxy to the wallet implemenation by not implementing a proxy import.

2. So it was just a normal wallet contract but the proxy gets deployed by using hre.zkUpgrades.deployProxy.

3. But while trying to populate a transaction and test it out for token transfers, errored up saying Sender is not an account.

4. Which means you're calling a contract which was not deployed using create2Account or createAccount, so in this case I might have to deploy the proxy for the implementation using a proxy factory.

5. I need reference on how to deploy a proxybytecodehash from the factory with the implementation address as a constructor parameter!

Repo Link (Optional)

No response

Additional Details

No response

[gleenai[bot]]

It seems like you are trying to deploy a proxy using a factory pattern on the ZKsync network, specifically using the create2Account method for deterministic address generation. Here’s how you can proceed based on the ZKsync documentation and best practices:

1. Deploy the Implementation Contract: You've already deployed the CharterWalletImplementation contract and obtained its address. This is correct as the implementation contract contains the logic.

2. Hash the Bytecode: You correctly hashed the bytecode of the proxy contract. This hash is crucial for the factory to know which implementation to use when deploying new proxies.

3. Deploy the Factory Contract: Your factory contract should take the implementation address and the hashed bytecode as parameters. This setup allows the factory to deploy new instances of the proxy with deterministic addresses using create2.

4. Using the Factory to Deploy Proxies:

   • When deploying a new proxy through the factory, you need to ensure that the factory contract has a method to accept the necessary parameters (like initial state or initialization arguments for the proxy).
   • The factory should use these parameters along with the stored implementation address and bytecode hash to deploy a new proxy instance using create2.

5. Initialize the Proxy:

   • After deploying the proxy, it's crucial to initialize it. This can be done by calling an initialization function that sets up the state of the proxy to ensure it operates correctly.
   • This step is necessary because the proxy needs to delegate calls to the implementation contract correctly.

6. Testing and Interaction:

   • Once deployed, interact with the proxy contract as you would with any other contract on ZKsync, ensuring that all calls are made through the proxy and not directly to the implementation.

7. Error Handling:

   • The error "Sender is not an account" suggests issues with how the contract is recognized on the network. Ensure that the proxy is deployed correctly and that any interaction with it is done through recognized and correctly set up accounts or contracts.

For more detailed guidance and examples, you might want to refer to the ZKsync documentation on deploying upgradable contracts and using factories. Here are some helpful links:

• Deploying Upgradable Contracts on ZKsync
• General Contract Deployment Practices

These resources should provide you with the necessary code snippets and explanations to successfully deploy and manage your contracts on ZKsync.

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.

[Haypierre]

I'm in a very similar situation (testing on a local node):

✅ Successfully deployed the smart account UpgradeableOpenfortAccount, which implements the IAccount interface from zkSync and the UUPS interface from openzeppelin (amongst other things).
✅ Successfully deployed the factory UpgradeableOpenfortFactory, which implements a custom createAccountWithNonce function to deploy a new proxy UpgradeableOpenfortProxy and initialize it with the smart account address.
🔴 Calling createAccountWithNonce fails with different errors depending on the build system I use (hardhat or forge).

By the way, It's really weird that two different build systems produce two different bytecodes and, therefore, a different bytecode hash for the proxy.

With forge, the ContractDeployer raises the following error: "The code hash is not known"

Adding the factory bytecode dependencies through the foundry-zksync --factory-deps option isn't working anymore (despite the option still being referenced in the getting started).

From my understanding of this PR, foundry-zksync would use the compiler information to directly include the factory dependencies in the transaction. Maybe something goes wrong at this level?

I'm forcing the forge parser to add the proxy bytecode to the factory dependency with the type(UpgradeableOpenfortProxy).creationCode instruction in the constructor. Otherwise, it doesn't appear in the build output zkout/UpgradableOpenfortFactory.json.

With hardhat, I'm stuck at the same point (calling the factory's createAccountWithNonce function)—with even less context on the error: An unexpected error occurred.

hardhat.config.ts

import "@matterlabs/hardhat-zksync-deploy"
import "@matterlabs/hardhat-zksync-solc"
import "@matterlabs/hardhat-zksync-upgradable"

import "tsconfig-paths/register"

module.exports = {
  zksolc: {
    version: "1.5.0", // Check for the latest version
    isSystem: true,
    compilerSource: "binary",
    settings: {},
  },
  defaultNetwork: "zkSyncLocal",
  networks: {
    zkSyncLocal: {
      url: "http://127.0.0.1:8011", // URL for the zkSync testnet
      ethNetwork: "mainnet", // The Ethereum network where zkSync operates (use "mainnet" for production)
      zksync: true,
    },
  },
  solidity: {
    version: "0.8.19",
  },
};

deployFactory.ts

import { utils, Wallet, Provider } from "zksync-ethers";
import * as ethers from "ethers";
import { HardhatRuntimeEnvironment } from "hardhat/types";
import { Deployer } from "@matterlabs/hardhat-zksync-deploy";

export default async function (hre: HardhatRuntimeEnvironment) {

  // Private key of the account used to deploy
  const wallet = new Wallet("3d3cbc973389cb26f657686445bcc75662b415b656078503592ac8c1abb8810e");
  const deployer = new Deployer(hre, wallet);

  // const aaArtifact = await deployer.loadArtifact("UpgradeableOpenfortAccount");
  const factoryArtifact = await deployer.loadArtifact("UpgradeableOpenfortFactory");
  const proxyArtifact = await deployer.loadArtifact("UpgradeableOpenfortProxy");



  // Getting the bytecodeHash of the account
  const bytecodeHash = utils.hashBytecode(proxyArtifact.bytecode);

  console.log(proxyArtifact.bytecode);
  // DEBUG ONLY
  const bytes32String = '0x' + Array.from(bytecodeHash)
    .map(byte => byte.toString(16).padStart(2, '0'))
    .join('');
  console.log(bytes32String);


  const factory = await deployer.deploy(factoryArtifact, ["0xd986b0cB0D1Ad4CCCF0C4947554003fC0Be548E9", bytecodeHash, "0x9c1a3d7C98dBF89c7f5d167F2219C29c2fe775A7", 100, 10, 10, 200, "0xbc989fde9e54cad2ab4392af6df60f04873a033a"], undefined, [
    // factoryDeps.
    proxyArtifact.bytecode,
  ]);

  const factoryAddress = await factory.getAddress();
  console.log(`AA factory address: ${factoryAddress}`);
  const aaFactory = new ethers.Contract(factoryAddress, factoryArtifact.abi, wallet)
  const owner = Wallet.createRandom();
  console.log("SC Account owner pk: ", owner.privateKey);


  // This is failing 
  const tx = await aaFactory.createAccountWithNonce(owner.address, "0x1000000000000000000000000000000000000000000000000000000000000000", false);
  await tx.wait()

  console.log(tx);
}

UpgradeableOpenfortFactory.sol

// SPDX-License-Identifier: GPL-3.0
pragma solidity =0.8.19;

import {
    IContractDeployer, DEPLOYER_SYSTEM_CONTRACT
} from "@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol";
import {SystemContractsCaller} from
    "@matterlabs/zksync-contracts/l2/system-contracts/libraries/SystemContractsCaller.sol";

import {UpgradeableOpenfortAccount} from "./UpgradeableOpenfortAccount.sol";
import {UpgradeableOpenfortProxy} from "./UpgradeableOpenfortProxy.sol";
import {BaseOpenfortFactory} from "../base/BaseOpenfortFactory.sol";

/**
 * @title UpgradeableOpenfortFactory (Non-upgradeable)
 * @notice Contract to create an on-chain factory to deploy new UpgradeableOpenfortAccounts.
 * It inherits from:
 *  - BaseOpenfortFactory
 */
contract UpgradeableOpenfortFactory is BaseOpenfortFactory {
    uint256 public recoveryPeriod;
    uint256 public securityPeriod;
    uint256 public securityWindow;
    uint256 public lockPeriod;
    address public initialGuardian;
    bytes32 public upgradeableOpenfortProxyCodeHash;


    
    error TooManyInitialGuardians();

    /**
     * @dev Emitted when the initial guardian is changed.
     */
    event InitialGuardianUpdated(address indexed oldInitialGuardian, address indexed newInitialGuardian);

    constructor(
        address _owner,
        bytes32 _upgradeableOpenfortProxyCodeHash,
        address _accountImplementation,
        uint256 _recoveryPeriod,
        uint256 _securityPeriod,
        uint256 _securityWindow,
        uint256 _lockPeriod,
        address _initialGuardian
    ) BaseOpenfortFactory(_owner, _accountImplementation) {
    
        // add UpgradeableOpenfortProxy to factoryDeps
       upgradeableOpenfortProxyCodeHash = keccak256(type(UpgradeableOpenfortProxy).creationCode);
       
       // hardcode hash of the proxy from the build info
       // upgradeableOpenfortProxyCodeHash = bytes32(0xf4ec4bd363bc9ac7515cb17983200705e78b01155ca2a3ab97a44daff53b3053);
       
       // To test with hardhat, build the hash in the script and give it  to the constructor
      // upgradeableOpenfortProxyCodeHash = _upgradeableOpenfortProxyCodeHash;

        if (_lockPeriod < _recoveryPeriod || _recoveryPeriod < _securityPeriod + _securityWindow) {
            revert InsecurePeriod();
        }
        recoveryPeriod = _recoveryPeriod;
        securityPeriod = _securityPeriod;
        securityWindow = _securityWindow;
        lockPeriod = _lockPeriod;
        if (_initialGuardian == address(0)) revert ZeroAddressNotAllowed();
        initialGuardian = _initialGuardian;
    }

    function updateInitialGuardian(address _newInitialGuardian) external onlyOwner {
        if (_newInitialGuardian == address(0)) revert ZeroAddressNotAllowed();
        emit InitialGuardianUpdated(initialGuardian, _newInitialGuardian);
        initialGuardian = _newInitialGuardian;
    }

    /*
     * @notice Deploy a new account for _admin with a _nonce.
     */
    function createAccountWithNonce(address _admin, bytes32 _nonce, bool _initializeGuardian)
        external
        returns (address account)
    {
        bytes32 salt = keccak256(abi.encode(_admin, _nonce));
        // account = getAddressWithNonce(_admin, _nonce);

        // uint256 codelen;

        // assembly {
        //     codelen := extcodesize(account)
        // }

        // if (codelen > 0) return account;

        // account = address(new UpgradeableOpenfortProxy{salt: salt}(_implementation, ""));

        (bool success, bytes memory returnData) = SystemContractsCaller.systemCallWithReturndata(
            uint32(gasleft()),
            address(DEPLOYER_SYSTEM_CONTRACT),
            uint128(0),
            abi.encodeCall(
                DEPLOYER_SYSTEM_CONTRACT.create2Account,
                (
                    salt,
                    // Contract Bytecode Hash
                    upgradeableOpenfortProxyCodeHash,
                    abi.encode(_implementation, ""),
                    IContractDeployer.AccountAbstractionVersion.Version1
                )
            )
        );

        require(success, string(abi.encodePacked("Deployment Failed: ", returnData)));
        emit AccountCreated(account, _admin);

        UpgradeableOpenfortAccount(payable(account)).initialize(
            _admin,
            recoveryPeriod,
            securityPeriod,
            securityWindow,
            lockPeriod,
            _initializeGuardian ? initialGuardian : address(0)
        );

        (account) = abi.decode(returnData, (address));
        //return account;
    }

    /*
     * @notice Return the address of an account that would be deployed with the given _admin signer and _nonce.
     */
    function getAddressWithNonce(address _admin, bytes32 _nonce) public returns (address account) {
        bytes32 salt = keccak256(abi.encode(_admin, _nonce));

        (bool success, bytes memory returnData) = SystemContractsCaller.systemCallWithReturndata(
            uint32(gasleft()),
            address(DEPLOYER_SYSTEM_CONTRACT),
            uint128(0),
            abi.encodeCall(
                DEPLOYER_SYSTEM_CONTRACT.getNewAddressCreate2,
                (
                    // Deployer address
                    address(this),
                    upgradeableOpenfortProxyCodeHash,
                    salt,
                    // Constructor Bytecode
                    abi.encode(_implementation, "")
                )
            )
        );
        require(success, string(abi.encodePacked("zkSync CREATE 2 address calculation failed", returnData)));
        (account) = abi.decode(returnData, (address));
    }
}

[bxpana]

Thanks for this @4NNNN and @Haypierre. We'll let you guys know when we have a working demo.

[uF4No]

hey @4NNNN @Haypierre

I'm trying to build a sample project for you guys but I'm not there yet. However, there are a few things that you could check:

• The contracts must be compiled with the isSystem: true (for zksolc 1.4.x) or enableEraVMExtensions: true (for zksolc 1.5.x) in the zksolc settings, as the accounts interact with the NonceHolder system contract.
• The Factory must deploy the accounts with createAccount or create2Account. If the factory is deploying a proxy that points to an implementation contract, then the proxy should be deployed with createAccount or create2Account. The error Validation revert: Sender is not an account means the address used as from in the transaction was not deployed with createAccount/create2Account.
• Have you tried testing locally on era-test-node? It might give you better error details. Details here

[uF4No]

Here is a repo with some examples. It contains multiple examples, from deploying an account manually, to deploying from a factory and lastly, deploying a proxy account from a factory.

the last scenario is the one you'll find useful in your case. To share some txs and contract addresses from my tests:

• I deployed a smart contract account
• from a ProxyFactory
• that uses the implementation logic from another contract.
• then I successfully sent a transaction from this account to interact with a contract.

Find all the details and considerations in the repo readme file. We'll see how we can improve the docs for this particular case.

[Haypierre]

Hey @uF4No, thanks for your time and answers.

Trying to make it work with Foundry, our main tooling @openfort.xyz.

As you can see on the screen, with foundry-zksync solc output isn't deterministic.

It's not the case with hardhat: your deployment script always produces the same proxy hash.

To have a successful deployment with Foundry, I don't have a more straightforward solution than:

• include type(UpgradeableOpenfortProxy).creationCode anywhere in the factory code.
  ignore the Warning: Statement has no effect. ... which doesn't seem optimal.

• get the "dynamic" hash in the factoryDependency of the build: cat zkout/UpgradeableOpenfortFactory.sol/UpgradeableOpenfortFactory.json | jq '.factoryDependencies | keys[0]'

• give it as a parameter to the factory constructor.

Had Foundry included a configuration option to produce deterministic output, the proxy bytecode hash could have been a constant in the factory contract.

[uF4No]

hey @Haypierre, thanks for reporting the issue. I'll share it with the foundry-zksync team to review it. Do you have a repo with the minimal code to replicate the issue?

[chiranjeev13]

Hey @uF4No ,
I'm encountering an issue.

I'm working with a factory contract that deploys proxy accounts using create2Account:

Factory.sol

(bool success, bytes memory returnData) = SystemContractsCaller
    .systemCallWithReturndata(
        uint32(gasleft()),
        address(DEPLOYER_SYSTEM_CONTRACT),
        uint128(0),
        abi.encodeCall(
            DEPLOYER_SYSTEM_CONTRACT.create2Account,
            (
                salt,
                aaBytecodeHash,
                // constructor params: address logic, address admin, bytes data
                abi.encode(implementation, ""),
                IContractDeployer.AccountAbstractionVersion.Version1
            )
        )
    );
require(success, "Deployment failed");

(proxyAddress) = abi.decode(returnData, (address));

// Call the initialize method
bool initializeSuccess;

assembly ("memory-safe") {
    initializeSuccess := call(
        gas(),
        proxyAddress,
        0,
        add(initializer, 0x20),
        mload(initializer),
        0,
        0
    );
}

Implementation deployment script->

const artifact = await hre.deployer.loadArtifact(contractArtifactName);
  const contract = await hre.deployer.deploy(artifact, constructorArguments, "create2Account");

  const ACCOUNT_ADDRESS = await contract.getAddress();
  console.log(`InitAccount deployed to: ${ACCOUNT_ADDRESS}`);

Factory deployment script ->

const proxyArtifactName = "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol:ERC1967Proxy";
  const facArtifact = await hre.deployer.loadArtifact(facArtifactName);
  const proxyArtifact = await hre.deployer.loadArtifact(proxyArtifactName);
  const proxyBytecodeHash = utils.hashBytecode(proxyArtifact.bytecode);
  console.log("Generated bytecode hash...");
  const factoryContract = await hre.deployer.deploy(
    facArtifact,
    // constructor params
    [proxyBytecodeHash, IMPLEMENTATION_ADDR],
    "create",
    undefined,
    [proxyArtifact.bytecode]
  );

My dependencies

devDependencies: {
    "@matterlabs/hardhat-zksync": "^1.0.0",
    "@matterlabs/zksync-contracts": "^0.6.1",
    "@typechain/ethers-v5": "^11.1.1",
    "@typechain/hardhat": "9.1.0",
    "@types/chai": "^4.3.4",
    "@types/elliptic": "^6.4.15",
    "@openzeppelin/contracts": "4.6",
    "@types/mocha": "^10.0.1",
    "chai": "^4.3.7",
    "dotenv": "^16.0.3",
    "elliptic": "^6.5.4",
    "ethers": "^6.9.2",
    "hardhat": "^2.12.4",
    "mocha": "^10.2.0",
    "prettier-plugin-solidity": "^1.1.3",
    "read-last-lines": "^1.8.0",
    "ts-node": "^10.9.1",
    "typechain": "^8.3.1",
    "typescript": "^4.9.5",
    "zksync-ethers": "^6.7.0"
  },
  "dependencies": {
    "@nomad-xyz/excessively-safe-call": "^0.0.1-rc.1",
    "@redstone-finance/evm-connector": "^0.3.6",
    "@scure/base": "^1.1.7",
    "solady": "^0.0.218"
  }
}

My Hardhat.config.ts ->

import { HardhatUserConfig } from "hardhat/config";

import "@matterlabs/hardhat-zksync";

import dotenv from "dotenv";

// Load env file
dotenv.config();

const config: HardhatUserConfig = {
  defaultNetwork: "inMemoryNode",
  networks: {
    zkSyncSepoliaTestnet: {
      url: "https://sepolia.era.zksync.dev",
      ethNetwork: "sepolia",
      zksync: true,
      verifyURL: "https://explorer.sepolia.era.zksync.dev/contract_verification",
      accounts:[process.env.WALLET_PRIVATE_KEY as any]
    },
    zkSyncMainnet: {
      url: "https://mainnet.era.zksync.io",
      ethNetwork: "mainnet",
      zksync: true,
      verifyURL: "https://zksync2-mainnet-explorer.zksync.io/contract_verification",
    },
    dockerizedNode: {
      url: "http://localhost:3050",
      ethNetwork: "http://localhost:8545",
      zksync: true,
    },
    inMemoryNode: {
        url: "http://127.0.0.1:8011",
        ethNetwork: 'localhost',
        zksync: true,
        accounts:[process.env.WALLET_PRIVATE_KEY as any]
      },
    hardhat: {
      zksync: true,
    },
  },
  zksolc: {
    version: "1.5.1",
    settings: {
      enableEraVMExtensions: true,
      // find all available options in the official documentation
      // https://era.zksync.io/docs/tools/hardhat/hardhat-zksync-solc.html#configuration
        libraries: {
              "contracts/modules/email-recovery/utils/StringUtils.sol": {
                "StringUtils": "0x9c1a3d7C98dBF89c7f5d167F2219C29c2fe775A7"
              }
            }
    },
  },
  mocha: {
    timeout: 100000000,
  },
  solidity: {
    version: "0.8.25",
  },
};

export default config;

Everything works fine when tested on the Era test node. However, when I run the tests on Sepolia, I get the following error for the proxy account address:
Error: failed to validate the transaction. Reason: Violated validation rules: Called contract with no code: 000000000000000000636f6e736f6c652e6c6f67

Test is a basic ERC20 transfer test.

Could you please help me figure out what's going wrong?

[uF4No]

hey @chiranjeev13 I'd need to see the account contract as it looks like you're accessing some restricted slots during the validation (like block.timestamp). Please check the verification limitations from our docs.

If this is the case and it works with era-test-node, then you can also create an issue in the era-test-node repo so we can fix it as it should have the same behaviour as testnet/mainnet.