fip-0100: remove batch balancer ("aggregate fee")

Closes: #1611

Author: rvagg

actors/miner/src/lib.rs

@@ -847,8 +847,6 @@ impl Actor {
             emit::sector_activated(rt, pc.info.sector_number, unsealed_cid, &data.pieces)?;
         }
 
-        // The aggregate fee is paid on the sectors successfully proven.
-        pay_aggregate_seal_proof_fee(rt, valid_precommits.len())?;
         Ok(())
     }
 
@@ -1586,22 +1584,8 @@ impl Actor {
         let mut fee_to_burn = TokenAmount::zero();
         let mut needs_cron = false;
         rt.transaction(|state: &mut State, rt| {
-            // Aggregate fee applies only when batching.
-            if sectors.len() > 1 {
-                let aggregate_fee = aggregate_pre_commit_network_fee(sectors.len(), &rt.base_fee());
-                // AggregateFee applied to fee debt to consolidate burn with outstanding debts
-                state.apply_penalty(&aggregate_fee)
-                    .map_err(|e| {
-                        actor_error!(
-                        illegal_state,
-                        "failed to apply penalty: {}",
-                        e
-                    )
-                    })?;
-            }
-            // available balance already accounts for fee debt so it is correct to call
-            // this before RepayDebts. We would have to
-            // subtract fee debt explicitly if we called this after.
+            // Available balance already accounts for fee debt so it is correct to call this before
+            // repay_debts. We would have to subtract fee debt explicitly if we called this after.
             let available_balance = state
                 .get_available_balance(&rt.current_balance())
                 .map_err(|e| {
@@ -1921,13 +1905,6 @@ impl Actor {
             &info,
         )?;
 
-        if !params.aggregate_proof.is_empty() {
-            // Aggregate fee is paid on the sectors successfully proven,
-            // but without regard to data activation which may have subsequently failed
-            // and prevented sector activation.
-            pay_aggregate_seal_proof_fee(rt, proven_activation_inputs.len())?;
-        }
-
         // Notify data consumers.
         let mut notifications: Vec<ActivationNotifications> = vec![];
         for (activations, sector) in &successful_sector_activations {
@@ -2207,13 +2184,6 @@ impl Actor {
 
         burn_funds(rt, fee_to_burn)?;
 
-        let len_for_aggregate_fee = if sectors_len <= NI_AGGREGATE_FEE_BASE_SECTOR_COUNT {
-            0
-        } else {
-            sectors_len - NI_AGGREGATE_FEE_BASE_SECTOR_COUNT
-        };
-        pay_aggregate_seal_proof_fee(rt, len_for_aggregate_fee)?;
-
         notify_pledge_changed(rt, &total_pledge)?;
 
         let state: State = rt.state()?;
@@ -5181,29 +5151,6 @@ fn verify_aggregate_seal(
     .context_code(ExitCode::USR_ILLEGAL_ARGUMENT, "aggregate seal verify failed")
 }
 
-// Compute and burn the aggregate network fee.
-fn pay_aggregate_seal_proof_fee(
-    rt: &impl Runtime,
-    aggregate_size: usize,
-) -> Result<(), ActorError> {
-    // State is loaded afresh as earlier operations for sector/data activation can change it.
-    let state: State = rt.state()?;
-    let aggregate_fee = aggregate_prove_commit_network_fee(aggregate_size, &rt.base_fee());
-    let unlocked_balance = state
-        .get_unlocked_balance(&rt.current_balance())
-        .map_err(|_e| actor_error!(illegal_state, "failed to determine unlocked balance"))?;
-    if unlocked_balance < aggregate_fee {
-        return Err(actor_error!(
-                insufficient_funds,
-                "remaining unlocked funds after prove-commit {} are insufficient to pay aggregation fee of {}",
-                unlocked_balance,
-                aggregate_fee
-            ));
-    }
-    burn_funds(rt, aggregate_fee)?;
-    state.check_balance_invariants(&rt.current_balance()).map_err(balance_invariants_broken)
-}
-
 fn verify_deals(
     rt: &impl Runtime,
     sectors: &[ext::market::SectorDeals],

actors/miner/src/monies.rs

@@ -1,13 +1,13 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use std::cmp::{self, max};
+use std::cmp;
 
 use fil_actors_runtime::network::EPOCHS_IN_DAY;
 use fil_actors_runtime::reward::math::PRECISION;
 use fil_actors_runtime::reward::{smooth, FilterEstimate};
 use fil_actors_runtime::EXPECTED_LEADERS_PER_EPOCH;
-use fvm_shared::bigint::{BigInt, Integer};
+use fvm_shared::bigint::Integer;
 use fvm_shared::clock::ChainEpoch;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::sector::StoragePower;
@@ -107,10 +107,6 @@ pub fn expected_reward_for_power(
 pub mod detail {
     use super::*;
 
-    lazy_static! {
-        pub static ref BATCH_BALANCER: TokenAmount = TokenAmount::from_nano(5);
-    }
-
     // BR but zero values are clamped at 1 attofil
     // Some uses of BR (PCD, IP) require a strictly positive value for BR derived values so
     // accounting variables can be used as succinct indicators of miner activity.
@@ -322,35 +318,3 @@ pub fn locked_reward_from_reward(reward: TokenAmount) -> (TokenAmount, &'static
     let lock_amount = (reward * LOCKED_REWARD_FACTOR_NUM).div_floor(LOCKED_REWARD_FACTOR_DENOM);
     (lock_amount, &REWARD_VESTING_SPEC)
 }
-
-const BATCH_DISCOUNT_NUM: u32 = 1;
-const BATCH_DISCOUNT_DENOM: u32 = 20;
-
-lazy_static! {
-    static ref ESTIMATED_SINGLE_PROVE_COMMIT_GAS_USAGE: BigInt = BigInt::from(49299973);
-    static ref ESTIMATED_SINGLE_PRE_COMMIT_GAS_USAGE: BigInt = BigInt::from(16433324);
-}
-
-pub fn aggregate_prove_commit_network_fee(
-    aggregate_size: usize,
-    base_fee: &TokenAmount,
-) -> TokenAmount {
-    aggregate_network_fee(aggregate_size, &ESTIMATED_SINGLE_PROVE_COMMIT_GAS_USAGE, base_fee)
-}
-
-pub fn aggregate_pre_commit_network_fee(
-    aggregate_size: usize,
-    base_fee: &TokenAmount,
-) -> TokenAmount {
-    aggregate_network_fee(aggregate_size, &ESTIMATED_SINGLE_PRE_COMMIT_GAS_USAGE, base_fee)
-}
-
-pub fn aggregate_network_fee(
-    aggregate_size: usize,
-    gas_usage: &BigInt,
-    base_fee: &TokenAmount,
-) -> TokenAmount {
-    let effective_gas_fee = max(base_fee, &*BATCH_BALANCER);
-    let network_fee_num = effective_gas_fee * gas_usage * aggregate_size * BATCH_DISCOUNT_NUM;
-    network_fee_num.div_floor(BATCH_DISCOUNT_DENOM)
-}

actors/miner/src/policy.rs

@@ -20,9 +20,6 @@ use super::{PowerPair, BASE_REWARD_FOR_DISPUTED_WINDOW_POST};
 /// Precision used for making QA power calculations
 pub const SECTOR_QUALITY_PRECISION: i64 = 20;
 
-/// Base number of sectors before imposing the additional aggregate fee in ProveCommitSectorsNI
-pub const NI_AGGREGATE_FEE_BASE_SECTOR_COUNT: usize = 5;
-
 lazy_static! {
     /// Quality multiplier for committed capacity (no deals) in a sector
     pub static ref QUALITY_BASE_MULTIPLIER: BigInt = BigInt::from(10);

actors/miner/tests/aggregate_network_fee_test.rs

@@ -10,7 +10,6 @@ use fvm_shared::{bigint::BigInt, clock::ChainEpoch, econ::TokenAmount};
 
 mod util;
 use fil_actors_runtime::test_utils::make_piece_cid;
-use num_traits::Zero;
 use util::*;
 
 // an expiration ~10 days greater than effective min expiration taking into account 30 days max
@@ -69,7 +68,6 @@ fn valid_precommits_then_aggregate_provecommit() {
             pcc,
             precommits,
             make_prove_commit_aggregate(&sector_nos_bf),
-            &TokenAmount::zero(),
         )
         .unwrap();