fix tests

Author: tediou5

actors/miner/src/lib.rs

@@ -186,7 +186,12 @@ impl Actor {
         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)?;
+        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)?;
         if balance < deposit {
             return Err(actor_error!(insufficient_funds;
                 "not enough balance to lock for create miner deposit: \
@@ -5618,6 +5623,7 @@ fn activate_new_sector_infos(
 pub fn calculate_create_miner_deposit(
     rt: &impl Runtime,
     network_qap: FilterEstimate,
+    sector_size: SectorSize,
 ) -> Result<TokenAmount, ActorError> {
     // set network pledge inputs
     let rew = request_current_epoch_block_reward(rt)?;
@@ -5632,20 +5638,6 @@ pub fn calculate_create_miner_deposit(
         ramp_duration_epochs: pwr.ramp_duration_epochs,
     };
 
-    /// 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());
     let sector_initial_pledge = initial_pledge_for_power(

actors/miner/tests/miner_actor_test_construction.rs

@@ -64,7 +64,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(633318697598976000u64));
+    env.rt.add_balance(TokenAmount::from_atto(798245441765376000u64));
     env
 }
 
@@ -146,18 +146,18 @@ fn simple_construction() {
 
     assert_eq!(TokenAmount::zero(), state.pre_commit_deposits);
     assert_eq!(TokenAmount::from_atto(633318697598976000u64), state.locked_funds);
-    assert_eq!(180, state.load_vesting_funds(&env.rt.store).unwrap().funds.len());
+    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.save_vesting_funds(&env.rt.store, &fil_actor_miner::VestingFunds::new()).unwrap();
+    state.vesting_funds = Default::default();
     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());
+    let create_depost_vesting_funds = state.vesting_funds.load(&env.rt.store).unwrap();
+    assert!(create_depost_vesting_funds.is_empty());
     assert!(state.locked_funds.is_zero());
 
     // according to original specs-actors test, this is set by running the code; magic...

actors/miner/tests/util.rs

@@ -156,7 +156,6 @@ pub struct ActorHarness {
     pub epoch_reward_smooth: FilterEstimate,
     pub epoch_qa_power_smooth: FilterEstimate,
 
-    pub base_fee: TokenAmount,
     pub create_depost: TokenAmount,
 
     pub options: HarnessOptions,
@@ -208,8 +207,8 @@ impl ActorHarness {
             epoch_reward_smooth: FilterEstimate::new(rwd.atto().clone(), BigInt::from(0)),
             epoch_qa_power_smooth: FilterEstimate::new(pwr, BigInt::from(0)),
 
-            base_fee: TokenAmount::zero(),
-            create_depost: TokenAmount::from_atto(633318697598976000u64),
+            create_depost: TokenAmount::from_atto(798245441765376000u64),
+
             options,
         }
     }
@@ -228,22 +227,22 @@ impl ActorHarness {
 
     pub fn check_create_miner_depost_and_reset_state(&self, rt: &MockRuntime) {
         let mut st = self.get_state(&rt);
-        let create_depost_vesting_funds = st.load_vesting_funds(&rt.store).unwrap();
+        let create_depost_vesting_funds = st.vesting_funds.load(&rt.store).unwrap();
 
         // create miner deposit
-        assert!(create_depost_vesting_funds.funds.len() == 180);
+        assert!(create_depost_vesting_funds.len() == 180);
         assert!(st.locked_funds == self.create_depost);
 
         // reset create miner deposit vesting funds
-        st.save_vesting_funds(&rt.store(), &VestingFunds::new()).unwrap();
+        st.vesting_funds = Default::default();
         st.locked_funds = TokenAmount::zero();
         rt.replace_state(&st);
         rt.set_balance(rt.get_balance() - &self.create_depost);
 
         let st = self.get_state(&rt);
-        let create_depost_vesting_funds = st.load_vesting_funds(&rt.store).unwrap();
+        let create_depost_vesting_funds = st.vesting_funds.load(&rt.store).unwrap();
 
-        assert!(create_depost_vesting_funds.funds.is_empty());
+        assert!(create_depost_vesting_funds.is_empty());
         assert!(st.locked_funds.is_zero());
     }
 

integration_tests/src/util/workflows.rs

@@ -160,16 +160,16 @@ pub fn create_miner_internal(
     let wrap_store = DynBlockstore::wrap(v.blockstore());
     vm_api::util::mutate_state(v, &res.id_address, |st: &mut MinerState| {
         // checkcreate miner deposit
-        assert!(st.load_vesting_funds(&wrap_store).unwrap().funds.len() == 180);
+        assert!(st.vesting_funds.load(&wrap_store).unwrap().len() == 180);
         assert!(st.locked_funds == TokenAmount::from_atto(CREATE_MINER_DEPOSIT));
 
         // reset create miner deposit vesting funds
-        st.save_vesting_funds(&wrap_store, &fil_actor_miner::VestingFunds::new()).unwrap();
+        st.vesting_funds = Default::default();
         st.locked_funds = TokenAmount::zero();
     });
 
     let state: MinerState = get_state(v, &res.id_address).unwrap();
-    assert!(state.load_vesting_funds(&wrap_store).unwrap().funds.is_empty());
+    assert!(state.vesting_funds.load(&wrap_store).unwrap().is_empty());
     assert!(state.locked_funds.is_zero());
 
     let mut actor_state = v.actor(&res.id_address).unwrap();