add tests to check not eligible for rewards when not have min bonded and cool down starts. initialise default bonded amounts to 0 in implementation

Author: ltfschoen

pallets/mining/rewards-allowance/src/lib.rs

@@ -899,7 +899,8 @@ pub mod pallet {
                 // half of 5000 DHX daily allowance (of 2500 DHX), but in that case we split the rewards
                 // (i.e. 25,133 DHX locked at 10:1 gives 2513 DHX reward)
 
-                let mut locks_first_amount_as_u128 = default_bonded_amount_u128.clone();
+                // initialise so they have no locks and are ineligible for rewards
+                let mut locks_first_amount_as_u128 = 0u128.clone();
                 let locked_vec = <pallet_balances::Pallet<T>>::locks(miner.clone()).into_inner();
                 if locked_vec.len() != 0 {
                     // println!("locked_vec: {:?}", locked_vec);
@@ -916,8 +917,9 @@ pub mod pallet {
                             locks_first_amount_as_u128 = x;
                         }
                     }
-                    log::info!("locks_first_amount_as_u128: {:?}", locks_first_amount_as_u128.clone());
                 }
+                log::info!("locks_first_amount_as_u128: {:?}", locks_first_amount_as_u128.clone());
+                // println!("locks_first_amount_as_u128 {:#?}", locks_first_amount_as_u128);
 
                 // Example output below of vote with 9.9999 tokens on a referendum associated with a proposal
                 // that was seconded
@@ -951,7 +953,6 @@ pub mod pallet {
                         bonded_dhx_current_u128 = x;
                     }
                 }
-                log::info!("set_bonded_dhx_of_account_for_date: {:?} {:?}", start_of_requested_date_millis.clone(), bonded_dhx_current_u128.clone());
 
                 let mut min_bonded_dhx_daily: BalanceOf<T> = 10u32.into();
                 let mut min_bonded_dhx_daily_u128;
@@ -972,6 +973,8 @@ pub mod pallet {
                     is_bonding_min_dhx = true;
                 }
                 log::info!("is_bonding_min_dhx: {:?} {:?}", is_bonding_min_dhx.clone(), miner.clone());
+                // println!("is_bonding_min_dhx {:#?}", is_bonding_min_dhx);
+                // println!("min_bonded_dhx_daily_u128 {:#?}", min_bonded_dhx_daily_u128);
 
                 // TODO - move this into off-chain workers function
                 let mut min_mpower_daily_u128: u128 = 5u128;

pallets/mining/rewards-allowance/src/tests.rs

@@ -53,26 +53,26 @@ fn it_sets_rewards_allowance_with_genesis_defaults_automatically_in_on_finalize_
 // same timestamp for all the blocks and tests below.
 fn it_distributes_rewards_automatically_in_on_finalize_for_default_amount() {
     new_test_ext().execute_with(|| {
-        setup_bonding(NORMAL_AMOUNT, TEN_DHX);
+        let r = setup_bonding(NORMAL_AMOUNT, TEN_DHX);
 
         setup_treasury_balance();
 
         setup_multiplier();
 
-        distribute_rewards(NORMAL_AMOUNT);
+        distribute_rewards(NORMAL_AMOUNT, r);
     })
 }
 
 #[test]
 fn it_distributes_rewards_automatically_in_on_finalize_for_large_amount() {
     new_test_ext().execute_with(|| {
-        setup_bonding(LARGE_AMOUNT_DHX, TEN_DHX);
+        let r = setup_bonding(LARGE_AMOUNT_DHX, TEN_DHX);
 
         setup_treasury_balance();
 
         setup_multiplier();
 
-        distribute_rewards(LARGE_AMOUNT_DHX);
+        distribute_rewards(LARGE_AMOUNT_DHX, r);
     })
 }
 
@@ -282,7 +282,7 @@ fn it_allows_us_to_retrieve_genesis_value_for_min_mpower_daily() {
     });
 }
 
-fn distribute_rewards(amount_bonded_each_miner: u128) {
+fn distribute_rewards(amount_bonded_each_miner: u128, referendum_index: u32) {
     assert_ok!(MiningRewardsAllowanceTestModule::set_registered_dhx_miner(Origin::signed(1)));
     assert_ok!(MiningRewardsAllowanceTestModule::set_registered_dhx_miner(Origin::signed(2)));
     assert_ok!(MiningRewardsAllowanceTestModule::set_registered_dhx_miner(Origin::signed(3)));
@@ -300,6 +300,93 @@ fn distribute_rewards(amount_bonded_each_miner: u128) {
     assert_eq!(MiningRewardsAllowanceTestModule::cooling_off_period_days(), Some(1));
     assert_eq!(MiningRewardsAllowanceTestModule::rewards_allowance_dhx_daily(), Some(FIVE_THOUSAND_DHX));
 
+    check_eligible_for_rewards_after_cooling_off_period_if_suffient_bonded(amount_bonded_each_miner.clone());
+
+    // check that rewards multiplier increases by multiplier every period days and that days total and remaining are reset
+    check_rewards_double_each_multiplier_period();
+
+    // check that after the multiplier doubles, they are no longer eligible to receive the rewards
+    // if they have the same amount bonded (since they’d then need twice the amount bonded as ratio changes from 10:1 to 20:1),
+    // even if they have sufficient mpower
+    check_ineligible_for_rewards_and_cooling_down_period_starts_if_insufficient_bonded(amount_bonded_each_miner.clone(), referendum_index.clone());
+}
+
+fn setup_bonding(amount_bonded_each_miner: u128, min_bonding_dhx_daily: u128) -> u32 {
+    assert_ok!(MiningRewardsAllowanceTestModule::set_min_bonded_dhx_daily(
+        Origin::signed(1),
+        min_bonding_dhx_daily.clone(),
+    ));
+    assert_eq!(MiningRewardsAllowanceTestModule::min_bonded_dhx_daily(), Some(min_bonding_dhx_daily.clone()));
+
+    // create a test that instead of using a hard-coded value for `locks_first_amount_as_u128`
+    // that is in the implementation, it instead sets the locked value of each of them using frame_balances
+    // for the 3x miners, since we can then store that with `set_bonded_dhx_of_account_for_date` and
+    // then use that easier for the tests too for trying different values that they have bonded.
+    //
+    // in this test we'll test that it distributes rewards when each of their account balances are very large
+    // (i.e. a third of the total supply) ONE_THIRD_OF_TOTAL_SUPPLY_DHX
+
+    assert_ok!(Balances::set_balance(Origin::root(), 1, amount_bonded_each_miner, 0));
+    assert_ok!(Balances::set_balance(Origin::root(), 2, amount_bonded_each_miner, 0));
+    assert_ok!(Balances::set_balance(Origin::root(), 3, amount_bonded_each_miner, 0));
+
+    assert_eq!(Balances::free_balance(&1), amount_bonded_each_miner);
+    assert_eq!(Balances::free_balance(&2), amount_bonded_each_miner);
+    assert_eq!(Balances::free_balance(&3), amount_bonded_each_miner);
+
+    assert_eq!(Balances::reserved_balance(&1), 0);
+
+    let pre_image_hash = BlakeTwo256::hash(b"test");
+    // params: end block, proposal hash, threshold, delay
+    let r = Democracy::inject_referendum(1, pre_image_hash.clone(), VoteThreshold::SuperMajorityApprove, 2);
+    // lock the whole balance of account 1, 2, and 3 in voting
+    let v1a1 = AccountVote::Standard { vote: AYE, balance: Balances::free_balance(1) };
+    let v1a2 = AccountVote::Standard { vote: AYE, balance: Balances::free_balance(2) };
+    let v1a3 = AccountVote::Standard { vote: AYE, balance: Balances::free_balance(3) };
+    // vote on referenda using time-lock voting with a conviction to scale the vote power
+    // note: second parameter is the referendum index being voted on
+    assert_ok!(Democracy::vote(Origin::signed(1), r, v1a1));
+    assert_ok!(Democracy::vote(Origin::signed(2), r, v1a2));
+    assert_ok!(Democracy::vote(Origin::signed(3), r, v1a3));
+
+    // // assert_eq!(tally(r), Tally { ayes: 0, nays: 0, turnout: 0 });
+    assert_eq!(Balances::locks(1)[0],
+        BalanceLock {
+            id: [100, 101, 109, 111, 99, 114, 97, 99],
+            amount: amount_bonded_each_miner,
+            reasons: Reasons::Misc
+        }
+    );
+
+    return r;
+}
+
+fn setup_multiplier() {
+    assert_ok!(MiningRewardsAllowanceTestModule::set_rewards_multiplier_operation(
+        Origin::signed(0),
+        1u8,
+    ));
+
+    // in the tests we want the period between each 10:1, 20:1 cycle to be just 2 days instead of 90 days
+    // since we don't want to wait so long to check that it changes each cycle in the tests
+    assert_ok!(MiningRewardsAllowanceTestModule::set_rewards_multiplier_default_period_days(
+        Origin::signed(0),
+        2u32,
+    ));
+
+    assert_ok!(MiningRewardsAllowanceTestModule::set_rewards_multiplier_next_period_days(
+        Origin::signed(0),
+        2u32,
+    ));
+}
+
+fn setup_treasury_balance() {
+    // set the balance of the treasury so it distributes rewards
+    Balances::set_balance(Origin::root(), Treasury::account_id(), INIT_DAO_BALANCE_DHX, 0);
+    assert_eq!(Balances::usable_balance(&Treasury::account_id()), INIT_DAO_BALANCE_DHX);
+}
+
+fn check_eligible_for_rewards_after_cooling_off_period_if_suffient_bonded(amount_bonded_each_miner: u128) {
     // since the timestamp is 0 (corresponds to 1970-01-01) at block number #1, we early exit from on_initialize in
     // that block in the implementation and do not set any storage values associated with the date until block #2.
     // in the tests we could set the timestamp before we run on_initialize(1), but that wouldn't reflect reality.
@@ -339,6 +426,8 @@ fn distribute_rewards(amount_bonded_each_miner: u128) {
     // 29th August 2021 @ 12am is 1630195200000 (start of day)
     Timestamp::set_timestamp(1630195200000u64);
     MiningRewardsAllowanceTestModule::on_initialize(4);
+    // a day before we start the new multiplier period and change from 10:1 to 20:1 since no more days remaining
+    assert_eq!(MiningRewardsAllowanceTestModule::rewards_multiplier_current_period_days_remaining(), Some((1630022400000, 1630195200000, 2u32, 0u32)));
 
     assert_eq!(MiningRewardsAllowanceTestModule::bonded_dhx_of_account_for_date((1630195200000, 1)), Some(amount_bonded_each_miner));
     assert_eq!(MiningRewardsAllowanceTestModule::bonded_dhx_of_account_for_date((1630195200000, 2)), Some(amount_bonded_each_miner));
@@ -397,85 +486,6 @@ fn distribute_rewards(amount_bonded_each_miner: u128) {
     // Update: difficult to add a test to check they are reset before next day, just check it works using the logs.
     // assert_eq!(MiningRewardsAllowanceTestModule::rewards_aggregated_dhx_for_all_miners_for_date(1630281600000), Some(0u128));
     // assert_eq!(MiningRewardsAllowanceTestModule::rewards_accumulated_dhx_for_miner_for_date((1630281600000, 1)), Some(0u128));
-
-    check_rewards_double_each_multiplier_period();
-}
-
-fn setup_bonding(amount_bonded_each_miner: u128, min_bonding_dhx_daily: u128) {
-    assert_ok!(MiningRewardsAllowanceTestModule::set_min_bonded_dhx_daily(
-        Origin::signed(1),
-        min_bonding_dhx_daily.clone(),
-    ));
-    assert_eq!(MiningRewardsAllowanceTestModule::min_bonded_dhx_daily(), Some(min_bonding_dhx_daily.clone()));
-
-    // create a test that instead of using a hard-coded value for `locks_first_amount_as_u128`
-    // that is in the implementation, it instead sets the locked value of each of them using frame_balances
-    // for the 3x miners, since we can then store that with `set_bonded_dhx_of_account_for_date` and
-    // then use that easier for the tests too for trying different values that they have bonded.
-    //
-    // in this test we'll test that it distributes rewards when each of their account balances are very large
-    // (i.e. a third of the total supply) ONE_THIRD_OF_TOTAL_SUPPLY_DHX
-
-    assert_ok!(Balances::set_balance(Origin::root(), 1, amount_bonded_each_miner, 0));
-    assert_ok!(Balances::set_balance(Origin::root(), 2, amount_bonded_each_miner, 0));
-    assert_ok!(Balances::set_balance(Origin::root(), 3, amount_bonded_each_miner, 0));
-
-    assert_eq!(Balances::free_balance(&1), amount_bonded_each_miner);
-    assert_eq!(Balances::free_balance(&2), amount_bonded_each_miner);
-    assert_eq!(Balances::free_balance(&3), amount_bonded_each_miner);
-
-    assert_eq!(Balances::reserved_balance(&1), 0);
-
-    let pre_image_hash = BlakeTwo256::hash(b"test");
-    let r = Democracy::inject_referendum(1, pre_image_hash.clone(), VoteThreshold::SuperMajorityApprove, 2);
-    // lock the whole balance of account 1, 2, and 3 in voting
-    let v1a1 = AccountVote::Standard { vote: AYE, balance: Balances::free_balance(1) };
-    let v1a2 = AccountVote::Standard { vote: AYE, balance: Balances::free_balance(2) };
-    let v1a3 = AccountVote::Standard { vote: AYE, balance: Balances::free_balance(3) };
-    // vote on referenda using time-lock voting with a conviction to scale the vote power
-    // note: second parameter is the referendum index being voted on
-    assert_ok!(Democracy::vote(Origin::signed(1), r, v1a1));
-    assert_ok!(Democracy::vote(Origin::signed(2), r, v1a2));
-    assert_ok!(Democracy::vote(Origin::signed(3), r, v1a3));
-    // let v2 = AccountVote::Split { aye: 1, nay: 2 };
-    // assert_ok!(Democracy::vote(Origin::signed(1), r, v2));
-
-    // TODO - use this later to simulate that unbonding works
-    // // assert_ok!(Democracy::remove_vote(Origin::signed(1), r));
-    // // assert_eq!(tally(r), Tally { ayes: 0, nays: 0, turnout: 0 });
-    // // assert_ok!(Democracy::unlock(Origin::signed(1), 5));
-    assert_eq!(Balances::locks(1)[0],
-        BalanceLock {
-            id: [100, 101, 109, 111, 99, 114, 97, 99],
-            amount: amount_bonded_each_miner,
-            reasons: Reasons::Misc
-        }
-    );
-}
-
-fn setup_multiplier() {
-    assert_ok!(MiningRewardsAllowanceTestModule::set_rewards_multiplier_operation(
-        Origin::signed(0),
-        1u8,
-    ));
-
-    // in the tests we want the period between each 10:1, 20:1 cycle to be just 2 days instead of 90 days
-    // since we don't want to wait so long to check that it changes each cycle in the tests
-    assert_ok!(MiningRewardsAllowanceTestModule::set_rewards_multiplier_default_period_days(
-        Origin::signed(0),
-        2u32,
-    ));
-
-    assert_ok!(MiningRewardsAllowanceTestModule::set_rewards_multiplier_next_period_days(
-        Origin::signed(0),
-        2u32,
-    ));
-}
-
-fn setup_treasury_balance() {
-    // set the balance of the treasury so it distributes rewards
-    Balances::set_balance(Origin::root(), Treasury::account_id(), INIT_DAO_BALANCE_DHX, 0);
-    assert_eq!(Balances::usable_balance(&Treasury::account_id()), INIT_DAO_BALANCE_DHX);
 }
 
 fn check_rewards_double_each_multiplier_period() {
@@ -506,3 +516,69 @@ fn check_rewards_double_each_multiplier_period() {
     // check that the min_bonded_dhx_daily doubled after 3 months (we're only doing it after 2 days in the tests though) from 20 DHX to 30 DHX
     assert_eq!(MiningRewardsAllowanceTestModule::min_bonded_dhx_daily(), Some(THIRTY_DHX));
 }
+
+fn check_ineligible_for_rewards_and_cooling_down_period_starts_if_insufficient_bonded(amount_bonded_each_miner: u128, referendum_index: u32) {
+    // 3rd Sept 2021 @ ~7am is 1630652400000
+    // 3rd Sept 2021 @ 12am is 1630627200000 (start of day)
+    Timestamp::set_timestamp(1630652400000u64);
+    MiningRewardsAllowanceTestModule::on_initialize(8);
+
+    // the below works to unbond each of the accounts
+
+    // check that the referendum that we created earlier still exists
+    assert_eq!(Democracy::referendum_count(), 1, "referenda not created");
+
+    // remove the votes and then unlock for each account
+    // note: `remove_vote` must be done before `unlock`
+    assert_ok!(Democracy::remove_vote(Origin::signed(1), referendum_index));
+    assert_ok!(Democracy::remove_vote(Origin::signed(2), referendum_index));
+    assert_ok!(Democracy::remove_vote(Origin::signed(3), referendum_index));
+    // we removed their votes
+    assert_eq!(Democracy::referendum_status(referendum_index).unwrap().tally, Tally { ayes: 0, nays: 0, turnout: 0 });
+    assert_ok!(Democracy::unlock(Origin::signed(1), 1));
+    assert_ok!(Democracy::unlock(Origin::signed(2), 2));
+    assert_ok!(Democracy::unlock(Origin::signed(3), 3));
+
+    // check that all accounts are unlocked
+    assert_eq!(Balances::locks(1), vec![]);
+    assert_eq!(Balances::locks(2), vec![]);
+    assert_eq!(Balances::locks(3), vec![]);
+
+    // now wait for the next day when we iterate through the miner accounts and they should have no locks
+    // 4th Sept 2021 @ ~7am is 1630738800000
+    // 4th Sept 2021 @ 12am is 1630713600000 (start of day)
+    Timestamp::set_timestamp(1630738800000u64);
+    MiningRewardsAllowanceTestModule::on_initialize(9);
+
+    // IMPORTANT NOTE: The min. DHX bonded has increased from 10 (10:1) to 20 (20:1) in order to be eligible
+    // for rewards, however none of the miner's increased their bonded DHX amount proportionally to still remain
+    // eligible for rewards, so since having insufficient bonded DHX is the same as unbonding, we expect the
+    // cooling off period days remaining to change so they are now going through the unbonding cool down period,
+    // (which we also count using `cooling_off_period_days_remaining`)
+    // where they aren't eligble for rewards until they bond the new min. DHX so cooling off period starts and
+    // then they'd be eligible for rewards after waiting that period, but also note that if they don't bond the new min.
+    // DHX and wait until the end of the cool down period then they'll be able to withdraw the amount they had bonded.
+    //
+    // but in the tests the initial bonded amounts were much more than the min. DHX bonded, so even after it increases
+    // from 10 (10:1) to 20 (20:1) they are still eligible for rewards.
+    // so in the tests we've just decided to remove their vote and `unlock` their bonded DHX so they don't have a lock
+    // and so don't satisfy the min. DHX bonded
+
+    // params: start of date, days remaining, bonding status
+    // note: since they don't have the min. DHX bonded their bonding status changes to `2`, which is unbonding
+    assert_eq!(MiningRewardsAllowanceTestModule::cooling_off_period_days_remaining(1), Some((1630713600000, 1, 2)));
+
+    assert_eq!(MiningRewardsAllowanceTestModule::bonded_dhx_of_account_for_date((1630713600000, 1)), Some(0u128));
+    assert_eq!(MiningRewardsAllowanceTestModule::bonded_dhx_of_account_for_date((1630713600000, 2)), Some(0u128));
+    assert_eq!(MiningRewardsAllowanceTestModule::bonded_dhx_of_account_for_date((1630713600000, 3)), Some(0u128));
+
+    // check they are not eligible for rewards due to insufficient bonded amount
+    assert_eq!(MiningRewardsAllowanceTestModule::rewards_aggregated_dhx_for_all_miners_for_date(1630713600000), None);
+
+    assert_eq!(MiningRewardsAllowanceTestModule::rewards_accumulated_dhx_for_miner_for_date((1630713600000, 1)), None);
+    assert_eq!(MiningRewardsAllowanceTestModule::rewards_accumulated_dhx_for_miner_for_date((1630713600000, 2)), None);
+    assert_eq!(MiningRewardsAllowanceTestModule::rewards_accumulated_dhx_for_miner_for_date((1630713600000, 3)), None);
+
+    assert_eq!(MiningRewardsAllowanceTestModule::rewards_allowance_dhx_for_date_remaining(1630713600000), Some(FIVE_THOUSAND_DHX));
+    assert_eq!(MiningRewardsAllowanceTestModule::rewards_allowance_dhx_for_date_remaining_distributed(1630713600000), Some(false));
+}