builtin actor registry in system actor (#401)

Author: vyzo

fvm/src/lib.rs

@@ -27,6 +27,7 @@ mod init_actor;
 mod market_actor;
 mod power_actor;
 mod reward_actor;
+mod system_actor;
 
 use cid::multihash::{Code, MultihashDigest};
 use cid::Cid;
@@ -134,7 +135,7 @@ mod test {
             Zero::zero(),
             fvm_shared::version::NetworkVersion::V14,
             root,
-            manifest_cid,
+            (0, Some(manifest_cid)),
             bs,
             DummyExterns,
         )

fvm/src/machine/default.rs

@@ -2,9 +2,9 @@ use std::ops::RangeInclusive;
 
 use anyhow::{anyhow, Context as _};
 use cid::Cid;
-use fvm_shared::actor::builtin::Manifest;
+use fvm_shared::actor::builtin::{load_manifest, Manifest};
 use fvm_shared::address::Address;
-use fvm_shared::blockstore::{Blockstore, Buffered, CborStore};
+use fvm_shared::blockstore::{Blockstore, Buffered};
 use fvm_shared::clock::ChainEpoch;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ErrorNumber;
@@ -19,6 +19,7 @@ use crate::externs::Externs;
 use crate::gas::price_list_by_network_version;
 use crate::kernel::{ClassifyResult, Context as _, Result};
 use crate::state_tree::{ActorState, StateTree};
+use crate::system_actor::State as SystemActorState;
 use crate::{syscall_error, Config};
 
 pub struct DefaultMachine<B, E> {
@@ -56,7 +57,7 @@ where
         circ_supply: TokenAmount,
         network_version: NetworkVersion,
         state_root: Cid,
-        builtin_actors: Cid,
+        builtin_actors: (u32, Option<Cid>),
         blockstore: B,
         externs: E,
     ) -> anyhow::Result<Self> {
@@ -93,29 +94,29 @@ where
             ));
         }
 
+        // Create a new state tree from the supplied root.
+        let state_tree = {
+            let bstore = BufferedBlockstore::new(blockstore);
+            StateTree::new_from_root(bstore, &context.initial_state_root)?
+        };
+
         // Load the built-in actors manifest.
         // TODO: Check that the actor bundle is sane for the network version.
-        let builtin_actors: Manifest = blockstore
-            .get_cbor(&builtin_actors)
-            .context("failed to load built-in actor index")?
-            .ok_or_else(|| {
-                anyhow!(
-                    "blockstore doesn't contain builtin actors index with CID {}",
-                    &builtin_actors
-                )
-            })?;
+        let builtin_actors_cid = match builtin_actors.1 {
+            Some(cid) => cid,
+            None => {
+                let (state, _) = SystemActorState::load(&state_tree)?;
+                state.builtin_actors
+            }
+        };
+        let builtin_actors =
+            load_manifest(state_tree.store(), &builtin_actors_cid, builtin_actors.0)?;
 
         // Preload any uncached modules.
         // This interface works for now because we know all actor CIDs
         // ahead of time, but with user-supplied code, we won't have that
         // guarantee.
-        engine.preload(&blockstore, builtin_actors.left_values())?;
-
-        // Create a new state tree from the supplied root.
-        let state_tree = {
-            let bstore = BufferedBlockstore::new(blockstore);
-            StateTree::new_from_root(bstore, &context.initial_state_root)?
-        };
+        engine.preload(state_tree.store(), builtin_actors.left_values())?;
 
         Ok(DefaultMachine {
             config,

fvm/src/system_actor.rs

@@ -0,0 +1,40 @@
+use anyhow::Context;
+use cid::Cid;
+use serde::{Deserialize, Serialize};
+
+use fvm_shared::address::Address;
+use fvm_shared::blockstore::{Blockstore, CborStore};
+use fvm_shared::encoding::Cbor;
+
+use crate::kernel::{ClassifyResult, Result};
+use crate::state_tree::{ActorState, StateTree};
+
+pub const SYSTEM_ACTOR_ADDR: Address = Address::new_id(0);
+
+#[derive(Default, Deserialize, Serialize)]
+pub struct State {
+    // builtin actor registry: Vec<(String, Cid)>
+    pub builtin_actors: Cid,
+}
+impl Cbor for State {}
+
+impl State {
+    pub fn load<B>(state_tree: &StateTree<B>) -> Result<(Self, ActorState)>
+    where
+        B: Blockstore,
+    {
+        let system_act = state_tree
+            .get_actor(&SYSTEM_ACTOR_ADDR)?
+            .context("system actor address could not be resolved")
+            .or_fatal()?;
+
+        let state = state_tree
+            .store()
+            .get_cbor(&system_act.state)
+            .or_fatal()?
+            .context("system actor state not found")
+            .or_fatal()?;
+
+        Ok((state, system_act))
+    }
+}

shared/src/actor/builtin.rs

@@ -1,8 +1,11 @@
+use anyhow::anyhow;
 use bimap::BiBTreeMap;
 use cid::Cid;
 use num_derive::FromPrimitive;
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
+use crate::blockstore::{Blockstore, CborStore};
+
 /// Identifies the builtin actor types for usage with the
 /// actor::resolve_builtin_actor_type syscall.
 #[derive(
@@ -82,5 +85,61 @@ impl TryFrom<&str> for Type {
     }
 }
 
+impl From<&Type> for String {
+    fn from(t: &Type) -> String {
+        match t {
+            Type::System => "system",
+            Type::Init => "init",
+            Type::Cron => "cron",
+            Type::Account => "account",
+            Type::Power => "storagepower",
+            Type::Miner => "storageminer",
+            Type::Market => "storagemarket",
+            Type::PaymentChannel => "paymentchannel",
+            Type::Multisig => "multisig",
+            Type::Reward => "reward",
+            Type::VerifiedRegistry => "verifiedregistry",
+        }
+        .to_string()
+    }
+}
+
 /// A mapping of builtin actor CIDs to their respective types.
 pub type Manifest = BiBTreeMap<Cid, Type>;
+
+pub fn load_manifest<B: Blockstore>(bs: &B, root_cid: &Cid, ver: u32) -> anyhow::Result<Manifest> {
+    match ver {
+        0 => load_manifest_v0(bs, root_cid),
+        1 => load_manifest_v1(bs, root_cid),
+        _ => Err(anyhow!("unknown manifest version {}", ver)),
+    }
+}
+
+pub fn load_manifest_v0<B: Blockstore>(bs: &B, root_cid: &Cid) -> anyhow::Result<Manifest> {
+    match bs.get_cbor::<Manifest>(root_cid)? {
+        Some(mf) => Ok(mf),
+        None => Err(anyhow!("cannot find manifest root cid {}", root_cid)),
+    }
+}
+
+pub fn load_manifest_v1<B: Blockstore>(bs: &B, root_cid: &Cid) -> anyhow::Result<Manifest> {
+    let vec: Vec<(String, Cid)> = match bs.get_cbor(root_cid)? {
+        Some(vec) => vec,
+        None => {
+            return Err(anyhow!("cannot find manifest root cid {}", root_cid));
+        }
+    };
+    let mut manifest = Manifest::new();
+    for (name, code_cid) in vec {
+        let t = Type::try_from(name.as_str());
+        match t {
+            Ok(t) => {
+                manifest.insert(code_cid, t);
+            }
+            Err(what) => {
+                return Err(anyhow!("bad builtin actor name: {}: {} ", name, what));
+            }
+        }
+    }
+    Ok(manifest)
+}

testing/conformance/src/vm.rs

@@ -85,7 +85,7 @@ impl TestMachine<Box<DefaultMachine<MemoryBlockstore, TestExterns>>> {
             BigInt::zero(),
             network_version,
             state_root,
-            builtin_actors,
+            (0, Some(builtin_actors)),
             blockstore,
             externs,
         )