make this sane

Author: jayantk

apps/fortuna/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fortuna"
-version = "6.8.1"
+version = "7.0.0"
 edition = "2021"
 
 [dependencies]

apps/fortuna/Cargo.toml

@@ -6,22 +6,32 @@ chains:
     # Keeper configuration for the chain
     reveal_delay_blocks: 0
     gas_limit: 500000
-    # Increase the transaction gas limit by 10% each time the callback fails
-    # defaults to 100 (i.e., don't change the gas limit) if not specified.
-    backoff_gas_multiplier_pct: 110
-    # Maximum percentage that the gas limit can be multiplied by during backoff retries
-    # defaults to 500 (i.e., up to 5x the original gas limit) if not specified.
-    backoff_gas_multiplier_cap_pct: 500
+
+    # Multiplier for the priority fee estimate, as a percentage (i.e., 100 = no change).
+    # Defaults to 100 if the field is omitted.
+    priority_fee_multiplier_pct: 100
+
+    escalation_policy:
+      # Pad the first callback transaction's gas estimate by 25%,
+      # then multiply each successive callback transaction's gas estimate by 10% until the cap is reached.
+      # All numbers are expressed as percentages where 100 = no change.
+      initial_gas_multiplier_pct: 125
+      gas_multiplier_pct: 110
+      gas_multiplier_cap_pct: 600
+
+      # Multiply successive callback transaction's fees by 10% until the cap is reached.
+      # All numbers are expressed as percentages where 100 = no change.
+      # (See also priority_fee_multiplier_pct above to generically adjust the priority fee estimates for the chain --
+      # adjusting that parameter will influence the fee of the first transaction, in addition to other things)
+      fee_multiplier_pct: 110
+      fee_multiplier_cap_pct: 200
+
     min_keeper_balance: 100000000000000000
 
     # Provider configuration
     # How much to charge in fees
     fee: 1500000000000000
 
-    # Multiplier for the priority fee estimate, as a percentage (i.e., 100 = no change).
-    # Defaults to 100 if the field is omitted.
-    priority_fee_multiplier_pct: 100
-
     # Configuration for dynamic fees under high gas prices. The keeper will set
     # on-chain fees to make between [min_profit_pct, max_profit_pct] of the max callback
     # cost in profit per transaction.

apps/fortuna/config.sample.yaml

@@ -224,7 +224,7 @@ mod test {
             contract: avax_read.clone(),
             provider_address: PROVIDER,
             reveal_delay_blocks: 2,
-            confirmed_block_status: BlockStatus::Latest
+            confirmed_block_status: BlockStatus::Latest,
         };
 
         let mut chains = HashMap::new();

apps/fortuna/src/api.rs

@@ -295,7 +295,7 @@ async fn setup_chain_state(
         contract,
         provider_address: *provider,
         reveal_delay_blocks: chain_config.reveal_delay_blocks,
-        confirmed_block_status: chain_config.confirmed_block_status
+        confirmed_block_status: chain_config.confirmed_block_status,
     };
     Ok(state)
 }

apps/fortuna/src/command/run.rs

@@ -134,6 +134,10 @@ pub struct EthereumConfig {
     /// The gas limit to use for entropy callback transactions.
     pub gas_limit: u64,
 
+    /// The percentage multiplier to apply to priority fee estimates (100 = no change, e.g. 150 = 150% of base fee)
+    #[serde(default = "default_priority_fee_multiplier_pct")]
+    pub priority_fee_multiplier_pct: u64,
+
     /// The escalation policy governs how the gas limit and fee are increased during backoff retries.
     pub escalation_policy: EscalationPolicyConfig,
 
@@ -171,6 +175,10 @@ pub struct EthereumConfig {
     pub max_num_hashes: Option<u32>,
 }
 
+fn default_priority_fee_multiplier_pct() -> u64 {
+    100
+}
+
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct EscalationPolicyConfig {
     /// The initial gas multiplier to apply to the gas limit.
@@ -185,11 +193,8 @@ pub struct EscalationPolicyConfig {
     #[serde(default = "default_gas_multiplier_cap_pct")]
     pub gas_multiplier_cap_pct: u64,
 
-    /// The initial fee multiplier to apply to the fee.
-    #[serde(default = "default_initial_fee_multiplier_pct")]
-    pub initial_fee_multiplier_pct: u64,
-
     /// The fee multiplier to apply to the fee during backoff retries.
+    /// The initial fee is 100% of the estimate (which itself may be padded based on our chain configuration)
     /// The fee on each successive retry is multiplied by this value, with the maximum multiplier capped at `fee_multiplier_cap_pct`.
     #[serde(default = "default_fee_multiplier_pct")]
     pub fee_multiplier_pct: u64,
@@ -199,14 +204,30 @@ pub struct EscalationPolicyConfig {
 
 impl EscalationPolicyConfig {
     pub fn get_gas_multiplier_pct(&self, num_retries: u64) -> u64 {
-        self.apply_escalation_policy(num_retries, self.initial_gas_multiplier_pct, self.gas_multiplier_pct, self.gas_multiplier_cap_pct)        
+        self.apply_escalation_policy(
+            num_retries,
+            self.initial_gas_multiplier_pct,
+            self.gas_multiplier_pct,
+            self.gas_multiplier_cap_pct,
+        )
     }
 
     pub fn get_fee_multiplier_pct(&self, num_retries: u64) -> u64 {
-        self.apply_escalation_policy(num_retries, self.initial_fee_multiplier_pct, self.fee_multiplier_pct, self.fee_multiplier_cap_pct)
+        self.apply_escalation_policy(
+            num_retries,
+            100,
+            self.fee_multiplier_pct,
+            self.fee_multiplier_cap_pct,
+        )
     }
 
-    fn apply_escalation_policy(&self, num_retries: u64, initial: u64, multiplier: u64, cap: u64) -> u64 {
+    fn apply_escalation_policy(
+        &self,
+        num_retries: u64,
+        initial: u64,
+        multiplier: u64,
+        cap: u64,
+    ) -> u64 {
         let mut current = initial;
         let mut i = 0;
         while i < num_retries && current < cap {
@@ -223,15 +244,11 @@ fn default_initial_gas_multiplier_pct() -> u64 {
 }
 
 fn default_gas_multiplier_pct() -> u64 {
-    100
+    110
 }
 
 fn default_gas_multiplier_cap_pct() -> u64 {
-    500
-}
-
-fn default_initial_fee_multiplier_pct() -> u64 {
-    100
+    600
 }
 
 fn default_fee_multiplier_pct() -> u64 {
@@ -289,10 +306,6 @@ fn default_chain_sample_interval() -> u64 {
     1
 }
 
-fn default_priority_fee_multiplier_pct() -> u64 {
-    100
-}
-
 /// Configuration values for the keeper service that are shared across chains.
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct KeeperConfig {

apps/fortuna/src/config.rs

@@ -8,8 +8,8 @@ use {
             reader::{BlockNumber, RequestedWithCallbackEvent},
             traced_client::{RpcMetrics, TracedClient},
         },
-        config::EthereumConfig,
         config::EscalationPolicyConfig,
+        config::EthereumConfig,
     },
     anyhow::{anyhow, Result},
     backoff::ExponentialBackoff,
@@ -56,8 +56,6 @@ const UPDATE_COMMITMENTS_INTERVAL: Duration = Duration::from_secs(30);
 const UPDATE_COMMITMENTS_THRESHOLD_FACTOR: f64 = 0.95;
 /// Rety last N blocks
 const RETRY_PREVIOUS_BLOCKS: u64 = 100;
-/// By default, we scale the gas estimate by 25% when submitting the tx.
-const DEFAULT_GAS_ESTIMATE_MULTIPLIER_PCT: u64 = 125;
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq, EncodeLabelSet)]
 pub struct AccountLabel {
@@ -273,7 +271,7 @@ pub async fn run_keeper_threads(
             },
             contract.clone(),
             gas_limit,
-            chain_eth_config.escalation_policy,
+            chain_eth_config.escalation_policy.clone(),
             chain_state.clone(),
             metrics.clone(),
             fulfilled_requests_cache.clone(),
@@ -299,7 +297,7 @@ pub async fn run_keeper_threads(
             rx,
             Arc::clone(&contract),
             gas_limit,
-            chain_eth_config.escalation_policy,
+            chain_eth_config.escalation_policy.clone(),
             metrics.clone(),
             fulfilled_requests_cache.clone(),
         )
@@ -328,8 +326,8 @@ pub async fn run_keeper_threads(
             // However, the keeper will pad the gas limit for transactions (per the escalation policy) to ensure reliable submission.
             // Consequently, fees can be adjusted such that transactions are still unprofitable.
             // While we could scale up this value based on the padding, that ends up overcharging users as most transactions cost nowhere
-            // near the maximum gas limit. 
-            // In the unlikely event that the keeper fees aren't sufficient, the solution to this is to configure the target 
+            // near the maximum gas limit.
+            // 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,
@@ -549,7 +547,6 @@ pub async fn process_event(
     // the padded gas estimate doesn't exceed the maximum amount of gas we are willing to use.
     let gas_estimate = gas_estimate.saturating_mul(gas_estimate_multiplier_pct.into()) / 100;
 
-
     let contract_call = contract
         .reveal_with_callback(
             event.provider_address,
@@ -572,7 +569,13 @@ pub async fn process_event(
 
     // Apply the fee escalation policy. Note: the unwrap_or_default should never default as we have a gas oracle
     // in the client that sets the gas price.
-    transaction.set_gas_price(transaction.gas_price().unwrap_or_default().saturating_mul(fee_estimate_multiplier_pct.into()) / 100);
+    transaction.set_gas_price(
+        transaction
+            .gas_price()
+            .unwrap_or_default()
+            .saturating_mul(fee_estimate_multiplier_pct.into())
+            / 100,
+    );
 
     let pending_tx = client
         .send_transaction(transaction.clone(), None)
@@ -668,7 +671,7 @@ pub async fn process_block_range(
     block_range: BlockRange,
     contract: Arc<InstrumentedSignablePythContract>,
     gas_limit: U256,
-    backoff_gas_multiplier_pct: u64,
+    escalation_policy: EscalationPolicyConfig,
     chain_state: api::BlockchainState,
     metrics: Arc<KeeperMetrics>,
     fulfilled_requests_cache: Arc<RwLock<HashSet<u64>>>,
@@ -692,7 +695,7 @@ pub async fn process_block_range(
             },
             contract.clone(),
             gas_limit,
-            backoff_gas_multiplier_pct,
+            escalation_policy.clone(),
             chain_state.clone(),
             metrics.clone(),
             fulfilled_requests_cache.clone(),
@@ -715,7 +718,7 @@ pub async fn process_single_block_batch(
     block_range: BlockRange,
     contract: Arc<InstrumentedSignablePythContract>,
     gas_limit: U256,
-    backoff_gas_multiplier_pct: u64,
+    escalation_policy: EscalationPolicyConfig,
     chain_state: api::BlockchainState,
     metrics: Arc<KeeperMetrics>,
     fulfilled_requests_cache: Arc<RwLock<HashSet<u64>>>,
@@ -742,7 +745,7 @@ pub async fn process_single_block_batch(
                                 chain_state.clone(),
                                 contract.clone(),
                                 gas_limit,
-                                backoff_gas_multiplier_pct,
+                                escalation_policy.clone(),
                                 metrics.clone(),
                             )
                             .in_current_span(),
@@ -900,7 +903,7 @@ pub async fn process_new_blocks(
                 block_range,
                 Arc::clone(&contract),
                 gas_limit,
-                escalation_policy,
+                escalation_policy.clone(),
                 chain_state.clone(),
                 metrics.clone(),
                 fulfilled_requests_cache.clone(),