feat: multisig: accept arbitrary public messages

actors/account/tests/account_actor_test.rs

@@ -14,6 +14,7 @@ use fil_actor_account::types::AuthenticateMessageParams;
 use fil_actor_account::{testing::check_state_invariants, Actor as AccountActor, Method, State};
 use fil_actors_runtime::builtin::SYSTEM_ACTOR_ADDR;
 use fil_actors_runtime::test_utils::*;
+use fil_actors_runtime::FIRST_EXPORTED_METHOD_NUMBER;
 
 #[test]
 fn construction() {
@@ -158,6 +159,46 @@ fn authenticate_message() {
         .unwrap());
 }
 
+#[test]
+fn accept_arbitrary() {
+    let mut rt = MockRuntime { receiver: Address::new_id(100), ..Default::default() };
+    rt.set_caller(*SYSTEM_ACTOR_CODE_ID, SYSTEM_ACTOR_ADDR);
+
+    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,
+        IpldBlock::serialize_cbor(&addr).unwrap(),
+    )
+    .unwrap();
+
+    let state: State = rt.get_state();
+    assert_eq!(state.address, addr);
+
+    // this is arbitrary
+    let params = IpldBlock::serialize_cbor(&vec![1u8, 2u8, 3u8]).unwrap();
+
+    // accept >= 2<<24
+    rt.expect_validate_caller_any();
+    let result =
+        rt.call::<AccountActor>(FIRST_EXPORTED_METHOD_NUMBER as MethodNum, params.clone()).unwrap();
+    assert!(result.is_none());
+
+    rt.expect_validate_caller_any();
+    let result = rt
+        .call::<AccountActor>(FIRST_EXPORTED_METHOD_NUMBER + 1 as MethodNum, params.clone())
+        .unwrap();
+    assert!(result.is_none());
+
+    // reject < 2<<24
+    rt.expect_validate_caller_any();
+    let result =
+        rt.call::<AccountActor>(FIRST_EXPORTED_METHOD_NUMBER - 1 as MethodNum, params.clone());
+    assert!(result.is_err());
+
+    rt.verify();
+}
+
 fn check_state(rt: &MockRuntime) {
     let test_address = Address::new_id(1000);
     let (_, acc) = check_state_invariants(&rt.get_state(), &test_address);

actors/multisig/src/lib.rs

@@ -4,11 +4,14 @@
 use fvm_actor_utils::receiver::UniversalReceiverParams;
 use std::collections::BTreeSet;
 
+use fil_actors_runtime::FIRST_EXPORTED_METHOD_NUMBER;
 use fvm_ipld_blockstore::Blockstore;
+use fvm_ipld_encoding::ipld_block::IpldBlock;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::address::Address;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ExitCode;
+use fvm_shared::MethodNum;
 use fvm_shared::{HAMT_BIT_WIDTH, METHOD_CONSTRUCTOR};
 use num_derive::FromPrimitive;
 use num_traits::Zero;
@@ -457,6 +460,19 @@ impl Actor {
         rt.validate_immediate_caller_accept_any()?;
         Ok(())
     }
+
+    pub fn fallback(
+        rt: &mut impl Runtime,
+        method: MethodNum,
+        _: Option<IpldBlock>,
+    ) -> Result<Option<IpldBlock>, ActorError> {
+        rt.validate_immediate_caller_accept_any()?;
+        if method >= FIRST_EXPORTED_METHOD_NUMBER {
+            Ok(None)
+        } else {
+            Err(actor_error!(unhandled_message; "invalid method: {}", method))
+        }
+    }
 }
 
 fn execute_transaction_if_approved(
@@ -569,5 +585,6 @@ impl ActorCode for Actor {
       ChangeNumApprovalsThreshold => change_num_approvals_threshold,
       LockBalance => lock_balance,
       UniversalReceiverHook => universal_receiver_hook,
+      _ => fallback [raw],
     }
 }

actors/multisig/tests/multisig_actor_test.rs

@@ -6,6 +6,7 @@ use fil_actor_multisig::{
 use fil_actors_runtime::cbor::serialize;
 use fil_actors_runtime::runtime::Runtime;
 use fil_actors_runtime::test_utils::*;
+use fil_actors_runtime::FIRST_EXPORTED_METHOD_NUMBER;
 use fil_actors_runtime::{INIT_ACTOR_ADDR, SYSTEM_ACTOR_ADDR};
 use fvm_actor_utils::receiver::UniversalReceiverParams;
 use fvm_ipld_encoding::ipld_block::IpldBlock;
@@ -2410,3 +2411,38 @@ fn token_receiver() {
 fn to_ipld_block(p: RawBytes) -> Option<IpldBlock> {
     Some(IpldBlock { codec: CBOR, data: p.to_vec() })
 }
+
+#[test]
+fn accept_arbitrary() {
+    let msig = Address::new_id(1000);
+    let anne = Address::new_id(101);
+    let bob = Address::new_id(102);
+
+    let mut rt = construct_runtime(msig);
+    let h = util::ActorHarness::new();
+    h.construct_and_verify(&mut rt, 2, 0, 0, vec![anne, bob]);
+
+    // this is arbitrary
+    let params = IpldBlock::serialize_cbor(&vec![1u8, 2u8, 3u8]).unwrap();
+
+    // accept >= 2<<24
+    rt.expect_validate_caller_any();
+    let result = rt
+        .call::<MultisigActor>(FIRST_EXPORTED_METHOD_NUMBER as MethodNum, params.clone())
+        .unwrap();
+    assert!(result.is_none());
+
+    rt.expect_validate_caller_any();
+    let result = rt
+        .call::<MultisigActor>(FIRST_EXPORTED_METHOD_NUMBER + 1 as MethodNum, params.clone())
+        .unwrap();
+    assert!(result.is_none());
+
+    // reject < 2<<24
+    rt.expect_validate_caller_any();
+    let result =
+        rt.call::<MultisigActor>(FIRST_EXPORTED_METHOD_NUMBER - 1 as MethodNum, params.clone());
+    assert!(result.is_err());
+
+    rt.verify();
+}

actors/paych/src/lib.rs

@@ -11,10 +11,12 @@ use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::CBOR;
 use fvm_shared::address::Address;
 
+use fil_actors_runtime::FIRST_EXPORTED_METHOD_NUMBER;
 use fvm_ipld_encoding::ipld_block::IpldBlock;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ExitCode;
 use fvm_shared::sys::SendFlags;
+use fvm_shared::MethodNum;
 use fvm_shared::{METHOD_CONSTRUCTOR, METHOD_SEND};
 use num_derive::FromPrimitive;
 use num_traits::Zero;
@@ -298,6 +300,19 @@ impl Actor {
 
         Ok(())
     }
+
+    pub fn fallback(
+        rt: &mut impl Runtime,
+        method: MethodNum,
+        _: Option<IpldBlock>,
+    ) -> Result<Option<IpldBlock>, ActorError> {
+        rt.validate_immediate_caller_accept_any()?;
+        if method >= FIRST_EXPORTED_METHOD_NUMBER {
+            Ok(None)
+        } else {
+            Err(actor_error!(unhandled_message; "invalid method: {}", method))
+        }
+    }
 }
 
 #[inline]
@@ -324,5 +339,6 @@ impl ActorCode for Actor {
         UpdateChannelState => update_channel_state,
         Settle => settle,
         Collect => collect,
+        _ => fallback [raw],
     }
 }

actors/paych/tests/paych_actor_test.rs

@@ -16,6 +16,7 @@ use fil_actor_paych::{
 use fil_actors_runtime::runtime::builtins::Type;
 use fil_actors_runtime::runtime::Runtime;
 use fil_actors_runtime::test_utils::*;
+use fil_actors_runtime::FIRST_EXPORTED_METHOD_NUMBER;
 use fil_actors_runtime::INIT_ACTOR_ADDR;
 use fvm_ipld_amt::Amt;
 use fvm_ipld_encoding::ipld_block::IpldBlock;
@@ -26,6 +27,7 @@ use fvm_shared::crypto::signature::Signature;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ExitCode;
 use fvm_shared::sys::SendFlags;
+use fvm_shared::MethodNum;
 use fvm_shared::METHOD_CONSTRUCTOR;
 use num_traits::Zero;
 
@@ -1149,3 +1151,31 @@ fn expect_authenticate_message(
         None,
     )
 }
+
+#[test]
+fn accept_arbitrary() {
+    let (mut rt, _) = require_create_channel_with_lanes(1);
+
+    // this is arbitrary
+    let params = IpldBlock::serialize_cbor(&vec![1u8, 2u8, 3u8]).unwrap();
+
+    // accept >= 2<<24
+    rt.expect_validate_caller_any();
+    let result =
+        rt.call::<PaychActor>(FIRST_EXPORTED_METHOD_NUMBER as MethodNum, params.clone()).unwrap();
+    assert!(result.is_none());
+
+    rt.expect_validate_caller_any();
+    let result = rt
+        .call::<PaychActor>(FIRST_EXPORTED_METHOD_NUMBER + 1 as MethodNum, params.clone())
+        .unwrap();
+    assert!(result.is_none());
+
+    // reject < 2<<24
+    rt.expect_validate_caller_any();
+    let result =
+        rt.call::<PaychActor>(FIRST_EXPORTED_METHOD_NUMBER - 1 as MethodNum, params.clone());
+    assert!(result.is_err());
+
+    rt.verify();
+}