Merge pull request #4828 from fizyk20/fix-gsug-unbonds-2

Fix handling of unbonds in global-state-update-gen

Author: sacherjj

utils/global-state-update-gen/src/generic.rs

@@ -120,6 +120,17 @@ fn update_auction_state<T: StateReader>(
 
     let validators_diff = validators_diff(&old_snapshot, &new_snapshot);
 
+    let bids = state.get_bids();
+    if slash {
+        // zero the unbonds for the removed validators independently of set_bid; set_bid will take
+        // care of zeroing the delegators if necessary
+        for pub_key in &validators_diff.removed {
+            if let Some(bid) = bids.get(pub_key) {
+                state.remove_withdraws_and_unbonds_with_bonding_purse(bid.bonding_purse());
+            }
+        }
+    }
+
     add_and_remove_bids(
         state,
         &validators_diff,
@@ -128,10 +139,6 @@ fn update_auction_state<T: StateReader>(
         slash,
     );
 
-    if slash {
-        state.remove_withdraws_and_unbonds(&validators_diff.removed);
-    }
-
     // We need to output the validators for the next era, which are contained in the first entry
     // in the snapshot.
     Some(

utils/global-state-update-gen/src/generic/state_reader.rs

@@ -2,7 +2,10 @@ use casper_engine_test_support::LmdbWasmTestBuilder;
 use casper_types::{
     account::{Account, AccountHash},
     system::{
-        auction::{Bids, UnbondingPurses, WithdrawPurses, SEIGNIORAGE_RECIPIENTS_SNAPSHOT_KEY},
+        auction::{
+            Bids, UnbondingPurses, WithdrawPurses, SEIGNIORAGE_RECIPIENTS_SNAPSHOT_KEY,
+            UNBONDING_DELAY_KEY,
+        },
         mint::TOTAL_SUPPLY_KEY,
     },
     Key, StoredValue,
@@ -22,6 +25,8 @@ pub trait StateReader {
     fn get_withdraws(&mut self) -> WithdrawPurses;
 
     fn get_unbonds(&mut self) -> UnbondingPurses;
+
+    fn get_unbonding_delay(&mut self) -> u64;
 }
 
 impl<'a, T> StateReader for &'a mut T
@@ -55,6 +60,10 @@ where
     fn get_unbonds(&mut self) -> UnbondingPurses {
         T::get_unbonds(self)
     }
+
+    fn get_unbonding_delay(&mut self) -> u64 {
+        T::get_unbonding_delay(self)
+    }
 }
 
 impl StateReader for LmdbWasmTestBuilder {
@@ -95,4 +104,22 @@ impl StateReader for LmdbWasmTestBuilder {
     fn get_unbonds(&mut self) -> UnbondingPurses {
         LmdbWasmTestBuilder::get_unbonds(self)
     }
+
+    fn get_unbonding_delay(&mut self) -> u64 {
+        // Find the hash of the auction contract.
+        let auction_contract_hash = self.get_system_auction_hash();
+
+        let unbonding_delay_key = self
+            .get_contract(auction_contract_hash)
+            .expect("auction should exist")
+            .named_keys()[UNBONDING_DELAY_KEY];
+
+        self.query(unbonding_delay_key)
+            .expect("should query")
+            .as_cl_value()
+            .cloned()
+            .expect("should be cl value")
+            .into_t()
+            .expect("should be u64")
+    }
 }

utils/global-state-update-gen/src/generic/state_tracker.rs

@@ -1,14 +1,17 @@
 use std::{
     cmp::Ordering,
-    collections::{btree_map::Entry, BTreeMap, BTreeSet},
+    collections::{btree_map::Entry, BTreeMap},
     convert::TryFrom,
 };
 
 use rand::Rng;
 
 use casper_types::{
     account::{Account, AccountHash},
-    system::auction::{Bid, Bids, SeigniorageRecipientsSnapshot, UnbondingPurse},
+    system::auction::{
+        Bid, Bids, SeigniorageRecipientsSnapshot, UnbondingPurse, UnbondingPurses, WithdrawPurse,
+        WithdrawPurses,
+    },
     AccessRights, CLValue, Key, PublicKey, StoredValue, URef, U512,
 };
 
@@ -21,6 +24,7 @@ pub struct StateTracker<T> {
     total_supply: U512,
     total_supply_key: Key,
     accounts_cache: BTreeMap<AccountHash, Account>,
+    withdraws_cache: BTreeMap<AccountHash, Vec<WithdrawPurse>>,
     unbonds_cache: BTreeMap<AccountHash, Vec<UnbondingPurse>>,
     purses_cache: BTreeMap<URef, U512>,
     bids_cache: Option<Bids>,
@@ -46,6 +50,7 @@ impl<T: StateReader> StateTracker<T> {
             total_supply_key,
             total_supply: total_supply.into_t().expect("should be U512"),
             accounts_cache: BTreeMap::new(),
+            withdraws_cache: BTreeMap::new(),
             unbonds_cache: BTreeMap::new(),
             purses_cache: BTreeMap::new(),
             bids_cache: None,
@@ -222,7 +227,12 @@ impl<T: StateReader> StateTracker<T> {
     pub fn set_bid(&mut self, public_key: PublicKey, bid: Bid, slash: bool) {
         let maybe_current_bid = self.get_bids().get(&public_key).cloned();
 
-        let new_amount = *bid.staked_amount();
+        let account_hash = public_key.to_account_hash();
+        let already_unbonded = self.already_unbonding_amount(&account_hash, &public_key);
+
+        // we need to put enough funds in the bonding purse to cover the staked amount and the
+        // amount that will be getting unbonded in the future
+        let new_amount = *bid.staked_amount() + already_unbonded;
         let old_amount = maybe_current_bid
             .as_ref()
             .map(|bid| self.get_purse_balance(*bid.bonding_purse()))
@@ -234,8 +244,6 @@ impl<T: StateReader> StateTracker<T> {
             .unwrap()
             .insert(public_key.clone(), bid.clone());
 
-        let account_hash = public_key.to_account_hash();
-
         // Replace the bid (overwrite the previous bid, if any):
         self.write_entry(Key::Bid(account_hash), bid.clone().into());
 
@@ -246,6 +254,8 @@ impl<T: StateReader> StateTracker<T> {
             if old_bid.bonding_purse() != bid.bonding_purse() {
                 self.set_purse_balance(*old_bid.bonding_purse(), U512::zero());
                 self.set_purse_balance(*bid.bonding_purse(), old_amount);
+                // the old bonding purse gets zeroed - the unbonds will get invalid, anyway
+                self.remove_withdraws_and_unbonds_with_bonding_purse(old_bid.bonding_purse());
             }
 
             for (delegator_pub_key, delegator) in old_bid
@@ -271,6 +281,8 @@ impl<T: StateReader> StateTracker<T> {
                         self.set_purse_balance(*new_delegator.bonding_purse(), old_amount);
                     }
                     self.set_purse_balance(*delegator.bonding_purse(), U512::zero());
+                    // the old bonding purse gets zeroed - remove the delegator's unbonds
+                    self.remove_withdraws_and_unbonds_with_bonding_purse(delegator.bonding_purse());
                 } else {
                     let amount = self.get_purse_balance(*delegator.bonding_purse());
                     let already_unbonding =
@@ -288,48 +300,78 @@ impl<T: StateReader> StateTracker<T> {
         if (slash && new_amount != old_amount) || new_amount > old_amount {
             self.set_purse_balance(*bid.bonding_purse(), new_amount);
         } else if new_amount < old_amount {
-            let already_unbonded = self.already_unbonding_amount(&account_hash, &public_key);
             self.create_unbonding_purse(
                 *bid.bonding_purse(),
                 &public_key,
                 &public_key,
-                old_amount - new_amount - already_unbonded,
+                old_amount - new_amount,
             );
         }
 
         for (delegator_public_key, delegator) in bid.delegators() {
             let old_amount = self.get_purse_balance(*delegator.bonding_purse());
-            let new_amount = *delegator.staked_amount();
+            let already_unbonded =
+                self.already_unbonding_amount(&account_hash, delegator_public_key);
+            let new_amount = *delegator.staked_amount() + already_unbonded;
             if (slash && new_amount != old_amount) || new_amount > old_amount {
-                self.set_purse_balance(*delegator.bonding_purse(), *delegator.staked_amount());
+                self.set_purse_balance(*delegator.bonding_purse(), new_amount);
             } else if new_amount < old_amount {
-                let already_unbonded = self.already_unbonding_amount(&account_hash, &public_key);
                 self.create_unbonding_purse(
                     *delegator.bonding_purse(),
                     &public_key,
                     delegator_public_key,
-                    old_amount - new_amount - already_unbonded,
+                    old_amount - new_amount,
                 );
             }
         }
     }
 
+    fn get_withdraws(&mut self) -> WithdrawPurses {
+        let mut result = self.reader.get_withdraws();
+        for (acc, purses) in &self.withdraws_cache {
+            result.insert(*acc, purses.clone());
+        }
+        result
+    }
+
+    fn get_unbonds(&mut self) -> UnbondingPurses {
+        let mut result = self.reader.get_unbonds();
+        for (acc, purses) in &self.unbonds_cache {
+            result.insert(*acc, purses.clone());
+        }
+        result
+    }
+
+    fn write_withdraw(&mut self, account_hash: AccountHash, withdraws: Vec<WithdrawPurse>) {
+        self.withdraws_cache.insert(account_hash, withdraws.clone());
+        self.write_entry(
+            Key::Withdraw(account_hash),
+            StoredValue::Withdraw(withdraws),
+        );
+    }
+
+    fn write_unbond(&mut self, account_hash: AccountHash, unbonds: Vec<UnbondingPurse>) {
+        self.unbonds_cache.insert(account_hash, unbonds.clone());
+        self.write_entry(Key::Unbond(account_hash), StoredValue::Unbonding(unbonds));
+    }
+
     /// Returns the sum of already unbonding purses for the given validator account & unbonder.
     fn already_unbonding_amount(&mut self, account: &AccountHash, unbonder: &PublicKey) -> U512 {
-        let existing_purses = self
-            .reader
-            .get_unbonds()
-            .get(account)
-            .cloned()
-            .unwrap_or_default();
+        let current_era = *self.read_snapshot().1.keys().next().unwrap();
+        let unbonding_delay = self.reader.get_unbonding_delay();
+        let limit_era = current_era.saturating_sub(unbonding_delay);
+
+        let existing_purses = self.get_unbonds().get(account).cloned().unwrap_or_default();
         let existing_purses_legacy = self
-            .reader
             .get_withdraws()
             .get(account)
             .cloned()
             .unwrap_or_default()
             .into_iter()
-            .map(UnbondingPurse::from);
+            .map(UnbondingPurse::from)
+            // There may be some leftover old legacy purses that haven't been purged - this is to
+            // make sure that we don't accidentally take them into account.
+            .filter(|purse| purse.era_of_creation() >= limit_era);
 
         existing_purses_legacy
             .chain(existing_purses)
@@ -338,26 +380,23 @@ impl<T: StateReader> StateTracker<T> {
             .sum()
     }
 
-    /// Generates the writes to the global state that will remove the pending withdraws and unbonds
-    /// of all the old validators that will cease to be validators, and slashes their unbonding
-    /// purses.
-    pub fn remove_withdraws_and_unbonds(&mut self, removed: &BTreeSet<PublicKey>) {
-        let withdraws = self.reader.get_withdraws();
-        let unbonds = self.reader.get_unbonds();
-        for removed_validator in removed {
-            let acc = removed_validator.to_account_hash();
-            if let Some(withdraw_set) = withdraws.get(&acc) {
-                for withdraw in withdraw_set {
-                    self.set_purse_balance(*withdraw.bonding_purse(), U512::zero());
-                }
-                self.write_entry(Key::Withdraw(acc), StoredValue::Withdraw(vec![]));
+    pub fn remove_withdraws_and_unbonds_with_bonding_purse(&mut self, affected_purse: &URef) {
+        let withdraws = self.get_withdraws();
+        let unbonds = self.get_unbonds();
+
+        for (acc, mut purses) in withdraws {
+            let old_len = purses.len();
+            purses.retain(|purse| purse.bonding_purse().addr() != affected_purse.addr());
+            if purses.len() != old_len {
+                self.write_withdraw(acc, purses);
             }
+        }
 
-            if let Some(unbond_set) = unbonds.get(&acc) {
-                for unbond in unbond_set {
-                    self.set_purse_balance(*unbond.bonding_purse(), U512::zero());
-                }
-                self.write_entry(Key::Unbond(acc), StoredValue::Unbonding(vec![]));
+        for (acc, mut purses) in unbonds {
+            let old_len = purses.len();
+            purses.retain(|purse| purse.bonding_purse().addr() != affected_purse.addr());
+            if purses.len() != old_len {
+                self.write_unbond(acc, purses);
             }
         }
     }