[Deployment] Latest version of Ethers (6.12.1) breaks deploying upgradeable contracts.

[Archethect]

Environment

Testnet

zkSolc Version

1.4.1

zksync-ethers Version

6.7.0

Hardhat.config.ts

import * as dotenv from "dotenv";
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "hardhat-deploy";
import "@matterlabs/hardhat-zksync";

dotenv.config();

import "./tasks/verify-playfi-contracts";

const config: HardhatUserConfig = {
  zksolc: {
    version: "latest",
    compilerSource: "binary",
    settings: {},
  },
  typechain: {
    target: "ethers-v6",
  },
  mocha: {
    timeout: 10000000000,
  },
  solidity: {
    version: "0.8.24",
    settings: {
      optimizer: {
        enabled: true,
        runs: 9999,
      },
    },
  },
  networks: {
    hardhat: {
      chainId: process.env.FORKING == "true" ? 42161 : 31337,
      forking: {
        url:
            "https://arbitrum-mainnet.infura.io/v3/" +
            (process.env.INFURA_KEY !== undefined ? process.env.INFURA_KEY : ""),
        blockNumber: 203592328,
        enabled: process.env.FORKING !== undefined && process.env.FORKING == "true" ? true : false,
      },
      accounts: {
        count: 300,
      },
    },
    sepolia: {
      url: "https://sepolia.infura.io/v3/" + (process.env.INFURA_KEY !== undefined ? process.env.INFURA_KEY : ""),
      accounts: process.env.SEPOLIA_PRIVATE_KEY !== undefined ? [process.env.SEPOLIA_PRIVATE_KEY] : [],
      gas: 210000000,
      gasPrice: 800000000,
    },
    zkSyncSepolia: {
      url: "https://zksync-sepolia.g.alchemy.com/v2/" + (process.env.ZKSYNC_SEPOLIA_ALCHEMY_KEY !== undefined ? process.env.ZKSYNC_SEPOLIA_ALCHEMY_KEY : ""),
      accounts: process.env.ZKSYNC_SEPOLIA_PRIVATE_KEY !== undefined ? [process.env.ZKSYNC_SEPOLIA_PRIVATE_KEY] : [],
      zksync: true,
      ethNetwork: "https://sepolia.infura.io/v3/" + (process.env.INFURA_KEY !== undefined ? process.env.INFURA_KEY : ""),
      verifyURL: "https://explorer.sepolia.era.zksync.dev/contract_verification",
    },
    ethereum: {
      url: "https://mainnet.infura.io/v3/" + (process.env.INFURA_KEY !== undefined ? process.env.INFURA_KEY : ""),
      accounts: process.env.MAINNET_PRIVATE_KEY !== undefined ? [process.env.MAINNET_PRIVATE_KEY] : [],
      gas: 210000000,
      gasPrice: 800000000,
    },
  },
  gasReporter: {
    enabled: process.env.REPORT_GAS !== undefined,
    currency: "USD",
  },
  namedAccounts: {
    deployer: {
      default: 0,
      42161: 0, //TODO: set correct address
    },
    deployerMultisig: {
      default: 1,
      42161: 1, //TODO: set correct address
      421614: "0x571E443ccd1A35fEb3AfCD9F4a72f589Ef7eA785",
      80002: "0x571E443ccd1A35fEb3AfCD9F4a72f589Ef7eA785",
      300: "0x571E443ccd1A35fEb3AfCD9F4a72f589Ef7eA785"
    },
    admin: {
      default: 2,
      42161: 2, //TODO: set correct address
      421614: "0xf558c6EECcf47ce88E644Ce48DD6ca9176e2C23b",
      80002: "0xf558c6EECcf47ce88E644Ce48DD6ca9176e2C23b",
      300: "0xf558c6EECcf47ce88E644Ce48DD6ca9176e2C23b"
    },
    guardian: {
      default: 3,
      42161: 3, //TODO: set correct address
      421614: 0,
      80002: 0,
      300: 0
    },
    merkleManager: {
      default: 4,
      42161: 4, //TODO: set correct address
      421614: 0,
      80002: 0,
      300: 0
    },
    referralManager: {
      default: 5,
      42161: 5, //TODO: set correct address
      421614: 0,
      80002: 0,
      300: 0
    },
  },
};

export default config;

Deployment Script (WITHOUT PRIVATE KEY)

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

dotenv.config();

const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) {
    const {
        deployerAdmin,
        admin,
        guardian,
        merkleManager,
        referralManager
    } = await getNamedAccounts();

    const contractName = "PlayFiLicenseSale";

    const PRIVATE_KEY = process.env.ZKSYNC_SEPOLIA_PRIVATE_KEY !== undefined ? process.env.ZKSYNC_SEPOLIA_PRIVATE_KEY : "";

    const zkWallet = new Wallet(PRIVATE_KEY);

    const deployer = new Deployer(hre, zkWallet);

    const contract = await deployer.loadArtifact(contractName);

    const plaiFiLicenseSale = await hre.zkUpgrades.deployProxy(deployer.zkWallet, contract, [admin, guardian, merkleManager, referralManager], { initializer: "initialize" });

    await plaiFiLicenseSale.waitForDeployment();

    await hre.zkUpgrades.admin.transferProxyAdminOwnership(deployerAdmin,zkWallet);

    return true;
};
export default func;
func.id = "DeployPlayFiLicenseSaleZKSync";
func.tags = ["DeployPlayFiLicenseSaleZKSync"];

Package.json

{
  "name": "playfi-license-sale",
  "version": "1.0.0",
  "description": "License sale for PlayFi nodes",
  "main": "index.js",
  "license": "MIT",
  "devDependencies": {
    "@matterlabs/hardhat-zksync": "^1.0.0",
    "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
    "@nomicfoundation/hardhat-ethers": "^3.0.0",
    "@nomicfoundation/hardhat-ignition": "^0.15.0",
    "@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
    "@nomicfoundation/hardhat-verify": "^2.0.0",
    "@openzeppelin/contracts": "4.9.5",
    "@openzeppelin/contracts-upgradeable": "4.9.5",
    "@openzeppelin/hardhat-upgrades": "^3.0.5",
    "@openzeppelin/upgrades-core": "1.27.3",
    "@typechain/ethers-v6": "^0.5.0",
    "@typechain/hardhat": "^2.3.1",
    "@types/chai": "^4.2.0",
    "@types/mocha": ">=9.1.0",
    "@types/node": ">=18.0.0",
    "chai": "^4.2.0",
    "commander": "^12.0.0",
    "dotenv": "^10.0.0",
    "ethers": "^6.12.1",
    "hardhat": "^2.22.2",
    "hardhat-deploy": "^0.11.4",
    "hardhat-gas-reporter": "^1.0.6",
    "solidity-coverage": "^0.7.17",
    "ts-node": ">=8.0.0",
    "typechain": "^8.3.0",
    "typescript": ">=4.5.0",
    "zksync-ethers": "^6.0.0"
  },
  "dependencies": {
    "hardhat-contract-sizer": "^2.5.1"
  }
}

Contract Code

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/utils/Strings.sol";

import "./interfaces/IPlayFiLicenseSale.sol";

/*

                 .-+*###+-.
               =*%%%%%%%%%%#=:
               :=*%%%%%%%%%%%#+-.
                   .-+#%%%%%%%%%%%*=:
    :+##+-             :=#%%%%%%%%%%%#+-
   *%%%%%%%*=:            .-+#%%%%%%%%%%*.
  *%%%%%%%%#+:                :=#%%%%%%%%*
  #%%%%%%*:         .==:         .*%%%%%%%
  #%%%%%%=       :+#%%%%#+-       -%%%%#+:
  #%%%%%%=     :#%%%%%%%%%%#-     -%*=.
  #%%%%%%=     -%%%%%%%%%%%%=     .
  #%%%%%%=     -%%%%%%%%%%%%=
  #%%%%%%=     -%%%%%%%%%%%%=            :
  #%%%%%%=      .=*%%%%%%*=:         .-+#%
  #%%%%%%=          -++-.         :=#%%%%%
  *%%%%%%=                    .-+#%%%%%%%#
  .#%%%%%=                 :=*%%%%%%%%%%#:
    =*%%%=       #+-.  .-+#%%%%%%%%%%%*=
       -+=       #%%%##%%%%%%%%%%%#*-.
                 #%%%%%%%%%%%%%#=:
                 #%%%%%%%%%#*-.
                 :=*%%%%#=:

*/


/// @title PlayFi node license sale contract
/// @author Archethect
/// @notice Contract used to handle whitelist and public node license sales in several tiers.
contract PlayFiLicenseSale is
Initializable,
AccessControlUpgradeable,
IPlayFiLicenseSale
{
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN");
    bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN");
    bytes32 public constant MERKLE_MANAGER_ROLE = keccak256("MERKLE_MANAGER");
    bytes32 public constant REFERRAL_MANAGER_ROLE = keccak256("REFERRAL_MANAGER");

    bytes32 public override teamMerkleRoot;
    bytes32 public override friendsFamilyMerkleRoot;
    bytes32 public override earlyAccessMerkleRoot;
    bytes32 public override partnerMerkleRoot;

    bool public override teamSaleActive;
    bool public override friendsFamilySaleActive;
    bool public override earlyAccessSaleActive;
    bool public override partnerSaleActive;
    bool public override publicSaleActive;

    uint256 public override standardCommissionPercentage;
    uint256 public override standardDiscountPercentage;
    uint256 public override totalLicenses;

    mapping(address => uint256) public teamClaimsPerAddress;
    mapping(address => uint256) public friendsFamilyClaimsPerAddress;
    mapping(address => uint256) public earlyAccessClaimsPerAddress;
    mapping(address => uint256) public partnerClaimsPerAddress;
    mapping(address => uint256) public publicClaimsPerAddress;

    mapping(uint256 => Tier) public tiers;
    mapping(string => Referral) public referrals;
    mapping(uint256 => mapping(address => uint256)) public claimsPerTierPerAddress;


    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    function initialize(
        address admin,
        address guardian,
        address merkleManager,
        address referralManager
    ) public initializer {
        __AccessControl_init();

        if (admin == address(0)) revert InvalidAddress(admin);
        if (guardian == address(0)) revert InvalidAddress(guardian);
        if (merkleManager == address(0)) revert InvalidAddress(merkleManager);
        if (referralManager == address(0)) revert InvalidAddress(referralManager);

        _grantRole(ADMIN_ROLE, admin);
        _setRoleAdmin(ADMIN_ROLE, ADMIN_ROLE);
        _grantRole(GUARDIAN_ROLE, guardian);
        _grantRole(GUARDIAN_ROLE, admin);
        _setRoleAdmin(GUARDIAN_ROLE, ADMIN_ROLE);
        _grantRole(MERKLE_MANAGER_ROLE, merkleManager);
        _setRoleAdmin(MERKLE_MANAGER_ROLE, ADMIN_ROLE);
        _grantRole(REFERRAL_MANAGER_ROLE, referralManager);
        _setRoleAdmin(REFERRAL_MANAGER_ROLE, ADMIN_ROLE);

        standardCommissionPercentage = 5;
        standardDiscountPercentage = 5;

        emit ContractInitialized();
    }

    /// @notice Claims licenses for team members and make sure they do not exceed their personal claim cap.
    /// @param amount The amount of licenses to claim
    /// @param data Index and claimCap in encoded format
    /// @param merkleProof The proof used to verify whether the caller is allowed to claim the licenses
    function claimLicenseTeam(uint256 amount, bytes calldata data, bytes32[] calldata merkleProof) external {
        if(!teamSaleActive) revert TeamSaleNotActive();
        (uint256 index, uint256 claimCap) = abi.decode(data,(uint256,uint256));
        uint256 claimedLicenses = teamClaimsPerAddress[msg.sender];
        if(amount + claimedLicenses > claimCap) revert IndividualClaimCapExceeded();
        bytes32 node = keccak256(abi.encodePacked(index, msg.sender, claimCap));
        if (!MerkleProof.verify(merkleProof, teamMerkleRoot, node)) revert InvalidProof();
        teamClaimsPerAddress[msg.sender] += amount;
        totalLicenses += amount;
        emit TeamLicensesClaimed(msg.sender, amount);
    }

    /// @notice Claims licenses for friends and family + make sure they do not exceed their personal claim cap and that
    /// they paid enough.
    /// @param amount The amount of licenses to claim
    /// @param data Index and claimCap in encoded format
    /// @param merkleProof The proof used to verify weather the caller is allowed to claim the licenses
    function claimLicenseFriendsFamily(uint256 amount, bytes calldata data, bytes32[] calldata merkleProof) external payable {
        if(!friendsFamilySaleActive) revert FriendsFamilySaleNotActive();
        (uint256 index, uint256 claimCap) = abi.decode(data,(uint256,uint256));
        uint256 claimedLicenses = friendsFamilyClaimsPerAddress[msg.sender];
        if(amount + claimedLicenses > claimCap) revert IndividualClaimCapExceeded();
        bytes32 node = keccak256(abi.encodePacked(index, msg.sender, claimCap));
        if (!MerkleProof.verify(merkleProof, friendsFamilyMerkleRoot, node)) revert InvalidProof();
        uint256 toPay = tiers[1].price * amount;
        if(msg.value < toPay) revert InsufficientPayment();
        friendsFamilyClaimsPerAddress[msg.sender] += amount;
        totalLicenses += amount;
        emit FriendsFamilyLicensesClaimed(msg.sender, toPay, amount);
    }

    /// @notice Claims licenses for early access addresses + make sure they do not exceed their personal claim cap and
    /// that they paid enough.
    /// @param amount The amount of licenses to claim
    /// @param data Index and claimCap in encoded format
    /// @param merkleProof The proof used to verify whether the caller is allowed to claim the licenses
    function claimLicenseEarlyAccess(uint256 amount, bytes calldata data, bytes32[] calldata merkleProof) external payable {
        if(!earlyAccessSaleActive) revert EarlyAccessSaleNotActive();
        (uint256 index, uint256 claimCap) = abi.decode(data,(uint256,uint256));
        uint256 claimedLicenses = earlyAccessClaimsPerAddress[msg.sender];
        if(amount + claimedLicenses > claimCap) revert IndividualClaimCapExceeded();
        bytes32 node = keccak256(abi.encodePacked(index, msg.sender, claimCap));
        if (!MerkleProof.verify(merkleProof, earlyAccessMerkleRoot, node)) revert InvalidProof();
        uint256 toPay = tiers[1].price * amount;
        if(msg.value < toPay) revert InsufficientPayment();
        earlyAccessClaimsPerAddress[msg.sender] += amount;
        totalLicenses += amount;
        emit EarlyAccessLicensesClaimed(msg.sender, toPay, amount);
    }

    /// @notice Claims licenses for partners + make sure they do not exceed their personal claim cap and that
    /// they paid enough.
    /// @param amount The amount of licenses to claim
    /// @param data Index and claimCap in encoded format
    /// @param merkleProof The proof used to verify weather the caller is allowed to claim the licenses
    function claimLicensePartner(uint256 amount, bytes calldata data, bytes32[] calldata merkleProof) external payable {
        if(!partnerSaleActive) revert PartnerSaleNotActive();
        (uint256 index, uint256 claimCap) = abi.decode(data,(uint256,uint256));
        uint256 claimedLicenses = partnerClaimsPerAddress[msg.sender];
        if(amount + claimedLicenses > claimCap) revert IndividualClaimCapExceeded();
        bytes32 node = keccak256(abi.encodePacked(index, msg.sender, claimCap));
        if (!MerkleProof.verify(merkleProof, partnerMerkleRoot, node)) revert InvalidProof();
        uint256 toPay = tiers[8].price * amount;
        if(msg.value < toPay) revert InsufficientPayment();
        partnerClaimsPerAddress[msg.sender] += amount;
        totalLicenses += amount;
        emit PartnerLicensesClaimed(msg.sender, toPay, amount);
    }

    /// @notice Claims licenses for the public in a specific tier + make sure they do not exceed their personal claim
    /// cap and total tier cap. Additionally also make sure that they paid enough.
    /// @param amount The amount of licenses to claim
    /// @param tier The tier to buy the licenses from
    /// @param referral A referral code that can give discounts.
    function claimLicensePublic(uint256 amount, uint256 tier, string calldata referral) external payable {
        if(!publicSaleActive) revert PublicSaleNotActive();
        if(tiers[tier].totalClaimed + amount > tiers[tier].totalCap) revert TotalTierCapExceeded();
        if(claimsPerTierPerAddress[tier][msg.sender] + amount > tiers[tier].individualCap) revert IndividualTierCapExceeded();
        (uint256 toPay, uint256 commission,) = paymentDetailsForReferral(amount, tier, referral);
        if(msg.value < toPay) revert InsufficientPayment();
        if(commission > 0) {
            (bool sent, ) = payable(referrals[referral].receiver).call{ value: commission }("");
            if (!sent) revert CommissionPayoutFailed();
            emit CommissionPaid(referral, referrals[referral].receiver, commission);
        }
        string memory addressAsString = Strings.toHexString(msg.sender);
        if(referrals[addressAsString].discountPercentage == 0) {
            _setReferral(addressAsString, msg.sender, standardCommissionPercentage, standardDiscountPercentage);
        }
        tiers[tier].totalClaimed += amount;
        publicClaimsPerAddress[msg.sender] += amount;
        totalLicenses += amount;
        emit PublicLicensesClaimed(msg.sender, amount, tier, toPay, referral);
    }
    /// @notice Calculates the price, commission and discount for X number of licenses in tier Y given referral code Z
    /// @param amount The amount of licenses to claim
    /// @param tier The tier to buy the licenses from
    /// @param referral A referral code that can give discounts.
    /// @return toPay The amount of ETH that should be paid by the claimer.
    /// @return commission The commission in ETH that the referrer will get.
    /// @return discount The discount in ETH the claimer will get
    function paymentDetailsForReferral(uint256 amount, uint256 tier, string calldata referral) public view returns (uint256 toPay, uint256 commission, uint256 discount) {
        uint256 fullPrice = tiers[tier].price * amount;
        discount = fullPrice * referrals[referral].discountPercentage / 100;
        commission = fullPrice * referrals[referral].commissionPercentage / 100;
        toPay = fullPrice - discount;
    }

    /// @notice Returns tier details provided a tier id
    /// @param id The tier id
    /// @return tier The tier
    function getTier(uint256 id) public view returns(Tier memory tier) {
        tier = tiers[id];
    }

    /// @notice Returns referral details provided a referral id
    /// @param id The referral id
    /// @return referral The referral
    function getReferral(string memory id) public view returns(Referral memory referral) {
        referral = referrals[id];
    }

    /// @notice Sets referral details
    /// @param code The referral code to be used when claiming
    /// @param receiver The receiver address for the commissions
    /// @param commission The percentage of the total price to be used as a commission
    /// @param discount The percentage of the total price to be used as a discount
    function setReferral(string memory code, address receiver, uint256 commission, uint256 discount) public onlyReferralManager {
        _setReferral(code, receiver, commission, discount);
    }

    /// @notice Sets tier details
    /// @param ids The ids of the tiers to set
    /// @param prices The prices of each tier to set
    /// @param individualCaps The maximum amount of licenses that can be claimed per address for the tiers.
    /// @param totalCaps The maximum amount of licenses that can be claimed in total for the tiers.
    function setTiers(uint256[] calldata ids, uint256[] calldata prices, uint256[] calldata individualCaps, uint256[] calldata totalCaps) external onlyAdmin {
        if(ids.length != prices.length || prices.length != individualCaps.length || individualCaps.length != totalCaps.length) revert InvalidTierInputs();
        for (uint256 i = 0; i < ids.length; ) {
            tiers[ids[i]] = Tier(prices[i], individualCaps[i], tiers[ids[i]].totalClaimed, totalCaps[i]);
            emit TierSet(ids[i], prices[i], individualCaps[i], tiers[ids[i]].totalClaimed, totalCaps[i]);
            unchecked {
                ++i;
            }
        }
    }

    /// @notice Sets the team sale merkle root
    /// @param _teamMerkleRoot The root of the team sale merkle tree
    function setTeamMerkleRoot(bytes32 _teamMerkleRoot) external onlyMerkleManager {
        teamMerkleRoot = _teamMerkleRoot;
        emit TeamMerkleRootSet(_teamMerkleRoot);
    }

    /// @notice Sets the friends and family sale merkle root
    /// @param _friendsFamilyMerkleRoot The root of the friends and family sale merkle tree
    function setFriendsFamilyMerkleRoot(bytes32 _friendsFamilyMerkleRoot) external onlyMerkleManager {
        friendsFamilyMerkleRoot = _friendsFamilyMerkleRoot;
        emit FriendsFamilyMerkleRootSet(_friendsFamilyMerkleRoot);
    }

    /// @notice Sets the early access sale merkle root
    /// @param _earlyAccessMerkleRoot The root of the early access sale merkle tree
    function setEarlyAccessMerkleRoot(bytes32 _earlyAccessMerkleRoot) external onlyMerkleManager {
        earlyAccessMerkleRoot = _earlyAccessMerkleRoot;
        emit EarlyAccessMerkleRootSet(_earlyAccessMerkleRoot);
    }

    /// @notice Sets the partner sale merkle root
    /// @param _partnerMerkleRoot The root of the partner sale merkle tree
    function setPartnerMerkleRoot(bytes32 _partnerMerkleRoot) external onlyMerkleManager {
        partnerMerkleRoot = _partnerMerkleRoot;
        emit PartnerMerkleRootSet(_partnerMerkleRoot);
    }

    /// @notice Sets the team sale status
    /// @param status The status to set for the team sale
    function setTeamSale(bool status) external onlyGuardian {
        teamSaleActive = status;
        emit TeamSaleStatusSet(status);
    }

    /// @notice Sets the friends and family sale status
    /// @param status The status to set for the friends and family sale
    function setFriendsFamilySale(bool status) external onlyGuardian {
        friendsFamilySaleActive = status;
        emit FriendsFamilySaleStatusSet(status);
    }

    /// @notice Sets the early access sale status
    /// @param status The status to set for the early access sale
    function setEarlyAccessSale(bool status) external onlyGuardian {
        earlyAccessSaleActive = status;
        emit EarlyAccessSaleStatusSet(status);
    }

    /// @notice Sets the partner sale status
    /// @param status The status to set for the partner sale
    function setPartnerSale(bool status) external onlyGuardian {
        partnerSaleActive = status;
        emit PartnerSaleStatusSet(status);
    }

    /// @notice Sets the public sale status
    /// @param status The status to set for the public sale
    function setPublicSale(bool status) external onlyGuardian {
        publicSaleActive = status;
        emit PublicSaleStatusSet(status);
    }

    /// @notice Withdraws the sale proceeds
    function withdrawProceeds() public onlyAdmin {
        uint256 amount = address(this).balance;
        (bool sent, ) = payable(msg.sender).call{ value: amount }("");
        if (!sent) revert WithdrawalFailed();
        emit ProceedsWithdrawn(msg.sender, amount);
    }

    function _setReferral(string memory code, address receiver, uint256 commission, uint256 discount) internal {
        if(discount > 50) revert InvalidDiscount();
        if(commission > 50) revert InvalidCommission();
        referrals[code].discountPercentage = discount;
        referrals[code].commissionPercentage = commission;
        referrals[code].receiver = receiver;
        emit ReferralUpdated(code, receiver, commission, discount);
    }

    modifier onlyAdmin() {
        if (!hasRole(ADMIN_ROLE, msg.sender)) revert AccessDenied();
        _;
    }

    modifier onlyMerkleManager() {
        if (!hasRole(MERKLE_MANAGER_ROLE, msg.sender)) revert AccessDenied();
        _;
    }

    modifier onlyReferralManager() {
        if (!hasRole(REFERRAL_MANAGER_ROLE, msg.sender)) revert AccessDenied();
        _;
    }

    modifier onlyGuardian() {
        if (!hasRole(GUARDIAN_ROLE, msg.sender)) revert AccessDenied();
        _;
    }
}

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

Yes:

• Arbitrum One Sepolia
• Polygon Amoy

Description of What Your Contract Does

We are deploying a transparent upgradeable proxy which fails on estimating the gas for deployment with
Error: execution reverted (no data present; likely require(false) occurred (action="estimateGas", data="0x", reason="require(false)", transaction={ "data": "0x9c4d535b00000000000000000000000000000000000000000000000000000000000000000100059b33df5afb37e373dd250eff83c4f7eac60c15621b4a5e2696b4c2d1aa00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000", "from": "0x96B71AD6b177B9CA96AC7d9b25088F0A956Fa25A", "to": "0x0000000000000000000000000000000000008006" }, invocation=null, revert=null, code=CALL_EXCEPTION, version=6.12.1)

Repo Link (Optional)

No response

Additional Details

No response

[bxpana]

Will check on this and get back to you. Thanks.

[bxpana]

@Archethect do you have any library dependencies? If so, try deploying the library first and then try deploying again.

[Yashiru]

Hey guys,

I have the exact same issue, but I have no external libraries.
Do you have any updates @Archethect ?

Or do you have any other ideas @bxpana ?

I tried to:

• Downgrade to [email protected] & [email protected]
• Deploy using foundry-zksync forge create --zksync

And got the same result.

[Malachy999]

thanks for this guys - i'm keen to know any updates

[kiriyaga-txfusion]

Hello @Archethect ,

I made some minor adjustments to the contract, particularly adding the interface that was missing. I copied the hardhat.config.ts and package.json files, and used both Yarn and npm to install dependencies. In both cases, I successfully deployed the proxy and transferred ownership. Could you add me to your repository so I can take a closer look at your setup?

Here is a proof :D

Note: I checked the zksync-ethers and ethers versions, and they match the versions you guys used and I think that is not a cause.

[Archethect]

@kiriyaga-txfusion The repo is public: https://github.com/PlayFi-Labs/node-license-sale-contracts/tree/develop

Make sure you rename hardhat.config.zksync.ts to hardhat.config.ts before running it.
I also downgraded ethers to 6.11.1 to make it work for now.

[kiriyaga-txfusion]

Hi @Archethect , this is strange behaviour on you side, and what's odd is that I couldn't replicate the error myself.

Here's what I did:

• Cloned your repo from https://github.com/PlayFi-Labs/node-license-sale-contracts.
• Renamed hardhat.config.zksync.ts to hardhat.config.ts.
• Set my .env variables and configured the zkSyncSepolia network as my default.
• Upgraded ethers version to 6.12.2.
• Ran yarn hardhat compile.
• Ran script with with yarn hardhat deploy-zksync --script 00_deploy_playfi_license_sale_zksync.ts.

Everything proceeded without a hitch. What's particularly strange is that I was working on version bumps yesterday, including updating ethers and zksync-ethers, and encountered no errors. All our tests passed on CI too (proof: matter-labs/hardhat-zksync#1111).

Picture proof :D

[Archethect]

Hmmm, weird. Let me try it on my end again and see if it still occurs.

[Archethect]

Ok, After some testing it seems that it is working on my side now as well.
Now I'm wondering what could have caused this... I'm pretty sure that downgrading ethers to 6.11.1 fixed it a month ago.

[Archethect]

Maybe it might have been a mismatch between ethers 6.12.1 and any of the other libraries I used that have since upgraded because newer versions became available?
I'm specifically looking at:

• @matterlabs/hardhat-zksync
• zksync-ethers