feat: basic f4 support (filecoin-project#684)

- Adds a create4 method to the init actor.
- Adds embryo actor creation to the test vm.

Author: Stebalien

Cargo.lock

@@ -14,7 +14,7 @@ crate-type = ["cdylib", "lib"]
 
 [dependencies]
 fvm_sdk = { version = "3.0.0-alpha.2", optional = true }
-fvm_shared = { version = "3.0.0-alpha.1", optional = true }
+fvm_shared = { version = "3.0.0-alpha.2", optional = true }
 
 [features]
 fil-actor = ["fvm_sdk", "fvm_shared"]

actors/embryo/Cargo.toml

@@ -15,7 +15,7 @@ crate-type = ["cdylib", "lib"]
 
 [dependencies]
 fil_actors_runtime = { version = "10.0.0-alpha.1", path = "../../runtime" }
-fvm_shared = { version = "3.0.0-alpha.1", default-features = false }
+fvm_shared = { version = "3.0.0-alpha.2", default-features = false }
 fvm_ipld_hamt = "0.5.1"
 serde = { version = "1.0.136", features = ["derive"] }
 serde_tuple = "0.5"

actors/evm/Cargo.toml

@@ -1,6 +1,8 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
+use std::iter;
+
 use cid::Cid;
 use fil_actors_runtime::runtime::{ActorCode, Runtime};
 use fil_actors_runtime::{actor_error, cbor, ActorContext, ActorError, SYSTEM_ACTOR_ADDR};
@@ -27,8 +29,9 @@ fil_actors_runtime::wasm_trampoline!(Actor);
 pub enum Method {
     Constructor = METHOD_CONSTRUCTOR,
     Exec = 2,
+    Exec4 = 3,
     #[cfg(feature = "m2-native")]
-    InstallCode = 3,
+    InstallCode = 4,
 }
 
 /// Init actor
@@ -81,7 +84,7 @@ impl Actor {
         log::trace!("robust address: {:?}", &robust_address);
 
         // Allocate an ID for this actor.
-        // Store mapping of pubkey or actor address to actor ID
+        // Store mapping of actor addresses to the actor ID.
         let id_address: ActorID = rt.transaction(|s: &mut State, rt| {
             s.map_address_to_new_id(rt.store(), &robust_address)
                 .context("failed to allocate ID address")
@@ -102,6 +105,58 @@ impl Actor {
         Ok(ExecReturn { id_address: Address::new_id(id_address), robust_address })
     }
 
+    /// Exec init actor
+    pub fn exec4<BS, RT>(rt: &mut RT, params: Exec4Params) -> Result<Exec4Return, ActorError>
+    where
+        BS: Blockstore,
+        RT: Runtime<BS>,
+    {
+        if cfg!(feature = "m2-native") {
+            rt.validate_immediate_caller_accept_any()?;
+        } else {
+            rt.validate_immediate_caller_is(iter::once(&EAM_ACTOR_ADDR))?;
+        }
+
+        // Compute the f4 address.
+        let caller_id = rt.message().caller().id().unwrap();
+        let delegated_address =
+            Address::new_delegated(caller_id, &params.subaddress).map_err(|e| {
+                ActorError::illegal_argument(format!("invalid delegated address: {}", e))
+            })?;
+
+        log::trace!("delegated address: {:?}", &delegated_address);
+
+        // Compute a re-org-stable address.
+        // This address exists for use by messages coming from outside the system, in order to
+        // stably address the newly created actor even if a chain re-org causes it to end up with
+        // a different ID.
+        let robust_address = rt.new_actor_address()?;
+
+        log::trace!("robust address: {:?}", &robust_address);
+
+        // Allocate an ID for this actor.
+        // Store mapping of actor addresses to the actor ID.
+        let id_address: ActorID = rt.transaction(|s: &mut State, rt| {
+            s.map_address_to_f4(rt.store(), &robust_address, &delegated_address).map_err(|e| {
+                e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to allocate ID address")
+            })
+        })?;
+
+        // Create an empty actor
+        rt.create_actor(params.code_cid, id_address)?;
+
+        // Invoke constructor
+        rt.send(
+            &Address::new_id(id_address),
+            METHOD_CONSTRUCTOR,
+            params.constructor_params,
+            rt.message().value_received(),
+        )
+        .map_err(|err| err.wrap("constructor failed"))?;
+
+        Ok(Exec4Return { id_address: Address::new_id(id_address), robust_address })
+    }
+
     #[cfg(feature = "m2-native")]
     pub fn install<BS, RT>(rt: &mut RT, params: InstallParams) -> Result<InstallReturn, ActorError>
     where
@@ -171,6 +226,10 @@ impl ActorCode for Actor {
                 let res = Self::exec(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::serialize(res)?)
             }
+            Some(Method::Exec4) => {
+                let res = Self::exec4(rt, cbor::deserialize_params(params)?)?;
+                Ok(RawBytes::serialize(res)?)
+            }
             #[cfg(feature = "m2-native")]
             Some(Method::InstallCode) => {
                 let res = Self::install(rt, cbor::deserialize_params(params)?)?;

actors/init/src/lib.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use cid::Cid;
+use fil_actors_runtime::actor_error;
 use fil_actors_runtime::{
     actor_error, make_empty_map, make_map_with_root_and_bitwidth, ActorError, AsActorError,
     FIRST_NON_SINGLETON_ADDR,
@@ -34,7 +35,8 @@ impl State {
     /// Allocates a new ID address and stores a mapping of the argument address to it.
     /// Fails if the argument address is already present in the map to facilitate a tombstone
     /// for when the predictable robust address generation is implemented.
-    /// Returns the newly-allocated address.
+    ///
+    /// Returns the newly-allocated actor ID.
     pub fn map_address_to_new_id<BS: Blockstore>(
         &mut self,
         store: &BS,
@@ -63,6 +65,48 @@ impl State {
         Ok(id)
     }
 
+    /// Allocates a new ID address and stores a mapping of the argument addresses to it.
+    /// Returns the newly-allocated actor ID.
+    pub fn map_address_to_f4<BS: Blockstore>(
+        &mut self,
+        store: &BS,
+        addr: &Address,
+        f4addr: &Address,
+    ) -> anyhow::Result<ActorID>
+    where
+        BS: Blockstore,
+    {
+        let mut map = make_map_with_root_and_bitwidth(&self.address_map, store, HAMT_BIT_WIDTH)?;
+
+        // Assign a new ID address, or use the one currently mapped to the f4 address. We don't
+        // bother checking if the target actor is an embryo here, the FVM will check that when we go to create the actor.
+        let f4addr_key = f4addr.to_bytes().into();
+        let id: u64 = match map.get(&f4addr_key)? {
+            Some(id) => *id,
+            None => {
+                let id = self.next_id;
+                self.next_id += 1;
+                map.set(f4addr_key, id)?;
+                id
+            }
+        };
+
+        // Then go ahead and assign the f2 address.
+        let is_new = map.set_if_absent(addr.to_bytes().into(), id)?;
+        if !is_new {
+            // this is impossible today as the robust address is a hash of unique inputs
+            // but in close future predictable address generation will make this possible
+            return Err(anyhow!(actor_error!(
+                forbidden,
+                "robust address {} is already allocated in the address map",
+                addr
+            )));
+        }
+        self.address_map = map.flush()?;
+
+        Ok(id)
+    }
+
     /// ResolveAddress resolves an address to an ID-address, if possible.
     /// If the provided address is an ID address, it is returned as-is.
     /// This means that mapped ID-addresses (which should only appear as values, not keys) and

actors/init/src/state.rs

@@ -29,7 +29,8 @@ pub fn check_state_invariants<BS: Blockstore>(
 
     let mut init_summary = StateSummary { ids_by_address: HashMap::new(), next_id: state.next_id };
 
-    let mut address_by_id = HashMap::<ActorID, Address>::new();
+    let mut stable_address_by_id = HashMap::<ActorID, Address>::new();
+    let mut delegated_address_by_id = HashMap::<ActorID, Address>::new();
     match Map::<_, ActorID>::load(&state.address_map, store) {
         Ok(address_map) => {
             let ret = address_map.for_each(|key, actor_id| {
@@ -44,11 +45,29 @@ pub fn check_state_invariants<BS: Blockstore>(
                     format!("unexpected singleton ID value {actor_id}"),
                 );
 
-                if let Some(duplicate) = address_by_id.insert(*actor_id, key_address) {
-                    acc.add(format!(
-                        "duplicate mapping to ID {actor_id}: {key_address} {duplicate}"
-                    ));
+                match key_address.protocol() {
+                    Protocol::ID => {
+                        acc.add(format!("key {key_address} is an ID address"));
+                    }
+                    Protocol::Delegated => {
+                        if let Some(duplicate) =
+                            delegated_address_by_id.insert(*actor_id, key_address)
+                        {
+                            acc.add(format!(
+                                "duplicate mapping to ID {actor_id}: {key_address} {duplicate}"
+                            ));
+                        }
+                    }
+                    _ => {
+                        if let Some(duplicate) = stable_address_by_id.insert(*actor_id, key_address)
+                        {
+                            acc.add(format!(
+                                "duplicate mapping to ID {actor_id}: {key_address} {duplicate}"
+                            ));
+                        }
+                    }
                 }
+
                 init_summary.ids_by_address.insert(key_address, *actor_id);
 
                 Ok(())