From 7a4c822862bf1348f5a2321f79c34d530139283e Mon Sep 17 00:00:00 2001 From: Rod Vagg Date: Tue, 14 Jan 2025 16:15:41 +1100 Subject: [PATCH] feat(miner): no batch fee in PCD & lower batch balancer to 2 Ref: https://github.com/filecoin-project/FIPs/pull/1094 --- actors/miner/src/lib.rs | 13 -- actors/miner/src/monies.rs | 10 +- .../miner/tests/aggregate_network_fee_test.rs | 91 +++------ .../tests/batch_method_network_fees_test.rs | 184 +----------------- .../tests/miner_actor_test_precommit_batch.rs | 30 +-- .../tests/prove_commit2_failures_test.rs | 6 +- actors/miner/tests/prove_commit2_test.rs | 4 +- actors/miner/tests/util.rs | 24 +-- integration_tests/src/util/workflows.rs | 22 +-- 9 files changed, 65 insertions(+), 319 deletions(-) diff --git a/actors/miner/src/lib.rs b/actors/miner/src/lib.rs index c8f047b3d..96d9c3345 100644 --- a/actors/miner/src/lib.rs +++ b/actors/miner/src/lib.rs @@ -1586,19 +1586,6 @@ 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. diff --git a/actors/miner/src/monies.rs b/actors/miner/src/monies.rs index 9fdef8384..ea655ba75 100644 --- a/actors/miner/src/monies.rs +++ b/actors/miner/src/monies.rs @@ -108,7 +108,7 @@ pub mod detail { use super::*; lazy_static! { - pub static ref BATCH_BALANCER: TokenAmount = TokenAmount::from_nano(5); + pub static ref BATCH_BALANCER: TokenAmount = TokenAmount::from_nano(2); } // BR but zero values are clamped at 1 attofil @@ -328,7 +328,6 @@ 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( @@ -338,13 +337,6 @@ pub fn aggregate_prove_commit_network_fee( 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, diff --git a/actors/miner/tests/aggregate_network_fee_test.rs b/actors/miner/tests/aggregate_network_fee_test.rs index fd2d433ad..7c4f71d36 100644 --- a/actors/miner/tests/aggregate_network_fee_test.rs +++ b/actors/miner/tests/aggregate_network_fee_test.rs @@ -1,89 +1,62 @@ +use fil_actor_miner::aggregate_prove_commit_network_fee; use fil_actor_miner::detail::BATCH_BALANCER; -use fil_actor_miner::{aggregate_pre_commit_network_fee, aggregate_prove_commit_network_fee}; use fvm_shared::econ::TokenAmount; use num_traits::zero; #[test] -fn constant_fee_per_sector_when_base_fee_is_below_5_nfil() { - for fee_func in [aggregate_prove_commit_network_fee, aggregate_pre_commit_network_fee] { - let one_sector_fee = fee_func(1, &zero()); - let ten_sector_fee = fee_func(10, &zero()); - assert_eq!(&one_sector_fee * 10, ten_sector_fee); +fn constant_fee_per_sector_when_base_fee_is_below_batch_balancer() { + let one_sector_fee = aggregate_prove_commit_network_fee(1, &zero()); + let ten_sector_fee = aggregate_prove_commit_network_fee(10, &zero()); + assert_eq!(&one_sector_fee * 10, ten_sector_fee); - let forty_sector_fee = fee_func(40, &TokenAmount::from_nano(1)); - assert_eq!(&one_sector_fee * 40, forty_sector_fee); + let forty_sector_fee = aggregate_prove_commit_network_fee(40, &TokenAmount::from_nano(1)); + assert_eq!(&one_sector_fee * 40, forty_sector_fee); - let two_hundred_sector_fee = fee_func(200, &TokenAmount::from_nano(3)); - assert_eq!(one_sector_fee * 200, two_hundred_sector_fee); - } + let two_hundred_sector_fee = + aggregate_prove_commit_network_fee(200, &TokenAmount::from_nano(2)); + assert_eq!(one_sector_fee * 200, two_hundred_sector_fee); } #[test] fn fee_increases_if_basefee_crosses_threshold() { - for fee_func in [aggregate_prove_commit_network_fee, aggregate_pre_commit_network_fee] { - let at_no_base_fee = fee_func(10, &zero()); - let at_balance_minus_one_base_fee = - fee_func(10, &(&*BATCH_BALANCER - TokenAmount::from_atto(1))); - let at_balance_base_fee = fee_func(10, &BATCH_BALANCER); - let at_balance_plus_one_base_fee = - fee_func(10, &(&*BATCH_BALANCER + TokenAmount::from_nano(1))); - let at_balance_plus_two_base_fee = - fee_func(10, &(&*BATCH_BALANCER + TokenAmount::from_nano(2))); - let at_balance_times_two_base = fee_func(10, &(2 * &*BATCH_BALANCER)); - - assert_eq!(at_no_base_fee, at_balance_minus_one_base_fee); - assert_eq!(at_no_base_fee, at_balance_base_fee); - assert!(at_balance_base_fee < at_balance_plus_one_base_fee); - assert!(at_balance_plus_one_base_fee < at_balance_plus_two_base_fee); - assert_eq!(at_balance_times_two_base, 2 * at_balance_base_fee); - } + let at_no_base_fee = aggregate_prove_commit_network_fee(10, &zero()); + let at_balance_minus_one_base_fee = + aggregate_prove_commit_network_fee(10, &(&*BATCH_BALANCER - TokenAmount::from_atto(1))); + let at_balance_base_fee = aggregate_prove_commit_network_fee(10, &BATCH_BALANCER); + let at_balance_plus_one_base_fee = + aggregate_prove_commit_network_fee(10, &(&*BATCH_BALANCER + TokenAmount::from_nano(1))); + let at_balance_plus_two_base_fee = + aggregate_prove_commit_network_fee(10, &(&*BATCH_BALANCER + TokenAmount::from_nano(2))); + let at_balance_times_two_base = aggregate_prove_commit_network_fee(10, &(2 * &*BATCH_BALANCER)); + + assert_eq!(at_no_base_fee, at_balance_minus_one_base_fee); + assert_eq!(at_no_base_fee, at_balance_base_fee); + assert!(at_balance_base_fee < at_balance_plus_one_base_fee); + assert!(at_balance_plus_one_base_fee < at_balance_plus_two_base_fee); + assert_eq!(at_balance_times_two_base, 2 * at_balance_base_fee); } #[test] fn regression_tests() { - let magic_number = 65733297; + let magic_number = 49299973; let fee = |aggregate_size, base_fee_multiplier| { aggregate_prove_commit_network_fee( aggregate_size, &TokenAmount::from_nano(base_fee_multiplier), - ) + aggregate_pre_commit_network_fee( - aggregate_size, - &TokenAmount::from_nano(base_fee_multiplier), ) }; - // (5/20) * x * 10 = (5/2) * x - let expected = (TokenAmount::from_nano(5) * magic_number).div_floor(2); + // Under batch balancer (2), so these two are the same: + // 2/20 * x * 10 = (2/2) * x = x + let expected = TokenAmount::from_nano(magic_number); assert_eq!(expected, fee(10, 0)); assert_eq!(expected, fee(10, 1)); - let expected = TokenAmount::from_nano(25) * magic_number; + // 3/20 * x * 100 = 15 * x + let expected = TokenAmount::from_nano(15) * magic_number; assert_eq!(expected, fee(100, 3)); + // 6/20 * x * 100 = 30 * x let expected = TokenAmount::from_nano(30) * magic_number; assert_eq!(expected, fee(100, 6)); } - -#[test] -fn split_25_75() { - // check 25/75% split up to uFIL precision - let one_micro_fil = TokenAmount::from_nano(1000); - - for base_fee_multiplier in [0, 5, 20] { - for aggregate_size in [13, 303] { - let fee_pre = aggregate_pre_commit_network_fee( - aggregate_size, - &TokenAmount::from_nano(base_fee_multiplier), - ) - .atto() - / one_micro_fil.atto(); - let fee_prove = aggregate_prove_commit_network_fee( - aggregate_size, - &TokenAmount::from_nano(base_fee_multiplier), - ) - .atto() - / one_micro_fil.atto(); - assert_eq!(fee_prove, 3 * fee_pre); - } - } -} diff --git a/actors/miner/tests/batch_method_network_fees_test.rs b/actors/miner/tests/batch_method_network_fees_test.rs index 7ee093171..b50d9c651 100644 --- a/actors/miner/tests/batch_method_network_fees_test.rs +++ b/actors/miner/tests/batch_method_network_fees_test.rs @@ -1,10 +1,8 @@ -use std::collections::HashMap; - use fil_actor_miner::{ - aggregate_pre_commit_network_fee, aggregate_prove_commit_network_fee, - pre_commit_deposit_for_power, qa_power_max, PreCommitSectorBatchParams, State, + aggregate_prove_commit_network_fee, pre_commit_deposit_for_power, qa_power_max, + PreCommitSectorBatchParams, State, }; -use fil_actors_runtime::test_utils::{expect_abort, expect_abort_contains_message}; +use fil_actors_runtime::test_utils::expect_abort; use fvm_ipld_bitfield::BitField; use fvm_shared::{clock::ChainEpoch, econ::TokenAmount, error::ExitCode}; use lazy_static::lazy_static; @@ -67,166 +65,6 @@ fn insufficient_funds_for_aggregated_prove_commit_network_fee() { rt.reset(); } -#[test] -fn insufficient_funds_for_batch_precommit_network_fee() { - let actor = ActorHarness::new(*PERIOD_OFFSET); - let rt = actor.new_runtime(); - rt.set_balance(BIG_BALANCE.clone()); - let precommit_epoch = *PERIOD_OFFSET + 1; - rt.set_epoch(precommit_epoch); - actor.construct_and_verify(&rt); - let dl_info = actor.deadline(&rt); - // something on deadline boundary but > 180 days - let expiration = - dl_info.period_end() + rt.policy.wpost_proving_period * DEFAULT_SECTOR_EXPIRATION as i64; - - let mut precommits = Vec::new(); - let mut sector_nos_bf = BitField::new(); - for i in 0..4 { - sector_nos_bf.set(i); - let precommit = actor.make_pre_commit_params(i, precommit_epoch - 1, expiration, vec![]); - precommits.push(precommit); - } - - // set base fee extremely high so AggregateProveCommitNetworkFee is > 1000 FIL. Set balance to 1000 FIL to easily cover PCD but not network fee - let balance = TokenAmount::from_whole(1000); - rt.set_balance(balance.clone()); - let base_fee = TokenAmount::from_atto(10u64.pow(16)); - rt.base_fee.replace(base_fee.clone()); - assert!(aggregate_pre_commit_network_fee(precommits.len(), &base_fee) > balance); - - let res = actor.pre_commit_sector_batch( - &rt, - PreCommitSectorBatchParams { sectors: precommits }, - &PreCommitBatchConfig { first_for_miner: true, ..Default::default() }, - &base_fee, - ); - - // state untouched - let state: State = rt.get_state(); - assert!(state.pre_commit_deposits.is_zero()); - let expirations = actor.collect_precommit_expirations(&rt, &state); - assert_eq!(HashMap::new(), expirations); - - expect_abort_contains_message( - ExitCode::USR_INSUFFICIENT_FUNDS, - "unlocked balance can not repay fee debt", - res, - ); - rt.reset(); -} - -#[test] -fn insufficient_funds_for_batch_precommit_in_combination_of_fee_debt_and_network_fee() { - let actor = ActorHarness::new(*PERIOD_OFFSET); - let rt = actor.new_runtime(); - rt.set_balance(BIG_BALANCE.clone()); - let precommit_epoch = *PERIOD_OFFSET + 1; - rt.set_epoch(precommit_epoch); - actor.construct_and_verify(&rt); - let dl_info = actor.deadline(&rt); - // something on deadline boundary but > 180 days - let expiration = - dl_info.period_end() + rt.policy.wpost_proving_period * DEFAULT_SECTOR_EXPIRATION as i64; - - let mut precommits = Vec::new(); - let mut sector_nos_bf = BitField::new(); - for i in 0..4 { - sector_nos_bf.set(i); - let precommit = actor.make_pre_commit_params(i, precommit_epoch - 1, expiration, vec![]); - precommits.push(precommit); - } - - // set base fee extremely high so AggregateProveCommitNetworkFee is > 1000 FIL. Set balance to 1000 FIL to easily cover PCD but not network fee - let base_fee = TokenAmount::from_atto(10u64.pow(16)); - rt.base_fee.replace(base_fee.clone()); - let net_fee = aggregate_pre_commit_network_fee(precommits.len(), &base_fee); - - // setup miner to have fee debt equal to net fee - let mut state: State = rt.get_state(); - state.fee_debt = net_fee.clone(); - rt.replace_state(&state); - - // give miner almost enough balance to pay both - let balance = (2 * net_fee) - TokenAmount::from_atto(1); - rt.set_balance(balance); - - let res = actor.pre_commit_sector_batch( - &rt, - PreCommitSectorBatchParams { sectors: precommits }, - &PreCommitBatchConfig { first_for_miner: true, ..Default::default() }, - &base_fee, - ); - - // state untouched - let state: State = rt.get_state(); - assert!(state.pre_commit_deposits.is_zero()); - let expirations = actor.collect_precommit_expirations(&rt, &state); - assert_eq!(HashMap::new(), expirations); - - expect_abort_contains_message( - ExitCode::USR_INSUFFICIENT_FUNDS, - "unlocked balance can not repay fee debt", - res, - ); - rt.reset(); -} - -#[test] -fn enough_funds_for_fee_debt_and_network_fee_but_not_for_pcd() { - let actor = ActorHarness::new(*PERIOD_OFFSET); - let rt = actor.new_runtime(); - rt.set_balance(BIG_BALANCE.clone()); - let precommit_epoch = *PERIOD_OFFSET + 1; - rt.set_epoch(precommit_epoch); - actor.construct_and_verify(&rt); - let dl_info = actor.deadline(&rt); - // something on deadline boundary but > 180 days - let expiration = - dl_info.period_end() + rt.policy.wpost_proving_period * DEFAULT_SECTOR_EXPIRATION as i64; - - let mut precommits = Vec::new(); - let mut sector_nos_bf = BitField::new(); - for i in 0..4 { - sector_nos_bf.set(i); - let precommit = actor.make_pre_commit_params(i, precommit_epoch - 1, expiration, vec![]); - precommits.push(precommit); - } - - // set base fee and fee debt high - let base_fee = TokenAmount::from_atto(10u64.pow(16)); - rt.base_fee.replace(base_fee.clone()); - let net_fee = aggregate_pre_commit_network_fee(precommits.len(), &base_fee); - // setup miner to have feed debt equal to net fee - let mut state: State = rt.get_state(); - state.fee_debt = net_fee.clone(); - rt.replace_state(&state); - - // give miner enough balance to pay both but not any extra for pcd - let balance = 2 * net_fee; - rt.set_balance(balance); - - let res = actor.pre_commit_sector_batch( - &rt, - PreCommitSectorBatchParams { sectors: precommits }, - &PreCommitBatchConfig { first_for_miner: true, ..Default::default() }, - &base_fee, - ); - - expect_abort_contains_message( - ExitCode::USR_INSUFFICIENT_FUNDS, - "insufficient funds 0.0 for pre-commit deposit", - res, - ); - rt.reset(); - - // state untouched - let state: State = rt.get_state(); - assert!(state.pre_commit_deposits.is_zero()); - let expirations = actor.collect_precommit_expirations(&rt, &state); - assert_eq!(HashMap::new(), expirations); -} - #[test] fn enough_funds_for_everything() { let actor = ActorHarness::new(*PERIOD_OFFSET); @@ -248,24 +86,13 @@ fn enough_funds_for_everything() { precommits.push(precommit); } - // set base fee extremely high so AggregateProveCommitNetworkFee is > 1000 FIL. Set balance to 1000 FIL to easily cover PCD but not network fee - let base_fee = TokenAmount::from_atto(10u64.pow(16)); - rt.base_fee.replace(base_fee.clone()); - let net_fee = aggregate_pre_commit_network_fee(precommits.len(), &base_fee); - - // setup miner to have fee debt equal to net fee - let mut state: State = rt.get_state(); - state.fee_debt = net_fee.clone(); - rt.replace_state(&state); - - // give miner enough balance to pay both and pcd - let mut balance = 2 * net_fee; + // give miner enough balance to pay pcd let expected_deposit = pre_commit_deposit_for_power( &actor.epoch_reward_smooth, &actor.epoch_qa_power_smooth, &qa_power_max(actor.sector_size), ) * precommits.len(); - balance += expected_deposit.clone(); + let balance = expected_deposit.clone(); rt.set_balance(balance); actor @@ -273,7 +100,6 @@ fn enough_funds_for_everything() { &rt, PreCommitSectorBatchParams { sectors: precommits }, &PreCommitBatchConfig { first_for_miner: true, ..Default::default() }, - &base_fee, ) .unwrap(); diff --git a/actors/miner/tests/miner_actor_test_precommit_batch.rs b/actors/miner/tests/miner_actor_test_precommit_batch.rs index 0413fb60c..87934bf03 100644 --- a/actors/miner/tests/miner_actor_test_precommit_batch.rs +++ b/actors/miner/tests/miner_actor_test_precommit_batch.rs @@ -1,7 +1,7 @@ use fil_actor_market::Method as MarketMethod; use fil_actor_miner::{ - aggregate_pre_commit_network_fee, max_prove_commit_duration, pre_commit_deposit_for_power, - qa_power_max, PreCommitSectorBatchParams, PreCommitSectorParams, State, + max_prove_commit_duration, pre_commit_deposit_for_power, qa_power_max, + PreCommitSectorBatchParams, PreCommitSectorParams, State, }; use fil_actor_power::Method as PowerMethod; use fil_actors_runtime::runtime::Policy; @@ -36,7 +36,6 @@ struct DealSpec { fn assert_simple_batch( batch_size: usize, balance_surplus: TokenAmount, - base_fee: TokenAmount, deal_specs: &[DealSpec], exit_code: ExitCode, error_str: &str, @@ -81,21 +80,14 @@ fn assert_simple_batch( &pwr_estimate, ); } - let net_fee = aggregate_pre_commit_network_fee(batch_size, &base_fee); let total_deposit: TokenAmount = deposits.iter().sum(); - let total_balance = net_fee + &total_deposit; - rt.set_balance(total_balance + balance_surplus); + rt.set_balance(&total_deposit + balance_surplus); if exit_code != ExitCode::OK { expect_abort_contains_message( exit_code, error_str, - h.pre_commit_sector_batch( - &rt, - PreCommitSectorBatchParams { sectors }, - &conf, - &base_fee, - ), + h.pre_commit_sector_batch(&rt, PreCommitSectorBatchParams { sectors }, &conf), ); rt.reset(); @@ -110,7 +102,6 @@ fn assert_simple_batch( &rt, PreCommitSectorBatchParams { sectors: sectors.clone() }, &conf, - &base_fee, ); // Check precommits @@ -156,17 +147,17 @@ mod miner_actor_precommit_batch { #[test] fn one_sector() { - assert_simple_batch(1, TokenAmount::zero(), TokenAmount::zero(), &[], ExitCode::OK, ""); + assert_simple_batch(1, TokenAmount::zero(), &[], ExitCode::OK, ""); } #[test] fn thirty_two_sectors() { - assert_simple_batch(32, TokenAmount::zero(), TokenAmount::zero(), &[], ExitCode::OK, ""); + assert_simple_batch(32, TokenAmount::zero(), &[], ExitCode::OK, ""); } #[test] fn max_sectors() { - assert_simple_batch(256, TokenAmount::zero(), TokenAmount::zero(), &[], ExitCode::OK, ""); + assert_simple_batch(256, TokenAmount::zero(), &[], ExitCode::OK, ""); } #[test] @@ -174,7 +165,6 @@ mod miner_actor_precommit_batch { assert_simple_batch( 3, TokenAmount::zero(), - TokenAmount::zero(), &[DealSpec { ids: vec![1], commd: Some(make_piece_cid("1".as_bytes())) }], ExitCode::OK, "", @@ -185,7 +175,6 @@ mod miner_actor_precommit_batch { assert_simple_batch( 3, TokenAmount::zero(), - TokenAmount::zero(), &[ DealSpec { ids: vec![1], commd: Some(make_piece_cid("1".as_bytes())) }, DealSpec { ids: vec![2], commd: Some(make_piece_cid("2".as_bytes())) }, @@ -201,7 +190,6 @@ mod miner_actor_precommit_batch { assert_simple_batch( 0, TokenAmount::zero(), - TokenAmount::zero(), &[], ExitCode::USR_ILLEGAL_ARGUMENT, "batch empty", @@ -213,7 +201,6 @@ mod miner_actor_precommit_batch { assert_simple_batch( Policy::default().pre_commit_sector_batch_max_size + 1, TokenAmount::zero(), - TokenAmount::zero(), &[], ExitCode::USR_ILLEGAL_ARGUMENT, "batch of 257 too large", @@ -224,7 +211,6 @@ mod miner_actor_precommit_batch { assert_simple_batch( 10, TokenAmount::from_atto(-1), - TokenAmount::zero(), &[], ExitCode::USR_INSUFFICIENT_FUNDS, "insufficient funds", @@ -267,7 +253,6 @@ mod miner_actor_precommit_batch { &rt, PreCommitSectorBatchParams { sectors }, &PreCommitBatchConfig { sector_unsealed_cid: vec![], first_for_miner: true }, - &TokenAmount::zero(), ), ); rt.reset(); @@ -304,7 +289,6 @@ mod miner_actor_precommit_batch { &rt, PreCommitSectorBatchParams { sectors }, &PreCommitBatchConfig { sector_unsealed_cid: vec![], first_for_miner: true }, - &TokenAmount::zero(), ), ); rt.reset(); diff --git a/actors/miner/tests/prove_commit2_failures_test.rs b/actors/miner/tests/prove_commit2_failures_test.rs index 028ccb383..c1d5d7408 100644 --- a/actors/miner/tests/prove_commit2_failures_test.rs +++ b/actors/miner/tests/prove_commit2_failures_test.rs @@ -3,7 +3,7 @@ use fvm_shared::address::Address; use fvm_shared::deal::DealID; use fvm_shared::error::ExitCode; use fvm_shared::sector::SectorNumber; -use fvm_shared::{bigint::Zero, clock::ChainEpoch, econ::TokenAmount, ActorID}; +use fvm_shared::{clock::ChainEpoch, ActorID}; use fil_actor_miner::ext::verifreg::AllocationID; use fil_actor_miner::{ @@ -134,7 +134,7 @@ fn reject_precommit_deals() { &[&[piece_size], &[piece_size]], ); precommits[0].deal_ids.push(1); - h.pre_commit_sector_batch_v2(&rt, &precommits, true, &TokenAmount::zero()).unwrap(); + h.pre_commit_sector_batch_v2(&rt, &precommits, true).unwrap(); rt.set_epoch(precommit_epoch + rt.policy.pre_commit_challenge_delay + 1); let manifests: Vec = precommits @@ -274,7 +274,7 @@ fn setup_precommits( sector_expiry, &piece_sizes, ); - h.pre_commit_sector_batch_v2(&rt, &precommits, true, &TokenAmount::zero()).unwrap(); + h.pre_commit_sector_batch_v2(&rt, &precommits, true).unwrap(); rt.set_epoch(precommit_epoch + rt.policy.pre_commit_challenge_delay + 1); let manifests = precommits diff --git a/actors/miner/tests/prove_commit2_test.rs b/actors/miner/tests/prove_commit2_test.rs index a2aaea21c..61442a57a 100644 --- a/actors/miner/tests/prove_commit2_test.rs +++ b/actors/miner/tests/prove_commit2_test.rs @@ -1,7 +1,7 @@ use fvm_ipld_encoding::RawBytes; use fvm_shared::error::ExitCode; use fvm_shared::sector::SectorNumber; -use fvm_shared::{bigint::Zero, clock::ChainEpoch, econ::TokenAmount, ActorID}; +use fvm_shared::{clock::ChainEpoch, ActorID}; use fil_actor_miner::ext::verifreg::{AllocationClaim, SectorAllocationClaims}; use fil_actor_miner::{ @@ -521,7 +521,7 @@ fn precommit_sectors_from( sector_expiry, piece_sizes, ); - h.pre_commit_sector_batch_v2(rt, &precommits, first_for_miner, &TokenAmount::zero()).unwrap(); + h.pre_commit_sector_batch_v2(rt, &precommits, first_for_miner).unwrap(); rt.set_epoch(precommit_epoch + rt.policy.pre_commit_challenge_delay + 1); precommits } diff --git a/actors/miner/tests/util.rs b/actors/miner/tests/util.rs index fdbceb349..de2e088ac 100644 --- a/actors/miner/tests/util.rs +++ b/actors/miner/tests/util.rs @@ -47,8 +47,7 @@ use fil_actor_market::{ VerifyDealsForActivationParams, VerifyDealsForActivationReturn, NO_ALLOCATION_ID, }; use fil_actor_miner::{ - aggregate_pre_commit_network_fee, aggregate_prove_commit_network_fee, consensus_fault_penalty, - ext, + aggregate_prove_commit_network_fee, consensus_fault_penalty, ext, ext::market::ON_MINER_SECTORS_TERMINATE_METHOD, ext::power::UPDATE_CLAIMED_POWER_METHOD, ext::verifreg::{ @@ -578,7 +577,6 @@ impl ActorHarness { rt: &MockRuntime, params: PreCommitSectorBatchParams, conf: &PreCommitBatchConfig, - base_fee: &TokenAmount, ) -> Result, ActorError> { let v2: Vec<_> = params .sectors @@ -595,7 +593,7 @@ impl ActorHarness { }) .collect(); - return self.pre_commit_sector_batch_v2(rt, &v2, conf.first_for_miner, base_fee); + return self.pre_commit_sector_batch_v2(rt, &v2, conf.first_for_miner); } pub fn pre_commit_sector_batch_v2( @@ -603,7 +601,6 @@ impl ActorHarness { rt: &MockRuntime, sectors: &[SectorPreCommitInfo], first_for_miner: bool, - base_fee: &TokenAmount, ) -> Result, ActorError> { rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, self.worker); rt.expect_validate_caller_addr(self.caller_addrs()); @@ -640,13 +637,9 @@ impl ActorHarness { let state = self.get_state(rt); - let mut expected_network_fee = TokenAmount::zero(); - if sectors.len() > 1 { - expected_network_fee = aggregate_pre_commit_network_fee(sectors.len(), base_fee); - } // burn networkFee - if state.fee_debt.is_positive() || expected_network_fee.is_positive() { - let expected_burn = expected_network_fee + state.fee_debt; + if state.fee_debt.is_positive() { + let expected_burn = state.fee_debt; rt.expect_send_simple( BURNT_FUNDS_ACTOR_ADDR, METHOD_SEND, @@ -691,9 +684,8 @@ impl ActorHarness { rt: &MockRuntime, params: PreCommitSectorBatchParams, conf: &PreCommitBatchConfig, - base_fee: &TokenAmount, ) -> Vec { - let result = self.pre_commit_sector_batch(rt, params.clone(), conf, base_fee).unwrap(); + let result = self.pre_commit_sector_batch(rt, params.clone(), conf).unwrap(); expect_empty(result); rt.verify(); @@ -712,7 +704,6 @@ impl ActorHarness { rt, PreCommitSectorBatchParams { sectors: vec![params] }, &PreCommitBatchConfig { sector_unsealed_cid: vec![conf.0], first_for_miner: first }, - &self.base_fee, ); result } @@ -723,7 +714,7 @@ impl ActorHarness { sectors: Vec, first: bool, ) -> Vec { - let result = self.pre_commit_sector_batch_v2(rt, §ors, first, &self.base_fee).unwrap(); + let result = self.pre_commit_sector_batch_v2(rt, §ors, first).unwrap(); expect_empty(result); rt.verify(); @@ -742,7 +733,6 @@ impl ActorHarness { rt, PreCommitSectorBatchParams { sectors: vec![params] }, &PreCommitBatchConfig { sector_unsealed_cid: vec![conf.0], first_for_miner: first }, - &self.base_fee, ); rt.verify(); result[0].clone() @@ -3370,7 +3360,7 @@ pub fn onboard_sectors( precommits: &[SectorPreCommitInfo], ) -> Vec { // Precommit sectors in batch. - h.pre_commit_sector_batch_v2(rt, &precommits, true, &TokenAmount::zero()).unwrap(); + h.pre_commit_sector_batch_v2(rt, &precommits, true).unwrap(); let precommits: Vec = precommits.iter().map(|sector| h.get_precommit(rt, sector.sector_number)).collect(); diff --git a/integration_tests/src/util/workflows.rs b/integration_tests/src/util/workflows.rs index 2ff417c3c..8b6b66702 100644 --- a/integration_tests/src/util/workflows.rs +++ b/integration_tests/src/util/workflows.rs @@ -38,14 +38,14 @@ use fil_actor_market::{ PublishStorageDealsReturn, SectorDeals, State as MarketState, MARKET_NOTIFY_DEAL_METHOD, }; use fil_actor_miner::{ - aggregate_pre_commit_network_fee, aggregate_prove_commit_network_fee, - max_prove_commit_duration, ChangeBeneficiaryParams, CompactCommD, DataActivationNotification, - DeadlineInfo, DeclareFaultsRecoveredParams, ExpirationExtension2, - ExtendSectorExpiration2Params, Method as MinerMethod, PieceActivationManifest, PoStPartition, - PowerPair, PreCommitSectorBatchParams2, ProveCommitAggregateParams, ProveCommitSectors3Params, - RecoveryDeclaration, SectorActivationManifest, SectorClaim, SectorPreCommitInfo, - SectorPreCommitOnChainInfo, State as MinerState, SubmitWindowedPoStParams, - VerifiedAllocationKey, WithdrawBalanceParams, WithdrawBalanceReturn, + aggregate_prove_commit_network_fee, max_prove_commit_duration, ChangeBeneficiaryParams, + CompactCommD, DataActivationNotification, DeadlineInfo, DeclareFaultsRecoveredParams, + ExpirationExtension2, ExtendSectorExpiration2Params, Method as MinerMethod, + PieceActivationManifest, PoStPartition, PowerPair, PreCommitSectorBatchParams2, + ProveCommitAggregateParams, ProveCommitSectors3Params, RecoveryDeclaration, + SectorActivationManifest, SectorClaim, SectorPreCommitInfo, SectorPreCommitOnChainInfo, + State as MinerState, SubmitWindowedPoStParams, VerifiedAllocationKey, WithdrawBalanceParams, + WithdrawBalanceReturn, }; use fil_actor_multisig::Method as MultisigMethod; use fil_actor_multisig::ProposeParams; @@ -270,12 +270,6 @@ pub fn precommit_sectors_v2_expect_code( if !sectors_with_deals.is_empty() { invocs.push(Expect::market_verify_deals(miner_id, sectors_with_deals.clone())); } - if param_sectors.len() > 1 { - invocs.push(Expect::burn( - miner_id, - Some(aggregate_pre_commit_network_fee(param_sectors.len(), &TokenAmount::zero())), - )); - } if expect_cron_enroll && msg_sector_idx_base == 0 { invocs.push(Expect::power_enrol_cron(miner_id)); }