fix: address GitHub PR feedback - remove Option types and refactor transaction logic

Co-Authored-By: Tejas Badadare <[email protected]>

Author: devin-ai-integration[bot]

apps/fortuna/src/command/run.rs

@@ -120,23 +120,31 @@ pub async fn run(opts: &RunOptions) -> Result<()> {
         let keeper_config_base = config.keeper.clone();
         spawn(async move {
             loop {
-                let keeper_config = if keeper_private_key_option.is_some() {
-                    Some(keeper_config_base.clone())
+                let setup_result = if keeper_private_key_option.is_some() {
+                    setup_chain_and_run_keeper(
+                        provider_config.clone(),
+                        &chain_id,
+                        chain_config.clone(),
+                        keeper_metrics.clone(),
+                        keeper_config_base.clone(),
+                        chains.clone(),
+                        &secret_copy,
+                        history.clone(),
+                        rpc_metrics.clone(),
+                    )
+                    .await
                 } else {
-                    None
+                    setup_chain_without_keeper(
+                        provider_config.clone(),
+                        &chain_id,
+                        chain_config.clone(),
+                        keeper_metrics.clone(),
+                        chains.clone(),
+                        &secret_copy,
+                        rpc_metrics.clone(),
+                    )
+                    .await
                 };
-                let setup_result = setup_chain_and_run_keeper(
-                    provider_config.clone(),
-                    &chain_id,
-                    chain_config.clone(),
-                    keeper_metrics.clone(),
-                    keeper_config,
-                    chains.clone(),
-                    &secret_copy,
-                    history.clone(),
-                    rpc_metrics.clone(),
-                )
-                .await;
                 match setup_result {
                     Ok(_) => {
                         tracing::info!("Chain {} initialized successfully", chain_id);
@@ -180,7 +188,7 @@ async fn setup_chain_and_run_keeper(
     chain_id: &ChainId,
     chain_config: EthereumConfig,
     keeper_metrics: Arc<KeeperMetrics>,
-    keeper_config: Option<KeeperConfig>,
+    keeper_config: KeeperConfig,
     chains: Arc<RwLock<HashMap<ChainId, ApiBlockChainState>>>,
     secret_copy: &str,
     history: Arc<History>,
@@ -200,17 +208,42 @@ async fn setup_chain_and_run_keeper(
         chain_id.clone(),
         ApiBlockChainState::Initialized(state.clone()),
     );
-    if let Some(keeper_config) = keeper_config {
-        keeper::run_keeper_threads(
-            keeper_config,
-            chain_config,
-            state,
-            keeper_metrics.clone(),
-            history,
-            rpc_metrics.clone(),
-        )
-        .await?;
-    }
+    keeper::run_keeper_threads(
+        keeper_config,
+        chain_config,
+        state,
+        keeper_metrics.clone(),
+        history,
+        rpc_metrics.clone(),
+    )
+    .await?;
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn setup_chain_without_keeper(
+    provider_config: ProviderConfig,
+    chain_id: &ChainId,
+    chain_config: EthereumConfig,
+    keeper_metrics: Arc<KeeperMetrics>,
+    chains: Arc<RwLock<HashMap<ChainId, ApiBlockChainState>>>,
+    secret_copy: &str,
+    rpc_metrics: Arc<RpcMetrics>,
+) -> Result<()> {
+    let state = setup_chain_state(
+        &provider_config.address,
+        secret_copy,
+        provider_config.chain_sample_interval,
+        chain_id,
+        &chain_config,
+        rpc_metrics.clone(),
+        keeper_metrics.clone(),
+    )
+    .await?;
+    chains.write().await.insert(
+        chain_id.clone(),
+        ApiBlockChainState::Initialized(state.clone()),
+    );
     Ok(())
 }
 

apps/fortuna/src/keeper/fee.rs

@@ -7,11 +7,11 @@ use {
     },
     anyhow::{anyhow, Result},
     ethers::{
-        middleware::Middleware,
+        middleware::{Middleware, SignerMiddleware},
         signers::{LocalWallet, Signer},
         types::{Address, TransactionRequest, U256},
     },
-    std::{str::FromStr, sync::Arc},
+    std::sync::Arc,
     tokio::time::{self, Duration},
     tracing::{self, Instrument},
 };
@@ -117,7 +117,8 @@ pub async fn withdraw_fees_if_necessary(
         let contract_call = contract.withdraw_as_fee_manager(provider_address, fees);
         send_and_confirm(contract_call).await?;
 
-        let fee_manager_wallet = LocalWallet::from_str(&fee_manager_private_key)
+        let fee_manager_wallet = fee_manager_private_key
+            .parse::<LocalWallet>()
             .map_err(|e| anyhow!("Invalid fee manager private key: {:?}", e))?;
         let fee_manager_address = fee_manager_wallet.address();
         let keeper_address = wallet.address();
@@ -130,43 +131,30 @@ pub async fn withdraw_fees_if_necessary(
             );
 
             let transfer_amount = U256::from(fees);
-            let chain_id = provider
-                .get_chainid()
-                .await
-                .map_err(|e| anyhow!("Failed to get chain ID: {:?}", e))?;
+            let chain_id = provider.get_chainid().await?;
 
-            let gas_price = provider
-                .get_gas_price()
-                .await
-                .map_err(|e| anyhow!("Failed to get gas price: {:?}", e))?;
-
-            let nonce = provider
-                .get_transaction_count(fee_manager_address, None)
-                .await
-                .map_err(|e| anyhow!("Failed to get nonce: {:?}", e))?;
+            let fee_manager_wallet = fee_manager_wallet.with_chain_id(chain_id.as_u64());
+            let fee_manager_provider = SignerMiddleware::new(provider.clone(), fee_manager_wallet);
 
             let tx = TransactionRequest::new()
                 .to(keeper_address)
                 .value(transfer_amount)
-                .from(fee_manager_address)
-                .gas(21000) // Standard ETH transfer gas limit
-                .gas_price(gas_price)
-                .nonce(nonce)
-                .chain_id(chain_id.as_u64());
-
-            let typed_tx = tx.into();
-            let signature = fee_manager_wallet
-                .sign_transaction(&typed_tx)
-                .await
-                .map_err(|e| anyhow!("Failed to sign transfer transaction: {:?}", e))?;
+                .gas(21000);
 
-            let signed_tx = typed_tx.rlp_signed(&signature);
-            let tx_hash = provider
-                .send_raw_transaction(signed_tx)
+            let pending_tx = fee_manager_provider
+                .send_transaction(tx, None)
                 .await
                 .map_err(|e| anyhow!("Failed to send transfer transaction: {:?}", e))?;
 
-            tracing::info!("Transfer transaction sent: {:?}", tx_hash);
+            let receipt = pending_tx
+                .await
+                .map_err(|e| anyhow!("Failed to get transfer transaction receipt: {:?}", e))?
+                .ok_or_else(|| anyhow!("Transfer transaction was dropped from mempool"))?;
+
+            tracing::info!(
+                "Transfer transaction confirmed: {:?}",
+                receipt.transaction_hash
+            );
         }
     } else if keeper_balance < min_balance {
         // NOTE: This log message triggers a grafana alert. If you want to change the text, please change the alert also.