Allow registering of Actors to the VM

blockchain/blocks/src/tipset.rs

@@ -152,6 +152,7 @@ impl FullTipset {
 
         // sort blocks on creation to allow for more seamless conversions between FullTipset
         // and Tipset
+        #[allow(clippy::unnecessary_sort_by)]
         blocks.sort_by(|block1, block2| block1.header().cmp(block2.header()));
         Ok(Self { blocks })
     }

tests/conformance_tests/Cargo.toml

@@ -30,3 +30,4 @@ crypto = { package = "forest_crypto", path = "../../crypto" }
 address = { package = "forest_address", path = "../../vm/address" }
 regex = "1.0"
 lazy_static = "1.4"
+actor = { path = "../../vm/actor" }

tests/conformance_tests/tests/conformance_runner.rs

@@ -6,6 +6,7 @@
 #[macro_use]
 extern crate lazy_static;
 
+use actor::{CHAOS_ACTOR_CODE_ID, PUPPET_ACTOR_CODE_ID};
 use address::Address;
 use blockstore::BlockStore;
 use cid::Cid;
@@ -125,12 +126,20 @@ struct MessageVector {
     epoch: Option<ChainEpoch>,
 }
 
+#[derive(Debug, Deserialize)]
+struct Selector {
+    #[serde(default)]
+    puppet_actor: Option<String>,
+    #[serde(default)]
+    chaos_actor: Option<String>,
+}
+
 #[derive(Debug, Deserialize)]
 #[serde(tag = "class")]
 enum TestVector {
     #[serde(rename = "message")]
     Message {
-        selector: Option<String>,
+        selector: Option<Selector>,
         #[serde(rename = "_meta")]
         meta: Option<MetaData>,
 
@@ -142,19 +151,19 @@ enum TestVector {
     },
     #[serde(rename = "block")]
     Block {
-        selector: Option<String>,
+        selector: Option<Selector>,
         #[serde(rename = "_meta")]
         meta: Option<MetaData>,
     },
     #[serde(rename = "tipset")]
     Tipset {
-        selector: Option<String>,
+        selector: Option<Selector>,
         #[serde(rename = "_meta")]
         meta: Option<MetaData>,
     },
     #[serde(rename = "chain")]
     Chain {
-        selector: Option<String>,
+        selector: Option<Selector>,
         #[serde(rename = "_meta")]
         meta: Option<MetaData>,
     },
@@ -228,6 +237,7 @@ fn execute_message(
     pre_root: &Cid,
     bs: &db::MemoryDB,
     epoch: ChainEpoch,
+    selector: &Option<Selector>,
 ) -> Result<(ApplyRet, Cid), Box<dyn StdError>> {
     let mut vm = VM::<_, _, _>::new(
         pre_root,
@@ -238,6 +248,23 @@ fn execute_message(
         BASE_FEE.clone(),
     )?;
 
+    if let Some(s) = &selector {
+        if s.puppet_actor
+            .as_ref()
+            .map(|s| s == "true")
+            .unwrap_or_default()
+        {
+            vm.register_actor(PUPPET_ACTOR_CODE_ID.clone());
+        }
+        if s.chaos_actor
+            .as_ref()
+            .map(|s| s == "true")
+            .unwrap_or_default()
+        {
+            vm.register_actor(CHAOS_ACTOR_CODE_ID.clone());
+        }
+    }
+
     // TODO register puppet actor (and conditionally chaos actor)
 
     let ret = vm.apply_message(msg)?;
@@ -247,7 +274,7 @@ fn execute_message(
 }
 
 fn execute_message_vector(
-    _selector: Option<String>,
+    selector: Option<Selector>,
     car: Vec<u8>,
     preconditions: PreConditions,
     apply_messages: Vec<MessageVector>,
@@ -274,7 +301,7 @@ fn execute_message_vector(
             epoch = ep;
         }
 
-        let (ret, post_root) = execute_message(&msg, &root, &bs, epoch)?;
+        let (ret, post_root) = execute_message(&msg, &root, &bs, epoch, &selector)?;
         root = post_root;
 
         let receipt = &postconditions.receipts[i];

vm/interpreter/src/default_runtime.rs

@@ -21,6 +21,7 @@ use num_bigint::BigInt;
 use runtime::{ActorCode, MessageInfo, Runtime, Syscalls};
 use state_tree::StateTree;
 use std::cell::RefCell;
+use std::collections::HashSet;
 use std::marker::PhantomData;
 use std::rc::Rc;
 use vm::{
@@ -54,7 +55,7 @@ impl MessageInfo for VMMsg {
 }
 
 /// Implementation of the Runtime trait.
-pub struct DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, BS, SYS, R, P = DevnetParams> {
+pub struct DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, 'act, BS, SYS, R, P = DevnetParams> {
     state: &'st mut StateTree<'db, BS>,
     store: GasBlockStore<'db, BS>,
     syscalls: GasSyscalls<'sys, SYS>,
@@ -69,11 +70,12 @@ pub struct DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, BS, SYS, R, P = DevnetParams
     rand: &'r R,
     caller_validated: bool,
     allow_internal: bool,
+    registered_actors: &'act HashSet<Cid>,
     params: PhantomData<P>,
 }
 
-impl<'db, 'msg, 'st, 'sys, 'r, BS, SYS, R, P>
-    DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, BS, SYS, R, P>
+impl<'db, 'msg, 'st, 'sys, 'r, 'act, BS, SYS, R, P>
+    DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, 'act, BS, SYS, R, P>
 where
     BS: BlockStore,
     SYS: Syscalls,
@@ -93,6 +95,7 @@ where
         origin_nonce: u64,
         num_actors_created: u64,
         rand: &'r R,
+        registered_actors: &'act HashSet<Cid>,
     ) -> Result<Self, ActorError> {
         let price_list = price_list_by_epoch(epoch);
         let gas_tracker = Rc::new(RefCell::new(GasTracker::new(message.gas_limit(), gas_used)));
@@ -133,6 +136,7 @@ where
             num_actors_created,
             price_list,
             rand,
+            registered_actors,
             allow_internal: true,
             caller_validated: false,
             params: PhantomData,
@@ -307,7 +311,7 @@ where
     }
 }
 
-impl<BS, SYS, R, P> Runtime<BS> for DefaultRuntime<'_, '_, '_, '_, '_, BS, SYS, R, P>
+impl<BS, SYS, R, P> Runtime<BS> for DefaultRuntime<'_, '_, '_, '_, '_, '_, BS, SYS, R, P>
 where
     BS: BlockStore,
     SYS: Syscalls,
@@ -602,8 +606,8 @@ where
 
 /// Shared logic between the DefaultRuntime and the Interpreter.
 /// It invokes methods on different Actors based on the Message.
-pub fn vm_send<'db, 'msg, 'st, 'sys, 'r, BS, SYS, R, P>(
-    rt: &mut DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, BS, SYS, R, P>,
+pub fn vm_send<'db, 'msg, 'st, 'sys, 'r, 'act, BS, SYS, R, P>(
+    rt: &mut DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, 'act, BS, SYS, R, P>,
     msg: &UnsignedMessage,
     gas_cost: Option<GasCharge>,
 ) -> Result<Serialized, ActorError>
@@ -708,8 +712,8 @@ fn transfer<BS: BlockStore>(
 }
 
 /// Calls actor code with method and parameters.
-fn invoke<'db, 'msg, 'st, 'sys, 'r, BS, SYS, R, P>(
-    rt: &mut DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, BS, SYS, R, P>,
+fn invoke<'db, 'msg, 'st, 'sys, 'r, 'act, BS, SYS, R, P>(
+    rt: &mut DefaultRuntime<'db, 'msg, 'st, 'sys, 'r, 'act, BS, SYS, R, P>,
     code: Cid,
     method_num: MethodNum,
     params: &Serialized,
@@ -733,7 +737,23 @@ where
         x if x == *MULTISIG_ACTOR_CODE_ID => multisig::Actor.invoke_method(rt, method_num, params),
         x if x == *REWARD_ACTOR_CODE_ID => reward::Actor.invoke_method(rt, method_num, params),
         x if x == *VERIFREG_ACTOR_CODE_ID => verifreg::Actor.invoke_method(rt, method_num, params),
-        _ => Err(actor_error!(SysErrorIllegalActor; "no code for actor at address {}", to)),
+        x => {
+            if rt.registered_actors.contains(&x) {
+                match x {
+                    x if x == *PUPPET_ACTOR_CODE_ID => {
+                        puppet::Actor.invoke_method(rt, method_num, params)
+                    }
+                    x if x == *CHAOS_ACTOR_CODE_ID => {
+                        chaos::Actor.invoke_method(rt, method_num, params)
+                    }
+                    _ => Err(
+                        actor_error!(SysErrorIllegalActor; "no code for registered actor at address {}", to),
+                    ),
+                }
+            } else {
+                Err(actor_error!(SysErrorIllegalActor; "no code for actor at address {}", to))
+            }
+        }
     }
 }
 

vm/interpreter/src/vm.rs

@@ -40,6 +40,7 @@ pub struct VM<'db, 'r, DB, SYS, R, P = DevnetParams> {
     syscalls: SYS,
     rand: &'r R,
     base_fee: BigInt,
+    registered_actors: HashSet<Cid>,
     params: PhantomData<P>,
 }
 
@@ -59,17 +60,29 @@ where
         base_fee: BigInt,
     ) -> Result<Self, String> {
         let state = StateTree::new_from_root(store, root)?;
+        let registered_actors = HashSet::new();
         Ok(VM {
             state,
             store,
             epoch,
             syscalls,
             rand,
             base_fee,
+            registered_actors,
             params: PhantomData,
         })
     }
 
+    /// Registers an actor that is not part of the set of default builtin actors by providing the code cid
+    pub fn register_actor(&mut self, code_cid: Cid) -> bool {
+        self.registered_actors.insert(code_cid)
+    }
+
+    /// Gets registered actors that are not part of the set of default builtin actors
+    pub fn registered_actors(&self) -> &HashSet<Cid> {
+        &self.registered_actors
+    }
+
     /// Flush stores in VM and return state root.
     pub fn flush(&mut self) -> Result<Cid, String> {
         self.state.flush()
@@ -422,7 +435,7 @@ where
         gas_cost: Option<GasCharge>,
     ) -> (
         Serialized,
-        Option<DefaultRuntime<'db, 'm, '_, '_, '_, DB, SYS, R, P>>,
+        Option<DefaultRuntime<'db, 'm, '_, '_, '_, '_, DB, SYS, R, P>>,
         Option<ActorError>,
     ) {
         let res = DefaultRuntime::new(
@@ -436,6 +449,7 @@ where
             msg.sequence(),
             0,
             self.rand,
+            &self.registered_actors,
         );
 
         match res {

vm/interpreter/tests/transfer_test.rs

@@ -11,6 +11,7 @@ use ipld_blockstore::BlockStore;
 use ipld_hamt::Hamt;
 use message::UnsignedMessage;
 use state_tree::StateTree;
+use std::collections::HashSet;
 use vm::{ActorState, Serialized};
 
 #[test]
@@ -93,6 +94,7 @@ fn transfer_test() {
     let default_syscalls = DefaultSyscalls::new(&store);
 
     let dummy_rand = ChainRand::new(TipsetKeys::new(vec![]));
+    let registered = HashSet::new();
     let mut runtime = DefaultRuntime::<_, _, _>::new(
         &mut state,
         &store,
@@ -104,6 +106,7 @@ fn transfer_test() {
         0,
         0,
         &dummy_rand,
+        &registered,
     )
     .unwrap();
     let _serialized = vm_send(&mut runtime, &message, None).unwrap();