feat: basic f4 support (#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]
 fil_actors_runtime = { version = "10.0.0-alpha.1", path = "../../runtime", features = ["fil-actor"] }
-fvm_shared = { version = "3.0.0-alpha.1", default-features = false }
+fvm_shared = { version = "3.0.0-alpha.2", default-features = false }
 serde = { version = "1.0.136", features = ["derive"] }
 num-traits = "0.2.14"
 num-derive = "0.3.3"

actors/account/Cargo.toml

@@ -15,7 +15,7 @@ crate-type = ["cdylib", "lib"]
 
 [dependencies]
 fil_actors_runtime = { version = "10.0.0-alpha.1", path = "../../runtime", features = ["fil-actor"] }
-fvm_shared = { version = "3.0.0-alpha.1", default-features = false }
+fvm_shared = { version = "3.0.0-alpha.2", default-features = false }
 num-traits = "0.2.14"
 num-derive = "0.3.3"
 log = "0.4.14"

actors/cron/Cargo.toml

@@ -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

@@ -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"] }
 num-traits = "0.2.14"

actors/init/Cargo.toml

@@ -1,8 +1,11 @@
 // 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::EAM_ACTOR_ADDR;
 use fil_actors_runtime::{actor_error, cbor, ActorDowncast, ActorError, SYSTEM_ACTOR_ADDR};
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::RawBytes;
@@ -28,8 +31,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
@@ -85,7 +89,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).map_err(|e| {
                 e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to allocate ID address")
@@ -107,6 +111,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
@@ -176,6 +232,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

@@ -5,8 +5,9 @@ use anyhow::anyhow;
 #[cfg(feature = "m2-native")]
 use cid::multihash::Code;
 use cid::Cid;
+use fil_actors_runtime::actor_error;
 use fil_actors_runtime::{
-    actor_error, make_empty_map, make_map_with_root_and_bitwidth, FIRST_NON_SINGLETON_ADDR,
+    make_empty_map, make_map_with_root_and_bitwidth, FIRST_NON_SINGLETON_ADDR,
 };
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::tuple::*;
@@ -45,7 +46,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,
@@ -70,6 +72,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