feat: Evm equivalence

l1-contracts/contracts/dev-contracts/test/CustomUpgradeTest.sol

@@ -31,7 +31,12 @@ contract CustomUpgradeTest is BaseZkSyncUpgrade {
         (uint32 newMinorVersion, bool isPatchOnly) = _setNewProtocolVersion(_proposedUpgrade.newProtocolVersion);
         _upgradeL1Contract(_proposedUpgrade.l1ContractsUpgradeCalldata);
         _upgradeVerifier(_proposedUpgrade.verifier, _proposedUpgrade.verifierParams);
-        _setBaseSystemContracts(_proposedUpgrade.bootloaderHash, _proposedUpgrade.defaultAccountHash, isPatchOnly);
+        _setBaseSystemContracts(
+            _proposedUpgrade.bootloaderHash,
+            _proposedUpgrade.defaultAccountHash,
+            _proposedUpgrade.evmSimulatorHash,
+            isPatchOnly
+        );
 
         bytes32 txHash;
         txHash = _setL2SystemContractUpgrade(

l1-contracts/contracts/dev-contracts/test/ExecutorProvingTest.sol

@@ -33,9 +33,14 @@ contract ExecutorProvingTest is ExecutorFacet {
     }
 
     /// Sets the DefaultAccount Hash and Bootloader Hash.
-    function setHashes(bytes32 l2DefaultAccountBytecodeHash, bytes32 l2BootloaderBytecodeHash) external {
+    function setHashes(
+        bytes32 l2DefaultAccountBytecodeHash,
+        bytes32 l2BootloaderBytecodeHash,
+        bytes32 l2EvmSimulatorBytecode
+    ) external {
         s.l2DefaultAccountBytecodeHash = l2DefaultAccountBytecodeHash;
         s.l2BootloaderBytecodeHash = l2BootloaderBytecodeHash;
+        s.l2EvmSimulatorBytecodeHash = l2EvmSimulatorBytecode;
         s.zkPorterIsAvailable = false;
     }
 }

l1-contracts/contracts/state-transition/StateTransitionManager.sol

@@ -356,6 +356,7 @@ contract StateTransitionManager is IStateTransitionManager, ReentrancyGuard, Own
             factoryDeps: bytesEmptyArray,
             bootloaderHash: bytes32(0),
             defaultAccountHash: bytes32(0),
+            evmSimulatorHash: bytes32(0),
             verifier: address(0),
             verifierParams: VerifierParams({
                 recursionNodeLevelVkHash: bytes32(0),

l1-contracts/contracts/state-transition/chain-deps/DiamondInit.sol

@@ -62,6 +62,7 @@ contract DiamondInit is ZkSyncHyperchainBase, IDiamondInit {
         s.__DEPRECATED_verifierParams = _initializeData.verifierParams;
         s.l2BootloaderBytecodeHash = _initializeData.l2BootloaderBytecodeHash;
         s.l2DefaultAccountBytecodeHash = _initializeData.l2DefaultAccountBytecodeHash;
+        s.l2EvmSimulatorBytecodeHash = _initializeData.l2EvmSimulatorBytecodeHash;
         s.priorityTxMaxGasLimit = _initializeData.priorityTxMaxGasLimit;
         s.feeParams = _initializeData.feeParams;
         s.blobVersionedHashRetriever = _initializeData.blobVersionedHashRetriever;

l1-contracts/contracts/state-transition/chain-deps/ZkSyncHyperchainStorage.sol

@@ -98,6 +98,9 @@ struct ZkSyncHyperchainStorage {
     /// @notice Bytecode hash of default account (bytecode for EOA).
     /// @dev Used as an input to zkp-circuit.
     bytes32 l2DefaultAccountBytecodeHash;
+    /// @notice Bytecode hash of evm simulator.
+    /// @dev Used as an input to zkp-circuit.
+    bytes32 l2EvmSimulatorBytecodeHash;
     /// @dev Indicates that the porter may be touched on L2 transactions.
     /// @dev Used as an input to zkp-circuit.
     bool zkPorterIsAvailable;

l1-contracts/contracts/state-transition/chain-deps/facets/Executor.sol

@@ -600,13 +600,13 @@ contract ExecutorFacet is ZkSyncHyperchainBase, IExecutor {
 
     function _batchMetaParameters() internal view returns (bytes memory) {
         bytes32 l2DefaultAccountBytecodeHash = s.l2DefaultAccountBytecodeHash;
+        bytes32 l2EvmSimulatorBytecodeHash = s.l2EvmSimulatorBytecodeHash;
         return
             abi.encodePacked(
                 s.zkPorterIsAvailable,
                 s.l2BootloaderBytecodeHash,
                 l2DefaultAccountBytecodeHash,
-                // VM 1.5.0 requires us to pass the EVM simulator code hash. For now it is the same as the default account.
-                l2DefaultAccountBytecodeHash
+                l2EvmSimulatorBytecodeHash
             );
     }
 

l1-contracts/contracts/state-transition/chain-deps/facets/Getters.sol

@@ -142,6 +142,11 @@ contract GettersFacet is ZkSyncHyperchainBase, IGetters, ILegacyGetters {
         return s.l2DefaultAccountBytecodeHash;
     }
 
+    /// @inheritdoc IGetters
+    function getL2EvmSimulatorBytecodeHash() external view returns (bytes32) {
+        return s.l2EvmSimulatorBytecodeHash;
+    }
+
     /// @inheritdoc IGetters
     function getVerifierParams() external view returns (VerifierParams memory) {
         return s.__DEPRECATED_verifierParams;

l1-contracts/contracts/state-transition/chain-interfaces/IDiamondInit.sol

@@ -36,6 +36,7 @@ struct InitializeData {
     VerifierParams verifierParams;
     bytes32 l2BootloaderBytecodeHash;
     bytes32 l2DefaultAccountBytecodeHash;
+    bytes32 l2EvmSimulatorBytecodeHash;
     uint256 priorityTxMaxGasLimit;
     FeeParams feeParams;
     address blobVersionedHashRetriever;
@@ -53,6 +54,7 @@ struct InitializeDataNewChain {
     VerifierParams verifierParams;
     bytes32 l2BootloaderBytecodeHash;
     bytes32 l2DefaultAccountBytecodeHash;
+    bytes32 l2EvmSimulatorBytecodeHash;
     uint256 priorityTxMaxGasLimit;
     FeeParams feeParams;
     address blobVersionedHashRetriever;

l1-contracts/contracts/state-transition/chain-interfaces/IGetters.sol

@@ -81,6 +81,9 @@ interface IGetters is IZkSyncHyperchainBase {
     /// @return Bytecode hash of default account (bytecode for EOA).
     function getL2DefaultAccountBytecodeHash() external view returns (bytes32);
 
+    /// @return Bytecode hash of EVM simulator.
+    function getL2EvmSimulatorBytecodeHash() external view returns (bytes32);
+
     /// @return Verifier parameters.
     /// @dev This function is deprecated and will soon be removed.
     function getVerifierParams() external view returns (VerifierParams memory);

l1-contracts/contracts/upgrades/BaseZkSyncUpgrade.sol

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: MIT
 
+// solhint-disable reason-string, gas-custom-errors
+
 pragma solidity 0.8.24;
 
 import {SafeCast} from "@openzeppelin/contracts-v4/utils/math/SafeCast.sol";
@@ -33,6 +35,7 @@ struct ProposedUpgrade {
     bytes[] factoryDeps;
     bytes32 bootloaderHash;
     bytes32 defaultAccountHash;
+    bytes32 evmSimulatorHash;
     address verifier;
     VerifierParams verifierParams;
     bytes l1ContractsUpgradeCalldata;
@@ -54,6 +57,8 @@ abstract contract BaseZkSyncUpgrade is ZkSyncHyperchainBase {
     /// @notice Сhanges to the bytecode that is used in L2 as a default account
     event NewL2DefaultAccountBytecodeHash(bytes32 indexed previousBytecodeHash, bytes32 indexed newBytecodeHash);
 
+    event NewL2EvmSimulatorBytecodeHash(bytes32 indexed previousBytecodeHash, bytes32 indexed newBytecodeHash);
+
     /// @notice Verifier address changed
     event NewVerifier(address indexed oldVerifier, address indexed newVerifier);
 
@@ -79,7 +84,12 @@ abstract contract BaseZkSyncUpgrade is ZkSyncHyperchainBase {
         (uint32 newMinorVersion, bool isPatchOnly) = _setNewProtocolVersion(_proposedUpgrade.newProtocolVersion);
         _upgradeL1Contract(_proposedUpgrade.l1ContractsUpgradeCalldata);
         _upgradeVerifier(_proposedUpgrade.verifier, _proposedUpgrade.verifierParams);
-        _setBaseSystemContracts(_proposedUpgrade.bootloaderHash, _proposedUpgrade.defaultAccountHash, isPatchOnly);
+        _setBaseSystemContracts(
+            _proposedUpgrade.bootloaderHash,
+            _proposedUpgrade.defaultAccountHash,
+            _proposedUpgrade.evmSimulatorHash,
+            isPatchOnly
+        );
 
         txHash = _setL2SystemContractUpgrade(
             _proposedUpgrade.l2ProtocolUpgradeTx,
@@ -115,6 +125,26 @@ abstract contract BaseZkSyncUpgrade is ZkSyncHyperchainBase {
         emit NewL2DefaultAccountBytecodeHash(previousDefaultAccountBytecodeHash, _l2DefaultAccountBytecodeHash);
     }
 
+    /// @notice Change default account bytecode hash, that is used on L2
+    /// @param _l2EvmSimulatorBytecodeHash The hash of default account L2 bytecode
+    /// @param _patchOnly Whether only the patch part of the protocol version semver has changed
+    function _setL2EvmSimulatorBytecodeHash(bytes32 _l2EvmSimulatorBytecodeHash, bool _patchOnly) private {
+        if (_l2EvmSimulatorBytecodeHash == bytes32(0)) {
+            return;
+        }
+
+        require(!_patchOnly, "Patch only upgrade can not set new default account");
+
+        L2ContractHelper.validateBytecodeHash(_l2EvmSimulatorBytecodeHash);
+
+        // Save previous value into the stack to put it into the event later
+        bytes32 previousL2EvmSimulatorBytecodeHash = s.l2EvmSimulatorBytecodeHash;
+
+        // Change the default account bytecode hash
+        s.l2EvmSimulatorBytecodeHash = _l2EvmSimulatorBytecodeHash;
+        emit NewL2EvmSimulatorBytecodeHash(previousL2EvmSimulatorBytecodeHash, _l2EvmSimulatorBytecodeHash);
+    }
+
     /// @notice Change bootloader bytecode hash, that is used on L2
     /// @param _l2BootloaderBytecodeHash The hash of bootloader L2 bytecode
     /// @param _patchOnly Whether only the patch part of the protocol version semver has changed
@@ -185,9 +215,15 @@ abstract contract BaseZkSyncUpgrade is ZkSyncHyperchainBase {
     /// @param _bootloaderHash The hash of the new bootloader bytecode. If zero, it will not be updated.
     /// @param _defaultAccountHash The hash of the new default account bytecode. If zero, it will not be updated.
     /// @param _patchOnly Whether only the patch part of the protocol version semver has changed.
-    function _setBaseSystemContracts(bytes32 _bootloaderHash, bytes32 _defaultAccountHash, bool _patchOnly) internal {
+    function _setBaseSystemContracts(
+        bytes32 _bootloaderHash,
+        bytes32 _defaultAccountHash,
+        bytes32 _evmSimulatorHash,
+        bool _patchOnly
+    ) internal {
         _setL2BootloaderBytecodeHash(_bootloaderHash, _patchOnly);
         _setL2DefaultAccountBytecodeHash(_defaultAccountHash, _patchOnly);
+        _setL2EvmSimulatorBytecodeHash(_evmSimulatorHash, _patchOnly);
     }
 
     /// @notice Sets the hash of the L2 system contract upgrade transaction for the next batch to be committed

l1-contracts/deploy-scripts/DeployL1.s.sol

@@ -120,6 +120,7 @@ contract DeployL1Script is Script {
         bytes diamondCutData;
         bytes32 bootloaderHash;
         bytes32 defaultAAHash;
+        bytes32 evmSimulatorHash;
     }
 
     struct TokensConfig {
@@ -442,6 +443,7 @@ contract DeployL1Script is Script {
             verifierParams: verifierParams,
             l2BootloaderBytecodeHash: config.contracts.bootloaderHash,
             l2DefaultAccountBytecodeHash: config.contracts.defaultAAHash,
+            l2EvmSimulatorBytecodeHash: config.contracts.evmSimulatorHash,
             priorityTxMaxGasLimit: config.contracts.priorityTxMaxGasLimit,
             feeParams: feeParams,
             blobVersionedHashRetriever: addresses.blobVersionedHashRetriever

l1-contracts/scripts/token-migration.ts

@@ -233,11 +233,15 @@ export async function transferTokensOnForkedNetwork(deployer: Deployer) {
     const erc20contract = IERC20Factory.connect(tokenAddress, provider);
     console.log(`Migrating token ${tokenAddress}`);
     console.log(
-      `Balance before: ${await erc20contract.balanceOf(deployer.addresses.Bridges.ERC20BridgeProxy)}, ${await erc20contract.balanceOf(deployer.addresses.Bridges.SharedBridgeProxy)}`
+      `Balance before: ${await erc20contract.balanceOf(
+        deployer.addresses.Bridges.ERC20BridgeProxy
+      )}, ${await erc20contract.balanceOf(deployer.addresses.Bridges.SharedBridgeProxy)}`
     );
     await transferTokens(deployer, tokenAddress);
     console.log(
-      `Balance after: ${await erc20contract.balanceOf(deployer.addresses.Bridges.ERC20BridgeProxy)}, ${await erc20contract.balanceOf(deployer.addresses.Bridges.SharedBridgeProxy)}`
+      `Balance after: ${await erc20contract.balanceOf(
+        deployer.addresses.Bridges.ERC20BridgeProxy
+      )}, ${await erc20contract.balanceOf(deployer.addresses.Bridges.SharedBridgeProxy)}`
     );
   }
   for (const tokenAddress of tokenList) {

l1-contracts/scripts/upgrade-consistency-checker.ts

@@ -66,8 +66,9 @@ const expectedGenesisRoot = "0xabdb766b18a479a5c783a4b80e12686bc8ea3cc2d8a305049
 const expectedRecursionNodeLevelVkHash = "0xf520cd5b37e74e19fdb369c8d676a04dce8a19457497ac6686d2bb95d94109c8";
 const expectedRecursionLeafLevelVkHash = "0xf9664f4324c1400fa5c3822d667f30e873f53f1b8033180cd15fe41c1e2355c6";
 const expectedRecursionCircuitsSetVksHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
-const expectedBootloaderHash = "0x010008e742608b21bf7eb23c1a9d0602047e3618b464c9b59c0fba3b3d7ab66e";
-const expectedDefaultAccountHash = "0x01000563374c277a2c1e34659a2a1e87371bb6d852ce142022d497bfb50b9e32";
+const expectedBootloaderHash = "0x010008e7894d0dd14681c76bdb4d5e4e7f6b51bfe40c957d50eed3fec829fdb0";
+const expectedDefaultAccountHash = "0x0100058deb36e1f2eeb48bf3846d0e8eb38e9176754b73116bb41a472459a4dd";
+const expectedEvmSimulatorHash = "0x01000f197081a9906cc411d0698c4961aeb5c74877f37f7071681da6e8ef3f31";
 
 const validatorOne = process.env.ETH_SENDER_SENDER_OPERATOR_COMMIT_ETH_ADDR!;
 const validatorTwo = process.env.ETH_SENDER_SENDER_OPERATOR_BLOBS_ETH_ADDR!;
@@ -221,6 +222,7 @@ async function extractProxyInitializationData(contract: ethers.Contract, data: s
     recursionCircuitsSetVksHash,
     l2BootloaderBytecodeHash,
     l2DefaultAccountBytecodeHash,
+    l2EvmSimulatorBytecodeHash,
     // priorityTxMaxGasLimit,
 
     // // We unpack fee params
@@ -240,6 +242,7 @@ async function extractProxyInitializationData(contract: ethers.Contract, data: s
       "bytes32",
       "bytes32",
       "bytes32",
+      "bytes32",
       "uint256",
       "uint256",
       "uint256",
@@ -276,6 +279,10 @@ async function extractProxyInitializationData(contract: ethers.Contract, data: s
     throw new Error("L2 default account bytecode hash is not correct");
   }
 
+  if (l2EvmSimulatorBytecodeHash.toLowerCase() !== expectedEvmSimulatorHash.toLowerCase()) {
+    throw new Error("L2 default account bytecode hash is not correct");
+  }
+
   console.log("STM init data correct!");
 }
 

l1-contracts/scripts/utils.ts

@@ -70,6 +70,11 @@ export function readSystemContractsBytecode(fileName: string) {
   return JSON.parse(artifact.toString()).bytecode;
 }
 
+export function readEvmSimulatorbytecode() {
+  const systemContractsPath = path.join(process.env.ZKSYNC_HOME as string, "contracts/system-contracts");
+  return fs.readFileSync(`${systemContractsPath}/contracts-preprocessed/artifacts/EvmInterpreter.yul.zbin`);
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function print(name: string, data: any) {
   console.log(`${name}:\n`, JSON.stringify(data, null, 4), "\n");

l1-contracts/src.ts/deploy-process.ts

@@ -16,6 +16,7 @@ import { ADDRESS_ONE } from "../src.ts/utils";
 
 export const L2_BOOTLOADER_BYTECODE_HASH = "0x1000100000000000000000000000000000000000000000000000000000000000";
 export const L2_DEFAULT_ACCOUNT_BYTECODE_HASH = "0x1001000000000000000000000000000000000000000000000000000000000000";
+export const L2_EVM_SIMULATOR_BYTECODE_HASH = "0x1010000000000000000000000000000000000000000000000000000000000000";
 
 export async function initialBridgehubDeployment(
   deployer: Deployer,

l1-contracts/src.ts/deploy-test-process.ts

@@ -15,6 +15,7 @@ import { Deployer } from "./deploy";
 import {
   L2_BOOTLOADER_BYTECODE_HASH,
   L2_DEFAULT_ACCOUNT_BYTECODE_HASH,
+  L2_EVM_SIMULATOR_BYTECODE_HASH,
   initialBridgehubDeployment,
   registerHyperchain,
 } from "./deploy-process";
@@ -65,6 +66,7 @@ export async function defaultDeployerForTests(deployWallet: Wallet, ownerAddress
     addresses: addressConfig,
     bootloaderBytecodeHash: L2_BOOTLOADER_BYTECODE_HASH,
     defaultAccountBytecodeHash: L2_DEFAULT_ACCOUNT_BYTECODE_HASH,
+    evmSimulatorBytecodeHash: L2_EVM_SIMULATOR_BYTECODE_HASH,
   });
 }
 
@@ -76,6 +78,7 @@ export async function defaultEraDeployerForTests(deployWallet: Wallet, ownerAddr
     addresses: addressConfig,
     bootloaderBytecodeHash: L2_BOOTLOADER_BYTECODE_HASH,
     defaultAccountBytecodeHash: L2_DEFAULT_ACCOUNT_BYTECODE_HASH,
+    evmSimulatorBytecodeHash: L2_EVM_SIMULATOR_BYTECODE_HASH,
   });
   const l2_rpc_addr = "http://localhost:3050";
   const web3Provider = new zkethers.Provider(l2_rpc_addr);
@@ -315,6 +318,7 @@ export class EraDeployer extends Deployer {
         verifierParams,
         l2BootloaderBytecodeHash: L2_BOOTLOADER_BYTECODE_HASH,
         l2DefaultAccountBytecodeHash: L2_DEFAULT_ACCOUNT_BYTECODE_HASH,
+        l2EvmSimulatorBytecodeHash: L2_EVM_SIMULATOR_BYTECODE_HASH,
         priorityTxMaxGasLimit,
         feeParams,
         blobVersionedHashRetriever: this.addresses.BlobVersionedHashRetriever,

l1-contracts/src.ts/deploy-utils.ts

@@ -72,7 +72,9 @@ export async function deployBytecodeViaCreate2(
 
   const gasUsed = receipt.gasUsed;
   log(
-    `${contractName} deployed, gasUsed: ${gasUsed.toString()}, tx hash: ${tx.hash}, expected address: ${expectedAddress}`
+    `${contractName} deployed, gasUsed: ${gasUsed.toString()}, tx hash: ${
+      tx.hash
+    }, expected address: ${expectedAddress}`
   );
 
   const deployedBytecodeAfter = await deployWallet.provider.getCode(expectedAddress);

l1-contracts/src.ts/deploy.ts

@@ -10,6 +10,7 @@ import {
   packSemver,
   readBatchBootloaderBytecode,
   readSystemContractsBytecode,
+  readEvmSimulatorbytecode,
   unpackStringSemVer,
 } from "../scripts/utils";
 import { getTokens } from "./deploy-token";
@@ -43,6 +44,7 @@ import type { Contract, Overrides } from "@ethersproject/contracts";
 
 let L2_BOOTLOADER_BYTECODE_HASH: string;
 let L2_DEFAULT_ACCOUNT_BYTECODE_HASH: string;
+let L2_EVM_SIMULATOR_BYTECODE_HASH: string;
 
 export interface DeployerConfig {
   deployWallet: Wallet;
@@ -51,6 +53,7 @@ export interface DeployerConfig {
   verbose?: boolean;
   bootloaderBytecodeHash?: string;
   defaultAccountBytecodeHash?: string;
+  evmSimulatorBytecodeHash?: string;
 }
 
 export interface Operation {
@@ -78,6 +81,9 @@ export class Deployer {
     L2_DEFAULT_ACCOUNT_BYTECODE_HASH = config.defaultAccountBytecodeHash
       ? config.defaultAccountBytecodeHash
       : hexlify(hashL2Bytecode(readSystemContractsBytecode("DefaultAccount")));
+    L2_EVM_SIMULATOR_BYTECODE_HASH = config.evmSimulatorBytecodeHash
+      ? config.evmSimulatorBytecodeHash
+      : hexlify(hashL2Bytecode(readEvmSimulatorbytecode()));
     this.ownerAddress = config.ownerAddress != null ? config.ownerAddress : this.deployWallet.address;
     this.chainId = parseInt(process.env.CHAIN_ETH_ZKSYNC_NETWORK_ID!);
   }
@@ -105,6 +111,7 @@ export class Deployer {
       verifierParams,
       L2_BOOTLOADER_BYTECODE_HASH,
       L2_DEFAULT_ACCOUNT_BYTECODE_HASH,
+      L2_EVM_SIMULATOR_BYTECODE_HASH,
       this.addresses.StateTransition.Verifier,
       this.addresses.BlobVersionedHashRetriever,
       +priorityTxMaxGasLimit,

l1-contracts/src.ts/diamondCut.ts

@@ -35,6 +35,7 @@ export interface InitializeData {
   allowList: BigNumberish;
   l2BootloaderBytecodeHash: string;
   l2DefaultAccountBytecodeHash: string;
+  l2EvmSimulatorBytecodeHash: string;
   priorityTxMaxGasLimit: BigNumberish;
 }