better version

Author: jayantk

apps/fortuna/src/chain/ethereum.rs

@@ -181,7 +181,7 @@ impl<T: JsonRpcClient + 'static + Clone> SignablePythContractInner<T> {
         let chain_id = provider.get_chainid().await?;
         let gas_oracle = EthProviderOracle::new(
             provider.clone(),
-            chain_config.priority_fee_multiplier_pct.multiplier(),
+            chain_config.priority_fee_multiplier_pct.value(),
         );
         let wallet__ = private_key
             .parse::<LocalWallet>()?

apps/fortuna/src/config.rs

@@ -87,10 +87,12 @@ impl Config {
 
         // Run correctness checks for the config and fail if there are any issues.
         for (chain_id, config) in config.chains.iter() {
-            if !(config.min_profit_pct.value() <= config.target_profit_pct.value()
-                && config.target_profit_pct.value() <= config.max_profit_pct.value())
+            if !(config.min_profit_multiplier_pct.value()
+                <= config.target_profit_multiplier_pct.value()
+                && config.target_profit_multiplier_pct.value()
+                    <= config.max_profit_multiplier_pct.value())
             {
-                return Err(anyhow!("chain id {:?} configuration is invalid. Config must satisfy min_profit_pct <= target_profit_pct <= max_profit_pct.", chain_id));
+                return Err(anyhow!("chain id {:?} configuration is invalid. Config must satisfy min_profit_multiplier_pct <= target_profit_multiplier_pct <= max_profit_multiplier_pct.", chain_id));
             }
         }
 
@@ -145,23 +147,26 @@ pub struct EthereumConfig {
     pub escalation_policy: EscalationPolicyConfig,
 
     /// The minimum percentage profit to earn as a function of the callback cost.
-    /// For example, 20 means a profit of 20% over the cost of a callback that uses the full gas limit.
+    /// A callback using the full gas limit has a cost of 100.
+    /// Thus, 120 means a profit of 20% over the cost of a callback that uses the full gas limit.
     /// The fee will be raised if the profit is less than this number.
-    /// The minimum value for this is -100. If set to < 0, it means the keeper may lose money on callbacks that use the full gas limit.
-    pub min_profit_pct: Percentage,
+    /// The minimum value for this is 0. If set to < 100, it means the keeper may lose money on callbacks that use the full gas limit.
+    pub min_profit_multiplier_pct: Percentage,
 
     /// The target percentage profit to earn as a function of the callback cost.
-    /// For example, 20 means a profit of 20% over the cost of a callback that uses the full gas limit.
+    /// A callback using the full gas limit has a cost of 100.
+    /// Thus, 120 means a profit of 20% over the cost of a callback that uses the full gas limit.
     /// The fee will be set to this target whenever it falls outside the min/max bounds.
-    /// The minimum value for this is -100. If set to < 0, it means the keeper may lose money on callbacks that use the full gas limit.
-    pub target_profit_pct: Percentage,
+    /// The minimum value for this is 0. If set to < 100, it means the keeper may lose money on callbacks that use the full gas limit.
+    pub target_profit_multiplier_pct: Percentage,
 
     /// The maximum percentage profit to earn as a function of the callback cost.
-    /// For example, 100 means a profit of 100% over the cost of a callback that uses the full gas limit.
+    /// A callback using the full gas limit has a cost of 100.
+    /// Thus, 200 means a profit of 100% over the cost of a callback that uses the full gas limit.
     /// The fee will be lowered if it is more profitable than specified here.
-    /// Must be larger than min_profit_pct.
-    /// The minimum value for this is -100. If set to < 0, it means the keeper may lose money on callbacks that use the full gas limit.
-    pub max_profit_pct: Percentage,
+    /// Must be larger than min_profit_multiplier_pct.
+    /// The minimum value for this is 0. If set to < 100, it means the keeper may lose money on callbacks that use the full gas limit.
+    pub max_profit_multiplier_pct: Percentage,
 
     /// Minimum wallet balance for the keeper. If the balance falls below this level, the keeper will
     /// withdraw fees from the contract to top up. This functionality requires the keeper to be the fee
@@ -192,7 +197,7 @@ fn default_block_delays() -> Vec<u64> {
 }
 
 fn default_priority_fee_multiplier_pct() -> Percentage {
-    Percentage::from_u32(100)
+    Percentage::new(100)
 }
 
 fn default_backlog_range() -> u64 {
@@ -228,27 +233,27 @@ pub struct EscalationPolicyConfig {
 }
 
 fn default_gas_limit_tolerance_pct() -> Percentage {
-    Percentage::from_u32(110)
+    Percentage::new(110)
 }
 
 fn default_initial_gas_multiplier_pct() -> Percentage {
-    Percentage::from_u32(125)
+    Percentage::new(125)
 }
 
 fn default_gas_multiplier_pct() -> Percentage {
-    Percentage::from_u32(110)
+    Percentage::new(110)
 }
 
 fn default_gas_multiplier_cap_pct() -> Percentage {
-    Percentage::from_u32(600)
+    Percentage::new(600)
 }
 
 fn default_fee_multiplier_pct() -> Percentage {
-    Percentage::from_u32(110)
+    Percentage::new(110)
 }
 
 fn default_fee_multiplier_cap_pct() -> Percentage {
-    Percentage::from_u32(200)
+    Percentage::new(200)
 }
 
 impl Default for EscalationPolicyConfig {
@@ -267,12 +272,12 @@ impl Default for EscalationPolicyConfig {
 impl EscalationPolicyConfig {
     pub fn to_policy(&self) -> EscalationPolicy {
         EscalationPolicy {
-            gas_limit_tolerance_pct: self.gas_limit_tolerance_pct.value() as u64,
-            initial_gas_multiplier_pct: self.initial_gas_multiplier_pct.value() as u64,
-            gas_multiplier_pct: self.gas_multiplier_pct.value() as u64,
-            gas_multiplier_cap_pct: self.gas_multiplier_cap_pct.value() as u64,
-            fee_multiplier_pct: self.fee_multiplier_pct.value() as u64,
-            fee_multiplier_cap_pct: self.fee_multiplier_cap_pct.value() as u64,
+            gas_limit_tolerance_pct: self.gas_limit_tolerance_pct.value(),
+            initial_gas_multiplier_pct: self.initial_gas_multiplier_pct.value(),
+            gas_multiplier_pct: self.gas_multiplier_pct.value(),
+            gas_multiplier_cap_pct: self.gas_multiplier_cap_pct.value(),
+            fee_multiplier_pct: self.fee_multiplier_pct.value(),
+            fee_multiplier_cap_pct: self.fee_multiplier_cap_pct.value(),
         }
     }
 }

apps/fortuna/src/keeper.rs

@@ -143,9 +143,9 @@ pub async fn run_keeper_threads(
             // In the unlikely event that the keeper fees aren't sufficient, the solution to this is to configure the target
             // fee percentage to be higher on that specific chain.
             chain_eth_config.gas_limit,
-            chain_eth_config.min_profit_pct.multiplier(),
-            chain_eth_config.target_profit_pct.multiplier(),
-            chain_eth_config.max_profit_pct.multiplier(),
+            chain_eth_config.min_profit_multiplier_pct.value(),
+            chain_eth_config.target_profit_multiplier_pct.value(),
+            chain_eth_config.max_profit_multiplier_pct.value(),
             chain_eth_config.fee,
             metrics.clone(),
         )

apps/fortuna/src/types/percentage.rs

@@ -1,36 +1,25 @@
-use anyhow::{anyhow, Result};
+use anyhow::Result;
 
-/// A type representing a percentage value that must be >= -100
+/// A type representing a percentage value that must be >= 0
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Percentage(i64);
+pub struct Percentage(u64);
 
 impl Percentage {
-    pub fn new(value: i64) -> Result<Self> {
-        if value < -100 {
-            return Err(anyhow!("Percentage value must be >= -100"));
-        }
-        Ok(Self(value))
-    }
-
-    pub fn from_u32(value: u32) -> Self {
-        Self(value as i64)
+    pub fn new(value: u64) -> Self {
+        Self(value)
     }
 
-    pub fn value(&self) -> i64 {
+    pub fn value(&self) -> u64 {
         self.0
     }
-
-    pub fn multiplier(&self) -> u64 {
-        u64::try_from(100 + self.0).unwrap_or(0)
-    }
 }
 
 impl serde::Serialize for Percentage {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        serializer.serialize_i64(self.0)
+        serializer.serialize_u64(self.0)
     }
 }
 
@@ -39,19 +28,13 @@ impl<'de> serde::Deserialize<'de> for Percentage {
     where
         D: serde::Deserializer<'de>,
     {
-        let value = i64::deserialize(deserializer)?;
-        Self::new(value).map_err(serde::de::Error::custom)
-    }
-}
-
-impl From<Percentage> for i64 {
-    fn from(p: Percentage) -> Self {
-        p.0
+        let value = u64::deserialize(deserializer)?;
+        Ok(Self(value))
     }
 }
 
 impl From<Percentage> for u64 {
     fn from(p: Percentage) -> Self {
-        p.0 as u64
+        p.0
     }
 }