Remove the Percent type

blueprints/olympus/src/lib.rs

@@ -136,8 +136,9 @@ mod olympus {
         /// Note the following:
         /// * The key is a [`LockupPeriod`] of the seconds of the lockup time.
         /// A u32 value of 1 equals 1 second.
-        /// * The value is a [`Percent`] which is a decimal between 0 and 1.
-        reward_rates: KeyValueStore<LockupPeriod, Percent>,
+        /// * The value is a [`Decimal`] which is a decimal value where 0
+        /// indicated 0%, 0.5 indicates 50%, 1 indicates 100%, and so on.
+        reward_rates: KeyValueStore<LockupPeriod, Decimal>,
 
         /// The resource address of the USDC, USDT, or any stablecoin. This
         /// resource is needed when trying to find the value of the tokens
@@ -154,7 +155,7 @@ mod olympus {
         /// price. If the price difference is above this protocol parameter,
         /// then the opening and closing of liquidity positions is not allowed
         /// and fails at runtime.
-        maximum_allowed_price_difference: Percent,
+        maximum_allowed_price_difference: Decimal,
 
         /// Controls whether the opening of new liquidity positions is enabled.
         ///
@@ -247,8 +248,7 @@ mod olympus {
                 is_close_liquidity_position_enabled: false,
                 reward_rates: KeyValueStore::new(),
                 maximum_allowed_price_staleness: 60, /* 1 Minutes */
-                maximum_allowed_price_difference: Percent::new(dec!(0.05))
-                    .unwrap(), /* 5% price difference allowed */
+                maximum_allowed_price_difference: dec!(0.05),
             }
             .instantiate()
             .prepare_to_globalize(owner_role)
@@ -346,7 +346,7 @@ mod olympus {
             let upfront_xrd_reward = self
                 .reward_rates
                 .get(&lockup_period)
-                .map(|percent| input_value_in_xrd * **percent)
+                .map(|percent| input_value_in_xrd * *percent)
                 .map(|reward_amount| self.withdraw(XRD, reward_amount))
                 .expect("No reward percentage associated with lockup period.");
 
@@ -368,7 +368,7 @@ mod olympus {
                 .relative_difference(&pool_price)
                 .expect("Oracle price and pool price are of different assets");
             assert!(
-                relative_difference <= *self.maximum_allowed_price_difference,
+                relative_difference <= self.maximum_allowed_price_difference,
                 "Found a {}% difference in the price of {}/{} when the maximum allowed is: {}",
                 relative_difference * dec!(100),
                 Runtime::bech32_encode_address(input_resource_address),
@@ -793,11 +793,11 @@ mod olympus {
         /// # Arguments
         ///
         /// * `lockup_period`: [`LockupPeriod`] - The lockup period.
-        /// * `rate`: [`Percent`] - The rewards rate as a percent.
+        /// * `rate`: [`Decimal`] - The rewards rate as a percent.
         pub fn add_rewards_rate(
             &mut self,
             lockup_period: LockupPeriod,
-            rate: Percent,
+            rate: Decimal,
         ) {
             self.reward_rates.insert(lockup_period, rate);
         }
@@ -857,10 +857,10 @@ mod olympus {
         ///
         /// # Arguments
         ///
-        /// `value`: [`Percent`] - The maximum allowed percentage difference.
+        /// `value`: [`Decimal`] - The maximum allowed percentage difference.
         pub fn update_maximum_allowed_price_difference(
             &mut self,
-            value: Percent,
+            value: Decimal,
         ) {
             self.maximum_allowed_price_difference = value;
         }

libraries/adapters-interface/src/common.rs

@@ -72,71 +72,6 @@ impl Price {
     }
 }
 
-/// Represents a percentage with the [`Decimal`] as the underlying type used to
-/// represent the percentage. This is a value between `0` and `1` where
-/// `dec!(0)` is 0% and `dec!(1)` is 100%. This type is checked upon SBOR
-/// decoding and construction to ensure that it matches these conditions.
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    ScryptoEncode,
-    ScryptoCategorize,
-    ScryptoDescribe,
-    PartialEq,
-    Eq,
-    PartialOrd,
-    Ord,
-    Hash,
-)]
-#[sbor(transparent)]
-pub struct Percent(Decimal);
-
-impl Percent {
-    pub fn new(value: Decimal) -> Option<Self> {
-        if value >= Decimal::ZERO && value <= Decimal::ONE {
-            Some(Self(value))
-        } else {
-            None
-        }
-    }
-
-    pub fn value(&self) -> &Decimal {
-        &self.0
-    }
-}
-
-impl Display for Percent {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}%", self.0 * 100)
-    }
-}
-
-impl std::ops::Deref for Percent {
-    type Target = Decimal;
-
-    fn deref(&self) -> &Self::Target {
-        self.value()
-    }
-}
-
-impl<D: Decoder<ScryptoCustomValueKind>> Decode<ScryptoCustomValueKind, D>
-    for Percent
-{
-    #[inline]
-    fn decode_body_with_value_kind(
-        decoder: &mut D,
-        value_kind: ValueKind<ScryptoCustomValueKind>,
-    ) -> Result<Self, DecodeError> {
-        let inner =
-            <Decimal as Decode<
-                ScryptoCustomValueKind,
-                D,
-            >>::decode_body_with_value_kind(decoder, value_kind)?;
-        Self::new(inner).ok_or(DecodeError::InvalidCustomValue)
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

unit-tests/tests/auth.rs

@@ -3,7 +3,6 @@
 mod utils;
 use utils::*;
 
-use adapters_interface::common::*;
 use olympus::types::*;
 use scrypto_test::prelude::*;
 
@@ -163,16 +162,10 @@ test_access_rules!(withdraw_pool_units(NonFungibleGlobalId::new(
     NonFungibleLocalId::integer(0)
 )));
 test_access_rules!(
-    add_rewards_rate(
-        LockupPeriod::from_seconds(10),
-        Percent::new(dec!(0.5)).unwrap()
-    ),
+    add_rewards_rate(LockupPeriod::from_seconds(10), dec!(0.5)),
     protocol_owner
 );
-test_access_rules!(add_rewards_rate(
-    LockupPeriod::from_seconds(10),
-    Percent::new(dec!(0.5)).unwrap()
-));
+test_access_rules!(add_rewards_rate(LockupPeriod::from_seconds(10), dec!(0.5)));
 test_access_rules!(
     remove_rewards_rate(LockupPeriod::from_seconds(10)),
     protocol_owner

unit-tests/tests/protocol.rs

@@ -3,7 +3,6 @@
 mod utils;
 use utils::*;
 
-use adapters_interface::common::*;
 use ociswap_adapter::*;
 use olympus::{LiquidityPosition, LockupPeriod};
 
@@ -191,8 +190,7 @@ fn can_open_position_on_an_ociswap_pool() -> Result<(), RuntimeError> {
     let price_bitcoin_base_xrd_quote = bitcoin_price / xrd_price;
 
     let lockup_period = LockupPeriod::from_months(6);
-    let upfront_reward_percentage =
-        Percent::new(dec!(0.1)).expect("Must succeed!");
+    let upfront_reward_percentage = dec!(0.1);
 
     protocol.oracle.set_price(
         resources.bitcoin.0,
@@ -230,7 +228,7 @@ fn can_open_position_on_an_ociswap_pool() -> Result<(), RuntimeError> {
         change.0.amount(env),
         Ok(price_bitcoin_base_xrd_quote
             * bitcoin_contribution_amount
-            * *upfront_reward_percentage)
+            * upfront_reward_percentage)
     );
     assert!(additional_resources.is_empty());
 
@@ -280,8 +278,7 @@ fn can_open_position_on_an_ociswap_pool() -> Result<(), RuntimeError> {
         adapter_specific_data
             .share_in_pool_when_opening_position
             .checked_round(6, RoundingMode::ToNearestMidpointTowardZero),
-        Percent::new(dec!(0.1) / dec!(1.1))
-            .unwrap()
+        (dec!(0.1) / dec!(1.1))
             .checked_round(6, RoundingMode::ToNearestMidpointTowardZero),
     );
 

unit-tests/tests/utils/environment.rs

@@ -4,7 +4,6 @@ use radix_engine_interface::prelude::*;
 use scrypto::prelude::{RoleDefinition, ToRoleEntry};
 use scrypto_test::prelude::*;
 
-use adapters_interface::common::*;
 use ociswap_adapter::test_bindings::*;
 use ociswap_adapter::*;
 use olympus::test_bindings::*;
@@ -179,12 +178,12 @@ impl Environment {
         // 6 months at 10% and 9 months at 20%.
         olympus.add_rewards_rate(
             LockupPeriod::from_months(6),
-            Percent::new(dec!(0.1)).expect("Must succeed!"),
+            dec!(0.1),
             &mut env,
         )?;
         olympus.add_rewards_rate(
             LockupPeriod::from_months(9),
-            Percent::new(dec!(0.2)).expect("Must succeed!"),
+            dec!(0.2),
             &mut env,
         )?;