feat: Evm equivalence in yul

.github/workflows/system-contracts-ci.yaml

@@ -100,7 +100,7 @@ jobs:
       - name: Use era-test-node for testing
         uses: dutterbutter/era-test-node-action@v0.1.3
         with:
-          releaseTag: v0.0.1-vm1.4.1
+          releaseTag: v0.0.1-vm1.5.0
 
       - name: Install dependencies
         run: yarn

.gitignore

@@ -16,3 +16,4 @@ tools/data/Verifier.sol
 typechain/
 yarn-debug.log*
 yarn-error.log*
+system-contracts/contracts/EvmInterpreterPreprocessed.yul

.prettierignore

@@ -2,3 +2,10 @@ tools/data
 l1-contracts/lib
 system-contracts/contracts/openzeppelin
 system-contracts/contracts/Constants.sol
+system-contracts/artifacts-zk
+system-contracts/cache-zk
+system-contracts/contracts-preprocessed
+l1-contracts/cache
+l1-contracts/cache-forge
+l1-contracts/artifacts
+l1-contracts/artifacts-forge

.solhintignore

@@ -3,6 +3,7 @@ node_modules
 
 # l1-contracts
 l1-contracts/cache
+l1-contracts/cache-forge
 l1-contracts/lib
 l1-contracts/node_modules
 

l1-contracts/contracts/common/libraries/L2ContractHelper.sol

@@ -40,13 +40,13 @@ library L2ContractHelper {
         uint8 version = uint8(_bytecodeHash[0]);
         require(version == 1 && _bytecodeHash[1] == bytes1(0), "zf"); // Incorrectly formatted bytecodeHash
 
-        require(_bytecodeLen(_bytecodeHash) % 2 == 1, "uy"); // Code length in words must be odd
+        require(bytecodeLen(_bytecodeHash) % 2 == 1, "uy"); // Code length in words must be odd
     }
 
     /// @notice Returns the length of the bytecode associated with the given hash.
     /// @param _bytecodeHash The hash of the bytecode.
     /// @return codeLengthInWords The length of the bytecode in words.
-    function _bytecodeLen(bytes32 _bytecodeHash) private pure returns (uint256 codeLengthInWords) {
+    function bytecodeLen(bytes32 _bytecodeHash) internal pure returns (uint256 codeLengthInWords) {
         codeLengthInWords = uint256(uint8(_bytecodeHash[2])) * 256 + uint256(uint8(_bytecodeHash[3]));
     }
 

l1-contracts/contracts/zksync/facets/Executor.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.20;
 
 import {Base} from "./Base.sol";
 import {COMMIT_TIMESTAMP_NOT_OLDER, COMMIT_TIMESTAMP_APPROXIMATION_DELTA, EMPTY_STRING_KECCAK, L2_TO_L1_LOG_SERIALIZE_SIZE, MAX_L2_TO_L1_LOGS_COMMITMENT_BYTES, PACKED_L2_BLOCK_TIMESTAMP_MASK, PUBLIC_INPUT_SHIFT, POINT_EVALUATION_PRECOMPILE_ADDR} from "../Config.sol";
-import {IExecutor, L2_LOG_ADDRESS_OFFSET, L2_LOG_KEY_OFFSET, L2_LOG_VALUE_OFFSET, SystemLogKey, LogProcessingOutput, PubdataSource, BLS_MODULUS, PUBDATA_COMMITMENT_SIZE, PUBDATA_COMMITMENT_CLAIMED_VALUE_OFFSET, PUBDATA_COMMITMENT_COMMITMENT_OFFSET, MAX_NUMBER_OF_BLOBS} from "../interfaces/IExecutor.sol";
+import {IExecutor, L2_LOG_ADDRESS_OFFSET, L2_LOG_KEY_OFFSET, L2_LOG_VALUE_OFFSET, SystemLogKey, LogProcessingOutput, PubdataSource, BLS_MODULUS, PUBDATA_COMMITMENT_SIZE, PUBDATA_COMMITMENT_CLAIMED_VALUE_OFFSET, PUBDATA_COMMITMENT_COMMITMENT_OFFSET, MAX_NUMBER_OF_BLOBS, TOTAL_BLOBS_IN_COMMITMENT} from "../interfaces/IExecutor.sol";
 import {PriorityQueue, PriorityOperation} from "../libraries/PriorityQueue.sol";
 import {UncheckedMath} from "../../common/libraries/UncheckedMath.sol";
 import {UnsafeBytes} from "../../common/libraries/UnsafeBytes.sol";
@@ -451,7 +451,15 @@ contract ExecutorFacet is Base, IExecutor {
     }
 
     function _batchMetaParameters() internal view returns (bytes memory) {
-        return abi.encodePacked(s.zkPorterIsAvailable, s.l2BootloaderBytecodeHash, s.l2DefaultAccountBytecodeHash);
+        bytes32 l2DefaultAccountBytecodeHash = s.l2DefaultAccountBytecodeHash;
+        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
+            );
     }
 
     function _batchAuxiliaryOutput(
@@ -465,23 +473,44 @@ contract ExecutorFacet is Base, IExecutor {
         bytes32 l2ToL1LogsHash = keccak256(_batch.systemLogs);
 
         return
-            abi.encode(
+            abi.encodePacked(
                 l2ToL1LogsHash,
                 _stateDiffHash,
                 _batch.bootloaderHeapInitialContentsHash,
                 _batch.eventsQueueStateHash,
-                // for each blob we have:
-                // linear hash (hash of preimage from system logs) and
-                // output hash of blob commitments: keccak(versioned hash || opening point || evaluation value)
-                // These values will all be bytes32(0) when we submit pubdata via calldata instead of blobs.
-                // If we only utilize a single blob, _blobHash[1] and _blobCommitments[1] will be bytes32(0)
-                _blobHashes[0],
-                _blobCommitments[0],
-                _blobHashes[1],
-                _blobCommitments[1]
+                _encodeBlobAuxilaryOutput(_blobCommitments, _blobHashes)
             );
     }
 
+    /// @dev Encodes the commitment to blobs to be used in the auxiliary output of the batch commitment
+    /// @param _blobCommitments - the commitments to the blobs
+    /// @param _blobHashes - the hashes of the blobs
+    /// @param blobAuxOutputWords - The circuit commitment to the blobs split into 32-byte words
+    function _encodeBlobAuxilaryOutput(
+        bytes32[] memory _blobCommitments,
+        bytes32[] memory _blobHashes
+    ) internal pure returns (bytes32[] memory blobAuxOutputWords) {
+        // These invariants should be checked by the caller of this function, but we double check
+        // just in case.
+        require(_blobCommitments.length == MAX_NUMBER_OF_BLOBS, "b10");
+        require(_blobHashes.length == MAX_NUMBER_OF_BLOBS, "b11");
+
+        // for each blob we have:
+        // linear hash (hash of preimage from system logs) and
+        // output hash of blob commitments: keccak(versioned hash || opening point || evaluation value)
+        // These values will all be bytes32(0) when we submit pubdata via calldata instead of blobs.
+        //
+        // For now, only up to 2 blobs are supported by the contract, while 16 are required by the circuits.
+        // All the unfilled blobs will have their commitment as 0, including the case when we use only 1 blob.
+
+        blobAuxOutputWords = new bytes32[](2 * TOTAL_BLOBS_IN_COMMITMENT);
+
+        for (uint i = 0; i < MAX_NUMBER_OF_BLOBS; i++) {
+            blobAuxOutputWords[i * 2] = _blobHashes[i];
+            blobAuxOutputWords[i * 2 + 1] = _blobCommitments[i];
+        }
+    }
+
     /// @notice Returns the keccak hash of the ABI-encoded StoredBatchInfo
     function _hashStoredBatchInfo(StoredBatchInfo memory _storedBatchInfo) internal pure returns (bytes32) {
         return keccak256(abi.encode(_storedBatchInfo));

l1-contracts/contracts/zksync/interfaces/IExecutor.sol

@@ -62,6 +62,11 @@ uint256 constant PUBDATA_COMMITMENT_COMMITMENT_OFFSET = 48;
 /// @dev Max number of blobs currently supported
 uint256 constant MAX_NUMBER_OF_BLOBS = 2;
 
+/// @dev The number of blobs that must be present in the commitment to a batch.
+/// It represents the maximal number of blobs that circuits can support and can be larger
+/// than the maximal number of blobs supported by the contract (`MAX_NUMBER_OF_BLOBS`).
+uint256 constant TOTAL_BLOBS_IN_COMMITMENT = 16;
+
 /// @title The interface of the zkSync Executor contract capable of processing events emitted in the zkSync protocol.
 /// @author Matter Labs
 /// @custom:security-contact security@matterlabs.dev

l1-contracts/contracts/zksync/libraries/TransactionValidator.sol

@@ -5,6 +5,7 @@ pragma solidity 0.8.20;
 import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 
 import {IMailbox} from "../interfaces/IMailbox.sol";
+import {L2ContractHelper} from "../../common/libraries/L2ContractHelper.sol";
 import {TX_SLOT_OVERHEAD_L2_GAS, MEMORY_OVERHEAD_GAS, L1_TX_INTRINSIC_L2_GAS, L1_TX_DELTA_544_ENCODING_BYTES, L1_TX_DELTA_FACTORY_DEPS_L2_GAS, L1_TX_MIN_L2_GAS_BASE, L1_TX_INTRINSIC_PUBDATA, L1_TX_DELTA_FACTORY_DEPS_PUBDATA, MAX_GAS_PER_TRANSACTION} from "../Config.sol";
 
 /// @title zkSync Library for validating L1 -> L2 transactions

l1-contracts/scripts/deploy-erc20.ts

@@ -3,6 +3,7 @@ import * as hardhat from "hardhat";
 
 import "@nomiclabs/hardhat-ethers";
 import { Command } from "commander";
+import type { Contract } from "ethers";
 import { Wallet } from "ethers";
 import { parseEther } from "ethers/lib/utils";
 import { web3Provider } from "./utils";
@@ -25,8 +26,64 @@ type Token = {
 
 type TokenDescription = Token & {
   implementation?: string;
+  contract?: Contract;
 };
 
+async function deployContracts(tokens: TokenDescription[], wallet: Wallet): Promise<number> {
+  let nonce = await wallet.getTransactionCount("pending");
+
+  for (const token of tokens) {
+    token.implementation = token.implementation || DEFAULT_ERC20;
+    const tokenFactory = await hardhat.ethers.getContractFactory(token.implementation, wallet);
+    const args = token.implementation !== "WETH9" ? [token.name, token.symbol, token.decimals] : [];
+
+    token.contract = await tokenFactory.deploy(...args, { gasLimit: 5000000, nonce: nonce++ });
+  }
+
+  await Promise.all(tokens.map(async (token) => token.contract.deployTransaction.wait()));
+
+  return nonce;
+}
+
+function getTestAddresses(): string[] {
+  return Array.from(
+    { length: 10 },
+    (_, i) =>
+      Wallet.fromMnemonic(ethTestConfig.test_mnemonic as string, `m/44'/60'/0'/0/${i}`).connect(provider).address
+  );
+}
+
+function unwrapToken(token: TokenDescription): Token {
+  token.address = token.contract.address;
+
+  delete token.contract;
+  if (token.implementation) {
+    delete token.implementation;
+  }
+
+  return token;
+}
+
+async function mintTokens(tokens: TokenDescription[], wallet: Wallet, nonce: number): Promise<Token[]> {
+  const targetAddresses = [wallet.address, ...getTestAddresses()];
+
+  const results = [];
+  const promises = [];
+  for (const token of tokens) {
+    if (token.implementation !== "WETH9") {
+      for (const address of targetAddresses) {
+        const tx = await token.contract.mint(address, parseEther("3000000000"), { nonce: nonce++ });
+        promises.push(tx.wait());
+      }
+    }
+
+    results.push(unwrapToken(token));
+  }
+  await Promise.all(promises);
+
+  return results;
+}
+
 async function deployToken(token: TokenDescription, wallet: Wallet): Promise<Token> {
   token.implementation = token.implementation || DEFAULT_ERC20;
   const tokenFactory = await hardhat.ethers.getContractFactory(token.implementation, wallet);
@@ -36,12 +93,12 @@ async function deployToken(token: TokenDescription, wallet: Wallet): Promise<Tok
 
   if (token.implementation !== "WETH9") {
     await erc20.mint(wallet.address, parseEther("3000000000"));
-  }
-  for (let i = 0; i < 10; ++i) {
-    const testWallet = Wallet.fromMnemonic(ethTestConfig.test_mnemonic as string, "m/44'/60'/0'/0/" + i).connect(
-      provider
-    );
-    if (token.implementation !== "WETH9") {
+
+    for (let i = 0; i < 10; ++i) {
+      const testWallet = Wallet.fromMnemonic(ethTestConfig.test_mnemonic as string, "m/44'/60'/0'/0/" + i).connect(
+        provider
+      );
+
       await erc20.mint(testWallet.address, parseEther("3000000000"));
     }
   }
@@ -90,15 +147,13 @@ async function main() {
     .description("Adds a multiple tokens given in JSON format")
     .action(async (tokens_json: string, cmd) => {
       const tokens: Array<TokenDescription> = JSON.parse(tokens_json);
-      const result = [];
 
       const wallet = cmd.privateKey
         ? new Wallet(cmd.privateKey, provider)
         : Wallet.fromMnemonic(ethTestConfig.mnemonic, "m/44'/60'/0'/0/1").connect(provider);
 
-      for (const token of tokens) {
-        result.push(await deployToken(token, wallet));
-      }
+      const nonce = await deployContracts(tokens, wallet);
+      const result = await mintTokens(tokens, wallet, nonce);
 
       console.log(JSON.stringify(result, null, 2));
     });

l1-contracts/test/foundry/unit/concrete/Utils/Utils.sol

@@ -12,6 +12,9 @@ address constant L2_KNOWN_CODE_STORAGE_ADDRESS = 0x00000000000000000000000000000
 address constant L2_TO_L1_MESSENGER = 0x0000000000000000000000000000000000008008;
 address constant PUBDATA_PUBLISHER_ADDRESS = 0x0000000000000000000000000000000000008011;
 
+uint256 constant MAX_NUMBER_OF_BLOBS = 2;
+uint256 constant TOTAL_BLOBS_IN_COMMITMENT = 16;
+
 library Utils {
     function packBatchTimestampAndBlockTimestamp(
         uint256 batchTimestamp,
@@ -193,7 +196,7 @@ library Utils {
     function _batchMetaParameters() internal pure returns (bytes memory) {
         // Used in __Executor_Shared.t.sol
         bytes8 dummyHash = 0x1234567890123456;
-        return abi.encodePacked(false, bytes32(dummyHash), bytes32(dummyHash));
+        return abi.encodePacked(false, bytes32(dummyHash), bytes32(dummyHash), bytes32(dummyHash));
     }
 
     function _batchAuxiliaryOutput(
@@ -205,20 +208,41 @@ library Utils {
         bytes32 l2ToL1LogsHash = keccak256(_batch.systemLogs);
 
         return
-            abi.encode(
+            abi.encodePacked(
                 l2ToL1LogsHash,
                 _stateDiffHash,
                 _batch.bootloaderHeapInitialContentsHash,
                 _batch.eventsQueueStateHash,
-                // for each blob we have:
-                // linear hash (hash of preimage from system logs) and
-                // output hash of blob commitments: keccak(versioned hash || opening point || evaluation value)
-                // These values will all be bytes32(0) when we submit pubdata via calldata instead of blobs.
-                // If we only utilize a single blob, _blobHash[1] and _blobCommitments[1] will be bytes32(0)
-                _blobHashes[0],
-                _blobCommitments[0],
-                _blobHashes[1],
-                _blobCommitments[1]
+                _encodeBlobAuxilaryOutput(_blobCommitments, _blobHashes)
             );
     }
+
+    /// @dev Encodes the commitment to blobs to be used in the auxiliary output of the batch commitment
+    /// @param _blobCommitments - the commitments to the blobs
+    /// @param _blobHashes - the hashes of the blobs
+    /// @param blobAuxOutputWords - The circuit commitment to the blobs split into 32-byte words
+    function _encodeBlobAuxilaryOutput(
+        bytes32[] memory _blobCommitments,
+        bytes32[] memory _blobHashes
+    ) internal pure returns (bytes32[] memory blobAuxOutputWords) {
+        // These invariants should be checked by the caller of this function, but we double check
+        // just in case.
+        require(_blobCommitments.length == MAX_NUMBER_OF_BLOBS, "b10");
+        require(_blobHashes.length == MAX_NUMBER_OF_BLOBS, "b11");
+
+        // for each blob we have:
+        // linear hash (hash of preimage from system logs) and
+        // output hash of blob commitments: keccak(versioned hash || opening point || evaluation value)
+        // These values will all be bytes32(0) when we submit pubdata via calldata instead of blobs.
+        //
+        // For now, only up to 2 blobs are supported by the contract, while 16 are required by the circuits.
+        // All the unfilled blobs will have their commitment as 0, including the case when we use only 1 blob.
+
+        blobAuxOutputWords = new bytes32[](2 * TOTAL_BLOBS_IN_COMMITMENT);
+
+        for (uint i = 0; i < MAX_NUMBER_OF_BLOBS; i++) {
+            blobAuxOutputWords[i * 2] = _blobHashes[i];
+            blobAuxOutputWords[i * 2 + 1] = _blobCommitments[i];
+        }
+    }
 }

l1-contracts/test/unit_tests/executor_proof.spec.ts

@@ -56,7 +56,7 @@ describe("Executor test", function () {
     );
     console.log("This block Commitment is : " + nextCommitment);
     expect(nextCommitment, "Commitment computation failed").is.equal(
-      "0x38ba669c30ce03475c4139fdab5d43fd8edd78f50ee3e99101cc55ad29b6efb0"
+      "0xab2238ade1c47671daadd8859d3f40986daf53a9349716fca57e6679e5dc1ece"
     );
 
     const prevCommitment = "0x6ebf945305689a8c3ac993df7f002d41d311a762cd6bf39bb054ead8d1f54404";
@@ -66,6 +66,6 @@ describe("Executor test", function () {
       // ignored.
       recursionCircuitsSetVksHash: "0x05dc05911af0aee6a0950ee36dad423981cf05a58cfdb479109bff3c2262eaac",
     });
-    expect(result.toHexString(), "").to.be.equal("0x3449f2e7025a7731ca98a7a232211f88ae4e5e8ae2ce41fd40866f7b");
+    expect(result.toHexString(), "").to.be.equal("0x23ef2434974fa8d0f7f7d29839aaa78fe767bf36edb3a5979d60a6b0");
   });
 });