Use Option<IpldBlock> for all message params (filecoin-project#913)

actors/account/Cargo.toml

@@ -14,7 +14,8 @@ crate-type = ["cdylib", "lib"]
 
 [dependencies]
 fil_actors_runtime = { version = "10.0.0-alpha.1", path = "../../runtime" }
-frc42_dispatch = "1.1.0"
+frc42_dispatch = "2.0.0"
+fvm_actor_utils = "2.0.0"
 fvm_shared = { version = "2.0.0-alpha.2", default-features = false }
 serde = { version = "1.0.136", features = ["derive"] }
 num-traits = "0.2.14"

actors/account/src/lib.rs

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
+use fvm_actor_utils::receiver::UniversalReceiverParams;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::address::{Address, Protocol};
 use fvm_shared::crypto::signature::SignatureType::{Secp256k1, BLS};
@@ -13,8 +14,8 @@ use num_traits::FromPrimitive;
 use crate::types::AuthenticateMessageParams;
 use fil_actors_runtime::builtin::singletons::SYSTEM_ACTOR_ADDR;
 use fil_actors_runtime::runtime::{ActorCode, Runtime};
-use fil_actors_runtime::{actor_error, restrict_internal_api, ActorError};
-use fil_actors_runtime::{cbor, ActorDowncast};
+use fil_actors_runtime::{actor_dispatch, ActorDowncast};
+use fil_actors_runtime::{actor_error, ActorError};
 
 pub use self::state::State;
 
@@ -42,16 +43,16 @@ pub struct Actor;
 
 impl Actor {
     /// Constructor for Account actor
-    pub fn constructor(rt: &mut impl Runtime, address: Address) -> Result<(), ActorError> {
+    pub fn constructor(rt: &mut impl Runtime, params: Address) -> Result<(), ActorError> {
         rt.validate_immediate_caller_is(std::iter::once(&SYSTEM_ACTOR_ADDR))?;
-        match address.protocol() {
+        match params.protocol() {
             Protocol::Secp256k1 | Protocol::BLS => {}
             protocol => {
                 return Err(actor_error!(illegal_argument;
                     "address must use BLS or SECP protocol, got {}", protocol));
             }
         }
-        rt.create(&State { address })?;
+        rt.create(&State { address: params })?;
         Ok(())
     }
 
@@ -94,38 +95,19 @@ impl Actor {
     // Always succeeds, accepting any transfers.
     pub fn universal_receiver_hook(
         rt: &mut impl Runtime,
-        _params: &RawBytes,
+        _params: UniversalReceiverParams,
     ) -> Result<(), ActorError> {
         rt.validate_immediate_caller_accept_any()?;
         Ok(())
     }
 }
 
 impl ActorCode for Actor {
-    fn invoke_method<RT>(
-        rt: &mut RT,
-        method: MethodNum,
-        params: &RawBytes,
-    ) -> Result<RawBytes, ActorError>
-    where
-        RT: Runtime,
-    {
-        restrict_internal_api(rt, method)?;
-
-        match FromPrimitive::from_u64(method) {
-            Some(Method::Constructor) => {
-                Self::constructor(rt, cbor::deserialize_params(params)?)?;
-                Ok(RawBytes::default())
-            }
-            Some(Method::PubkeyAddress) => {
-                let addr = Self::pubkey_address(rt)?;
-                Ok(RawBytes::serialize(addr)?)
-            }
-            Some(Method::AuthenticateMessageExported) => {
-                Self::authenticate_message(rt, cbor::deserialize_params(params)?)?;
-                Ok(RawBytes::default())
-            }
-            None => Err(actor_error!(unhandled_message; "Invalid method")),
-        }
+    type Methods = Method;
+    actor_dispatch! {
+        Constructor => constructor,
+        PubkeyAddress => pubkey_address,
+        AuthenticateMessage => authenticate_message,
+        UniversalReceiverHook => universal_receiver_hook,
     }
 }

actors/account/tests/account_actor_test.rs

@@ -2,10 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use anyhow::anyhow;
-use fil_actor_account::types::AuthenticateMessageParams;
-use fil_actor_account::{testing::check_state_invariants, Actor as AccountActor, State};
-use fil_actors_runtime::builtin::SYSTEM_ACTOR_ADDR;
-use fil_actors_runtime::test_utils::*;
+use fvm_actor_utils::receiver::UniversalReceiverParams;
+use fvm_ipld_encoding::ipld_block::IpldBlock;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::address::Address;
 use fvm_shared::crypto::signature::Signature;
@@ -26,7 +24,7 @@ fn construction() {
         if exit_code.is_success() {
             rt.call::<AccountActor>(
                 Method::Constructor as MethodNum,
-                &RawBytes::serialize(addr).unwrap(),
+                IpldBlock::serialize_cbor(&addr).unwrap(),
             )
             .unwrap();
 
@@ -35,14 +33,17 @@ fn construction() {
             rt.expect_validate_caller_any();
 
             let pk: Address = rt
-                .call::<AccountActor>(Method::PubkeyAddress as MethodNum, &RawBytes::default())
+                .call::<AccountActor>(Method::PubkeyAddress as MethodNum, None)
                 .unwrap()
                 .deserialize()
                 .unwrap();
             assert_eq!(pk, addr);
             check_state(&rt);
         } else {
-            expect_abort(exit_code, rt.call::<AccountActor>(1, &RawBytes::serialize(addr).unwrap()))
+            expect_abort(
+                exit_code,
+                rt.call::<AccountActor>(1, IpldBlock::serialize_cbor(&addr).unwrap()),
+            )
         }
         rt.verify();
     }
@@ -65,15 +66,19 @@ fn token_receiver() {
     let param = Address::new_secp256k1(&[2; fvm_shared::address::SECP_PUB_LEN]).unwrap();
     rt.call::<AccountActor>(
         Method::Constructor as MethodNum,
-        &RawBytes::serialize(&param).unwrap(),
+        IpldBlock::serialize_cbor(&param).unwrap(),
     )
     .unwrap();
 
     rt.set_caller(make_identity_cid(b"1234"), Address::new_id(1000));
     rt.expect_validate_caller_any();
     let ret = rt.call::<AccountActor>(
-        Method::FungibleTokenReceiverHook as MethodNum,
-        &RawBytes::new(vec![1, 2, 3]),
+        Method::UniversalReceiverHook as MethodNum,
+        IpldBlock::serialize_cbor(&UniversalReceiverParams {
+            type_: 0,
+            payload: RawBytes::new(vec![1, 2, 3]),
+        })
+        .unwrap(),
     );
     assert!(ret.is_ok());
     assert_eq!(RawBytes::default(), ret.unwrap());
@@ -86,15 +91,17 @@ fn authenticate_message() {
 
     let addr = Address::new_secp256k1(&[2; fvm_shared::address::SECP_PUB_LEN]).unwrap();
     rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]);
-    rt.call::<AccountActor>(Method::Constructor as MethodNum, &RawBytes::serialize(addr).unwrap())
-        .unwrap();
+
+    rt.call::<AccountActor>(1, IpldBlock::serialize_cbor(&addr).unwrap()).unwrap();
 
     let state: State = rt.get_state();
     assert_eq!(state.address, addr);
 
-    let params =
-        RawBytes::serialize(AuthenticateMessageParams { signature: vec![], message: vec![] })
-            .unwrap();
+    let params = IpldBlock::serialize_cbor(&AuthenticateMessageParams {
+        signature: vec![],
+        message: vec![],
+    })
+    .unwrap();
 
     // Valid signature
     rt.expect_validate_caller_any();
@@ -104,11 +111,7 @@ fn authenticate_message() {
         plaintext: vec![],
         result: Ok(()),
     });
-    assert_eq!(
-        RawBytes::default(),
-        rt.call::<AccountActor>(Method::AuthenticateMessageExported as MethodNum, &params).unwrap()
-    );
-    rt.verify();
+    assert_eq!(RawBytes::default(), rt.call::<AccountActor>(3, params.clone()).unwrap());
 
     // Invalid signature
     rt.expect_validate_caller_any();
@@ -120,8 +123,7 @@ fn authenticate_message() {
     });
     expect_abort_contains_message(
         ExitCode::USR_ILLEGAL_ARGUMENT,
-        "bad signature",
-        rt.call::<AccountActor>(Method::AuthenticateMessageExported as MethodNum, &params),
+        rt.call::<AccountActor>(3, params).unwrap_err().exit_code()
     );
     rt.verify();
 

actors/cron/src/lib.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use fil_actors_runtime::runtime::{ActorCode, Runtime};
-use fil_actors_runtime::{actor_error, cbor, restrict_internal_api, ActorError, SYSTEM_ACTOR_ADDR};
+use fil_actors_runtime::{actor_dispatch, actor_error, ActorError, SYSTEM_ACTOR_ADDR};
 
 use fvm_ipld_encoding::tuple::*;
 use fvm_ipld_encoding::RawBytes;
@@ -40,6 +40,7 @@ pub struct ConstructorParams {
 
 /// Cron actor
 pub struct Actor;
+
 impl Actor {
     /// Constructor for Cron actor
     fn constructor(rt: &mut impl Runtime, params: ConstructorParams) -> Result<(), ActorError> {
@@ -56,12 +57,7 @@ impl Actor {
         let st: State = rt.state()?;
         for entry in st.entries {
             // Intentionally ignore any error when calling cron methods
-            let res = rt.send(
-                &entry.receiver,
-                entry.method_num,
-                RawBytes::default(),
-                TokenAmount::zero(),
-            );
+            let res = rt.send(&entry.receiver, entry.method_num, None, TokenAmount::zero());
             if let Err(e) = res {
                 log::error!(
                     "cron failed to send entry to {}, send error code {}",
@@ -75,25 +71,9 @@ impl Actor {
 }
 
 impl ActorCode for Actor {
-    fn invoke_method<RT>(
-        rt: &mut RT,
-        method: MethodNum,
-        params: &RawBytes,
-    ) -> Result<RawBytes, ActorError>
-    where
-        RT: Runtime,
-    {
-        restrict_internal_api(rt, method)?;
-        match FromPrimitive::from_u64(method) {
-            Some(Method::Constructor) => {
-                Self::constructor(rt, cbor::deserialize_params(params)?)?;
-                Ok(RawBytes::default())
-            }
-            Some(Method::EpochTick) => {
-                Self::epoch_tick(rt)?;
-                Ok(RawBytes::default())
-            }
-            None => Err(actor_error!(unhandled_message; "Invalid method")),
-        }
+    type Methods = Method;
+    actor_dispatch! {
+        Constructor => constructor,
+        EpochTick => epoch_tick,
     }
 }

actors/cron/tests/cron_actor_test.rs

@@ -5,6 +5,7 @@ use fil_actor_cron::testing::check_state_invariants;
 use fil_actor_cron::{Actor as CronActor, ConstructorParams, Entry, State};
 use fil_actors_runtime::test_utils::*;
 use fil_actors_runtime::SYSTEM_ACTOR_ADDR;
+use fvm_ipld_encoding::ipld_block::IpldBlock;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::address::Address;
 use fvm_shared::econ::TokenAmount;
@@ -24,6 +25,7 @@ fn construct_runtime() -> MockRuntime {
         ..Default::default()
     }
 }
+
 #[test]
 fn construct_with_empty_entries() {
     let mut rt = construct_runtime();
@@ -61,6 +63,7 @@ fn epoch_tick_with_empty_entries() {
     construct_and_verify(&mut rt, &ConstructorParams { entries: vec![] });
     epoch_tick_and_verify(&mut rt);
 }
+
 #[test]
 fn epoch_tick_with_entries() {
     let mut rt = construct_runtime();
@@ -80,31 +83,31 @@ fn epoch_tick_with_entries() {
     rt.expect_send(
         entry1.receiver,
         entry1.method_num,
-        RawBytes::default(),
+        None,
         TokenAmount::zero(),
         RawBytes::default(),
         ExitCode::OK,
     );
     rt.expect_send(
         entry2.receiver,
         entry2.method_num,
-        RawBytes::default(),
+        None,
         TokenAmount::zero(),
         RawBytes::default(),
         ExitCode::USR_ILLEGAL_ARGUMENT,
     );
     rt.expect_send(
         entry3.receiver,
         entry3.method_num,
-        RawBytes::default(),
+        None,
         TokenAmount::zero(),
         RawBytes::default(),
         ExitCode::OK,
     );
     rt.expect_send(
         entry4.receiver,
         entry4.method_num,
-        RawBytes::default(),
+        None,
         TokenAmount::zero(),
         RawBytes::default(),
         ExitCode::OK,
@@ -116,14 +119,14 @@ fn epoch_tick_with_entries() {
 fn construct_and_verify(rt: &mut MockRuntime, params: &ConstructorParams) {
     rt.set_caller(*SYSTEM_ACTOR_CODE_ID, SYSTEM_ACTOR_ADDR);
     rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]);
-    let ret = rt.call::<CronActor>(1, &RawBytes::serialize(&params).unwrap()).unwrap();
+    let ret = rt.call::<CronActor>(1, IpldBlock::serialize_cbor(&params).unwrap()).unwrap();
     assert_eq!(RawBytes::default(), ret);
     rt.verify();
 }
 
 fn epoch_tick_and_verify(rt: &mut MockRuntime) {
     rt.expect_validate_caller_addr(vec![SYSTEM_ACTOR_ADDR]);
-    let ret = rt.call::<CronActor>(2, &RawBytes::default()).unwrap();
+    let ret = rt.call::<CronActor>(2, None).unwrap();
     assert_eq!(RawBytes::default(), ret);
     rt.verify();
     check_state(rt);

actors/datacap/Cargo.toml

@@ -17,9 +17,9 @@ crate-type = ["cdylib", "lib"]
 fil_actors_runtime = { version = "10.0.0-alpha.1", path = "../../runtime"}
 
 cid = { version = "0.8.3", default-features = false, features = ["serde-codec"] }
-frc42_dispatch = "1.1.0"
-frc46_token = "2.0.0"
-fvm_actor_utils = "1.0.0"
+frc42_dispatch = "2.0.0"
+frc46_token = "3.0.0"
+fvm_actor_utils = "2.0.0"
 fvm_ipld_blockstore = "0.1.1"
 fvm_ipld_encoding = "0.2.3"
 fvm_ipld_hamt = "0.5.1"