Rust Test VM for integration tests (#184)

* Introduce sub crate for test vm
* Fundamental VM type
* Implementation of state manipulation: actor set / get, checkpoint, rollback
* Tests of basic functionality
Co-authored-by: zenground0 <[email protected]>

Author: ZenGround0

Cargo.toml

@@ -36,6 +36,7 @@ devnet = []
 [workspace]
 members = [
      "actors/*",
+     "test_vm",
 ]
 
 ## Uncomment when working locally on ref-fvm and this repo simultaneously.

actors/runtime/src/test_utils.rs

@@ -65,7 +65,7 @@ lazy_static! {
 const IPLD_RAW: u64 = 0x55;
 
 /// Returns an identity CID for bz.
-fn make_builtin(bz: &[u8]) -> Cid {
+pub fn make_builtin(bz: &[u8]) -> Cid {
     Cid::new_v1(IPLD_RAW, Multihash::wrap(0, bz).expect("name too long"))
 }
 

test_vm/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "test_vm"
+description = "Reference vm for integration testing builtin actors"
+version = "8.0.0-alpha.1"
+license = "MIT OR Apache-2.0"
+authors = ["Protocol Labs", "Filecoin Core Devs"]
+edition = "2021"
+keywords = ["filecoin", "web3", "wasm"]
+
+[lib]
+
+[dependencies]
+fil_actors_runtime = { version = "8.0.0-alpha.1", path = "../actors/runtime" }
+fvm_shared = { version = "0.2.2", default-features = false }
+fvm_ipld_hamt = "0.2.0"
+num-traits = "0.2.14"
+num-derive = "0.3.3"
+log = "0.4.14"
+indexmap = { version = "1.8.0", features = ["serde-1"] }
+cid = { version = "0.8.3", default-features = false, features = ["serde-codec"] }
+serde = { version = "1.0.136", features = ["derive"] }
+thiserror = "1.0.30"
+anyhow = "1.0.56"
+[dev-dependencies]
+fil_actors_runtime = { version = "8.0.0-alpha.1", path = "../actors/runtime", features = ["test_utils", "sector-default"] }
+
+

test_vm/src/lib.rs

@@ -0,0 +1,85 @@
+use cid::Cid;
+use fvm_ipld_hamt::{BytesKey, Hamt, Sha256};
+use fvm_shared::address::Address;
+use fvm_shared::bigint::bigint_ser;
+use fvm_shared::blockstore::MemoryBlockstore;
+use fvm_shared::econ::TokenAmount;
+use fvm_shared::encoding::tuple::*;
+use std::error::Error;
+use std::fmt;
+
+pub struct VM<'bs> {
+    store: &'bs MemoryBlockstore,
+    state_root: Cid,
+    actors_dirty: bool,
+    actors: Hamt<&'bs MemoryBlockstore, Actor, BytesKey>,
+}
+
+impl<'bs> VM<'bs> {
+    pub fn new(store: &'bs MemoryBlockstore) -> VM<'bs> {
+        let mut actors = Hamt::<&'bs MemoryBlockstore, Actor, BytesKey, Sha256>::new(store);
+        VM { store, state_root: actors.flush().unwrap(), actors_dirty: false, actors }
+    }
+
+    pub fn get_actor(&self, addr: &Address) -> Option<&Actor> {
+        self.actors.get(&addr.to_bytes()).unwrap()
+    }
+
+    // blindly overwrite the actor at this address whether it previously existed or not
+    pub fn set_actor(&mut self, key: &Address, a: Actor) {
+        let _ = self.actors.set(key.to_bytes().into(), a).unwrap();
+    }
+
+    pub fn checkpoint(&mut self) -> Cid {
+        self.state_root = self.actors.flush().unwrap();
+        self.actors_dirty = false;
+        self.state_root
+    }
+
+    pub fn rollback(&mut self, root: &Cid) {
+        self.actors =
+            Hamt::<&'bs MemoryBlockstore, Actor, BytesKey, Sha256>::load(root, self.store).unwrap();
+        self.state_root = *root;
+        self.actors_dirty = false;
+    }
+}
+
+#[derive(Serialize_tuple, Deserialize_tuple, Clone, PartialEq, Debug)]
+pub struct Actor {
+    pub code: Cid, // Might want to mock this out to avoid dealing with the annoying bundler
+    pub head: Cid,
+    pub call_seq_num: u64,
+    #[serde(with = "bigint_ser")]
+    pub balance: TokenAmount,
+}
+
+pub fn actor(code: Cid, head: Cid, seq: u64, bal: TokenAmount) -> Actor {
+    Actor { code, head, call_seq_num: seq, balance: bal }
+}
+
+#[derive(Debug)]
+pub struct TestVMError {
+    msg: String,
+}
+
+impl fmt::Display for TestVMError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.msg)
+    }
+}
+
+impl Error for TestVMError {
+    fn description(&self) -> &str {
+        &self.msg
+    }
+}
+
+impl From<fvm_ipld_hamt::Error> for TestVMError {
+    fn from(h_err: fvm_ipld_hamt::Error) -> Self {
+        vm_err(h_err.to_string().as_str())
+    }
+}
+
+pub fn vm_err(msg: &str) -> TestVMError {
+    TestVMError { msg: msg.to_string() }
+}

test_vm/tests/test_vm_test.rs

@@ -0,0 +1,30 @@
+use fil_actors_runtime::test_utils::{make_builtin, ACCOUNT_ACTOR_CODE_ID, PAYCH_ACTOR_CODE_ID};
+use fvm_shared::address::Address;
+use fvm_shared::blockstore::MemoryBlockstore;
+use fvm_shared::econ::TokenAmount;
+use test_vm::{actor, VM};
+
+#[test]
+fn state_control() {
+    let store = MemoryBlockstore::new();
+    let mut v = VM::new(&store);
+    let addr1 = Address::new_id(1000);
+    let addr2 = Address::new_id(2222);
+
+    // set actor
+    let a1 = actor(*ACCOUNT_ACTOR_CODE_ID, make_builtin(b"a1-head"), 42, TokenAmount::from(10u8));
+    v.set_actor(&addr1, a1.clone());
+    let out = v.get_actor(&addr1).unwrap();
+    assert_eq!(out, &a1);
+    let check = v.checkpoint();
+
+    let a2 = actor(*PAYCH_ACTOR_CODE_ID, make_builtin(b"a2-head"), 88, TokenAmount::from(1u8));
+    v.set_actor(&addr2, a2.clone());
+    assert_eq!(v.get_actor(&addr2).unwrap(), &a2);
+    // rollback removes a2 but not a1
+    v.rollback(&check);
+
+    // a2 is gone
+    assert_eq!(None, v.get_actor(&addr2));
+    assert_eq!(v.get_actor(&addr1).unwrap(), &a1);
+}