Moving get_minimum_delegation_rate back to runtime

Author: zajko

execution_engine/src/runtime/mod.rs

@@ -52,7 +52,7 @@ use casper_types::{
     },
     system::{
         self,
-        auction::{self, DelegatorKind, EraInfo},
+        auction::{self, DelegatorKind, EraInfo, MINIMUM_DELEGATION_RATE_KEY},
         handle_payment,
         mint::{self, MINT_SUSTAIN_PURSE_KEY},
         CallStackElement, Caller, CallerInfo, SystemEntityType, AUCTION, HANDLE_PAYMENT, MINT,
@@ -1084,7 +1084,7 @@ where
 
                 let max_delegators_per_validator =
                     self.context.engine_config().max_delegators_per_validator();
-
+                let minimum_delegation_rate = self.get_minimum_delegation_rate()?;
                 let minimum_bid_amount = self.context().engine_config().minimum_bid_amount();
 
                 let result = runtime
@@ -1099,6 +1099,7 @@ where
                         reserved_slots,
                         global_minimum_delegation_amount,
                         global_maximum_delegation_amount,
+                        minimum_delegation_rate,
                     )
                     .map_err(Self::reverter)?;
 
@@ -1325,8 +1326,9 @@ where
                 let reservations =
                     Self::get_named_argument(runtime_args, auction::ARG_RESERVATIONS)?;
 
+                let minimum_delegation_rate = self.get_minimum_delegation_rate()?;
                 runtime
-                    .add_reservations(reservations)
+                    .add_reservations(reservations, minimum_delegation_rate)
                     .map_err(Self::reverter)?;
 
                 CLValue::from_t(()).map_err(Self::reverter)
@@ -4665,6 +4667,31 @@ where
         )?;
         Ok(Ok(()))
     }
+
+    fn get_minimum_delegation_rate(&self) -> Result<u8, ExecError> {
+        let auction_contract_hash = self.context.get_system_contract(AUCTION)?;
+        let auction_named_keys = self
+            .context
+            .state()
+            .borrow_mut()
+            .get_named_keys(EntityAddr::System(auction_contract_hash.value()))?;
+        let minimum_delegation_rate_key =
+            auction_named_keys.get(MINIMUM_DELEGATION_RATE_KEY).ok_or(
+                ExecError::NamedKeyNotFound(MINIMUM_DELEGATION_RATE_KEY.to_string()),
+            )?;
+        let stored_value = self
+            .context
+            .state()
+            .borrow_mut()
+            .read(minimum_delegation_rate_key)?
+            .ok_or_else(|| ExecError::KeyNotFound(*minimum_delegation_rate_key))?;
+        if let StoredValue::CLValue(cl_value) = stored_value {
+            let minimum_delegation_rate: u8 = cl_value.into_t().map_err(ExecError::CLValue)?;
+            Ok(minimum_delegation_rate)
+        } else {
+            Err(ExecError::UnexpectedStoredValueVariant)
+        }
+    }
 }
 
 #[cfg(feature = "test-support")]

storage/src/global_state/state/mod.rs

@@ -1271,20 +1271,25 @@ pub trait StateProvider: Send + Sync + Sized {
                 minimum_bid_amount,
                 reserved_slots,
             } => runtime
-                .add_bid(
-                    public_key,
-                    delegation_rate,
-                    amount,
-                    minimum_delegation_amount,
-                    maximum_delegation_amount,
-                    minimum_bid_amount,
-                    max_delegators_per_validator,
-                    reserved_slots,
-                    global_minimum_delegation_limit,
-                    global_maximum_delegation_limit,
-                )
-                .map(AuctionMethodRet::UpdatedAmount)
-                .map_err(TrackingCopyError::Api),
+                .get_minimum_delegation_rate()
+                .and_then(|minimum_delegation_rate| {
+                    runtime
+                        .add_bid(
+                            public_key,
+                            delegation_rate,
+                            amount,
+                            minimum_delegation_amount,
+                            maximum_delegation_amount,
+                            minimum_bid_amount,
+                            max_delegators_per_validator,
+                            reserved_slots,
+                            global_minimum_delegation_limit,
+                            global_maximum_delegation_limit,
+                            minimum_delegation_rate,
+                        )
+                        .map(AuctionMethodRet::UpdatedAmount)
+                        .map_err(TrackingCopyError::Api)
+                }),
             AuctionMethod::WithdrawBid {
                 public_key,
                 amount,
@@ -1335,10 +1340,14 @@ pub trait StateProvider: Send + Sync + Sized {
                     TrackingCopyError::SystemContract(system::Error::Auction(auc_err))
                 }),
             AuctionMethod::AddReservations { reservations } => runtime
-                .add_reservations(reservations)
-                .map(|_| AuctionMethodRet::Unit)
-                .map_err(|auc_err| {
-                    TrackingCopyError::SystemContract(system::Error::Auction(auc_err))
+                .get_minimum_delegation_rate()
+                .and_then(|minimum_delegation_rate| {
+                    runtime
+                        .add_reservations(reservations, minimum_delegation_rate)
+                        .map(|_| AuctionMethodRet::Unit)
+                        .map_err(|auc_err| {
+                            TrackingCopyError::SystemContract(system::Error::Auction(auc_err))
+                        })
                 }),
             AuctionMethod::CancelReservations {
                 validator,

storage/src/system/auction.rs

@@ -80,14 +80,14 @@ pub trait Auction:
         reserved_slots: u32,
         global_minimum_delegation_amount: u64,
         global_maximum_delegation_amount: u64,
+        minimum_delegation_rate: u8,
     ) -> Result<U512, ApiError> {
         if !self.allow_auction_bids() {
             // The validator set may be closed on some side chains,
             // which is configured by disabling bids.
             return Err(Error::AuctionBidsDisabled.into());
         }
 
-        let minimum_delegation_rate = detail::get_minimum_delegation_rate(self)?;
         if amount == U512::zero() {
             return Err(Error::BondTooSmall.into());
         }
@@ -397,12 +397,15 @@ pub trait Auction:
     /// delegator slots is exceeded it returns an error.
     ///
     /// If given reservation exists already and the delegation rate was changed it's updated.
-    fn add_reservations(&mut self, reservations: Vec<Reservation>) -> Result<(), Error> {
+    fn add_reservations(
+        &mut self,
+        reservations: Vec<Reservation>,
+        minimum_delegation_rate: u8,
+    ) -> Result<(), Error> {
         if !self.allow_auction_bids() {
             // The auction process can be disabled on a given network.
             return Err(Error::AuctionBidsDisabled);
         }
-        let minimum_delegation_rate = detail::get_minimum_delegation_rate(self)?;
         for reservation in reservations {
             if !self
                 .is_allowed_session_caller(&AccountHash::from(reservation.validator_public_key()))

storage/src/system/auction/detail.rs

@@ -6,14 +6,13 @@ use super::{
 use casper_types::{
     bytesrepr::{FromBytes, ToBytes},
     system::auction::{
-        BidAddr, BidAddrTag, BidKind, DelegationRate, DelegatorBid, DelegatorBids, DelegatorKind,
-        Error, Reservation, Reservations, SeigniorageRecipient, SeigniorageRecipientV2,
+        BidAddr, BidAddrTag, BidKind, DelegatorBid, DelegatorBids, DelegatorKind, Error,
+        Reservation, Reservations, SeigniorageRecipient, SeigniorageRecipientV2,
         SeigniorageRecipientsSnapshot, SeigniorageRecipientsSnapshotV1,
         SeigniorageRecipientsSnapshotV2, SeigniorageRecipientsV2, Unbond, UnbondEra, UnbondKind,
         ValidatorBid, ValidatorBids, ValidatorCredit, ValidatorCredits, WeightsBreakout,
         AUCTION_DELAY_KEY, DELEGATION_RATE_DENOMINATOR, ERA_END_TIMESTAMP_MILLIS_KEY, ERA_ID_KEY,
-        MINIMUM_DELEGATION_RATE_KEY, SEIGNIORAGE_RECIPIENTS_SNAPSHOT_KEY, UNBONDING_DELAY_KEY,
-        VALIDATOR_SLOTS_KEY,
+        SEIGNIORAGE_RECIPIENTS_SNAPSHOT_KEY, UNBONDING_DELAY_KEY, VALIDATOR_SLOTS_KEY,
     },
     AccessRights, ApiError, CLTyped, EraId, Key, KeyTag, PublicKey, URef, U512,
 };
@@ -404,14 +403,6 @@ where
     read_from(provider, SEIGNIORAGE_RECIPIENTS_SNAPSHOT_KEY)
 }
 
-/// Returns minimum_delegation_rate.
-pub fn get_minimum_delegation_rate<P>(provider: &mut P) -> Result<DelegationRate, Error>
-where
-    P: StorageProvider + RuntimeProvider + ?Sized,
-{
-    read_from(provider, MINIMUM_DELEGATION_RATE_KEY)
-}
-
 /// Returns seigniorage recipients snapshot in legacy format.
 pub fn get_legacy_seigniorage_recipients_snapshot<P>(
     provider: &mut P,

storage/src/system/runtime_native.rs

@@ -4,9 +4,12 @@ use crate::{
     AddressGenerator, TrackingCopy,
 };
 use casper_types::{
-    account::AccountHash, contracts::NamedKeys, Chainspec, ContextAccessRights, EntityAddr,
-    FeeHandling, Key, Phase, ProtocolVersion, PublicKey, RefundHandling, RewardsHandling,
-    RuntimeFootprint, StoredValue, TransactionHash, Transfer, URef, U512,
+    account::AccountHash,
+    contracts::NamedKeys,
+    system::{auction::MINIMUM_DELEGATION_RATE_KEY, AUCTION},
+    Chainspec, ContextAccessRights, EntityAddr, FeeHandling, Key, Phase, ProtocolVersion,
+    PublicKey, RefundHandling, RewardsHandling, RuntimeFootprint, StoredValue, TransactionHash,
+    Transfer, URef, U512,
 };
 use num_rational::Ratio;
 use parking_lot::RwLock;
@@ -600,4 +603,25 @@ where
     pub(crate) fn native_transfer_cost(&self) -> u32 {
         self.config.native_transfer_cost
     }
+
+    pub(crate) fn get_minimum_delegation_rate(&self) -> Result<u8, TrackingCopyError> {
+        let mut borrow_mut = self.tracking_copy.borrow_mut();
+        let key = borrow_mut
+            .system_contract_named_key(AUCTION, MINIMUM_DELEGATION_RATE_KEY)?
+            .ok_or(TrackingCopyError::NamedKeyNotFound(
+                MINIMUM_DELEGATION_RATE_KEY.to_string(),
+            ))?;
+        let stored_value = borrow_mut
+            .read(&key)?
+            .ok_or(TrackingCopyError::ValueNotFound(
+                MINIMUM_DELEGATION_RATE_KEY.to_string(),
+            ))?;
+        if let StoredValue::CLValue(cl_value) = stored_value {
+            let minimum_delegation_rate: u8 =
+                cl_value.into_t().map_err(TrackingCopyError::CLValue)?;
+            Ok(minimum_delegation_rate)
+        } else {
+            Err(TrackingCopyError::UnexpectedStoredValueVariant)
+        }
+    }
 }