Merge pull request #16 from Moonsong-Labs/aon/feat-add-vm-warp-cheatcode

aon · web-flow · commit a2e6888df147 · 2023-11-22T15:27:34.000-03:00
Add vm.warp cheatcode
diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml
@@ -38,11 +38,13 @@ jobs:
         uses: actions/configure-pages@v3
 
       - name: Install mdbook
-        run: cargo +nightly install mdbook
+        run: cargo install mdbook
+
       - name: Generate rust docs
         run: |
           echo "Generating docs..."
-          cargo +nightly doc --no-deps
+          cargo doc --no-deps
+
       - name: Make index.html
         run: echo '<!DOCTYPE HTML>
           <html lang="en-US">
diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml
@@ -31,3 +31,31 @@ jobs:
         
     - name: Run tests
       run: cargo nextest run
+  
+  smoke-test:
+    name: smoke-test
+    runs-on: ubuntu-22.04-github-hosted-16core
+    env:
+      TEST_REPO_DIR: test-repo
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4 
+      with:
+        path: ${{ env.TEST_REPO_DIR }}
+        ref: ${{ github.event.pull_request.head.sha }}
+    
+    - name: Install Rust
+      uses: actions-rust-lang/setup-rust-toolchain@v1
+      with:
+        toolchain: nightly-2023-07-23
+    
+    - name: Run smoke-test
+      env:
+        TEST_REPO: ${{ github.event.repository.name }}
+        TEST_REPO_DIR: "../${{ env.TEST_REPO_DIR }}"
+        RUST_BACKTRACE: full
+      run: |
+        git clone https://github.com/matter-labs/zkfoundry-smoke-test
+        cd zkfoundry-smoke-test
+        ./smoke-test.sh
diff --git a/e2e-tests/contracts/TestCheatcodes.sol b/e2e-tests/contracts/TestCheatcodes.sol
@@ -25,4 +25,15 @@ contract TestCheatcodes {
     (bool success, ) = CHEATCODE_ADDRESS.call(abi.encodeWithSignature("setNonce(address,uint64)", account, nonce));
     require(success, "setNonce failed");
   }
+
+  function warp(uint256 timestamp) external {
+    uint256 initialTimestamp = block.timestamp;
+    require(timestamp != initialTimestamp, "timestamp must be different than current block timestamp");
+
+    (bool success, ) = CHEATCODE_ADDRESS.call(abi.encodeWithSignature("warp(uint256)", timestamp));
+    require(success, "warp failed");
+
+    uint256 finalTimestamp = block.timestamp;
+    require(finalTimestamp == timestamp, "timestamp was not changed");
+  }
 }
diff --git a/e2e-tests/test/cheatcodes.test.ts b/e2e-tests/test/cheatcodes.test.ts
@@ -80,4 +80,27 @@ describe("Cheatcodes", function () {
     // Assert
     expect(receipt.status).to.eq(1);
   });
+
+  it("Should test vm.warp", async function () {
+    // Arrange
+    const wallet = new Wallet(RichAccounts[0].PrivateKey);
+    const deployer = new Deployer(hre, wallet);
+
+    const timeIncreaseInMS = 123;
+    let expectedTimestamp: number = await provider.send("config_getCurrentTimestamp", []);
+    expectedTimestamp += timeIncreaseInMS;
+
+    // Act
+    const cheatcodes = await deployContract(deployer, "TestCheatcodes", []);
+    const tx = await cheatcodes.warp(expectedTimestamp, {
+      gasLimit: 1000000,
+    });
+    expectedTimestamp += 2; // New transaction will add two blocks
+    const receipt = await tx.wait();
+
+    // Assert
+    expect(receipt.status).to.eq(1);
+    const newBlockTimestamp = (await provider.getBlock("latest")).timestamp;
+    expect(newBlockTimestamp).to.equal(expectedTimestamp);
+  });
 });
diff --git a/rust-toolchain b/rust-toolchain
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly-2023-07-23"
+components = ["rustfmt", "clippy"]
diff --git a/src/bootloader_debug.rs b/src/bootloader_debug.rs
@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use multivm::vm_virtual_blocks::{
-    constants::BOOTLOADER_HEAP_PAGE, BootloaderState, DynTracer, ExecutionEndTracer,
-    ExecutionProcessing, HistoryMode, SimpleMemory, VmExecutionStopReason, VmTracer, ZkSyncVmState,
+use multivm::vm_latest::{
+    constants::BOOTLOADER_HEAP_PAGE, BootloaderState, DynTracer, HistoryMode, SimpleMemory,
+    VmExecutionStopReason, VmTracer, ZkSyncVmState,
 };
 use once_cell::sync::OnceCell;
 use zksync_basic_types::U256;
@@ -83,7 +83,13 @@ pub struct BootloaderDebugTracer {
 
 impl<S, H: HistoryMode> DynTracer<S, H> for BootloaderDebugTracer {}
 
-impl<S: WriteStorage, H: HistoryMode> ExecutionProcessing<S, H> for BootloaderDebugTracer {
+fn load_debug_slot<H: HistoryMode>(memory: &SimpleMemory<H>, slot: usize) -> U256 {
+    memory
+        .read_slot(BOOTLOADER_HEAP_PAGE as usize, DEBUG_START_SLOT + slot)
+        .value
+}
+
+impl<S: WriteStorage, H: HistoryMode> VmTracer<S, H> for BootloaderDebugTracer {
     fn after_vm_execution(
         &mut self,
         state: &mut ZkSyncVmState<S, H>,
@@ -96,16 +102,6 @@ impl<S: WriteStorage, H: HistoryMode> ExecutionProcessing<S, H> for BootloaderDe
     }
 }
 
-fn load_debug_slot<H: HistoryMode>(memory: &SimpleMemory<H>, slot: usize) -> U256 {
-    memory
-        .read_slot(BOOTLOADER_HEAP_PAGE as usize, DEBUG_START_SLOT + slot)
-        .value
-}
-
-impl<H: HistoryMode> ExecutionEndTracer<H> for BootloaderDebugTracer {}
-
-impl<S: WriteStorage, H: HistoryMode> VmTracer<S, H> for BootloaderDebugTracer {}
-
 impl BootloaderDebug {
     pub fn load_from_memory<H: HistoryMode>(
         memory: &SimpleMemory<H>,
diff --git a/src/cheatcodes.rs b/src/cheatcodes.rs
@@ -1,22 +1,28 @@
-use crate::{node::InMemoryNodeInner, utils::bytecode_to_factory_dep};
-use anyhow::{anyhow, Result};
+use crate::{
+    node::{BlockContext, InMemoryNodeInner},
+    utils::bytecode_to_factory_dep,
+};
 use ethers::{abi::AbiDecode, prelude::abigen};
 use multivm::{
+    interface::L1BatchEnv,
     vm_1_3_2::zk_evm_1_3_3::{
-        tracing::{AfterExecutionData, BeforeExecutionData, VmLocalStateData},
+        tracing::{BeforeExecutionData, VmLocalStateData},
         zkevm_opcode_defs::all::Opcode,
         zkevm_opcode_defs::{FatPointer, CALL_IMPLICIT_CALLDATA_FAT_PTR_REGISTER},
     },
-    vm_virtual_blocks::{
-        DynTracer, ExecutionEndTracer, ExecutionProcessing, HistoryMode, SimpleMemory, VmTracer,
-    },
+    vm_latest::{DynTracer, HistoryMode, SimpleMemory, VmTracer},
+};
+use std::{
+    fmt::Debug,
+    sync::{Arc, Mutex, RwLock},
 };
-use std::sync::{Arc, RwLock};
-use zksync_basic_types::{H160, H256};
+use zksync_basic_types::{AccountTreeId, H160, H256};
 use zksync_state::{StoragePtr, WriteStorage};
 use zksync_types::{
+    block::{pack_block_info, unpack_block_info},
     get_code_key, get_nonce_key,
     utils::{decompose_full_nonce, nonces_to_full_nonce, storage_key_for_eth_balance},
+    StorageKey,
 };
 use zksync_utils::{h256_to_u256, u256_to_h256};
 
@@ -27,11 +33,12 @@ const CHEATCODE_ADDRESS: H160 = H160([
 
 #[derive(Clone, Debug, Default)]
 pub struct CheatcodeTracer<F> {
-    factory_deps: F,
+    node_ctx: F,
 }
 
-pub trait FactoryDeps {
-    fn store_factory_dep(&mut self, hash: H256, bytecode: Vec<u8>) -> Result<()>;
+pub trait NodeCtx {
+    fn set_time(&mut self, time: u64);
+    fn store_factory_dep(&mut self, hash: H256, bytecode: Vec<u8>);
 }
 
 abigen!(
@@ -40,10 +47,11 @@ abigen!(
         function deal(address who, uint256 newBalance)
         function etch(address who, bytes calldata code)
         function setNonce(address account, uint64 nonce)
+        function warp(uint256 timestamp)
     ]"#
 );
 
-impl<F: FactoryDeps, S: WriteStorage, H: HistoryMode> DynTracer<S, H> for CheatcodeTracer<F> {
+impl<F: NodeCtx, S: WriteStorage, H: HistoryMode> DynTracer<S, H> for CheatcodeTracer<F> {
     fn before_execution(
         &mut self,
         state: VmLocalStateData<'_>,
@@ -86,16 +94,11 @@ impl<F: FactoryDeps, S: WriteStorage, H: HistoryMode> DynTracer<S, H> for Cheatc
     }
 }
 
-impl<F: FactoryDeps + Send, S: WriteStorage, H: HistoryMode> VmTracer<S, H> for CheatcodeTracer<F> {}
-impl<F: FactoryDeps, H: HistoryMode> ExecutionEndTracer<H> for CheatcodeTracer<F> {}
-impl<F: FactoryDeps, S: WriteStorage, H: HistoryMode> ExecutionProcessing<S, H>
-    for CheatcodeTracer<F>
-{
-}
+impl<F: NodeCtx + Send, S: WriteStorage, H: HistoryMode> VmTracer<S, H> for CheatcodeTracer<F> {}
 
-impl<F: FactoryDeps> CheatcodeTracer<F> {
-    pub fn new(factory_deps: F) -> Self {
-        Self { factory_deps }
+impl<F: NodeCtx> CheatcodeTracer<F> {
+    pub fn new(node_ctx: F) -> Self {
+        Self { node_ctx }
     }
 
     fn dispatch_cheatcode<S: WriteStorage, H: HistoryMode>(
@@ -119,7 +122,7 @@ impl<F: FactoryDeps> CheatcodeTracer<F> {
                 let code_key = get_code_key(&who);
                 let (hash, code) = bytecode_to_factory_dep(code.0.into());
                 let hash = u256_to_h256(hash);
-                if let Err(err) = self.factory_deps.store_factory_dep(
+                self.node_ctx.store_factory_dep(
                     hash,
                     code.iter()
                         .flat_map(|entry| {
@@ -128,13 +131,7 @@ impl<F: FactoryDeps> CheatcodeTracer<F> {
                             bytes.to_vec()
                         })
                         .collect(),
-                ) {
-                    tracing::error!(
-                        "Etch cheatcode failed, failed to store factory dep: {:?}",
-                        err
-                    );
-                    return;
-                }
+                );
                 storage.borrow_mut().set_value(code_key, hash);
             }
             SetNonce(SetNonceCall { account, nonce }) => {
@@ -170,17 +167,58 @@ impl<F: FactoryDeps> CheatcodeTracer<F> {
                 );
                 storage.set_value(nonce_key, u256_to_h256(enforced_full_nonce));
             }
+            Warp(WarpCall { timestamp }) => {
+                tracing::info!("Setting block timestamp {}", timestamp);
+                self.node_ctx.set_time(timestamp.as_u64());
+
+                let key = StorageKey::new(
+                    AccountTreeId::new(zksync_types::SYSTEM_CONTEXT_ADDRESS),
+                    zksync_types::CURRENT_VIRTUAL_BLOCK_INFO_POSITION,
+                );
+                let mut storage = storage.borrow_mut();
+                let (block_number, _) = unpack_block_info(h256_to_u256(storage.read_value(&key)));
+                storage.set_value(
+                    key,
+                    u256_to_h256(pack_block_info(block_number, timestamp.as_u64())),
+                );
+            }
         };
     }
 }
 
-impl<T> FactoryDeps for Arc<RwLock<InMemoryNodeInner<T>>> {
-    fn store_factory_dep(&mut self, hash: H256, bytecode: Vec<u8>) -> Result<()> {
-        self.try_write()
-            .map_err(|e| anyhow!(format!("Failed to grab write lock: {e}")))?
+pub struct CheatcodeNodeContext<T> {
+    pub in_memory_node_inner: Arc<RwLock<InMemoryNodeInner<T>>>,
+    pub batch_env: Arc<Mutex<L1BatchEnv>>,
+    pub block_ctx: Arc<Mutex<BlockContext>>,
+}
+
+impl<T> CheatcodeNodeContext<T> {
+    pub fn new(
+        in_memory_node_inner: Arc<RwLock<InMemoryNodeInner<T>>>,
+        batch_env: Arc<Mutex<L1BatchEnv>>,
+        block_ctx: Arc<Mutex<BlockContext>>,
+    ) -> Self {
+        Self {
+            in_memory_node_inner,
+            batch_env,
+            block_ctx,
+        }
+    }
+}
+
+impl<T> NodeCtx for CheatcodeNodeContext<T> {
+    fn set_time(&mut self, time: u64) {
+        self.in_memory_node_inner.write().unwrap().current_timestamp = time;
+        self.batch_env.lock().unwrap().timestamp = time + 1;
+        self.block_ctx.lock().unwrap().timestamp = time + 1;
+    }
+
+    fn store_factory_dep(&mut self, hash: H256, bytecode: Vec<u8>) {
+        self.in_memory_node_inner
+            .write()
+            .unwrap()
             .fork_storage
-            .store_factory_dep(hash, bytecode);
-        Ok(())
+            .store_factory_dep(hash, bytecode)
     }
 }
 
diff --git a/src/node/eth.rs b/src/node/eth.rs
@@ -223,7 +223,7 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> EthNamespa
 
                     Ok(Some(block))
                 }
-                None => Err(into_jsrpc_error(Web3Error::NoBlock)),
+                None => Ok(None),
             }
         })
     }
@@ -451,7 +451,7 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> EthNamespa
 
                     Ok(Some(block))
                 }
-                None => Err(into_jsrpc_error(Web3Error::NoBlock)),
+                None => Ok(None),
             }
         })
     }
@@ -814,7 +814,7 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> EthNamespa
     ///
     /// A `BoxFuture` containing a `jsonrpc_core::Result` that resolves to an array of logs, block hashes, or transaction hashes,
     /// depending on the filter type, which occurred since last poll.
-    /// * Filters created with `eth_newFilter` return [Log] objects.
+    /// * Filters created with `eth_newFilter` return [zksync_types::api::Log] objects.
     /// * Filters created with `eth_newBlockFilter` return block hashes.
     /// * Filters created with `eth_newPendingTransactionFilter` return transaction hashes.
     fn get_filter_changes(&self, id: U256) -> RpcResult<FilterChanges> {
@@ -1365,13 +1365,15 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_get_block_by_hash_produces_no_block_error_for_non_existing_block() {
+    async fn test_get_block_by_hash_returns_none_for_non_existing_block() {
         let node = InMemoryNode::<HttpForkSource>::default();
 
-        let expected_err = into_jsrpc_error(Web3Error::NoBlock);
-        let result = node.get_block_by_hash(H256::repeat_byte(0x01), false).await;
+        let result = node
+            .get_block_by_hash(H256::repeat_byte(0x01), false)
+            .await
+            .expect("failed fetching block by hash");
 
-        assert_eq!(expected_err, result.unwrap_err());
+        assert!(result.is_none());
     }
 
     #[tokio::test]
@@ -1514,15 +1516,15 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_get_block_by_number_produces_no_block_error_for_non_existing_block() {
+    async fn test_get_block_by_number_returns_none_for_non_existing_block() {
         let node = InMemoryNode::<HttpForkSource>::default();
 
-        let expected_err = into_jsrpc_error(Web3Error::NoBlock);
         let result = node
             .get_block_by_number(BlockNumber::Number(U64::from(42)), false)
-            .await;
+            .await
+            .expect("failed fetching block by number");
 
-        assert_eq!(expected_err, result.unwrap_err());
+        assert!(result.is_none());
     }
 
     #[tokio::test]
diff --git a/src/node/in_memory.rs b/src/node/in_memory.rs
diff --git a/src/node/zks.rs b/src/node/zks.rs
diff --git a/src/testing.rs b/src/testing.rs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+[toolchain]`
	`2`	`+channel = "nightly-2023-07-23"`
	`3`	`+components = ["rustfmt", "clippy"]`
Original file line number	Diff line number	Diff line change
`@@ -223,7 +223,7 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> EthNamespa`
`223`	`223`
`224`	`224`	`Ok(Some(block))`
`225`	`225`	`}`
`226`		`- None => Err(into_jsrpc_error(Web3Error::NoBlock)),`
	`226`	`+ None => Ok(None),`
`227`	`227`	`}`
`228`	`228`	`})`
`229`	`229`	`}`
`@@ -451,7 +451,7 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> EthNamespa`
`451`	`451`
`452`	`452`	`Ok(Some(block))`
`453`	`453`	`}`
`454`		`- None => Err(into_jsrpc_error(Web3Error::NoBlock)),`
	`454`	`+ None => Ok(None),`
`455`	`455`	`}`
`456`	`456`	`})`
`457`	`457`	`}`
`@@ -814,7 +814,7 @@ impl<S: ForkSource + std::fmt::Debug + Clone + Send + Sync + 'static> EthNamespa`
`814`	`814`	`///`
`815`	`815`	/// A `BoxFuture` containing a `jsonrpc_core::Result` that resolves to an array of logs, block hashes, or transaction hashes,
`816`	`816`	`/// depending on the filter type, which occurred since last poll.`
`817`		- /// * Filters created with `eth_newFilter` return [Log] objects.
	`817`	+ /// * Filters created with `eth_newFilter` return [zksync_types::api::Log] objects.
`818`	`818`	/// * Filters created with `eth_newBlockFilter` return block hashes.
`819`	`819`	/// * Filters created with `eth_newPendingTransactionFilter` return transaction hashes.
`820`	`820`	`fn get_filter_changes(&self, id: U256) -> RpcResult<FilterChanges> {`
`@@ -1365,13 +1365,15 @@ mod tests {`
`1365`	`1365`	`}`
`1366`	`1366`
`1367`	`1367`	`#[tokio::test]`
`1368`		`- async fn test_get_block_by_hash_produces_no_block_error_for_non_existing_block() {`
	`1368`	`+ async fn test_get_block_by_hash_returns_none_for_non_existing_block() {`
`1369`	`1369`	`let node = InMemoryNode::<HttpForkSource>::default();`
`1370`	`1370`
`1371`		`- let expected_err = into_jsrpc_error(Web3Error::NoBlock);`
`1372`		`- let result = node.get_block_by_hash(H256::repeat_byte(0x01), false).await;`
	`1371`	`+ let result = node`
	`1372`	`+ .get_block_by_hash(H256::repeat_byte(0x01), false)`
	`1373`	`+ .await`
	`1374`	`+ .expect("failed fetching block by hash");`
`1373`	`1375`
`1374`		`- assert_eq!(expected_err, result.unwrap_err());`
	`1376`	`+ assert!(result.is_none());`
`1375`	`1377`	`}`
`1376`	`1378`
`1377`	`1379`	`#[tokio::test]`
`@@ -1514,15 +1516,15 @@ mod tests {`
`1514`	`1516`	`}`
`1515`	`1517`
`1516`	`1518`	`#[tokio::test]`
`1517`		`- async fn test_get_block_by_number_produces_no_block_error_for_non_existing_block() {`
	`1519`	`+ async fn test_get_block_by_number_returns_none_for_non_existing_block() {`
`1518`	`1520`	`let node = InMemoryNode::<HttpForkSource>::default();`
`1519`	`1521`
`1520`		`- let expected_err = into_jsrpc_error(Web3Error::NoBlock);`
`1521`	`1522`	`let result = node`
`1522`	`1523`	`.get_block_by_number(BlockNumber::Number(U64::from(42)), false)`
`1523`		`- .await;`
	`1524`	`+ .await`
	`1525`	`+ .expect("failed fetching block by number");`
`1524`	`1526`
`1525`		`- assert_eq!(expected_err, result.unwrap_err());`
	`1527`	`+ assert!(result.is_none());`
`1526`	`1528`	`}`
`1527`	`1529`
`1528`	`1530`	`#[tokio::test]`