FIP-0077: Add Cost Opportunity For New Miner Creation (#1535)

* feat(FIP-0077): add create miner deposit

* chore: remove magic numbers in tests

* feat: modify the deposit amount to 10% of the previous

* chore: address review comments

Author: tediou5

actors/miner/src/ext.rs

@@ -93,7 +93,7 @@ pub mod power {
     pub const SUBMIT_POREP_FOR_BULK_VERIFY_METHOD: u64 = 8;
     pub const CURRENT_TOTAL_POWER_METHOD: u64 = 9;
 
-    #[derive(Serialize_tuple, Deserialize_tuple)]
+    #[derive(Serialize_tuple, Deserialize_tuple, Default)]
     pub struct CurrentTotalPowerReturn {
         #[serde(with = "bigint_ser")]
         pub raw_byte_power: StoragePower,
@@ -104,6 +104,7 @@ pub mod power {
         pub ramp_start_epoch: i64,
         pub ramp_duration_epochs: u64,
     }
+
     #[derive(Serialize_tuple, Deserialize_tuple)]
     pub struct EnrollCronEventParams {
         pub event_epoch: ChainEpoch,

actors/miner/src/lib.rs

@@ -47,7 +47,9 @@ pub use expiration_queue::*;
 use fil_actors_runtime::cbor::{serialize, serialize_vec};
 use fil_actors_runtime::reward::{FilterEstimate, ThisEpochRewardReturn};
 use fil_actors_runtime::runtime::builtins::Type;
-use fil_actors_runtime::runtime::policy_constants::MAX_SECTOR_NUMBER;
+use fil_actors_runtime::runtime::policy_constants::{
+    CREATE_MINER_DEPOSIT_POWER, MAX_SECTOR_NUMBER,
+};
 use fil_actors_runtime::runtime::{ActorCode, DomainSeparationTag, Policy, Runtime};
 use fil_actors_runtime::{
     ActorContext, ActorDowncast, ActorError, AsActorError, BURNT_FUNDS_ACTOR_ADDR, BatchReturn,
@@ -185,6 +187,14 @@ impl Actor {
         check_peer_info(rt.policy(), &params.peer_id, &params.multi_addresses)?;
         check_valid_post_proof_type(rt.policy(), params.window_post_proof_type)?;
 
+        let balance = rt.current_balance();
+        let deposit = calculate_create_miner_deposit(rt)?;
+        if balance < deposit {
+            return Err(actor_error!(insufficient_funds;
+                "not enough balance to lock for create miner deposit: \
+                sent balance {} < deposit {}", balance.atto(), deposit.atto()));
+        }
+
         let owner = rt.resolve_address(&params.owner).ok_or_else(|| {
             actor_error!(illegal_argument, "unable to resolve owner address: {}", params.owner)
         })?;
@@ -243,7 +253,10 @@ impl Actor {
             e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to construct illegal state")
         })?;
 
-        let st = State::new(policy, rt.store(), info_cid, period_start, deadline_idx)?;
+        let store = rt.store();
+        let mut st = State::new(policy, store, info_cid, period_start, deadline_idx)?;
+        st.add_locked_funds(store, rt.curr_epoch(), &deposit, &REWARD_VESTING_SPEC)
+            .map_err(|e| actor_error!(illegal_state, e))?;
         rt.create(&st)?;
         Ok(())
     }
@@ -5248,6 +5261,23 @@ fn activate_new_sector_infos(
     Ok(())
 }
 
+/// Calculate create miner deposit by MINIMUM_CONSENSUS_POWER x StateMinerInitialPledgeCollateral / 10
+/// See FIP-0077, https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0077.md
+pub fn calculate_create_miner_deposit(rt: &impl Runtime) -> Result<TokenAmount, ActorError> {
+    let rew = request_current_epoch_block_reward(rt)?;
+    let pwr = request_current_total_power(rt)?;
+
+    Ok(initial_pledge_for_power(
+        &BigInt::from(CREATE_MINER_DEPOSIT_POWER),
+        &rew.this_epoch_baseline_power,
+        &rew.this_epoch_reward_smoothed,
+        &pwr.quality_adj_power_smoothed,
+        &rt.total_fil_circ_supply(),
+        rt.curr_epoch() - pwr.ramp_start_epoch,
+        pwr.ramp_duration_epochs,
+    ))
+}
+
 pub struct SectorPiecesActivationInput {
     pub piece_manifests: Vec<PieceActivationManifest>,
     pub sector_expiry: ChainEpoch,

actors/miner/src/state.rs

@@ -208,6 +208,7 @@ impl State {
     pub fn deadline_info(&self, policy: &Policy, current_epoch: ChainEpoch) -> DeadlineInfo {
         new_deadline_info_from_offset_and_epoch(policy, self.proving_period_start, current_epoch)
     }
+
     // Returns deadline calculations for the state recorded proving period and deadline.
     // This is out of date if the a miner does not have an active miner cron
     pub fn recorded_deadline_info(

actors/miner/tests/miner_actor_test_construction.rs

@@ -1,22 +1,27 @@
-use fil_actors_runtime::INIT_ACTOR_ADDR;
-use fil_actors_runtime::test_utils::*;
+use fil_actors_runtime::reward::FilterEstimate;
+use fil_actors_runtime::{INIT_ACTOR_ADDR, REWARD_ACTOR_ADDR};
+use fil_actors_runtime::{STORAGE_POWER_ACTOR_ADDR, test_utils::*};
 
 use fil_actor_account::Method as AccountMethod;
 use fil_actor_miner::{
     Actor, Deadline, Deadlines, Method, MinerConstructorParams as ConstructorParams, State,
 };
+use fil_actor_power::{CurrentTotalPowerReturn, Method as PowerMethod};
+use fil_actor_reward::{Method as RewardMethod, ThisEpochRewardReturn};
 
 use fvm_ipld_encoding::{BytesDe, CborStore};
 use fvm_shared::address::Address;
+use fvm_shared::bigint::BigInt;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ExitCode;
-use fvm_shared::sector::{RegisteredPoStProof, SectorSize};
+use fvm_shared::sector::{RegisteredPoStProof, SectorSize, StoragePower};
 
 use cid::Cid;
 use fvm_ipld_encoding::ipld_block::IpldBlock;
-use num_traits::Zero;
+use num_traits::{FromPrimitive, Zero};
 
 mod util;
+use util::create_miner_deposit_for_test;
 
 #[allow(dead_code)]
 struct TestEnv {
@@ -27,10 +32,16 @@ struct TestEnv {
     control_addrs: Vec<Address>,
     peer_id: Vec<u8>,
     multiaddrs: Vec<BytesDe>,
+    power: StoragePower,
+    reward: TokenAmount,
+    epoch_reward_smooth: FilterEstimate,
     rt: MockRuntime,
 }
 
 fn prepare_env() -> TestEnv {
+    let reward = TokenAmount::from_whole(10);
+    let power = StoragePower::from_i128(1 << 50).unwrap();
+    let epoch_reward_smooth = FilterEstimate::new(reward.atto().clone(), BigInt::from(0u8));
     let mut env = TestEnv {
         receiver: Address::new_id(1000),
         owner: Address::new_id(100),
@@ -39,6 +50,9 @@ fn prepare_env() -> TestEnv {
         control_addrs: vec![Address::new_id(999), Address::new_id(998)],
         peer_id: vec![1, 2, 3],
         multiaddrs: vec![BytesDe(vec![1, 2, 3])],
+        power,
+        reward,
+        epoch_reward_smooth,
         rt: MockRuntime::default(),
     };
 
@@ -50,6 +64,12 @@ fn prepare_env() -> TestEnv {
     env.rt.hash_func = Box::new(hash);
     env.rt.caller.replace(INIT_ACTOR_ADDR);
     env.rt.caller_type.replace(*INIT_ACTOR_CODE_ID);
+    // add balance for create miner deposit
+    env.rt.add_balance(create_miner_deposit_for_test(
+        &env.rt,
+        &env.power,
+        &env.epoch_reward_smooth,
+    ));
     env
 }
 
@@ -67,10 +87,32 @@ fn constructor_params(env: &TestEnv) -> ConstructorParams {
 #[test]
 fn simple_construction() {
     let env = prepare_env();
+    let current_reward = ThisEpochRewardReturn {
+        this_epoch_baseline_power: env.power.clone(),
+        this_epoch_reward_smoothed: env.epoch_reward_smooth.clone(),
+    };
+    let current_total_power = CurrentTotalPowerReturn::default();
+
     let params = constructor_params(&env);
 
     env.rt.set_caller(*INIT_ACTOR_CODE_ID, INIT_ACTOR_ADDR);
     env.rt.expect_validate_caller_addr(vec![INIT_ACTOR_ADDR]);
+    env.rt.expect_send_simple(
+        REWARD_ACTOR_ADDR,
+        RewardMethod::ThisEpochReward as u64,
+        None,
+        TokenAmount::zero(),
+        IpldBlock::serialize_cbor(&current_reward).unwrap(),
+        ExitCode::OK,
+    );
+    env.rt.expect_send_simple(
+        STORAGE_POWER_ACTOR_ADDR,
+        PowerMethod::CurrentTotalPower as u64,
+        Default::default(),
+        TokenAmount::zero(),
+        IpldBlock::serialize_cbor(&current_total_power).unwrap(),
+        ExitCode::OK,
+    );
     env.rt.expect_send_simple(
         env.worker,
         AccountMethod::PubkeyAddress as u64,
@@ -87,7 +129,7 @@ fn simple_construction() {
     expect_empty(result);
     env.rt.verify();
 
-    let state = env.rt.get_state::<State>();
+    let mut state = env.rt.get_state::<State>();
 
     let info = state.get_info(&env.rt.store).unwrap();
     assert_eq!(env.owner, info.owner);
@@ -100,10 +142,24 @@ fn simple_construction() {
     assert_eq!(2349, info.window_post_partition_sectors);
 
     assert_eq!(TokenAmount::zero(), state.pre_commit_deposits);
-    assert_eq!(TokenAmount::zero(), state.locked_funds);
+    assert_eq!(
+        create_miner_deposit_for_test(&env.rt, &env.power, &env.epoch_reward_smooth),
+        state.locked_funds
+    );
+    assert_eq!(180, state.vesting_funds.load(&env.rt.store).unwrap().len());
     assert_ne!(Cid::default(), state.pre_committed_sectors);
     assert_ne!(Cid::default(), state.sectors);
 
+    // reset create miner deposit vesting funds
+    state.vesting_funds = Default::default();
+    state.locked_funds = TokenAmount::zero();
+    env.rt.replace_state(&state);
+
+    let state = env.rt.get_state::<State>();
+    let create_deposit_vesting_funds = state.vesting_funds.load(&env.rt.store).unwrap();
+    assert!(create_deposit_vesting_funds.is_empty());
+    assert!(state.locked_funds.is_zero());
+
     // according to original specs-actors test, this is set by running the code; magic...
     let proving_period_start = -2222;
     assert_eq!(proving_period_start, state.proving_period_start);
@@ -128,9 +184,53 @@ fn simple_construction() {
     util::check_state_invariants_from_mock_runtime(&env.rt);
 }
 
+#[test]
+fn fails_if_insufficient_to_cover_the_miner_creation_deposit() {
+    let env = prepare_env();
+    env.rt.set_balance(TokenAmount::zero());
+    let current_reward = ThisEpochRewardReturn {
+        this_epoch_baseline_power: env.power.clone(),
+        this_epoch_reward_smoothed: env.epoch_reward_smooth.clone(),
+    };
+    let current_total_power = CurrentTotalPowerReturn::default();
+
+    let params = constructor_params(&env);
+
+    env.rt.set_caller(*INIT_ACTOR_CODE_ID, INIT_ACTOR_ADDR);
+    env.rt.expect_validate_caller_addr(vec![INIT_ACTOR_ADDR]);
+    env.rt.expect_send_simple(
+        REWARD_ACTOR_ADDR,
+        RewardMethod::ThisEpochReward as u64,
+        None,
+        TokenAmount::zero(),
+        IpldBlock::serialize_cbor(&current_reward).unwrap(),
+        ExitCode::OK,
+    );
+    env.rt.expect_send_simple(
+        STORAGE_POWER_ACTOR_ADDR,
+        PowerMethod::CurrentTotalPower as u64,
+        Default::default(),
+        TokenAmount::zero(),
+        IpldBlock::serialize_cbor(&current_total_power).unwrap(),
+        ExitCode::OK,
+    );
+
+    expect_abort(
+        ExitCode::USR_INSUFFICIENT_FUNDS,
+        env.rt
+            .call::<Actor>(Method::Constructor as u64, IpldBlock::serialize_cbor(&params).unwrap()),
+    );
+    env.rt.verify();
+}
+
 #[test]
 fn control_addresses_are_resolved_during_construction() {
     let mut env = prepare_env();
+    let current_reward = ThisEpochRewardReturn {
+        this_epoch_baseline_power: env.power.clone(),
+        this_epoch_reward_smoothed: env.epoch_reward_smooth.clone(),
+    };
+    let current_total_power = CurrentTotalPowerReturn::default();
 
     let control1 = new_bls_addr(1);
     let control1id = Address::new_id(555);
@@ -146,6 +246,22 @@ fn control_addresses_are_resolved_during_construction() {
     let params = constructor_params(&env);
     env.rt.set_caller(*INIT_ACTOR_CODE_ID, INIT_ACTOR_ADDR);
     env.rt.expect_validate_caller_addr(vec![INIT_ACTOR_ADDR]);
+    env.rt.expect_send_simple(
+        REWARD_ACTOR_ADDR,
+        RewardMethod::ThisEpochReward as u64,
+        None,
+        TokenAmount::zero(),
+        IpldBlock::serialize_cbor(&current_reward).unwrap(),
+        ExitCode::OK,
+    );
+    env.rt.expect_send_simple(
+        STORAGE_POWER_ACTOR_ADDR,
+        PowerMethod::CurrentTotalPower as u64,
+        Default::default(),
+        TokenAmount::zero(),
+        IpldBlock::serialize_cbor(&current_total_power).unwrap(),
+        ExitCode::OK,
+    );
     env.rt.expect_send_simple(
         env.worker,
         AccountMethod::PubkeyAddress as u64,