wip

Author: dylanlott

src/tasks/submit.rs

@@ -4,7 +4,7 @@ use crate::{
     utils::extract_signature_components,
 };
 use alloy::{
-    consensus::{SimpleCoder, Transaction, constants::GWEI_TO_WEI},
+    consensus::SimpleCoder,
     eips::BlockNumberOrTag,
     network::{TransactionBuilder, TransactionBuilder4844},
     primitives::{FixedBytes, TxHash, U256},
@@ -101,10 +101,8 @@ impl SubmitTask {
         let data = submitCall { fills, header, v, r, s }.abi_encode();
 
         let sidecar = block.encode_blob::<SimpleCoder>().build()?;
-        Ok(TransactionRequest::default()
-            .with_blob_sidecar(sidecar)
-            .with_input(data)
-            .with_max_priority_fee_per_gas((GWEI_TO_WEI * 16) as u128))
+
+        Ok(TransactionRequest::default().with_blob_sidecar(sidecar).with_input(data))
     }
 
     /// Returns the next host block height.
@@ -169,7 +167,7 @@ impl SubmitTask {
                 .unwrap_or_default()
             {
                 debug!(%e, "incorrect host block");
-                return Some(Ok(ControlFlow::Retry));
+                return Some(Ok(ControlFlow::Skip));
             }
 
             if e.as_revert_data()
@@ -208,7 +206,8 @@ impl SubmitTask {
         let (v, r, s) = extract_signature_components(&resp.sig);
 
         // Calculate gas limits based on retry attempts
-        let (max_fee_per_gas, max_priority_fee_per_gas) = calculate_gas_limits(retry_count);
+        let (max_fee_per_gas, max_priority_fee_per_gas, max_fee_per_blob_gas) =
+            calculate_gas_limits(retry_count);
 
         // manually retrieve nonce
         let nonce =
@@ -228,12 +227,12 @@ impl SubmitTask {
         // Create a blob transaction with the blob header and signature values and return it
         let tx = self
             .build_blob_tx(fills, header, v, r, s, block)?
-            .with_from(self.provider().default_signer_address())
-            .with_to(self.config.builder_helper_address)
-            .with_max_fee_per_gas(max_fee_per_gas.into())
-            .with_max_priority_fee_per_gas(max_priority_fee_per_gas)
-            .with_max_fee_per_blob_gas(max_fee_per_gas)
-            .with_nonce(nonce);
+            // .with_from(self.provider().default_signer_address())
+            .with_to(self.config.builder_helper_address);
+            // .with_max_fee_per_gas(max_fee_per_gas)
+            // .with_max_priority_fee_per_gas(max_priority_fee_per_gas)
+            // .with_max_fee_per_blob_gas(max_fee_per_blob_gas)
+            // .with_nonce(nonce);
 
         debug!(?tx, "prepared transaction request");
         Ok(tx)
@@ -247,20 +246,18 @@ impl SubmitTask {
         tx: TransactionRequest,
     ) -> Result<ControlFlow, eyre::Error> {
         debug!(
-            ?tx.max_fee_per_gas,
-            ?tx.max_fee_per_blob_gas,
-            ?tx.max_priority_fee_per_gas,
-            nonce = ?tx.nonce,
+            ?tx,
             host_block_number = %resp.req.host_block_number,
             gas_limit = %resp.req.gas_limit,
             "sending transaction to network"
         );
 
         // assign the nonce and fill the rest of the values
+        debug!(?tx, "blob transaction request before fill");
         let SendableTx::Envelope(tx) = self.provider().fill(tx).await? else {
             bail!("failed to fill transaction")
         };
-        debug!(tx_hash = %tx.tx_hash(), nonce = ?tx.nonce(), gas_limit = ?tx.gas_limit(), blob_gas_used = ?tx.blob_gas_used(), "filled blob transaction");
+        debug!(?tx, "filled blob transaction");
 
         // send the tx via the primary host_provider
         let fut = spawn_provider_send!(self.provider(), &tx);
@@ -280,8 +277,7 @@ impl SubmitTask {
         if let Err(e) = fut.await? {
             let err_str = e.to_string();
             if err_str.contains("replacement transaction underpriced") {
-                // bump gas and repeat
-                debug!("UNDERPRICE ERROR DETECTED");
+                debug!(?tx, "underpriced transaction error - retrying tx with gas bump");
                 return Ok(ControlFlow::Retry);
             }
             error!(error = %e, "Primary tx broadcast failed. Skipping transaction.");
@@ -349,16 +345,16 @@ impl SubmitTask {
                         control_flow
                     }
                     Err(err) => {
-                        retries += 1;
                         // Delay until next slot if we get a 403 error
                         if err.to_string().contains("403 Forbidden") {
                             let (slot_number, _, _) = self.calculate_slot_window()?;
-                            debug!(slot_number, ?block, "403 detected - not assigned to slot");
+                            debug!(slot_number, "403 detected - skipping slot");
                             return Ok(ControlFlow::Skip);
                         } else {
                             error!(error = %err, "error handling inbound block");
                         }
 
+                        retries += 1;
                         ControlFlow::Retry
                     }
                 };
@@ -442,7 +438,7 @@ impl SubmitTask {
             last_block_attempted = block.block_number();
             debug!(last_block_attempted, "resetting last block attempted");
 
-            if self.retrying_handle_inbound(&block, 3).await.is_err() {
+            if self.retrying_handle_inbound(&block, 10).await.is_err() {
                 debug!("error handling inbound block");
                 continue;
             };
@@ -458,20 +454,25 @@ impl SubmitTask {
     }
 }
 
-fn calculate_gas_limits(retry_count: usize) -> (u128, u128) {
-    // Set a base gas amount
-    let base_gas = 1_500_000;
-    // Define a gas coefficient
-    let gas_coefficient: u64 = 1 + (retry_count as u64);
-    // Determine gas limit by multiplying base gas by the coefficient
-    let max_fee_per_gas: u128 = (base_gas + (gas_coefficient * base_gas)) as u128;
-    // Determine priority gas fee by multiplying retry count by the coefficient
-    let max_priority_fee_per_gas: u128 =
-        (1 + retry_count as u128) * (gas_coefficient as u128 * 100_000);
+fn calculate_gas_limits(retry_count: usize) -> (u128, u128, u128) {
+    let base_fee_per_gas: u128 = 60_000_000;
+    let base_priority_fee_per_gas: u128 = 20_000_000;
+    let base_fee_per_blob_gas: u128 = 1_000_000;
+
+    let bump_multiplier = 1500u128.pow(retry_count as u32);
+    let bump_divisor = 1000u128.pow(retry_count as u32);
+
+    let max_fee_per_gas = base_fee_per_gas * bump_multiplier / bump_divisor;
+    let max_priority_fee_per_gas = base_priority_fee_per_gas * bump_multiplier / bump_divisor;
+    let max_fee_per_blob_gas = base_fee_per_blob_gas * bump_multiplier / bump_divisor;
 
     debug!(
         retry_count,
-        gas_coefficient, max_fee_per_gas, max_priority_fee_per_gas, "calculated gas limits"
+        max_fee_per_gas,
+        max_priority_fee_per_gas,
+        max_fee_per_blob_gas,
+        "calculated bumped gas parameters"
     );
-    (max_fee_per_gas, max_priority_fee_per_gas)
+
+    (max_fee_per_gas, max_priority_fee_per_gas, max_fee_per_blob_gas)
 }