feat: anvil API

SUPPORTED_APIS.md

@@ -14,6 +14,14 @@ The `status` options are:
 
 | Namespace | API | <div style="width:130px">Status</div> | Description |
 | --- | --- | --- | --- |
+| `ANVIL` | `anvil_setNonce` | `SUPPORTED` | Sets the nonce of a given account |
+| `ANVIL` | `anvil_impersonateAccount` | `SUPPORTED` | Impersonate an account |
+| `ANVIL` | `anvil_stopImpersonatingAccount` | `SUPPORTED` | Stop impersonating an account after having previously used `anvil_impersonateAccount` |
+| `ANVIL` | `anvil_reset` | `PARTIALLY` | Resets the state of the network; cannot revert to past block numbers, unless they're in a fork |
+| `ANVIL` | `anvil_mine` | `SUPPORTED` | Mine any number of blocks at once, in constant time |
+| `ANVIL` | `anvil_setBalance` | `SUPPORTED` | Modifies the balance of an account |
+| `ANVIL` | `anvil_setCode` | `SUPPORTED` | Sets the bytecode of a given account |
+| `ANVIL` | `anvil_setStorageAt` | `SUPPORTED` | Sets the storage value at a given key for a given account |
 | [`CONFIG`](#config-namespace) | [`config_getShowCalls`](#config_getshowcalls) | `SUPPORTED` | Gets the current value of `show_calls` that's originally set with `--show-calls` option |
 | [`CONFIG`](#config-namespace) | [`config_getShowOutputs`](#config_getshowoutputs) | `SUPPORTED` | Gets the current value of `show_outputs` that's originally set with `--show-outputs` option |
 | [`CONFIG`](#config-namespace) | [`config_getCurrentTimestamp`](#config_getcurrenttimestamp) | `SUPPORTED` | Gets the value of `current_timestamp` for the node |
@@ -85,7 +93,7 @@ The `status` options are:
 | [`EVM`](#evm-namespace) | [`evm_revert`](#evm_revert) | `SUPPORTED` | Revert the state of the blockchain to a previous snapshot |
 | `EVM` | `evm_setAccountBalance` | `NOT IMPLEMENTED` | Sets the given account's balance to the specified WEI value |
 | `EVM` | `evm_setAccountCode` | `NOT IMPLEMENTED` | Sets the given account's code to the specified data |
-| `EVM` | `evm_setAccountNonce` | `NOT IMPLEMENTED` | Sets the given account's nonce to the specified value |
+| [`EVM`](#evm-namespace) | [`evm_setAccountNonce`](#evm_setaccountnonce) | `SUPPORTED` | Sets the given account's nonce to the specified value |
 | `EVM` | `evm_setAccountStorageAt` | `NOT IMPLEMENTED` | Sets the given account's storage slot to the specified data |
 | `EVM` | `evm_setAutomine` | `NOT IMPLEMENTED` | Enables or disables the automatic mining of new blocks with each new transaction submitted to the network |
 | `EVM` | `evm_setBlockGasLimit` | `NOT IMPLEMENTED` | Sets the Block Gas Limit of the network |

e2e-tests/test/anvil-apis.test.ts

@@ -0,0 +1,190 @@
+import { expect } from "chai";
+import { Wallet } from "zksync-web3";
+import { deployContract, expectThrowsAsync, getTestProvider } from "../helpers/utils";
+import { RichAccounts } from "../helpers/constants";
+import { ethers } from "hardhat";
+import { Deployer } from "@matterlabs/hardhat-zksync-deploy";
+import * as hre from "hardhat";
+import { keccak256 } from "ethers/lib/utils";
+import { BigNumber } from "ethers";
+
+const provider = getTestProvider();
+
+describe("anvil_setBalance", function () {
+  it("Should update the balance of an account", async function () {
+    // Arrange
+    const userWallet = Wallet.createRandom().connect(provider);
+    const newBalance = ethers.utils.parseEther("42");
+
+    // Act
+    await provider.send("anvil_setBalance", [userWallet.address, newBalance._hex]);
+
+    // Assert
+    const balance = await userWallet.getBalance();
+    expect(balance.eq(newBalance)).to.true;
+  });
+});
+
+describe("anvil_setNonce", function () {
+  it("Should update the nonce of an account", async function () {
+    // Arrange
+    const userWallet = Wallet.createRandom().connect(provider);
+    const newNonce = 42;
+
+    // Act
+    await provider.send("anvil_setNonce", [userWallet.address, ethers.utils.hexlify(newNonce)]);
+
+    // Assert
+    const nonce = await userWallet.getNonce();
+    expect(nonce).to.equal(newNonce);
+  });
+});
+
+describe("anvil_mine", function () {
+  it("Should mine multiple blocks with a given interval", async function () {
+    // Arrange
+    const numberOfBlocks = 100;
+    const intervalInSeconds = 60;
+    const startingBlock = await provider.getBlock("latest");
+    const startingTimestamp: number = await provider.send("config_getCurrentTimestamp", []);
+
+    // Act
+    await provider.send("anvil_mine", [ethers.utils.hexlify(numberOfBlocks), ethers.utils.hexlify(intervalInSeconds)]);
+
+    // Assert
+    const latestBlock = await provider.getBlock("latest");
+    expect(latestBlock.number).to.equal(startingBlock.number + numberOfBlocks, "Block number mismatch");
+    expect(latestBlock.timestamp).to.equal(
+      startingTimestamp + (numberOfBlocks - 1) * intervalInSeconds * 1000 + 1,
+      "Timestamp mismatch"
+    );
+  });
+});
+
+describe("anvil_impersonateAccount & anvil_stopImpersonatingAccount", function () {
+  it("Should allow transfers of funds without knowing the Private Key", async function () {
+    // Arrange
+    const userWallet = Wallet.createRandom().connect(provider);
+    const beforeBalance = await provider.getBalance(RichAccounts[5].Account);
+
+    // Act
+    await provider.send("anvil_impersonateAccount", [RichAccounts[5].Account]);
+
+    const signer = await ethers.getSigner(RichAccounts[5].Account);
+    const tx = {
+      to: userWallet.address,
+      value: ethers.utils.parseEther("0.42"),
+    };
+
+    const recieptTx = await signer.sendTransaction(tx);
+    await recieptTx.wait();
+
+    await provider.send("anvil_stopImpersonatingAccount", [RichAccounts[5].Account]);
+
+    // Assert
+    expect((await userWallet.getBalance()).eq(ethers.utils.parseEther("0.42"))).to.true;
+    expect((await provider.getBalance(RichAccounts[5].Account)).eq(beforeBalance.sub(ethers.utils.parseEther("0.42"))))
+      .to.true;
+  });
+});
+
+describe("anvil_setCode", function () {
+  it("Should set code at an address", async function () {
+    // Arrange
+    const wallet = new Wallet(RichAccounts[0].PrivateKey);
+    const deployer = new Deployer(hre, wallet);
+
+    const address = "0x1000000000000000000000000000000000001111";
+    const artifact = await deployer.loadArtifact("Return5");
+    const contractCode = [...ethers.utils.arrayify(artifact.deployedBytecode)];
+
+    // Act
+    await provider.send("anvil_setCode", [address, contractCode]);
+
+    // Assert
+    const result = await provider.send("eth_call", [
+      {
+        to: address,
+        data: keccak256(ethers.utils.toUtf8Bytes("value()")).substring(0, 10),
+        from: wallet.address,
+        gas: "0x1000",
+        gasPrice: "0x0ee6b280",
+        value: "0x0",
+        nonce: "0x1",
+      },
+      "latest",
+    ]);
+    expect(BigNumber.from(result).toNumber()).to.eq(5);
+  });
+
+  it("Should reject invalid code", async function () {
+    const action = async () => {
+      // Arrange
+      const wallet = new Wallet(RichAccounts[0].PrivateKey);
+      const deployer = new Deployer(hre, wallet);
+
+      const address = "0x1000000000000000000000000000000000001111";
+      const artifact = await deployer.loadArtifact("Return5");
+      const contractCode = [...ethers.utils.arrayify(artifact.deployedBytecode)];
+      const shortCode = contractCode.slice(0, contractCode.length - 1);
+
+      // Act
+      await provider.send("anvil_setCode", [address, shortCode]);
+    };
+
+    await expectThrowsAsync(action, "bytes must be divisible by 32");
+  });
+
+  it("Should update code with a different smart contract", async function () {
+    // Arrange
+    const wallet = new Wallet(RichAccounts[0].PrivateKey);
+    const deployer = new Deployer(hre, wallet);
+
+    const greeter = await deployContract(deployer, "Greeter", ["Hi"]);
+    expect(await greeter.greet()).to.eq("Hi");
+    const artifact = await deployer.loadArtifact("Return5");
+    const newContractCode = [...ethers.utils.arrayify(artifact.deployedBytecode)];
+
+    // Act
+    await provider.send("anvil_setCode", [greeter.address, newContractCode]);
+
+    // Assert
+    const result = await provider.send("eth_call", [
+      {
+        to: greeter.address,
+        data: keccak256(ethers.utils.toUtf8Bytes("value()")).substring(0, 10),
+        from: wallet.address,
+        gas: "0x1000",
+        gasPrice: "0x0ee6b280",
+        value: "0x0",
+        nonce: "0x1",
+      },
+      "latest",
+    ]);
+    expect(BigNumber.from(result).toNumber()).to.eq(5);
+  });
+});
+
+describe("anvil_setStorageAt", function () {
+  it("Should set storage at an address", async function () {
+    const wallet = new Wallet(RichAccounts[0].PrivateKey, provider);
+    const userWallet = Wallet.createRandom().connect(provider);
+    await wallet.sendTransaction({
+      to: userWallet.address,
+      value: ethers.utils.parseEther("3"),
+    });
+
+    const deployer = new Deployer(hre, userWallet);
+    const artifact = await deployer.loadArtifact("MyERC20");
+    const token = await deployer.deploy(artifact, ["MyToken", "MyToken", 18]);
+
+    const before = await provider.send("eth_getStorageAt", [token.address, "0x0", "latest"]);
+    expect(BigNumber.from(before).toNumber()).to.eq(0);
+
+    const value = ethers.utils.hexlify(ethers.utils.zeroPad("0x10", 32));
+    await provider.send("anvil_setStorageAt", [token.address, "0x0", value]);
+
+    const after = await provider.send("eth_getStorageAt", [token.address, "0x0", "latest"]);
+    expect(BigNumber.from(after).toNumber()).to.eq(16);
+  });
+});

e2e-tests/test/evm-apis.test.ts

@@ -8,6 +8,21 @@ import { Deployer } from "@matterlabs/hardhat-zksync-deploy";
 
 const provider = getTestProvider();
 
+describe("evm_setAccountNonce", function () {
+  it("Should update the nonce of an account", async function () {
+    // Arrange
+    const userWallet = Wallet.createRandom().connect(provider);
+    const newNonce = 42;
+
+    // Act
+    await provider.send("evm_setAccountNonce", [userWallet.address, ethers.utils.hexlify(newNonce)]);
+
+    // Assert
+    const nonce = await userWallet.getNonce();
+    expect(nonce).to.equal(newNonce);
+  });
+});
+
 describe("evm_mine", function () {
   it("Should mine one block", async function () {
     // Arrange

e2e-tests/test/hardhat-apis.test.ts

@@ -68,12 +68,12 @@ describe("hardhat_impersonateAccount & hardhat_stopImpersonatingAccount", functi
   it("Should allow transfers of funds without knowing the Private Key", async function () {
     // Arrange
     const userWallet = Wallet.createRandom().connect(provider);
-    const beforeBalance = await provider.getBalance(RichAccounts[0].Account);
+    const beforeBalance = await provider.getBalance(RichAccounts[5].Account);
 
     // Act
-    await provider.send("hardhat_impersonateAccount", [RichAccounts[0].Account]);
+    await provider.send("hardhat_impersonateAccount", [RichAccounts[5].Account]);
 
-    const signer = await ethers.getSigner(RichAccounts[0].Account);
+    const signer = await ethers.getSigner(RichAccounts[5].Account);
     const tx = {
       to: userWallet.address,
       value: ethers.utils.parseEther("0.42"),
@@ -82,9 +82,11 @@ describe("hardhat_impersonateAccount & hardhat_stopImpersonatingAccount", functi
     const recieptTx = await signer.sendTransaction(tx);
     await recieptTx.wait();
 
+    await provider.send("hardhat_stopImpersonatingAccount", [RichAccounts[5].Account]);
+
     // Assert
     expect((await userWallet.getBalance()).eq(ethers.utils.parseEther("0.42"))).to.true;
-    expect((await provider.getBalance(RichAccounts[0].Account)).eq(beforeBalance.sub(ethers.utils.parseEther("0.42"))))
+    expect((await provider.getBalance(RichAccounts[5].Account)).eq(beforeBalance.sub(ethers.utils.parseEther("0.42"))))
       .to.true;
   });
 });
@@ -165,3 +167,27 @@ describe("hardhat_setCode", function () {
     expect(BigNumber.from(result).toNumber()).to.eq(5);
   });
 });
+
+describe("hardhat_setStorageAt", function () {
+  it("Should set storage at an address", async function () {
+    const wallet = new Wallet(RichAccounts[0].PrivateKey, provider);
+    const userWallet = Wallet.createRandom().connect(provider);
+    await wallet.sendTransaction({
+      to: userWallet.address,
+      value: ethers.utils.parseEther("3"),
+    });
+
+    const deployer = new Deployer(hre, userWallet);
+    const artifact = await deployer.loadArtifact("MyERC20");
+    const token = await deployer.deploy(artifact, ["MyToken", "MyToken", 18]);
+
+    const before = await provider.send("eth_getStorageAt", [token.address, "0x0", "latest"]);
+    expect(BigNumber.from(before).toNumber()).to.eq(0);
+
+    const value = ethers.utils.hexlify(ethers.utils.zeroPad("0x10", 32));
+    await provider.send("hardhat_setStorageAt", [token.address, "0x0", value]);
+
+    const after = await provider.send("eth_getStorageAt", [token.address, "0x0", "latest"]);
+    expect(BigNumber.from(after).toNumber()).to.eq(16);
+  });
+});

e2e-tests/test/main.test.ts

@@ -62,8 +62,13 @@ describe("Greeter Smart Contract", function () {
 
     // Validate log is created
     expect(receipt.logs.length).to.greaterThanOrEqual(1);
-    const setGreetingLog = receipt.logs[0];
-    expect(setGreetingLog.address).to.equal(greeter.address);
+    var setGreetingLog = null;
+    for (var i = 0; setGreetingLog == null && i < receipt.logs.length; ++i) {
+      if (receipt.logs[i].address == greeter.address) {
+        setGreetingLog = receipt.logs[i];
+      }
+    }
+    expect(setGreetingLog).not.to.equal(null);
 
     const eventInterface = new ethers.utils.Interface(["event LogString(string value)"]);
     expect(eventInterface.parseLog(setGreetingLog).args[0]).to.equal("Greeting is being updated to Luke Skywalker");
@@ -78,8 +83,17 @@ describe("Greeter Smart Contract", function () {
     const setGreetingTx = await greeter.setGreeting("Luke Skywalker");
     let receipt: TransactionReceipt = await setGreetingTx.wait();
 
+    expect(receipt.logs.length).to.greaterThanOrEqual(1);
+    var setGreetingLog = null;
+    for (var i = 0; setGreetingLog == null && i < receipt.logs.length; ++i) {
+      if (receipt.logs[i].address == greeter.address) {
+        setGreetingLog = receipt.logs[i];
+      }
+    }
+    expect(setGreetingLog).not.to.equal(null);
+
     // Create filter
-    const topic = receipt.logs[0].topics[0];
+    const topic = setGreetingLog.topics[0];
     const filterId = await provider.send("eth_newFilter", [
       {
         fromBlock: "earliest",

e2e-tests/test/zks-apis.test.ts

@@ -30,13 +30,14 @@ describe("zks_estimateFee", function () {
     // Act
     const response: Fee = await provider.send("zks_estimateFee", [transaction]);
     // Assert
-    expect(ethers.BigNumber.from(response.gas_limit)).to.eql(ethers.BigNumber.from("3606743"), "Unexpected gas_limit");
+    expect(ethers.BigNumber.from(response.gas_limit).toNumber()).to.be.within(3606743, 5868728, "Unexpected gas_limit");
     expect(ethers.BigNumber.from(response.gas_per_pubdata_limit)).to.eql(
       ethers.BigNumber.from("50000"),
       "Unexpected gas_per_pubdata_limit"
     );
-    expect(ethers.BigNumber.from(response.max_fee_per_gas)).to.eql(
-      ethers.BigNumber.from("37500000"),
+    expect(ethers.BigNumber.from(response.max_fee_per_gas).toNumber()).to.be.within(
+      25500297,
+      37500000,
       "Unexpected max_fee_per_gas"
     );
     expect(ethers.BigNumber.from(response.max_priority_fee_per_gas)).to.eql(

src/main.rs

@@ -45,8 +45,9 @@ use jsonrpc_core::MetaIoHandler;
 use zksync_basic_types::H160;
 
 use crate::namespaces::{
-    ConfigurationApiNamespaceT, DebugNamespaceT, EthNamespaceT, EthTestNodeNamespaceT,
-    EvmNamespaceT, HardhatNamespaceT, NetNamespaceT, Web3NamespaceT, ZksNamespaceT,
+    AnvilNamespaceT, ConfigurationApiNamespaceT, DebugNamespaceT, EthNamespaceT,
+    EthTestNodeNamespaceT, EvmNamespaceT, HardhatNamespaceT, NetNamespaceT, Web3NamespaceT,
+    ZksNamespaceT,
 };
 
 /// List of legacy wallets (address, private key) that we seed with tokens at start.
@@ -166,6 +167,7 @@ async fn build_json_http<
         io.extend_with(DebugNamespaceT::to_delegate(node.clone()));
         io.extend_with(EthNamespaceT::to_delegate(node.clone()));
         io.extend_with(EthTestNodeNamespaceT::to_delegate(node.clone()));
+        io.extend_with(AnvilNamespaceT::to_delegate(node.clone()));
         io.extend_with(EvmNamespaceT::to_delegate(node.clone()));
         io.extend_with(HardhatNamespaceT::to_delegate(node.clone()));
         io.extend_with(ZksNamespaceT::to_delegate(node));