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