Miner: Export several more methods (#863)

* Miner: Export ChangeWorkerAddress

* Miner: Export ChangePeerID

* Miner: Export WithdrawBalance

* Miner: Export ChangeMultiaddrs

* Miner: Export ConfirmUpdateWorkerKey

* Miner: Export RepayDebt

* Miner: Export ChangeOwnerAddress

* Miner: Add exported getters for PeerID & multiaddrs

* Miner: Refactor: Rename ConfirmUpdateWorkerKey to ConfirmChangeWorkerAddress

Author: arajasek

actors/miner/src/lib.rs

@@ -112,7 +112,7 @@ pub enum Method {
     ChangeMultiaddrs = 18,
     CompactPartitions = 19,
     CompactSectorNumbers = 20,
-    ConfirmUpdateWorkerKey = 21,
+    ConfirmChangeWorkerAddress = 21,
     RepayDebt = 22,
     ChangeOwnerAddress = 23,
     DisputeWindowedPoSt = 24,
@@ -125,13 +125,22 @@ pub enum Method {
     GetBeneficiary = 31,
     ExtendSectorExpiration2 = 32,
     // Method numbers derived from FRC-0042 standards
+    ChangeWorkerAddressExported = frc42_dispatch::method_hash!("ChangeWorkerAddress"),
+    ChangePeerIDExported = frc42_dispatch::method_hash!("ChangePeerID"),
+    WithdrawBalanceExported = frc42_dispatch::method_hash!("WithdrawBalance"),
+    ChangeMultiaddrsExported = frc42_dispatch::method_hash!("ChangeMultiaddrs"),
+    ConfirmChangeWorkerAddressExported = frc42_dispatch::method_hash!("ConfirmChangeWorkerAddress"),
+    RepayDebtExported = frc42_dispatch::method_hash!("RepayDebt"),
+    ChangeOwnerAddressExported = frc42_dispatch::method_hash!("ChangeOwnerAddress"),
     ChangeBenificiaryExported = frc42_dispatch::method_hash!("ChangeBeneficiary"),
     GetBeneficiaryExported = frc42_dispatch::method_hash!("GetBeneficiary"),
     GetOwnerExported = frc42_dispatch::method_hash!("GetOwner"),
     IsControllingAddressExported = frc42_dispatch::method_hash!("IsControllingAddress"),
     GetSectorSizeExported = frc42_dispatch::method_hash!("GetSectorSize"),
     GetAvailableBalanceExported = frc42_dispatch::method_hash!("GetAvailableBalance"),
     GetVestingFundsExported = frc42_dispatch::method_hash!("GetVestingFunds"),
+    GetPeerIDExported = frc42_dispatch::method_hash!("GetPeerID"),
+    GetMultiaddrsExported = frc42_dispatch::method_hash!("GetMultiaddrs"),
 }
 
 pub const ERR_BALANCE_INVARIANTS_BROKEN: ExitCode = ExitCode::new(1000);
@@ -344,7 +353,7 @@ impl Actor {
     }
 
     /// Triggers a worker address change if a change has been requested and its effective epoch has arrived.
-    fn confirm_update_worker_key(rt: &mut impl Runtime) -> Result<(), ActorError> {
+    fn confirm_change_worker_address(rt: &mut impl Runtime) -> Result<(), ActorError> {
         rt.transaction(|state: &mut State, rt| {
             let mut info = get_miner_info(rt.store(), state)?;
 
@@ -413,6 +422,13 @@ impl Actor {
         })
     }
 
+    fn get_peer_id(rt: &mut impl Runtime) -> Result<GetPeerIDReturn, ActorError> {
+        rt.validate_immediate_caller_accept_any()?;
+        let state: State = rt.state()?;
+        let peer_id = get_miner_info(rt.store(), &state)?.peer_id;
+        Ok(GetPeerIDReturn { peer_id })
+    }
+
     fn change_peer_id(rt: &mut impl Runtime, params: ChangePeerIDParams) -> Result<(), ActorError> {
         let policy = rt.policy();
         check_peer_info(policy, &params.new_id, &[])?;
@@ -434,6 +450,13 @@ impl Actor {
         Ok(())
     }
 
+    fn get_multiaddresses(rt: &mut impl Runtime) -> Result<GetMultiaddrsReturn, ActorError> {
+        rt.validate_immediate_caller_accept_any()?;
+        let state: State = rt.state()?;
+        let multi_addrs = get_miner_info(rt.store(), &state)?.multi_address;
+        Ok(GetMultiaddrsReturn { multi_addrs })
+    }
+
     fn change_multiaddresses(
         rt: &mut impl Runtime,
         params: ChangeMultiaddrsParams,
@@ -4936,11 +4959,11 @@ impl ActorCode for Actor {
                 let res = Self::control_addresses(rt)?;
                 Ok(RawBytes::serialize(&res)?)
             }
-            Some(Method::ChangeWorkerAddress) => {
+            Some(Method::ChangeWorkerAddress) | Some(Method::ChangeWorkerAddressExported) => {
                 Self::change_worker_address(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
-            Some(Method::ChangePeerID) => {
+            Some(Method::ChangePeerID) | Some(Method::ChangePeerIDExported) => {
                 Self::change_peer_id(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
@@ -4988,15 +5011,15 @@ impl ActorCode for Actor {
                 Self::report_consensus_fault(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
-            Some(Method::WithdrawBalance) => {
+            Some(Method::WithdrawBalance) | Some(Method::WithdrawBalanceExported) => {
                 let res = Self::withdraw_balance(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::serialize(&res)?)
             }
             Some(Method::ConfirmSectorProofsValid) => {
                 Self::confirm_sector_proofs_valid(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
-            Some(Method::ChangeMultiaddrs) => {
+            Some(Method::ChangeMultiaddrs) | Some(Method::ChangeMultiaddrsExported) => {
                 Self::change_multiaddresses(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
@@ -5008,15 +5031,16 @@ impl ActorCode for Actor {
                 Self::compact_sector_numbers(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
-            Some(Method::ConfirmUpdateWorkerKey) => {
-                Self::confirm_update_worker_key(rt)?;
+            Some(Method::ConfirmChangeWorkerAddress)
+            | Some(Method::ConfirmChangeWorkerAddressExported) => {
+                Self::confirm_change_worker_address(rt)?;
                 Ok(RawBytes::default())
             }
-            Some(Method::RepayDebt) => {
+            Some(Method::RepayDebt) | Some(Method::RepayDebtExported) => {
                 Self::repay_debt(rt)?;
                 Ok(RawBytes::default())
             }
-            Some(Method::ChangeOwnerAddress) => {
+            Some(Method::ChangeOwnerAddress) | Some(Method::ChangeOwnerAddressExported) => {
                 Self::change_owner_address(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
@@ -5077,6 +5101,14 @@ impl ActorCode for Actor {
                 let res = Self::get_vesting_funds(rt)?;
                 Ok(RawBytes::serialize(res)?)
             }
+            Some(Method::GetPeerIDExported) => {
+                let res = Self::get_peer_id(rt)?;
+                Ok(RawBytes::serialize(res)?)
+            }
+            Some(Method::GetMultiaddrsExported) => {
+                let res = Self::get_multiaddresses(rt)?;
+                Ok(RawBytes::serialize(res)?)
+            }
         }
     }
 }

actors/miner/src/types.rs

@@ -529,3 +529,14 @@ pub struct GetVestingFundsReturn {
 }
 
 impl Cbor for GetVestingFundsReturn {}
+
+#[derive(Debug, Default, PartialEq, Eq, Clone, Serialize_tuple, Deserialize_tuple)]
+pub struct GetPeerIDReturn {
+    #[serde(with = "serde_bytes")]
+    pub peer_id: Vec<u8>,
+}
+
+#[derive(Debug, Default, PartialEq, Clone, Serialize_tuple, Deserialize_tuple)]
+pub struct GetMultiaddrsReturn {
+    pub multi_addrs: Vec<BytesDe>,
+}

actors/miner/tests/change_owner_address_test.rs

@@ -1,6 +1,9 @@
+use fil_actor_miner::{Actor, Method};
 use fil_actors_runtime::test_utils::{
-    expect_abort, new_bls_addr, MockRuntime, ACCOUNT_ACTOR_CODE_ID, MULTISIG_ACTOR_CODE_ID,
+    expect_abort, expect_abort_contains_message, make_identity_cid, new_bls_addr, MockRuntime,
+    ACCOUNT_ACTOR_CODE_ID, MULTISIG_ACTOR_CODE_ID,
 };
+use fvm_ipld_encoding::RawBytes;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::{address::Address, error::ExitCode};
 
@@ -52,6 +55,47 @@ fn successful_change() {
     h.check_state(&rt);
 }
 
+#[test]
+fn change_owner_address_restricted_correctly() {
+    let (h, mut rt) = setup();
+
+    let params = &RawBytes::serialize(NEW_ADDRESS).unwrap();
+    rt.set_caller(make_identity_cid(b"1234"), h.owner);
+
+    // fail to call the unexported method
+
+    expect_abort_contains_message(
+        ExitCode::USR_FORBIDDEN,
+        "must be built-in",
+        rt.call::<Actor>(Method::ChangeOwnerAddress as u64, params),
+    );
+
+    // can call the exported method
+
+    rt.expect_validate_caller_addr(vec![h.owner]);
+    rt.call::<Actor>(Method::ChangeOwnerAddressExported as u64, params).unwrap();
+
+    rt.verify();
+
+    let info = h.get_info(&rt);
+    assert_eq!(h.owner, info.owner);
+    assert_eq!(NEW_ADDRESS, info.pending_owner_address.unwrap());
+
+    // new owner can also call the exported method
+
+    rt.expect_validate_caller_addr(vec![NEW_ADDRESS]);
+    rt.set_caller(make_identity_cid(b"1234"), NEW_ADDRESS);
+    rt.call::<Actor>(Method::ChangeOwnerAddressExported as u64, params).unwrap();
+
+    rt.verify();
+    let info = h.get_info(&rt);
+    assert_eq!(NEW_ADDRESS, info.owner);
+    assert_eq!(NEW_ADDRESS, info.beneficiary);
+    assert!(info.pending_owner_address.is_none());
+
+    h.check_state(&rt);
+}
+
 #[test]
 fn successful_keep_beneficiary_when_change_owner() {
     let (mut h, mut rt) = setup();

actors/miner/tests/change_peer_id_test.rs

@@ -1,4 +1,9 @@
-use fil_actors_runtime::test_utils::MockRuntime;
+use fil_actor_miner::{Actor, ChangePeerIDParams, GetPeerIDReturn, Method};
+use fil_actors_runtime::test_utils::{
+    expect_abort_contains_message, make_identity_cid, MockRuntime,
+};
+use fvm_ipld_encoding::RawBytes;
+use fvm_shared::error::ExitCode;
 
 mod util;
 use util::*;
@@ -24,3 +29,42 @@ fn successfully_change_peer_id() {
 
     h.check_state(&rt);
 }
+
+#[test]
+fn change_peer_id_restricted_correctly() {
+    let (h, mut rt) = setup();
+
+    let new_id = b"cthulhu".to_vec();
+
+    let params = RawBytes::serialize(ChangePeerIDParams { new_id: new_id.clone() }).unwrap();
+
+    rt.set_caller(make_identity_cid(b"1234"), h.worker);
+
+    // fail to call the unexported setter
+
+    expect_abort_contains_message(
+        ExitCode::USR_FORBIDDEN,
+        "must be built-in",
+        rt.call::<Actor>(Method::ChangePeerID as u64, &params),
+    );
+
+    // call the exported setter
+
+    rt.expect_validate_caller_addr(h.caller_addrs());
+
+    rt.call::<Actor>(Method::ChangePeerIDExported as u64, &params).unwrap();
+
+    // call the exported getter
+
+    rt.expect_validate_caller_any();
+    let ret: GetPeerIDReturn = rt
+        .call::<Actor>(Method::GetPeerIDExported as u64, &RawBytes::default())
+        .unwrap()
+        .deserialize()
+        .unwrap();
+    rt.verify();
+
+    assert_eq!(new_id, ret.peer_id);
+
+    h.check_state(&rt);
+}

actors/miner/tests/change_worker_address_test.rs

@@ -11,6 +11,7 @@ use fvm_ipld_encoding::RawBytes;
 use fvm_shared::{address::Address, econ::TokenAmount, error::ExitCode};
 
 mod util;
+use fil_actors_runtime::test_utils::make_identity_cid;
 use itertools::Itertools;
 use num_traits::Zero;
 use util::*;
@@ -50,7 +51,7 @@ fn successfully_change_only_the_worker_address() {
     rt.set_epoch(deadline.period_end());
     assert!(deadline.period_end() < effective_epoch);
 
-    h.confirm_update_worker_key(&mut rt).unwrap();
+    h.confirm_change_worker_address(&mut rt).unwrap();
 
     let info = h.get_info(&rt);
     assert_eq!(info.pending_worker_key.unwrap().new_worker, new_worker);
@@ -60,7 +61,7 @@ fn successfully_change_only_the_worker_address() {
     rt.set_epoch(effective_epoch);
 
     // enact worker change
-    h.confirm_update_worker_key(&mut rt).unwrap();
+    h.confirm_change_worker_address(&mut rt).unwrap();
 
     // assert address has changed
     let info = h.get_info(&rt);
@@ -73,6 +74,77 @@ fn successfully_change_only_the_worker_address() {
     h.check_state(&rt);
 }
 
+#[test]
+fn change_and_confirm_worker_address_restricted_correctly() {
+    let (h, mut rt) = setup();
+
+    let original_control_addresses = h.control_addrs.clone();
+    let new_worker = Address::new_id(999);
+
+    rt.set_address_actor_type(new_worker, *ACCOUNT_ACTOR_CODE_ID);
+
+    let params = RawBytes::serialize(ChangeWorkerAddressParams {
+        new_worker,
+        new_control_addresses: original_control_addresses,
+    })
+    .unwrap();
+
+    rt.set_caller(make_identity_cid(b"1234"), h.owner);
+
+    // fail to call the unexported method
+
+    expect_abort_contains_message(
+        ExitCode::USR_FORBIDDEN,
+        "must be built-in",
+        rt.call::<Actor>(Method::ChangeWorkerAddress as u64, &params),
+    );
+
+    // call the exported method
+    rt.expect_send(
+        new_worker,
+        AccountMethod::PubkeyAddress as u64,
+        RawBytes::default(),
+        TokenAmount::zero(),
+        RawBytes::serialize(h.worker_key).unwrap(),
+        ExitCode::OK,
+    );
+
+    rt.expect_validate_caller_addr(vec![h.owner]);
+
+    rt.call::<Actor>(Method::ChangeWorkerAddressExported as u64, &params).unwrap();
+
+    rt.verify();
+
+    // assert change has been made in state
+    let pending_worker_key = h.get_info(&rt).pending_worker_key.unwrap();
+    assert_eq!(pending_worker_key.new_worker, new_worker);
+
+    // confirmation time
+
+    // move to deadline containing effective epoch
+    rt.set_epoch(rt.epoch + rt.policy.worker_key_change_delay);
+
+    // fail to call the unexported method
+
+    expect_abort_contains_message(
+        ExitCode::USR_FORBIDDEN,
+        "must be built-in",
+        rt.call::<Actor>(Method::ConfirmChangeWorkerAddress as u64, &RawBytes::default()),
+    );
+
+    // call the exported method
+    rt.expect_validate_caller_addr(vec![h.owner]);
+    rt.call::<Actor>(Method::ConfirmChangeWorkerAddressExported as u64, &RawBytes::default())
+        .unwrap();
+    rt.verify();
+
+    // assert address has changed
+    let info = h.get_info(&rt);
+    assert_eq!(new_worker, info.worker);
+
+    h.check_state(&rt);
+}
+
 #[test]
 fn change_cannot_be_overridden() {
     let (h, mut rt) = setup();
@@ -100,7 +172,7 @@ fn change_cannot_be_overridden() {
     assert_eq!(pending_worker_key.effective_at, effective_epoch);
 
     rt.set_epoch(effective_epoch);
-    h.confirm_update_worker_key(&mut rt).unwrap();
+    h.confirm_change_worker_address(&mut rt).unwrap();
 
     // assert original change is effected
     assert_eq!(new_worker_1, h.get_info(&rt).worker);
@@ -146,7 +218,7 @@ fn successfully_change_both_worker_and_control_addresses() {
 
     // set current epoch and update worker key
     rt.set_epoch(effective_epoch);
-    h.confirm_update_worker_key(&mut rt).unwrap();
+    h.confirm_change_worker_address(&mut rt).unwrap();
 
     // assert both worker and control addresses have changed
     let info = h.get_info(&rt);