feat(FIP-0077): add create miner deposit

Author: tediou5

actors/miner/src/lib.rs

@@ -46,7 +46,7 @@ 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::{MAX_SECTOR_NUMBER, MINIMUM_CONSENSUS_POWER};
 use fil_actors_runtime::runtime::{ActorCode, DomainSeparationTag, Policy, Runtime};
 use fil_actors_runtime::{
     actor_dispatch, actor_error, deserialize_block, extract_send_result, util, ActorContext,
@@ -180,6 +180,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, params.network_qap)?;
+        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)
         })?;
@@ -238,7 +246,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(())
     }
@@ -311,6 +322,7 @@ impl Actor {
             .load_vesting_funds(rt.store())
             .map_err(|e| actor_error!(illegal_state, "failed to load vesting funds: {}", e))?;
         let ret = vesting_funds.funds.into_iter().map(|v| (v.epoch, v.amount)).collect_vec();
+
         Ok(GetVestingFundsReturn { vesting_funds: ret })
     }
 
@@ -755,6 +767,7 @@ impl Actor {
 
         Ok(())
     }
+
     /// Checks state of the corresponding sector pre-commitments and verifies aggregate proof of replication
     /// of these sectors. If valid, the sectors' deals are activated, sectors are assigned a deadline and charged pledge
     /// and precommit state is removed.
@@ -4951,7 +4964,6 @@ fn resolve_worker_address(rt: &impl Runtime, raw: Address) -> Result<ActorID, Ac
 }
 
 fn burn_funds(rt: &impl Runtime, amount: TokenAmount) -> Result<(), ActorError> {
-    log::debug!("storage provder {} burning {}", rt.message().receiver(), amount);
     if amount.is_positive() {
         extract_send_result(rt.send_simple(&BURNT_FUNDS_ACTOR_ADDR, METHOD_SEND, None, amount))?;
     }
@@ -5356,6 +5368,49 @@ fn activate_new_sector_infos(
     Ok(())
 }
 
+/// Calculate create miner deposit by MINIMUM_CONSENSUS_POWER x StateMinerInitialPledgeCollateral
+/// See FIP-0077, https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0077.md
+pub fn calculate_create_miner_deposit(
+    rt: &impl Runtime,
+    network_qap: FilterEstimate,
+) -> Result<TokenAmount, ActorError> {
+    // set network pledge inputs
+    let rew = request_current_epoch_block_reward(rt)?;
+    let circulating_supply = rt.total_fil_circ_supply();
+    let pledge_inputs = NetworkPledgeInputs {
+        network_qap,
+        network_baseline: rew.this_epoch_baseline_power,
+        circulating_supply,
+        epoch_reward: rew.this_epoch_reward_smoothed,
+    };
+
+    /// set sector size with min power
+    #[cfg(feature = "min-power-2k")]
+    let sector_size = SectorSize::_2KiB;
+    #[cfg(feature = "min-power-2g")]
+    let sector_size = SectorSize::_8MiB;
+    #[cfg(feature = "min-power-32g")]
+    let sector_size = SectorSize::_512MiB;
+    #[cfg(not(any(
+        feature = "min-power-2k",
+        feature = "min-power-2g",
+        feature = "min-power-32g"
+    )))]
+    let sector_size = SectorSize::_32GiB;
+
+    let sector_number = MINIMUM_CONSENSUS_POWER / sector_size as i64;
+    let power =
+        qa_power_for_weight(sector_size, MIN_SECTOR_EXPIRATION, &BigInt::zero(), &BigInt::zero());
+    let sector_initial_pledge = initial_pledge_for_power(
+        &power,
+        &pledge_inputs.network_baseline,
+        &pledge_inputs.epoch_reward,
+        &pledge_inputs.network_qap,
+        &pledge_inputs.circulating_supply,
+    );
+    Ok(sector_initial_pledge * sector_number)
+}
+
 pub struct SectorPiecesActivationInput {
     pub piece_manifests: Vec<PieceActivationManifest>,
     pub sector_expiry: ChainEpoch,

actors/miner/src/state.rs

@@ -214,6 +214,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(
@@ -828,6 +829,7 @@ impl State {
                 amount_unlocked
             ));
         }
+
         // add locked funds now
         vesting_funds.add_locked_funds(current_epoch, vesting_sum, self.proving_period_start, spec);
         self.locked_funds += vesting_sum;
@@ -888,6 +890,7 @@ impl State {
 
         Ok(std::mem::take(&mut self.fee_debt))
     }
+
     /// Unlocks an amount of funds that have *not yet vested*, if possible.
     /// The soonest-vesting entries are unlocked first.
     /// Returns the amount actually unlocked.
@@ -959,6 +962,7 @@ impl State {
     pub fn get_unlocked_balance(&self, actor_balance: &TokenAmount) -> anyhow::Result<TokenAmount> {
         let unlocked_balance =
             actor_balance - &self.locked_funds - &self.pre_commit_deposits - &self.initial_pledge;
+
         if unlocked_balance.is_negative() {
             return Err(anyhow!("negative unlocked balance {}", unlocked_balance));
         }
@@ -990,6 +994,7 @@ impl State {
         }
 
         let min_balance = &self.pre_commit_deposits + &self.locked_funds + &self.initial_pledge;
+
         if balance < &min_balance {
             return Err(anyhow!("fee debt is negative: {}", self.fee_debt));
         }

actors/miner/src/testing.rs

@@ -268,8 +268,7 @@ fn check_miner_balances<BS: Blockstore>(
         !state.fee_debt.is_negative(),
         format!("miner fee debt is less than zero: {}", state.fee_debt),
     );
-
-    acc.require(!(balance - &state.locked_funds - &state.pre_commit_deposits - &state.initial_pledge).is_negative(), format!("miner balance {balance} is less than sum of locked funds ({}), precommit deposit ({}) and initial pledge ({})", state.locked_funds, state.pre_commit_deposits, state.initial_pledge));
+    acc.require(!(balance - &state.locked_funds - &state.pre_commit_deposits - &state.initial_pledge).is_negative(), format!("miner balance {balance} is less than sum of locked funds ({}), precommit deposit ({}), initial pledge ({})", state.locked_funds, state.pre_commit_deposits, state.initial_pledge));
 
     // locked funds must be sum of vesting table and vesting table payments must be quantized
     let mut vesting_sum = TokenAmount::zero();

actors/miner/src/types.rs

@@ -45,6 +45,7 @@ pub struct MinerConstructorParams {
     #[serde(with = "strict_bytes")]
     pub peer_id: Vec<u8>,
     pub multi_addresses: Vec<BytesDe>,
+    pub network_qap: FilterEstimate,
 }
 
 #[derive(Serialize_tuple, Deserialize_tuple)]
@@ -105,6 +106,11 @@ pub struct DeferredCronEventParams {
     pub quality_adj_power_smoothed: FilterEstimate,
 }
 
+#[derive(Serialize_tuple, Deserialize_tuple)]
+pub struct LockCreateMinerDepositParams {
+    pub amount: TokenAmount,
+}
+
 #[derive(Serialize_tuple, Deserialize_tuple)]
 pub struct PoStPartition {
     /// Partitions are numbered per-deadline, from zero.

actors/miner/tests/apply_rewards.rs

@@ -43,13 +43,6 @@ fn funds_vest() {
     let rt = h.new_runtime();
     rt.set_balance(BIG_BALANCE.clone());
     h.construct_and_verify(&rt);
-    let st = h.get_state(&rt);
-
-    let vesting_funds = st.load_vesting_funds(&rt.store).unwrap();
-
-    // Nothing vesting to start
-    assert!(vesting_funds.funds.is_empty());
-    assert!(st.locked_funds.is_zero());
 
     // Lock some funds with AddLockedFund
     let amt = TokenAmount::from_atto(600_000);
@@ -115,14 +108,13 @@ fn penalty_is_partially_burnt_and_stored_as_fee_debt() {
     let st = h.get_state(&rt);
     assert!(st.fee_debt.is_zero());
 
-    let amt = rt.get_balance();
+    let amt = BIG_BALANCE.clone();
     let penalty = &amt * 3;
     let reward = amt.clone();
 
     // manually update actor balance to include the added funds on reward message
     let new_balance = &reward + &amt;
     rt.set_balance(new_balance);
-
     rt.set_caller(*REWARD_ACTOR_CODE_ID, REWARD_ACTOR_ADDR);
     rt.expect_validate_caller_addr(vec![REWARD_ACTOR_ADDR]);
 
@@ -163,8 +155,6 @@ fn rewards_pay_back_fee_debt() {
     h.construct_and_verify(&rt);
     let mut st = h.get_state(&rt);
 
-    assert!(st.locked_funds.is_zero());
-
     let amt = rt.get_balance();
     let available_before = h.get_available_balance(&rt).unwrap();
     assert!(available_before.is_positive());

actors/miner/tests/deadline_cron.rs

@@ -30,9 +30,9 @@ fn cron_on_inactive_state() {
     h.construct_and_verify(&rt);
 
     let st = h.get_state(&rt);
-    assert_eq!(PERIOD_OFFSET - rt.policy.wpost_proving_period, st.proving_period_start);
     assert!(!st.continue_deadline_cron());
 
+    assert_eq!(PERIOD_OFFSET - rt.policy.wpost_proving_period, st.proving_period_start);
     // cron does nothing and does not enroll another cron
     let deadline = h.deadline(&rt);
     rt.set_epoch(deadline.last());

actors/miner/tests/miner_actor_test_construction.rs

@@ -1,20 +1,23 @@
+use fil_actors_runtime::reward::FilterEstimate;
 use fil_actors_runtime::test_utils::*;
-use fil_actors_runtime::INIT_ACTOR_ADDR;
+use fil_actors_runtime::{INIT_ACTOR_ADDR, REWARD_ACTOR_ADDR};
 
 use fil_actor_account::Method as AccountMethod;
 use fil_actor_miner::{
     Actor, Deadline, Deadlines, Method, MinerConstructorParams as ConstructorParams, State,
 };
+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;
 
@@ -27,10 +30,19 @@ 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 +51,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 +65,7 @@ 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);
+    env.rt.add_balance(TokenAmount::from_atto(633318697598976000u64));
     env
 }
 
@@ -61,16 +77,29 @@ fn constructor_params(env: &TestEnv) -> ConstructorParams {
         window_post_proof_type: RegisteredPoStProof::StackedDRGWindow32GiBV1P1,
         peer_id: env.peer_id.clone(),
         multi_addresses: env.multiaddrs.clone(),
+        network_qap: env.epoch_reward_smooth.clone(),
     }
 }
 
 #[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 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(
         env.worker,
         AccountMethod::PubkeyAddress as u64,
@@ -87,7 +116,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 +129,21 @@ 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!(TokenAmount::from_atto(633318697598976000u64), state.locked_funds);
+    assert_eq!(180, state.load_vesting_funds(&env.rt.store).unwrap().funds.len());
     assert_ne!(Cid::default(), state.pre_committed_sectors);
     assert_ne!(Cid::default(), state.sectors);
 
+    // reset create miner deposit vesting funds
+    state.save_vesting_funds(&env.rt.store, &fil_actor_miner::VestingFunds::new()).unwrap();
+    state.locked_funds = TokenAmount::zero();
+    env.rt.replace_state(&state);
+
+    let state = env.rt.get_state::<State>();
+    let create_depost_vesting_funds = state.load_vesting_funds(&env.rt.store).unwrap();
+    assert!(create_depost_vesting_funds.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);
@@ -131,6 +171,10 @@ fn simple_construction() {
 #[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 control1 = new_bls_addr(1);
     let control1id = Address::new_id(555);
@@ -146,6 +190,14 @@ 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(
         env.worker,
         AccountMethod::PubkeyAddress as u64,