making this work on the new contracts

Author: jayantk

apps/fortuna/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fortuna"
-version = "7.5.3"
+version = "8.0.0"
 edition = "2021"
 
 [lib]

apps/fortuna/Cargo.toml

@@ -200,23 +200,6 @@ fn default_backlog_range() -> u64 {
 
 #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
 pub struct EscalationPolicyConfig {
-    // The keeper will perform the callback as long as the tx is within this percentage of the configured gas limit.
-    // Default value is 110, meaning a 10% tolerance over the configured value.
-    #[serde(default = "default_gas_limit_tolerance_pct")]
-    pub gas_limit_tolerance_pct: u64,
-
-    /// The initial gas multiplier to apply to the tx gas estimate
-    #[serde(default = "default_initial_gas_multiplier_pct")]
-    pub initial_gas_multiplier_pct: u64,
-
-    /// The gas multiplier to apply to the tx gas estimate during backoff retries.
-    /// The gas on each successive retry is multiplied by this value, with the maximum multiplier capped at `gas_multiplier_cap_pct`.
-    #[serde(default = "default_gas_multiplier_pct")]
-    pub gas_multiplier_pct: u64,
-    /// The maximum gas multiplier to apply to the tx gas estimate during backoff retries.
-    #[serde(default = "default_gas_multiplier_cap_pct")]
-    pub gas_multiplier_cap_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`.
@@ -226,22 +209,6 @@ pub struct EscalationPolicyConfig {
     pub fee_multiplier_cap_pct: u64,
 }
 
-fn default_gas_limit_tolerance_pct() -> u64 {
-    110
-}
-
-fn default_initial_gas_multiplier_pct() -> u64 {
-    125
-}
-
-fn default_gas_multiplier_pct() -> u64 {
-    110
-}
-
-fn default_gas_multiplier_cap_pct() -> u64 {
-    600
-}
-
 fn default_fee_multiplier_pct() -> u64 {
     110
 }
@@ -253,10 +220,6 @@ fn default_fee_multiplier_cap_pct() -> u64 {
 impl Default for EscalationPolicyConfig {
     fn default() -> Self {
         Self {
-            gas_limit_tolerance_pct: default_gas_limit_tolerance_pct(),
-            initial_gas_multiplier_pct: default_initial_gas_multiplier_pct(),
-            gas_multiplier_pct: default_gas_multiplier_pct(),
-            gas_multiplier_cap_pct: default_gas_multiplier_cap_pct(),
             fee_multiplier_pct: default_fee_multiplier_pct(),
             fee_multiplier_cap_pct: default_fee_multiplier_cap_pct(),
         }
@@ -266,10 +229,6 @@ impl Default for EscalationPolicyConfig {
 impl EscalationPolicyConfig {
     pub fn to_policy(&self) -> EscalationPolicy {
         EscalationPolicy {
-            gas_limit_tolerance_pct: self.gas_limit_tolerance_pct,
-            initial_gas_multiplier_pct: self.initial_gas_multiplier_pct,
-            gas_multiplier_pct: self.gas_multiplier_pct,
-            gas_multiplier_cap_pct: self.gas_multiplier_cap_pct,
             fee_multiplier_pct: self.fee_multiplier_pct,
             fee_multiplier_cap_pct: self.fee_multiplier_cap_pct,
         }

apps/fortuna/src/config.rs

@@ -6,7 +6,7 @@ use {
     ethers::{
         contract::ContractCall,
         middleware::Middleware,
-        types::{TransactionReceipt, U256},
+        types::TransactionReceipt,
     },
     std::sync::{atomic::AtomicU64, Arc},
     tokio::time::{timeout, Duration},
@@ -18,27 +18,13 @@ const TX_CONFIRMATION_TIMEOUT_SECS: u64 = 30;
 #[derive(Debug)]
 pub struct SubmitTxResult {
     pub num_retries: u64,
-    pub gas_multiplier: u64,
     pub fee_multiplier: u64,
     pub duration: Duration,
     pub receipt: TransactionReceipt,
 }
 
 #[derive(Clone, Debug)]
 pub struct EscalationPolicy {
-    // The keeper will perform the callback as long as the tx is within this percentage of the configured gas limit.
-    // Default value is 110, meaning a 10% tolerance over the configured value.
-    pub gas_limit_tolerance_pct: u64,
-
-    /// The initial gas multiplier to apply to the tx gas estimate
-    pub initial_gas_multiplier_pct: u64,
-
-    /// The gas multiplier to apply to the tx gas estimate during backoff retries.
-    /// The gas on each successive retry is multiplied by this value, with the maximum multiplier capped at `gas_multiplier_cap_pct`.
-    pub gas_multiplier_pct: u64,
-    /// The maximum gas multiplier to apply to the tx gas estimate during backoff retries.
-    pub gas_multiplier_cap_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`.
@@ -47,15 +33,6 @@ pub struct EscalationPolicy {
 }
 
 impl EscalationPolicy {
-    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,
-        )
-    }
-
     pub fn get_fee_multiplier_pct(&self, num_retries: u64) -> u64 {
         self.apply_escalation_policy(
             num_retries,
@@ -154,7 +131,6 @@ pub async fn estimate_tx_cost<T: Middleware + 'static>(
 pub async fn submit_tx_with_backoff<T: Middleware + NonceManaged + 'static>(
     middleware: Arc<T>,
     call: ContractCall<T, ()>,
-    gas_limit: U256,
     escalation_policy: EscalationPolicy,
 ) -> Result<SubmitTxResult> {
     let start_time = std::time::Instant::now();
@@ -167,20 +143,15 @@ pub async fn submit_tx_with_backoff<T: Middleware + NonceManaged + 'static>(
 
     let num_retries = Arc::new(AtomicU64::new(0));
 
-    let padded_gas_limit = U256::from(escalation_policy.gas_limit_tolerance_pct) * gas_limit / 100;
-
     let success = backoff::future::retry_notify(
         backoff,
         || async {
             let num_retries = num_retries.load(std::sync::atomic::Ordering::Relaxed);
 
-            let gas_multiplier_pct = escalation_policy.get_gas_multiplier_pct(num_retries);
             let fee_multiplier_pct = escalation_policy.get_fee_multiplier_pct(num_retries);
             submit_tx(
                 middleware.clone(),
                 &call,
-                padded_gas_limit,
-                gas_multiplier_pct,
                 fee_multiplier_pct,
             )
             .await
@@ -203,7 +174,6 @@ pub async fn submit_tx_with_backoff<T: Middleware + NonceManaged + 'static>(
 
     Ok(SubmitTxResult {
         num_retries,
-        gas_multiplier: escalation_policy.get_gas_multiplier_pct(num_retries),
         fee_multiplier: escalation_policy.get_fee_multiplier_pct(num_retries),
         duration,
         receipt: success,
@@ -217,36 +187,10 @@ pub async fn submit_tx_with_backoff<T: Middleware + NonceManaged + 'static>(
 pub async fn submit_tx<T: Middleware + NonceManaged + 'static>(
     client: Arc<T>,
     call: &ContractCall<T, ()>,
-    gas_limit: U256,
-    // A value of 100 submits the tx with the same gas/fee as the estimate.
-    gas_estimate_multiplier_pct: u64,
+    // A value of 100 submits the tx with the same fee as the estimate.
     fee_estimate_multiplier_pct: u64,
 ) -> Result<TransactionReceipt, backoff::Error<anyhow::Error>> {
-    let gas_estimate_res = call.estimate_gas().await;
-
-    let gas_estimate = gas_estimate_res.map_err(|e| {
-        // we consider the error transient even if it is a contract revert since
-        // it can be because of routing to a lagging RPC node. Retrying such errors will
-        // incur a few additional RPC calls, but it is fine.
-        backoff::Error::transient(anyhow!("Error estimating gas for reveal: {:?}", e))
-    })?;
-
-    // The gas limit on the simulated transaction is the maximum expected tx gas estimate,
-    // but we are willing to pad the gas a bit to ensure reliable submission.
-    /*
-    if gas_estimate > gas_limit {
-        return Err(backoff::Error::permanent(anyhow!(
-            "Gas estimate for reveal with callback is higher than the gas limit {} > {}",
-            gas_estimate,
-            gas_limit
-        )));
-    }
-    */
-
-    // Pad the gas estimate after checking it against the simulation gas limit.
-    let gas_estimate = gas_estimate.saturating_mul(gas_estimate_multiplier_pct.into()) / 100;
 
-    let call = call.clone().gas(gas_estimate);
     let mut transaction = call.tx.clone();
 
     // manually fill the tx with the gas info, so we can log the details in case of error

apps/fortuna/src/eth_utils/utils.rs

@@ -39,7 +39,6 @@ pub struct KeeperMetrics {
     pub reveals: Family<AccountLabel, Counter>,
     pub request_duration_ms: Family<AccountLabel, Histogram>,
     pub retry_count: Family<AccountLabel, Histogram>,
-    pub final_gas_multiplier: Family<AccountLabel, Histogram>,
     pub final_fee_multiplier: Family<AccountLabel, Histogram>,
     pub gas_price_estimate: Family<AccountLabel, Gauge<f64, AtomicU64>>,
     pub accrued_pyth_fees: Family<ChainIdLabel, Gauge<f64, AtomicU64>>,
@@ -76,11 +75,6 @@ impl Default for KeeperMetrics {
             retry_count: Family::new_with_constructor(|| {
                 Histogram::new(vec![0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 10.0, 15.0, 20.0].into_iter())
             }),
-            final_gas_multiplier: Family::new_with_constructor(|| {
-                Histogram::new(
-                    vec![100.0, 125.0, 150.0, 200.0, 300.0, 400.0, 500.0, 600.0].into_iter(),
-                )
-            }),
             final_fee_multiplier: Family::new_with_constructor(|| {
                 Histogram::new(vec![100.0, 110.0, 120.0, 140.0, 160.0, 180.0, 200.0].into_iter())
             }),
@@ -198,12 +192,6 @@ impl KeeperMetrics {
             keeper_metrics.retry_count.clone(),
         );
 
-        writable_registry.register(
-            "final_gas_multiplier",
-            "Final gas multiplier percentage for successful transactions",
-            keeper_metrics.final_gas_multiplier.clone(),
-        );
-
         writable_registry.register(
             "final_fee_multiplier",
             "Final fee multiplier percentage for successful transactions",
@@ -270,7 +258,6 @@ impl KeeperMetrics {
         let _ = self.reveals.get_or_create(&account_label);
         let _ = self.request_duration_ms.get_or_create(&account_label);
         let _ = self.retry_count.get_or_create(&account_label);
-        let _ = self.final_gas_multiplier.get_or_create(&account_label);
         let _ = self.final_fee_multiplier.get_or_create(&account_label);
         let _ = self.gas_price_estimate.get_or_create(&account_label);
     }

apps/fortuna/src/keeper/keeper_metrics.rs

@@ -19,7 +19,7 @@ pub async fn process_event_with_backoff(
     event: RequestedWithCallbackEvent,
     chain_state: BlockchainState,
     contract: Arc<InstrumentedSignablePythContract>,
-    gas_limit: U256,
+    _gas_limit: U256,
     escalation_policy: EscalationPolicy,
     metrics: Arc<KeeperMetrics>,
 ) -> Result<()> {
@@ -51,7 +51,6 @@ pub async fn process_event_with_backoff(
     let success = submit_tx_with_backoff(
         contract.client(),
         contract_call,
-        gas_limit,
         escalation_policy,
     )
     .await;
@@ -86,11 +85,6 @@ pub async fn process_event_with_backoff(
                 .get_or_create(&account_label)
                 .observe(result.num_retries as f64);
 
-            metrics
-                .final_gas_multiplier
-                .get_or_create(&account_label)
-                .observe(result.gas_multiplier as f64);
-
             metrics
                 .final_fee_multiplier
                 .get_or_create(&account_label)