chore: remove magic numbers in tests

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

@@ -186,12 +186,7 @@ impl Actor {
         check_valid_post_proof_type(rt.policy(), params.window_post_proof_type)?;
 
         let balance = rt.current_balance();
-        let sector_size = params
-            .window_post_proof_type
-            .sector_size()
-            .map_err(|e| actor_error!(illegal_argument, "invalid sector size: {}", e))?;
-
-        let deposit = calculate_create_miner_deposit(rt, params.network_qap, sector_size)?;
+        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: \
@@ -5446,36 +5441,19 @@ fn activate_new_sector_infos(
 
 /// 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,
-    sector_size: SectorSize,
-) -> Result<TokenAmount, ActorError> {
-    // set network pledge inputs
+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)?;
-    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,
-        epochs_since_ramp_start: rt.curr_epoch() - pwr.ramp_start_epoch,
-        ramp_duration_epochs: pwr.ramp_duration_epochs,
-    };
 
-    let sector_number = MINIMUM_CONSENSUS_POWER / sector_size as i64;
-    let power = qa_power_for_weight(sector_size, MIN_SECTOR_EXPIRATION, &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,
-        pledge_inputs.epochs_since_ramp_start,
-        pledge_inputs.ramp_duration_epochs,
-    );
-    Ok(sector_initial_pledge * sector_number)
+    Ok(initial_pledge_for_power(
+        &BigInt::from(MINIMUM_CONSENSUS_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 {

actors/miner/src/types.rs

@@ -45,7 +45,6 @@ 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)]

actors/miner/tests/miner_actor_test_construction.rs

@@ -1,12 +1,13 @@
+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 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 fvm_ipld_encoding::{BytesDe, CborStore};
 use fvm_shared::address::Address;
@@ -20,6 +21,7 @@ use fvm_ipld_encoding::ipld_block::IpldBlock;
 use num_traits::{FromPrimitive, Zero};
 
 mod util;
+use util::minimum_initial_pledge;
 
 #[allow(dead_code)]
 struct TestEnv {
@@ -40,7 +42,6 @@ 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),
@@ -64,7 +65,7 @@ fn prepare_env() -> TestEnv {
     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(TokenAmount::from_atto(798245441765376000u64));
+    env.rt.add_balance(minimum_initial_pledge(&env.rt, &env.power, &env.epoch_reward_smooth));
     env
 }
 
@@ -76,7 +77,6 @@ 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(),
     }
 }
 
@@ -87,14 +87,7 @@ fn simple_construction() {
         this_epoch_baseline_power: env.power.clone(),
         this_epoch_reward_smoothed: env.epoch_reward_smooth.clone(),
     };
-    let current_total_power = CurrentTotalPowerReturn {
-        raw_byte_power: Default::default(),
-        quality_adj_power: Default::default(),
-        pledge_collateral: Default::default(),
-        quality_adj_power_smoothed: Default::default(),
-        ramp_start_epoch: Default::default(),
-        ramp_duration_epochs: Default::default(),
-    };
+    let current_total_power = CurrentTotalPowerReturn::default();
 
     let params = constructor_params(&env);
 
@@ -145,7 +138,10 @@ fn simple_construction() {
     assert_eq!(2349, info.window_post_partition_sectors);
 
     assert_eq!(TokenAmount::zero(), state.pre_commit_deposits);
-    assert_eq!(TokenAmount::from_atto(633318697598976000u64), state.locked_funds);
+    assert_eq!(
+        minimum_initial_pledge(&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);
@@ -156,8 +152,8 @@ fn simple_construction() {
     env.rt.replace_state(&state);
 
     let state = env.rt.get_state::<State>();
-    let create_depost_vesting_funds = state.vesting_funds.load(&env.rt.store).unwrap();
-    assert!(create_depost_vesting_funds.is_empty());
+    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...
@@ -192,14 +188,7 @@ fn fails_if_insufficient_to_cover_the_miner_creation_deposit() {
         this_epoch_baseline_power: env.power.clone(),
         this_epoch_reward_smoothed: env.epoch_reward_smooth.clone(),
     };
-    let current_total_power = CurrentTotalPowerReturn {
-        raw_byte_power: Default::default(),
-        quality_adj_power: Default::default(),
-        pledge_collateral: Default::default(),
-        quality_adj_power_smoothed: Default::default(),
-        ramp_start_epoch: Default::default(),
-        ramp_duration_epochs: Default::default(),
-    };
+    let current_total_power = CurrentTotalPowerReturn::default();
 
     let params = constructor_params(&env);
 
@@ -237,14 +226,7 @@ fn control_addresses_are_resolved_during_construction() {
         this_epoch_baseline_power: env.power.clone(),
         this_epoch_reward_smoothed: env.epoch_reward_smooth.clone(),
     };
-    let current_total_power = CurrentTotalPowerReturn {
-        raw_byte_power: Default::default(),
-        quality_adj_power: Default::default(),
-        pledge_collateral: Default::default(),
-        quality_adj_power_smoothed: Default::default(),
-        ramp_start_epoch: Default::default(),
-        ramp_duration_epochs: Default::default(),
-    };
+    let current_total_power = CurrentTotalPowerReturn::default();
 
     let control1 = new_bls_addr(1);
     let control1id = Address::new_id(555);

actors/miner/tests/util.rs

@@ -8,6 +8,7 @@ use std::ops::Neg;
 use anyhow::anyhow;
 use cid::Cid;
 use fil_actors_runtime::reward::FilterEstimate;
+use fil_actors_runtime::runtime::policy_constants::MINIMUM_CONSENSUS_POWER;
 use fvm_ipld_amt::Amt;
 use fvm_ipld_bitfield::iter::Ranges;
 use fvm_ipld_bitfield::{BitField, UnvalidatedBitField, Validate};
@@ -38,7 +39,7 @@ use fvm_shared::{ActorID, HAMT_BIT_WIDTH, METHOD_SEND};
 use itertools::Itertools;
 use lazy_static::lazy_static;
 use multihash_codetable::MultihashDigest;
-use num_traits::{FromPrimitive, Signed};
+use num_traits::Signed;
 
 use fil_actor_account::Method as AccountMethod;
 use fil_actor_market::{
@@ -132,6 +133,24 @@ pub fn setup() -> (ActorHarness, MockRuntime) {
     (h, rt)
 }
 
+pub fn minimum_initial_pledge(
+    rt: &MockRuntime,
+    baseline_power: &StoragePower,
+    reward_estimated: &FilterEstimate,
+) -> TokenAmount {
+    let pwr = CurrentTotalPowerReturn::default();
+
+    initial_pledge_for_power(
+        &BigInt::from(MINIMUM_CONSENSUS_POWER),
+        baseline_power,
+        reward_estimated,
+        &pwr.quality_adj_power_smoothed,
+        &rt.circulating_supply.borrow(),
+        *rt.epoch.borrow() - pwr.ramp_start_epoch,
+        pwr.ramp_duration_epochs,
+    )
+}
+
 pub struct ActorHarness {
     pub receiver: Address,
     pub owner: Address,
@@ -155,8 +174,6 @@ pub struct ActorHarness {
     pub epoch_reward_smooth: FilterEstimate,
     pub epoch_qa_power_smooth: FilterEstimate,
 
-    pub create_depost: TokenAmount,
-
     pub options: HarnessOptions,
 }
 
@@ -206,8 +223,6 @@ impl ActorHarness {
             epoch_reward_smooth: FilterEstimate::new(rwd.atto().clone(), BigInt::from(0)),
             epoch_qa_power_smooth: FilterEstimate::new(pwr, BigInt::from(0)),
 
-            create_depost: TokenAmount::from_atto(798245441765376000u64),
-
             options,
         }
     }
@@ -224,24 +239,27 @@ impl ActorHarness {
         check_state_invariants_from_mock_runtime(rt);
     }
 
-    pub fn check_create_miner_depost_and_reset_state(&self, rt: &MockRuntime) {
+    pub fn check_create_miner_deposit_and_reset_state(&self, rt: &MockRuntime) {
+        let create_deposit =
+            minimum_initial_pledge(rt, &self.baseline_power, &self.epoch_reward_smooth);
+
         let mut st = self.get_state(&rt);
-        let create_depost_vesting_funds = st.vesting_funds.load(&rt.store).unwrap();
+        let create_deposit_vesting_funds = st.vesting_funds.load(&rt.store).unwrap();
 
         // create miner deposit
-        assert!(create_depost_vesting_funds.len() == 180);
-        assert!(st.locked_funds == self.create_depost);
+        assert!(create_deposit_vesting_funds.len() == 180);
+        assert!(st.locked_funds == create_deposit);
 
         // reset create miner deposit vesting funds
         st.vesting_funds = Default::default();
         st.locked_funds = TokenAmount::zero();
         rt.replace_state(&st);
-        rt.set_balance(rt.get_balance() - &self.create_depost);
+        rt.set_balance(rt.get_balance() - &create_deposit);
 
         let st = self.get_state(&rt);
-        let create_depost_vesting_funds = st.vesting_funds.load(&rt.store).unwrap();
+        let create_deposit_vesting_funds = st.vesting_funds.load(&rt.store).unwrap();
 
-        assert!(create_depost_vesting_funds.is_empty());
+        assert!(create_deposit_vesting_funds.is_empty());
         assert!(st.locked_funds.is_zero());
     }
 
@@ -271,23 +289,12 @@ impl ActorHarness {
     }
 
     pub fn construct_and_verify(&self, rt: &MockRuntime) {
-        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 current_reward = ThisEpochRewardReturn {
-            this_epoch_baseline_power: power.clone(),
-            this_epoch_reward_smoothed: epoch_reward_smooth.clone(),
+            this_epoch_baseline_power: self.baseline_power.clone(),
+            this_epoch_reward_smoothed: self.epoch_reward_smooth.clone(),
         };
 
-        let current_total_power = CurrentTotalPowerReturn {
-            raw_byte_power: Default::default(),
-            quality_adj_power: Default::default(),
-            pledge_collateral: Default::default(),
-            quality_adj_power_smoothed: Default::default(),
-            ramp_start_epoch: Default::default(),
-            ramp_duration_epochs: Default::default(),
-        };
+        let current_total_power = CurrentTotalPowerReturn::default();
 
         let params = ConstructorParams {
             owner: self.owner,
@@ -296,7 +303,6 @@ impl ActorHarness {
             window_post_proof_type: self.window_post_proof_type,
             peer_id: vec![0],
             multi_addresses: vec![],
-            network_qap: epoch_reward_smooth,
         };
 
         rt.actor_code_cids.borrow_mut().insert(self.owner, *ACCOUNT_ACTOR_CODE_ID);
@@ -305,7 +311,9 @@ impl ActorHarness {
             rt.actor_code_cids.borrow_mut().insert(*a, *ACCOUNT_ACTOR_CODE_ID);
         }
 
-        rt.add_balance(self.create_depost.clone());
+        // set circulating supply non-zero so we get non-zero fees
+        rt.set_circulating_supply(TokenAmount::from_whole(500_000));
+        rt.add_balance(minimum_initial_pledge(rt, &self.baseline_power, &self.epoch_reward_smooth));
         rt.set_caller(*INIT_ACTOR_CODE_ID, INIT_ACTOR_ADDR);
         rt.expect_validate_caller_addr(vec![INIT_ACTOR_ADDR]);
         rt.expect_send_simple(
@@ -332,15 +340,13 @@ impl ActorHarness {
             IpldBlock::serialize_cbor(&self.worker_key).unwrap(),
             ExitCode::OK,
         );
-        // set circulating supply non-zero so we get non-zero fees
-        rt.set_circulating_supply(TokenAmount::from_whole(500_000));
 
         let result = rt
             .call::<Actor>(Method::Constructor as u64, IpldBlock::serialize_cbor(&params).unwrap())
             .unwrap();
         expect_empty(result);
         rt.verify();
-        self.check_create_miner_depost_and_reset_state(rt);
+        self.check_create_miner_deposit_and_reset_state(rt);
     }
 
     pub fn set_peer_id(&self, rt: &MockRuntime, new_id: Vec<u8>) {

actors/power/src/ext.rs

@@ -46,7 +46,6 @@ pub mod miner {
         #[serde(with = "strict_bytes")]
         pub peer_id: Vec<u8>,
         pub multi_addresses: Vec<BytesDe>,
-        pub network_qap: FilterEstimate,
     }
 
     #[derive(Serialize_tuple, Deserialize_tuple)]
@@ -61,7 +60,6 @@ pub mod miner {
 pub mod reward {
     use super::*;
 
-    pub const THIS_EPOCH_REWARD_METHOD: u64 = 3;
     pub const UPDATE_NETWORK_KPI: u64 = 4;
 
     #[derive(FromPrimitive)]

actors/power/src/lib.rs

@@ -83,15 +83,13 @@ impl Actor {
         rt.validate_immediate_caller_accept_any()?;
         let value = rt.message().value_received();
 
-        let state: State = rt.state()?;
         let constructor_params = RawBytes::serialize(ext::miner::MinerConstructorParams {
             owner: params.owner,
             worker: params.worker,
             window_post_proof_type: params.window_post_proof_type,
             peer_id: params.peer,
             multi_addresses: params.multiaddrs,
             control_addresses: Default::default(),
-            network_qap: state.this_epoch_qa_power_smoothed,
         })?;
 
         let miner_actor_code_cid = rt.get_code_cid_for_type(Type::Miner);