[DO NOT MERGE] CI EVM Yul

.github/workflows/ci-evm-yul.yml

@@ -0,0 +1,111 @@
+name: CI Yul equivalent EVM
+
+on:
+  pull_request:
+  merge_group:
+  push:
+    branches:
+      - staging
+      - trying
+      - main
+      - evm-equivalence-yul
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    name: Run tests
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+          submodules: "recursive"
+
+      - name: Install Rust
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+
+      - name: Install node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 21.7
+
+      - name: Install yarn
+        run: corepack enable
+        # https://yarnpkg.com/corepack
+
+      - name: Install preprocessor
+        run: npm install -g preprocess-cli-tool
+
+      - name: Install sqlx
+        run: cargo install sqlx-cli@^0.5 --locked
+
+      - name: Download solc
+        run: |
+          curl -L -o bin/solc https://github.com/ethereum/solidity/releases/download/v0.8.24/solc-static-linux \
+            && chmod +x bin/solc
+
+      - name: Download zksolc
+        run: |
+          curl -L -o bin/zksolc https://github.com/matter-labs/zksolc-bin/releases/download/v1.4.0/zksolc-linux-amd64-musl-v1.4.0 \
+            && chmod +x bin/zksolc
+
+      - name: Setup environment
+        run: |
+          echo ZKSYNC_HOME=$(pwd) >> $GITHUB_ENV
+          echo $(pwd)/bin >> $GITHUB_PATH
+          echo IN_DOCKER=1 >> .env
+          echo ZKSYNC_DEBUG_LOGS=true >> .env
+
+      - name: Build system contracts
+        run: |
+          cd contracts/system-contracts \
+            && yarn install \
+            && yarn build
+
+      - name: Build EVM test contracts
+        run: |
+          cd etc/evm-contracts-test-data \
+            && yarn install \
+            && yarn build
+
+      - name: Build zkEVM test contracts
+        run: |
+          cd etc/contracts-test-data \
+            && sed -i 's/zksolc-macosx-arm64/zksolc-linux-amd64-musl/' hardhat.config.ts \
+            && yarn install \
+            && yarn build
+
+      - name: Compile EVM interpreter
+        run: bash recompile_interpreter.sh
+
+      - name: Run unit tests
+        run: ZKSYNC_HOME=$(pwd) cargo test evm_simulator
+        env:
+          RUSTFLAGS: ""
+
+      - name: Start services
+        run: |
+          mkdir -p ./volumes/postgres ./volumes/reth/data
+          docker compose up -d
+
+      - name: Init
+        run: |
+          sed -i 's/zksolc-macosx-arm64/zksolc-linux-amd64-musl/' etc/contracts-test-data/hardhat.config.ts
+          zk
+          zk env dev
+          zk config compile dev
+          zk init
+        env:
+          RUSTFLAGS: ""
+
+      - name: Run integration tests
+        run: |
+          zk server --components "api,tree,eth,state_keeper,housekeeper" >/dev/null &
+          sleep 10
+          cd core/tests/ts-integration && yarn test evm-contracts-test.ts
+        env:
+          RUSTFLAGS: ""

.gitignore

@@ -16,6 +16,7 @@ cobertura.xml
 tags
 *.orig
 .direnv
+.envrc
 
 # Yarn files
 .yarn/

core/lib/contracts/src/lib.rs

@@ -301,7 +301,7 @@ impl BaseSystemContracts {
         // so it is better to rely on more dynamic value instead of disk value
         let evm_simulator_bytecode =
             // read_sys_contract_bytecode("", "EvmInterpreter", ContractLanguage::Sol);
-            read_sys_contract_bytecode("", "EvmInterpreter", ContractLanguage::Yul);
+            read_sys_contract_bytecode("", "EvmInterpreterPreprocessed", ContractLanguage::Yul);
         let evm_simulator_hash = hash_bytecode(&evm_simulator_bytecode);
         let evm_simulator = SystemContractCode {
             code: bytes_to_be_words(evm_simulator_bytecode),

core/lib/multivm/src/tracers/call_tracer/vm_latest/mod.rs

@@ -1,8 +1,10 @@
+use std::str::FromStr;
+
 use zk_evm_1_5_0::{
-    tracing::{AfterExecutionData, VmLocalStateData},
+    tracing::{AfterExecutionData, BeforeExecutionData, VmLocalStateData},
     zkevm_opcode_defs::{
-        FarCallABI, FatPointer, Opcode, RetOpcode, CALL_IMPLICIT_CALLDATA_FAT_PTR_REGISTER,
-        RET_IMPLICIT_RETURNDATA_PARAMS_REGISTER,
+        FarCallABI, FatPointer, Opcode, RetOpcode, UMAOpcode,
+        CALL_IMPLICIT_CALLDATA_FAT_PTR_REGISTER, RET_IMPLICIT_RETURNDATA_PARAMS_REGISTER,
     },
 };
 use zksync_state::{StoragePtr, WriteStorage};
@@ -20,10 +22,77 @@ use crate::{
         VmRevertReason,
     },
     tracers::call_tracer::CallTracer,
-    vm_latest::{BootloaderState, HistoryMode, SimpleMemory, VmTracer, ZkSyncVmState},
+    vm_latest::{
+        utils::heap_page_from_base, BootloaderState, HistoryMode, SimpleMemory, VmTracer,
+        ZkSyncVmState,
+    },
 };
 
 impl<S, H: HistoryMode> DynTracer<S, SimpleMemory<H>> for CallTracer {
+    fn before_execution(
+        &mut self,
+        state: VmLocalStateData<'_>,
+        data: BeforeExecutionData,
+        memory: &SimpleMemory<H>,
+        storage: StoragePtr<S>,
+    ) {
+        // FIXME: this catches not only Evm contracts
+
+        let opcode_variant = data.opcode.variant;
+        let heap_page =
+            heap_page_from_base(state.vm_local_state.callstack.current.base_memory_page).0;
+
+        let src0_value = data.src0_value.value;
+
+        let fat_ptr = FatPointer::from_u256(src0_value);
+
+        let value = data.src1_value.value;
+
+        const DEBUG_SLOT: u32 = 32 * 32;
+
+        let debug_magic = U256::from_dec_str(
+            "33509158800074003487174289148292687789659295220513886355337449724907776218753",
+        )
+        .unwrap();
+
+        // Only `UMA` opcodes in the bootloader serve for vm hooks
+        if !matches!(opcode_variant.opcode, Opcode::UMA(UMAOpcode::HeapWrite))
+            || fat_ptr.offset != DEBUG_SLOT
+            || value != debug_magic
+        {
+            // println!("I tried");
+            return;
+        }
+
+        let how_to_print_value = memory.read_slot(heap_page as usize, 32 + 1).value;
+        let value_to_print = memory.read_slot(heap_page as usize, 32 + 2).value;
+
+        let print_as_hex_value =
+            U256::from_str("0x00debdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebde")
+                .unwrap();
+        let print_as_string_value =
+            U256::from_str("0x00debdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdebdf")
+                .unwrap();
+
+        if how_to_print_value == print_as_hex_value {
+            print!("PRINTED: ");
+            println!("0x{:02x}", value_to_print);
+        }
+
+        if how_to_print_value == print_as_string_value {
+            print!("PRINTED: ");
+            let mut value = value_to_print.0;
+            value.reverse();
+            for limb in value {
+                print!(
+                    "{}",
+                    String::from_utf8(limb.to_be_bytes().to_vec()).unwrap()
+                );
+            }
+            println!("");
+        }
+    }
+
     fn after_execution(
         &mut self,
         state: VmLocalStateData<'_>,