diff --git a/AllContractsHashes.json b/AllContractsHashes.json index 4176e9f098..5a04d130cf 100644 --- a/AllContractsHashes.json +++ b/AllContractsHashes.json @@ -87,38 +87,6 @@ "evmBytecodePath": null, "evmDeployedBytecodeHash": null }, - { - "contractName": "system-contracts/DummyChainAssetHandler", - "zkBytecodeHash": "0x010000155973300832b2697d53a543ab1742e89f918eba767e272e79c5e6d3b2", - "zkBytecodePath": "/system-contracts/zkout/DummyChainAssetHandler.sol/DummyChainAssetHandler.json", - "evmBytecodeHash": null, - "evmBytecodePath": null, - "evmDeployedBytecodeHash": null - }, - { - "contractName": "system-contracts/DummyL2AssetRouter", - "zkBytecodeHash": "0x01000013e110725a16943b61efbc6aef12898a846761162d8738500c003cce7c", - "zkBytecodePath": "/system-contracts/zkout/DummyL2AssetRouter.sol/DummyL2AssetRouter.json", - "evmBytecodeHash": null, - "evmBytecodePath": null, - "evmDeployedBytecodeHash": null - }, - { - "contractName": "system-contracts/DummyL2NativeTokenVault", - "zkBytecodeHash": "0x010000173d8ca2f2fcdb53c0f8cd3404aab085d61dbb0b3810144d225f1fd449", - "zkBytecodePath": "/system-contracts/zkout/DummyL2NativeTokenVault.sol/DummyL2NativeTokenVault.json", - "evmBytecodeHash": null, - "evmBytecodePath": null, - "evmDeployedBytecodeHash": null - }, - { - "contractName": "system-contracts/DummyMessageRoot", - "zkBytecodeHash": "0x010000134e39355067d9da937bb94de9853965f6a2bc037081417bbc7d922023", - "zkBytecodePath": "/system-contracts/zkout/DummyMessageRoot.sol/DummyMessageRoot.json", - "evmBytecodeHash": null, - "evmBytecodePath": null, - "evmDeployedBytecodeHash": null - }, { "contractName": "system-contracts/ERC1967Proxy", "zkBytecodeHash": "0x01000099061056e891546ad811105c25405ec2dcfa53acd6a2fe34a008005233", diff --git a/l1-contracts/test/foundry/l1/integration/l2-tests-abstract/_SharedL2ContractDeployer.sol b/l1-contracts/test/foundry/l1/integration/l2-tests-abstract/_SharedL2ContractDeployer.sol index 0a1fd7d125..2e4b052329 100644 --- a/l1-contracts/test/foundry/l1/integration/l2-tests-abstract/_SharedL2ContractDeployer.sol +++ b/l1-contracts/test/foundry/l1/integration/l2-tests-abstract/_SharedL2ContractDeployer.sol @@ -77,7 +77,7 @@ abstract contract SharedL2ContractDeployer is Test, DeployIntegrationUtils { IChainTypeManager internal chainTypeManager; - function setUp() public { + function setUp() public virtual { standardErc20Impl = new BridgedStandardERC20(); beacon = new UpgradeableBeacon(address(standardErc20Impl)); beacon.transferOwnership(ownerWallet); diff --git a/l1-contracts/test/foundry/l2/integration/L2ComplexUpgrader.t.sol b/l1-contracts/test/foundry/l2/integration/L2ComplexUpgrader.t.sol new file mode 100644 index 0000000000..1a0b754168 --- /dev/null +++ b/l1-contracts/test/foundry/l2/integration/L2ComplexUpgrader.t.sol @@ -0,0 +1,34 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.28; + +import {Test} from "forge-std/Test.sol"; + +import {L2ComplexUpgrader} from "contracts/l2-upgrades/L2ComplexUpgrader.sol"; +import {L2_COMPLEX_UPGRADER_ADDR, L2_FORCE_DEPLOYER_ADDR} from "contracts/common/l2-helpers/L2ContractAddresses.sol"; +import {MockContract} from "contracts/dev-contracts/MockContract.sol"; +import {Unauthorized} from "contracts/common/L1ContractErrors.sol"; +import {Utils} from "deploy-scripts/Utils.sol"; + +contract L2ComplexUpgraderTest is Test { + MockContract public dummyUpgrade; + + function setUp() public { + bytes memory code = Utils.readZKFoundryBytecodeL1("L2ComplexUpgrader.sol", "L2ComplexUpgrader"); + vm.etch(L2_COMPLEX_UPGRADER_ADDR, code); + dummyUpgrade = new MockContract(); + } + + function test_RevertWhen_NonForceDeployerCallsUpgrade() public { + vm.expectRevert(abi.encodeWithSelector(Unauthorized.selector, address(this))); + L2ComplexUpgrader(L2_COMPLEX_UPGRADER_ADDR).upgrade(address(dummyUpgrade), hex"deadbeef"); + } + + function test_SuccessfulUpgrade() public { + vm.expectEmit(true, true, false, true, L2_COMPLEX_UPGRADER_ADDR); + emit MockContract.Called(0, hex"deadbeef"); + + vm.prank(L2_FORCE_DEPLOYER_ADDR); + L2ComplexUpgrader(L2_COMPLEX_UPGRADER_ADDR).upgrade(address(dummyUpgrade), hex"deadbeef"); + } +} diff --git a/l1-contracts/test/foundry/l2/integration/L2GenesisUpgrade.t.sol b/l1-contracts/test/foundry/l2/integration/L2GenesisUpgrade.t.sol new file mode 100644 index 0000000000..c1bd67365e --- /dev/null +++ b/l1-contracts/test/foundry/l2/integration/L2GenesisUpgrade.t.sol @@ -0,0 +1,183 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.8.28; + +import {Test} from "forge-std/Test.sol"; + +import {L2ComplexUpgrader} from "contracts/l2-upgrades/L2ComplexUpgrader.sol"; +import {L2GenesisUpgrade} from "contracts/l2-upgrades/L2GenesisUpgrade.sol"; +import {IL2GenesisUpgrade} from "contracts/state-transition/l2-deps/IL2GenesisUpgrade.sol"; +import {L2_COMPLEX_UPGRADER_ADDR, L2_FORCE_DEPLOYER_ADDR, L2_GENESIS_UPGRADE_ADDR, L2_SYSTEM_CONTEXT_SYSTEM_CONTRACT_ADDR, L2_MESSAGE_ROOT_ADDR, L2_BRIDGEHUB_ADDR, L2_ASSET_ROUTER_ADDR, L2_WRAPPED_BASE_TOKEN_IMPL_ADDR, L2_NTV_BEACON_DEPLOYER_ADDR, L2_KNOWN_CODE_STORAGE_SYSTEM_CONTRACT_ADDR, L2_CHAIN_ASSET_HANDLER_ADDR} from "contracts/common/l2-helpers/L2ContractAddresses.sol"; +import {Utils} from "deploy-scripts/Utils.sol"; +import {L2ContractHelper} from "contracts/common/l2-helpers/L2ContractHelper.sol"; +import {FixedForceDeploymentsData, ZKChainSpecificForceDeploymentsData} from "contracts/state-transition/l2-deps/IL2GenesisUpgrade.sol"; +import {L2WrappedBaseToken} from "contracts/bridge/L2WrappedBaseToken.sol"; +import {L2MessageRoot} from "contracts/bridgehub/L2MessageRoot.sol"; +import {L2Bridgehub} from "contracts/bridgehub/L2Bridgehub.sol"; +import {L2AssetRouter} from "contracts/bridge/asset-router/L2AssetRouter.sol"; +import {L2ChainAssetHandler} from "contracts/bridgehub/L2ChainAssetHandler.sol"; +import {UpgradeableBeaconDeployer} from "contracts/bridge/ntv/UpgradeableBeaconDeployer.sol"; +import {SharedL2ContractDeployer} from "../../l1/integration/l2-tests-abstract/_SharedL2ContractDeployer.sol"; +import {SharedL2ContractL2Deployer} from "./_SharedL2ContractL2Deployer.sol"; +import {SystemContractsArgs} from "./L2Utils.sol"; +import {SharedL2ContractL2Deployer} from "./_SharedL2ContractL2Deployer.sol"; +import {ISystemContext} from "contracts/state-transition/l2-deps/ISystemContext.sol"; +import {L2GatewayTestAbstract} from "../../l1/integration/l2-tests-abstract/L2GatewayTestAbstract.t.sol"; +import {SharedL2ContractDeployer} from "../../l1/integration/l2-tests-abstract/_SharedL2ContractDeployer.sol"; +import {Create2FactoryUtils} from "deploy-scripts/Create2FactoryUtils.s.sol"; + +contract L2GenesisUpgradeTest is Test, SharedL2ContractDeployer, SharedL2ContractL2Deployer { + uint256 constant CHAIN_ID = 270; + address ctmDeployerAddress = makeAddr("ctmDeployer"); + address bridgehubOwnerAddress = makeAddr("bridgehubOwner"); + + bytes fixedForceDeploymentsData; + bytes additionalForceDeploymentsData; + + function test() internal virtual override(SharedL2ContractDeployer, SharedL2ContractL2Deployer) {} + + function initSystemContracts( + SystemContractsArgs memory _args + ) internal override(SharedL2ContractDeployer, SharedL2ContractL2Deployer) { + super.initSystemContracts(_args); + } + + function deployViaCreate2( + bytes memory creationCode, + bytes memory constructorArgs + ) internal override(Create2FactoryUtils, SharedL2ContractL2Deployer) returns (address) { + return super.deployViaCreate2(creationCode, constructorArgs); + } + + function deployL2Contracts( + uint256 _l1ChainId + ) public override(SharedL2ContractL2Deployer, SharedL2ContractDeployer) { + super.deployL2Contracts(_l1ChainId); + } + + function setUp() public override { + super.setUp(); + + // Deploy and etch L2ComplexUpgrader + bytes memory complexUpgraderCode = Utils.readZKFoundryBytecodeL1("L2ComplexUpgrader.sol", "L2ComplexUpgrader"); + vm.etch(L2_COMPLEX_UPGRADER_ADDR, complexUpgraderCode); + + // Deploy and etch L2GenesisUpgrade + bytes memory genesisUpgradeCode = Utils.readZKFoundryBytecodeL1("L2GenesisUpgrade.sol", "L2GenesisUpgrade"); + vm.etch(L2_GENESIS_UPGRADE_ADDR, genesisUpgradeCode); + + // Deploy and etch SystemContext + bytes memory systemContextCode = Utils.readZKFoundryBytecodeSystemContracts( + "SystemContext.sol", + "SystemContext" + ); + vm.etch(L2_SYSTEM_CONTEXT_SYSTEM_CONTRACT_ADDR, systemContextCode); + + // Deploy and etch L2WrappedBaseToken + bytes memory wrappedBaseTokenCode = Utils.readZKFoundryBytecodeL1( + "L2WrappedBaseToken.sol", + "L2WrappedBaseToken" + ); + vm.etch(L2_WRAPPED_BASE_TOKEN_IMPL_ADDR, wrappedBaseTokenCode); + + // Deploy and etch UpgradeableBeaconDeployer + new UpgradeableBeaconDeployer(); + bytes memory upgradeableBeaconDeployerCode = Utils.readZKFoundryBytecodeL1( + "UpgradeableBeaconDeployer.sol", + "UpgradeableBeaconDeployer" + ); + vm.etch(L2_NTV_BEACON_DEPLOYER_ADDR, upgradeableBeaconDeployerCode); + + additionalForceDeploymentsData = abi.encode( + ZKChainSpecificForceDeploymentsData({ + baseTokenAssetId: bytes32(0x0100056f53fd9e940906d998a80ed53392e5c50a8eb198baf9f78fd84ce7ec70), + l2LegacySharedBridge: address(0), + predeployedL2WethAddress: address(1), + baseTokenL1Address: address(1), + baseTokenName: "Ether", + baseTokenSymbol: "ETH" + }) + ); + + bytes memory messageRootBytecode = Utils.readZKFoundryBytecodeL1("L2MessageRoot.sol", "L2MessageRoot"); + bytes memory messageRootBytecodeInfo = abi.encode(L2ContractHelper.hashL2Bytecode(messageRootBytecode)); + + bytes memory l2NativeTokenVaultBytecode = Utils.readZKFoundryBytecodeL1( + "L2NativeTokenVault.sol", + "L2NativeTokenVault" + ); + bytes memory l2NtvBytecodeInfo = abi.encode(L2ContractHelper.hashL2Bytecode(l2NativeTokenVaultBytecode)); + + bytes memory l2AssetRouterBytecode = Utils.readZKFoundryBytecodeL1("L2AssetRouter.sol", "L2AssetRouter"); + bytes memory l2AssetRouterBytecodeInfo = abi.encode(L2ContractHelper.hashL2Bytecode(l2AssetRouterBytecode)); + + bytes memory bridgehubBytecode = Utils.readZKFoundryBytecodeL1("L2Bridgehub.sol", "L2Bridgehub"); + bytes memory bridgehubBytecodeInfo = abi.encode(L2ContractHelper.hashL2Bytecode(bridgehubBytecode)); + + bytes memory chainAssetHandlerBytecode = Utils.readZKFoundryBytecodeL1( + "L2ChainAssetHandler.sol", + "L2ChainAssetHandler" + ); + bytes memory chainAssetHandlerBytecodeInfo = abi.encode( + L2ContractHelper.hashL2Bytecode(chainAssetHandlerBytecode) + ); + + bytes memory beaconDeployerBytecode = Utils.readZKFoundryBytecodeL1( + "UpgradeableBeaconDeployer.sol", + "UpgradeableBeaconDeployer" + ); + bytes memory beaconDeployerBytecodeInfo = abi.encode(L2ContractHelper.hashL2Bytecode(beaconDeployerBytecode)); + + fixedForceDeploymentsData = abi.encode( + FixedForceDeploymentsData({ + l1ChainId: 1, + eraChainId: CHAIN_ID, + l1AssetRouter: address(1), + l2TokenProxyBytecodeHash: bytes32(0x0100056f53fd9e940906d998a80ed53392e5c50a8eb198baf9f78fd84ce7ec70), + aliasedL1Governance: address(1), + maxNumberOfZKChains: 100, + bridgehubBytecodeInfo: bridgehubBytecodeInfo, + l2AssetRouterBytecodeInfo: l2AssetRouterBytecodeInfo, + l2NtvBytecodeInfo: l2NtvBytecodeInfo, + messageRootBytecodeInfo: messageRootBytecodeInfo, + chainAssetHandlerBytecodeInfo: chainAssetHandlerBytecodeInfo, + beaconDeployerInfo: beaconDeployerBytecodeInfo, + // For genesis upgrade these values will always be zero + l2SharedBridgeLegacyImpl: address(0), + l2BridgedStandardERC20Impl: address(0), + dangerousTestOnlyForcedBeacon: address(0) + }) + ); + + vm.mockCall( + L2_SYSTEM_CONTEXT_SYSTEM_CONTRACT_ADDR, + abi.encodeWithSelector(ISystemContext.setChainId.selector), + "" + ); + vm.mockCall(L2_BRIDGEHUB_ADDR, abi.encodeWithSelector(L2Bridgehub.initL2.selector), ""); + vm.mockCall(L2_ASSET_ROUTER_ADDR, abi.encodeWithSelector(L2AssetRouter.initL2.selector), ""); + vm.mockCall(L2_CHAIN_ASSET_HANDLER_ADDR, abi.encodeWithSelector(L2ChainAssetHandler.initL2.selector), ""); + vm.mockCall( + L2_KNOWN_CODE_STORAGE_SYSTEM_CONTRACT_ADDR, + abi.encodeWithSelector(bytes4(keccak256("getMarker(bytes32)"))), + abi.encode(1) + ); + } + + function test_SuccessfulGenesisUpgrade() public { + bytes memory genesisUpgradeCalldata = abi.encodeWithSelector( + IL2GenesisUpgrade.genesisUpgrade.selector, + false, // _isZKsyncOS + CHAIN_ID, + ctmDeployerAddress, + fixedForceDeploymentsData, + additionalForceDeploymentsData + ); + + vm.expectEmit(true, false, false, true, L2_COMPLEX_UPGRADER_ADDR); + emit IL2GenesisUpgrade.UpgradeComplete(CHAIN_ID); + + vm.prank(L2_FORCE_DEPLOYER_ADDR); + L2ComplexUpgrader(L2_COMPLEX_UPGRADER_ADDR).upgrade(L2_GENESIS_UPGRADE_ADDR, genesisUpgradeCalldata); + } +} diff --git a/system-contracts/contracts/test-contracts/DummyChainAssetHandler.sol b/system-contracts/contracts/test-contracts/DummyChainAssetHandler.sol deleted file mode 100644 index 77a1f2c8bc..0000000000 --- a/system-contracts/contracts/test-contracts/DummyChainAssetHandler.sol +++ /dev/null @@ -1,9 +0,0 @@ -// SPDX-License-Identifier: MIT - -pragma solidity 0.8.28; - -contract DummyChainAssetHandler { - constructor(uint256 _l1ChainId, address _owner, address _bridgehub, address _assetRouter, address _messageRoot) { - // do nothing - } -} diff --git a/system-contracts/contracts/test-contracts/DummyL2AssetRouter.sol b/system-contracts/contracts/test-contracts/DummyL2AssetRouter.sol deleted file mode 100644 index 10d05dfe91..0000000000 --- a/system-contracts/contracts/test-contracts/DummyL2AssetRouter.sol +++ /dev/null @@ -1,13 +0,0 @@ -// SPDX-License-Identifier: MIT - -pragma solidity 0.8.28; - -contract DummyL2AssetRouter { - constructor( - uint256 _l1ChainId, - address _l1AssetRouter, - address _aliasedL1Governance, - bytes32 _baseTokenAssetId, - uint256 _maxNumberOfZKChains - ) {} -} diff --git a/system-contracts/contracts/test-contracts/DummyL2NativeTokenVault.sol b/system-contracts/contracts/test-contracts/DummyL2NativeTokenVault.sol deleted file mode 100644 index edc4d25403..0000000000 --- a/system-contracts/contracts/test-contracts/DummyL2NativeTokenVault.sol +++ /dev/null @@ -1,15 +0,0 @@ -// SPDX-License-Identifier: MIT - -pragma solidity 0.8.28; - -contract DummyL2NativeTokenVault { - constructor( - uint256 _l1ChainId, - address _aliasedL1Governance, - bytes32 _l2TokenProxyBytecodeHash, - address _bridgedTokenBeacon, - bool _contractsDeployedAlready, - address _wethToken, - bytes32 _baseTokenAssetId - ) {} -} diff --git a/system-contracts/contracts/test-contracts/DummyMessageRoot.sol b/system-contracts/contracts/test-contracts/DummyMessageRoot.sol deleted file mode 100644 index 33b879c274..0000000000 --- a/system-contracts/contracts/test-contracts/DummyMessageRoot.sol +++ /dev/null @@ -1,7 +0,0 @@ -// SPDX-License-Identifier: MIT - -pragma solidity 0.8.28; - -contract DummyMessageRoot { - constructor(address _bridgehub, uint256 _l1ChainId) {} -} diff --git a/system-contracts/test/ComplexUpgrader.spec.ts b/system-contracts/test/ComplexUpgrader.spec.ts deleted file mode 100644 index e9104e0100..0000000000 --- a/system-contracts/test/ComplexUpgrader.spec.ts +++ /dev/null @@ -1,40 +0,0 @@ -import { expect } from "chai"; -import { ethers, network } from "hardhat"; -import type { ComplexUpgrader, MockContract } from "../typechain"; -import { ComplexUpgraderFactory } from "../typechain"; -import { TEST_COMPLEX_UPGRADER_CONTRACT_ADDRESS, TEST_FORCE_DEPLOYER_ADDRESS } from "./shared/constants"; -import { deployContract, deployContractOnAddress, getWallets } from "./shared/utils"; - -describe("ComplexUpgrader tests", function () { - let complexUpgrader: ComplexUpgrader; - let dummyUpgrade: MockContract; - - before(async () => { - const wallet = (await getWallets())[0]; - await deployContractOnAddress(TEST_COMPLEX_UPGRADER_CONTRACT_ADDRESS, "ComplexUpgrader"); - complexUpgrader = ComplexUpgraderFactory.connect(TEST_COMPLEX_UPGRADER_CONTRACT_ADDRESS, wallet); - dummyUpgrade = (await deployContract("MockContract")) as MockContract; - }); - - describe("upgrade", function () { - it("non force deployer failed to call", async () => { - await expect(complexUpgrader.upgrade(dummyUpgrade.address, "0xdeadbeef")).to.be.revertedWithCustomError( - complexUpgrader, - "Unauthorized" - ); - }); - - it("successfully upgraded", async () => { - const force_deployer = await ethers.getImpersonatedSigner(TEST_FORCE_DEPLOYER_ADDRESS); - - await expect(complexUpgrader.connect(force_deployer).upgrade(dummyUpgrade.address, "0xdeadbeef")) - .to.emit(dummyUpgrade.attach(TEST_COMPLEX_UPGRADER_CONTRACT_ADDRESS), "Called") - .withArgs(0, "0xdeadbeef"); - - await network.provider.request({ - method: "hardhat_stopImpersonatingAccount", - params: [TEST_FORCE_DEPLOYER_ADDRESS], - }); - }); - }); -}); diff --git a/system-contracts/test/L2GenesisUpgrade.spec.ts b/system-contracts/test/L2GenesisUpgrade.spec.ts deleted file mode 100644 index d69e4b6560..0000000000 --- a/system-contracts/test/L2GenesisUpgrade.spec.ts +++ /dev/null @@ -1,156 +0,0 @@ -import { expect } from "chai"; -import { ethers, network } from "hardhat"; -import * as zksync from "zksync-ethers"; -import type { ComplexUpgrader, L2GenesisUpgrade } from "../typechain"; -import { ComplexUpgraderFactory, L2GenesisUpgradeFactory } from "../typechain"; -import { - TEST_L2_GENESIS_UPGRADE_CONTRACT_ADDRESS, - TEST_FORCE_DEPLOYER_ADDRESS, - REAL_L2_ASSET_ROUTER_ADDRESS, - REAL_L2_MESSAGE_ROOT_ADDRESS, - REAL_L2_CHAIN_ASSET_HANDLER_ADDRESS, - TEST_COMPLEX_UPGRADER_CONTRACT_ADDRESS, - ADDRESS_ONE, -} from "./shared/constants"; -import { deployContractOnAddress, loadArtifact } from "./shared/utils"; -import { prepareEnvironment, setResult } from "./shared/mocks"; - -describe("L2GenesisUpgrade tests", function () { - let l2GenesisUpgrade: L2GenesisUpgrade; - let complexUpgrader: ComplexUpgrader; - const chainId = 270; - - const ctmDeployerAddress = ethers.utils.hexlify(ethers.utils.randomBytes(20)); - const bridgehubOwnerAddress = ethers.utils.hexlify(ethers.utils.randomBytes(20)); - - const forceDeployments = [ - { - bytecodeHash: "0x0100056f53fd9e940906d998a80ed53392e5c50a8eb198baf9f78fd84ce7ec70", - newAddress: "0x0000000000000000000000000000000000020002", - callConstructor: true, - value: 0, - input: "0x", - }, - ]; - - let fixedForceDeploymentsData: string; - - const additionalForceDeploymentsData = ethers.utils.defaultAbiCoder.encode( - [ - "tuple(bytes32 baseTokenAssetId, address l2LegacySharedBridge, address predeployedL2WethAddress, address baseTokenL1Address, string baseTokenName, string baseTokenSymbol)", - ], - [ - { - baseTokenAssetId: "0x0100056f53fd9e940906d998a80ed53392e5c50a8eb198baf9f78fd84ce7ec70", - l2LegacySharedBridge: ethers.constants.AddressZero, - predeployedL2WethAddress: ADDRESS_ONE, - baseTokenL1Address: ADDRESS_ONE, - baseTokenName: "Ether", - baseTokenSymbol: "ETH", - }, - ] - ); - - before(async () => { - await prepareEnvironment(); - - const wallet = await ethers.getImpersonatedSigner(TEST_FORCE_DEPLOYER_ADDRESS); - await deployContractOnAddress(TEST_COMPLEX_UPGRADER_CONTRACT_ADDRESS, "ComplexUpgrader"); - await deployContractOnAddress(TEST_L2_GENESIS_UPGRADE_CONTRACT_ADDRESS, "L2GenesisUpgrade"); - complexUpgrader = ComplexUpgraderFactory.connect(TEST_COMPLEX_UPGRADER_CONTRACT_ADDRESS, wallet); - l2GenesisUpgrade = L2GenesisUpgradeFactory.connect(TEST_L2_GENESIS_UPGRADE_CONTRACT_ADDRESS, wallet); - - await setResult( - "IBridgehub", - "setAddresses", - [ - REAL_L2_ASSET_ROUTER_ADDRESS, - ctmDeployerAddress, - REAL_L2_MESSAGE_ROOT_ADDRESS, - REAL_L2_CHAIN_ASSET_HANDLER_ADDRESS, - ], - { - failure: false, - returnData: "0x", - } - ); - await setResult("IBridgehub", "owner", [], { - failure: false, - returnData: ethers.utils.defaultAbiCoder.encode(["address"], [bridgehubOwnerAddress]), - }); - - await setResult("SystemContext", "setChainId", [chainId], { - failure: false, - returnData: "0x", - }); - - await setResult("ContractDeployer", "forceDeployOnAddresses", [forceDeployments], { - failure: false, - returnData: "0x", - }); - - const interopRootBytecode = (await loadArtifact("DummyMessageRoot")).bytecode; - const messageRootBytecodeHash = zksync.utils.hashBytecode(interopRootBytecode); - - const ntvBytecode = (await loadArtifact("DummyL2NativeTokenVault")).bytecode; - const ntvBytecodeHash = zksync.utils.hashBytecode(ntvBytecode); - - const l2AssetRouterBytecode = (await loadArtifact("DummyL2AssetRouter")).bytecode; - const l2AssetRouterBytecodeHash = zksync.utils.hashBytecode(l2AssetRouterBytecode); - - const bridgehubBytecode = (await loadArtifact("DummyBridgehub")).bytecode; - const bridgehubBytecodeHash = zksync.utils.hashBytecode(bridgehubBytecode); - - const chainAssetHandlerBytecode = (await loadArtifact("DummyChainAssetHandler")).bytecode; - const chainAssetHandlerBytecodeHash = zksync.utils.hashBytecode(chainAssetHandlerBytecode); - - fixedForceDeploymentsData = ethers.utils.defaultAbiCoder.encode( - [ - "tuple(uint256 l1ChainId, uint256 eraChainId, address l1AssetRouter, bytes32 l2TokenProxyBytecodeHash, address aliasedL1Governance, uint256 maxNumberOfZKChains, bytes32 bridgehubBytecodeHash, bytes32 l2AssetRouterBytecodeHash, bytes32 l2NtvBytecodeHash, bytes32 messageRootBytecodeHash, bytes32 chainAssetHandlerBytecodeHash, address l2SharedBridgeLegacyImpl, address l2BridgedStandardERC20Impl, address dangerousTestOnlyForcedBeacon)", - ], - [ - { - l1ChainId: 1, - eraChainId: 1, - l1AssetRouter: ADDRESS_ONE, - l2TokenProxyBytecodeHash: "0x0100056f53fd9e940906d998a80ed53392e5c50a8eb198baf9f78fd84ce7ec70", - aliasedL1Governance: ADDRESS_ONE, - maxNumberOfZKChains: 100, - bridgehubBytecodeHash: bridgehubBytecodeHash, - l2AssetRouterBytecodeHash: l2AssetRouterBytecodeHash, - l2NtvBytecodeHash: ntvBytecodeHash, - messageRootBytecodeHash: messageRootBytecodeHash, - chainAssetHandlerBytecodeHash: chainAssetHandlerBytecodeHash, - // For genesis upgrade these values will always be zero - l2SharedBridgeLegacyImpl: ethers.constants.AddressZero, - l2BridgedStandardERC20Impl: ethers.constants.AddressZero, - dangerousTestOnlyForcedBeacon: ethers.constants.AddressZero, - }, - ] - ); - }); - - describe("upgrade", function () { - it("successfully upgraded", async () => { - const data = l2GenesisUpgrade.interface.encodeFunctionData("genesisUpgrade", [ - chainId, - ctmDeployerAddress, - fixedForceDeploymentsData, - additionalForceDeploymentsData, - ]); - - // Note, that the event is emitted at the complex upgrader, but the event declaration is taken from the l2GenesisUpgrade contract. - await expect(complexUpgrader.upgrade(l2GenesisUpgrade.address, data)) - .to.emit( - new ethers.Contract(complexUpgrader.address, l2GenesisUpgrade.interface, complexUpgrader.signer), - "UpgradeComplete" - ) - .withArgs(chainId); - - await network.provider.request({ - method: "hardhat_stopImpersonatingAccount", - params: [TEST_FORCE_DEPLOYER_ADDRESS], - }); - }); - }); -});