Baseline bug fix (FIP-0081)

actors/miner/src/ext.rs

@@ -92,6 +92,7 @@ pub mod power {
     pub const UPDATE_PLEDGE_TOTAL_METHOD: u64 = 6;
     pub const SUBMIT_POREP_FOR_BULK_VERIFY_METHOD: u64 = 8;
     pub const CURRENT_TOTAL_POWER_METHOD: u64 = 9;
+    pub const MINER_RAMP_PARAMS_METHOD: u64 = 10;  // TODO: how to set this value properly??
 
     #[derive(Serialize_tuple, Deserialize_tuple)]
     pub struct CurrentTotalPowerReturn {
@@ -116,6 +117,11 @@ pub mod power {
         pub quality_adjusted_delta: StoragePower,
     }
 
+    #[derive(Serialize_tuple, Deserialize_tuple)]
+    pub struct MinerRampParamsReturn {
+        pub ramp_duration_epochs: u64
+    }
+
     pub const MAX_MINER_PROVE_COMMITS_PER_EPOCH: usize = 200;
 }
 

actors/miner/src/lib.rs

@@ -811,11 +811,13 @@ impl Actor {
         let rew = request_current_epoch_block_reward(rt)?;
         let pwr = request_current_total_power(rt)?;
         let circulating_supply = rt.total_fil_circ_supply();
+        let ramp_duration_epochs = request_miner_ramp_params(rt)?.ramp_duration_epochs;
         let pledge_inputs = NetworkPledgeInputs {
             network_qap: pwr.quality_adj_power_smoothed,
             network_baseline: rew.this_epoch_baseline_power,
             circulating_supply,
             epoch_reward: rew.this_epoch_reward_smoothed,
+            ramp_duration_epochs: ramp_duration_epochs,
         };
 
         /*
@@ -1908,11 +1910,13 @@ impl Actor {
         let rew = request_current_epoch_block_reward(rt)?;
         let pwr = request_current_total_power(rt)?;
         let circulating_supply = rt.total_fil_circ_supply();
+        let ramp_duration_epochs = request_miner_ramp_params(rt)?.ramp_duration_epochs;
         let pledge_inputs = NetworkPledgeInputs {
             network_qap: pwr.quality_adj_power_smoothed,
             network_baseline: rew.this_epoch_baseline_power,
             circulating_supply,
             epoch_reward: rew.this_epoch_reward_smoothed,
+            ramp_duration_epochs: ramp_duration_epochs
         };
         activate_new_sector_infos(
             rt,
@@ -3844,11 +3848,13 @@ where
     let rew = request_current_epoch_block_reward(rt)?;
     let pow = request_current_total_power(rt)?;
     let circulating_supply = rt.total_fil_circ_supply();
+    let ramp_duration_epochs = request_miner_ramp_params(rt)?.ramp_duration_epochs;
     let pledge_inputs = NetworkPledgeInputs {
         network_qap: pow.quality_adj_power_smoothed,
         network_baseline: rew.this_epoch_baseline_power,
         circulating_supply,
         epoch_reward: rew.this_epoch_reward_smoothed,
+        ramp_duration_epochs: ramp_duration_epochs
     };
     let mut power_delta = PowerPair::zero();
     let mut pledge_delta = TokenAmount::zero();
@@ -4045,6 +4051,7 @@ fn update_existing_sector_info(
             &pledge_inputs.epoch_reward,
             &pledge_inputs.network_qap,
             &pledge_inputs.circulating_supply,
+            &pledge_inputs.ramp_duration_epochs,
         ),
     );
     new_sector_info
@@ -4803,6 +4810,21 @@ fn request_current_total_power(
     )
 }
 
+/// Request the ramp duration from the power actor
+fn request_miner_ramp_params(
+    rt: &impl Runtime,
+) -> Result<ext::power::MinerRampParamsReturn, ActorError> {
+    deserialize_block(
+        extract_send_result(rt.send_simple(
+            &STORAGE_POWER_ACTOR_ADDR,
+            ext::power::MINER_RAMP_PARAMS_METHOD,
+            Default::default(),
+            TokenAmount::zero(),
+        ))
+        .map_err(|e| e.wrap("failed to check miner ramp params"))?,
+    )
+}
+
 /// Resolves an address to an ID address and verifies that it is address of an account actor with an associated BLS key.
 /// The worker must be BLS since the worker key will be used alongside a BLS-VRF.
 fn resolve_worker_address(rt: &impl Runtime, raw: Address) -> Result<ActorID, ActorError> {
@@ -5166,6 +5188,7 @@ fn activate_new_sector_infos(
                 &pledge_inputs.epoch_reward,
                 &pledge_inputs.network_qap,
                 &pledge_inputs.circulating_supply,
+                &pledge_inputs.ramp_duration_epochs,
             );
 
             deposit_to_unlock += pci.pre_commit_deposit.clone();
@@ -5578,6 +5601,7 @@ struct NetworkPledgeInputs {
     pub network_baseline: StoragePower,
     pub circulating_supply: TokenAmount,
     pub epoch_reward: FilterEstimate,
+    pub ramp_duration_epochs: u64
 }
 
 // Note: probably better to push this one level down into state

actors/miner/src/monies.rs

@@ -75,6 +75,8 @@ pub const TERMINATION_LIFETIME_CAP: ChainEpoch = 140;
 // Multiplier of whole per-winner rewards for a consensus fault penalty.
 const CONSENSUS_FAULT_FACTOR: u64 = 5;
 
+const FIXED_POINT_FACTOR: i64 = 1000; // 3 decimal places
+
 /// The projected block reward a sector would earn over some period.
 /// Also known as "BR(t)".
 /// BR(t) = ProjectedRewardFraction(t) * SectorQualityAdjustedPower
@@ -255,6 +257,7 @@ pub fn initial_pledge_for_power(
     reward_estimate: &FilterEstimate,
     network_qa_power_estimate: &FilterEstimate,
     circulating_supply: &TokenAmount,
+    epochs_since_ramp_start: i64,
 ) -> TokenAmount {
     let ip_base = expected_reward_for_power_clamped_at_atto_fil(
         reward_estimate,
@@ -267,10 +270,30 @@ pub fn initial_pledge_for_power(
     let lock_target_denom = LOCK_TARGET_FACTOR_DENOM;
     let pledge_share_num = qa_power;
     let network_qa_power = network_qa_power_estimate.estimate();
-    let pledge_share_denom = cmp::max(cmp::max(&network_qa_power, baseline_power), qa_power);
+
+    // Compute gamma based on current_epoch
+    let mut gamma = FIXED_POINT_FACTOR; // Initialize as 1000
+    if epochs_since_ramp_start > 0 {
+        if epochs_since_ramp_start as u64 < RAMP_DURATION_EPOCHS {
+            let reduction = (300 * FIXED_POINT_FACTOR) / RAMP_DURATION_EPOCHS; // 0.3 as fixed-point
+            gamma -= reduction;
+        } else {
+            gamma = 700; // 0.7 as fixed-point
+        }
+    }
+
     let additional_ip_num = lock_target_num * pledge_share_num;
-    let additional_ip_denom = pledge_share_denom * lock_target_denom;
-    let additional_ip = additional_ip_num.div_floor(&additional_ip_denom);
+
+    let pledge_share_denom_baseline = cmp::max(cmp::max(&network_qa_power, baseline_power), qa_power);
+    let pledge_share_denom_simple = cmp::max(network_qa_power, qa_power);
+
+    let additional_ip_denom_baseline = pledge_share_denom_baseline * lock_target_denom;
+    let additional_ip_baseline = additional_ip_num.div_floor(&additional_ip_denom_baseline);
+    let additional_ip_denom_simple = pledge_share_denom_simple * lock_target_denom;
+    let additional_ip_simple = additional_ip_num.div_floor(&additional_ip_denom_simple);
+
+    // convex combination of simple and baseline pledge
+    let additional_ip = (additional_ip_baseline * gamma + additional_ip_simple * (FIXED_POINT_FACTOR - gamma)) / FIXED_POINT_FACTOR;
 
     let nominal_pledge = ip_base + TokenAmount::from_atto(additional_ip);
     let pledge_cap = TokenAmount::from_atto(INITIAL_PLEDGE_MAX_PER_BYTE.atto() * qa_power);

actors/power/src/lib.rs

@@ -316,6 +316,13 @@ impl Actor {
         Ok(MinerConsensusCountReturn { miner_consensus_count: st.miner_above_min_power_count })
     }
 
+    fn ramp_duration(rt: &impl Runtime) -> Result<u64, ActorError> {
+        rt.validate_immediate_caller_accept_any()?;
+        let st: State = rt.state()?;
+
+        Ok(st.ramp_duration_epochs)
+    }
+
     fn process_deferred_cron_events(
         rt: &impl Runtime,
         rewret: ThisEpochRewardReturn,
@@ -438,5 +445,6 @@ impl ActorCode for Actor {
         MinerRawPowerExported => miner_raw_power,
         MinerCountExported => miner_count,
         MinerConsensusCountExported => miner_consensus_count,
+        RampDurationExported => ramp_duration,
     }
 }

actors/power/src/state.rs

@@ -44,6 +44,8 @@ pub const CRON_QUEUE_AMT_BITWIDTH: u32 = 6;
 pub type ClaimsMap<BS> = Map2<BS, Address, Claim>;
 pub const CLAIMS_CONFIG: Config = DEFAULT_HAMT_CONFIG;
 
+const RAMP_DURATION_EPOCHS: u64 = 365 * 2880; // 1Y
+
 /// Storage power actor state
 #[derive(Default, Serialize_tuple, Deserialize_tuple, Clone, Debug)]
 pub struct State {
@@ -68,6 +70,8 @@ pub struct State {
     /// Number of miners having proven the minimum consensus power.
     pub miner_above_min_power_count: i64,
 
+    pub ramp_duration_epochs: u64,
+
     /// A queue of events to be triggered by cron, indexed by epoch.
     pub cron_event_queue: Cid, // Multimap, (HAMT[ChainEpoch]AMT[CronEvent]