feat: add vm.addr cheatcode

e2e-tests/contracts/TestCheatcodes.sol

@@ -5,6 +5,13 @@ pragma solidity ^0.8.0;
 contract TestCheatcodes {
   address constant CHEATCODE_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;
 
+  function testAddr(uint256 privateKey, address addr) external {
+    (bool success, bytes memory data) = CHEATCODE_ADDRESS.call(abi.encodeWithSignature("addr(uint256)", privateKey));
+    require(success, "addr failed");
+    address recovered = abi.decode(data, (address));
+    require(recovered == addr, "address mismatch");
+  }
+
   function testDeal(address account, uint256 amount) external {
     uint balanceBefore = address(account).balance;
     (bool success, ) = CHEATCODE_ADDRESS.call(abi.encodeWithSignature("deal(address,uint256)", account, amount));

e2e-tests/test/cheatcodes.test.ts

@@ -8,6 +8,23 @@ import { deployContract, getTestProvider } from "../helpers/utils";
 const provider = getTestProvider();
 
 describe("Cheatcodes", function () {
+  it("Should test vm.addr", async function () {
+    // Arrange
+    const wallet = new Wallet(RichAccounts[0].PrivateKey);
+    const deployer = new Deployer(hre, wallet);
+    const randomWallet = Wallet.createRandom().connect(provider);
+
+    // Act
+    const greeter = await deployContract(deployer, "TestCheatcodes", []);
+    const tx = await greeter.testAddr(randomWallet.privateKey, randomWallet.address, {
+      gasLimit: 1000000,
+    });
+    const receipt = await tx.wait();
+
+    // Assert
+    expect(receipt.status).to.eq(1);
+  });
+
   it("Should test vm.deal", async function () {
     // Arrange
     const wallet = new Wallet(RichAccounts[0].PrivateKey);

src/cheatcodes.rs

@@ -52,6 +52,7 @@
 abigen!(
     CheatcodeContract,
     r#"[
+        function addr(uint256 privateKey)
         function deal(address who, uint256 newBalance)
         function etch(address who, bytes calldata code)
         function setNonce(address account, uint64 nonce)
@@ -170,6 +171,16 @@
     ) {
         use CheatcodeContractCalls::*;
         match call {
+            Addr(AddrCall { private_key }) => {
+                tracing::info!("Getting address for private key");
+                let Ok(address) = zksync_types::PackedEthSignature::address_from_private_key(
+                    &u256_to_h256(private_key),
+                ) else {
+                    tracing::error!("Failed generating address for private key");
+                    return;
+                };
+                self.returndata = Some(vec![h256_to_u256(address.into())]);
+            }
             Deal(DealCall { who, new_balance }) => {
                 tracing::info!("Setting balance for {who:?} to {new_balance}");
                 storage
@@ -205,7 +216,7 @@
                     account_nonce.as_u64()
                 );
                 tracing::info!("👷 Setting returndata",);
-                self.returndata = Some(vec![account_nonce.into()]);
+                self.returndata = Some(vec![account_nonce]);
             }
             SetNonce(SetNonceCall { account, nonce }) => {
                 tracing::info!("Setting nonce for {account:?} to {nonce}");
@@ -318,14 +329,14 @@
     use crate::{
         deps::system_contracts::bytecode_from_slice,
         http_fork_source::HttpForkSource,
         node::{InMemoryNode, TransactionResult},
         testing::{self, LogBuilder, TransactionBuilder},
     };
     use ethers::abi::{short_signature, AbiEncode, HumanReadableParser, ParamType, Token};
     use zksync_basic_types::{Address, L2ChainId, Nonce, H160, H256, U256};
     use zksync_core::api_server::web3::backend_jsonrpc::namespaces::eth::EthNamespaceT;
     use zksync_types::{
         api::{Block, CallTracerConfig, SupportedTracers, TransactionReceipt},
         fee::Fee,
         l2::L2Tx,
         transaction_request::CallRequestBuilder,