cleanup

Author: dylanlott

src/tasks/submit.rs

@@ -122,7 +122,7 @@ impl SubmitTask {
     ) -> eyre::Result<ControlFlow> {
         let tx = self.prepare_tx(retry_count, resp, block).await?;
 
-        self.send_transaction(resp, tx).await
+        self.send_transaction(retry_count, resp, tx).await
     }
 
     /// Prepares the transaction by extracting the signature components, creating the transaction
@@ -155,13 +155,7 @@ impl SubmitTask {
         if let Err(TransportError::ErrorResp(e)) =
             self.provider().call(tx.clone()).block(BlockNumberOrTag::Pending.into()).await
         {
-            error!(
-                code = e.code,
-                message = %e.message,
-                data = ?e.data,
-                "error in transaction submission"
-            );
-
+            // NB: These errors are all handled the same way but are logged for debugging purposes
             if e.as_revert_data()
                 .map(|data| data.starts_with(&IncorrectHostBlock::SELECTOR))
                 .unwrap_or_default()
@@ -186,6 +180,12 @@ impl SubmitTask {
                 return Some(Ok(ControlFlow::Skip));
             }
 
+            error!(
+                code = e.code,
+                message = %e.message,
+                data = ?e.data,
+                "unknown error in host transaction simulation call"
+            );
             return Some(Ok(ControlFlow::Skip));
         }
 
@@ -209,7 +209,7 @@ impl SubmitTask {
         let (max_fee_per_gas, max_priority_fee_per_gas, max_fee_per_blob_gas) =
             calculate_gas_limits(retry_count);
 
-        // manually retrieve nonce
+        // manually retrieve nonce // TODO: Maybe this should be done in Env task and passed through elsewhere
         let nonce =
             self.provider().get_transaction_count(self.provider().default_signer_address()).await?;
         debug!(nonce, "assigned nonce");
@@ -233,59 +233,51 @@ impl SubmitTask {
             .with_max_fee_per_blob_gas(max_fee_per_blob_gas)
             .with_nonce(nonce);
 
-        debug!(?tx, "prepared transaction request");
         Ok(tx)
     }
 
     /// Fills the transaction request with the provider and sends it to the network
     /// and any additionally configured broadcast providers.
     async fn send_transaction(
         &self,
+        retry_count: usize,
         resp: &SignResponse,
         tx: TransactionRequest,
     ) -> Result<ControlFlow, eyre::Error> {
-        debug!(
-            ?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, "filled blob transaction");
+        debug!(tx_hash = ?tx.hash(), host_block_number = %resp.req.host_block_number, "sending transaction to network");
 
         // send the tx via the primary host_provider
         let fut = spawn_provider_send!(self.provider(), &tx);
 
-        // spawn send_tx futures for all additional broadcast host_providers
-        for host_provider in self.config.connect_additional_broadcast() {
-            spawn_provider_send!(&host_provider, &tx);
+        // spawn send_tx futures on retry attempts for all additional broadcast host_providers
+        if retry_count > 0 {
+            for host_provider in self.config.connect_additional_broadcast() {
+                spawn_provider_send!(&host_provider, &tx);
+            }
         }
 
         // send the in-progress transaction over the outbound_tx_channel
         if self.outbound_tx_channel.send(*tx.tx_hash()).is_err() {
             error!("receipts task gone");
         }
 
-        // question mark unwraps join error, which would be an internal panic
-        // then if let checks for rpc error
         if let Err(e) = fut.await? {
-            let err_str = e.to_string();
-            if err_str.contains("replacement transaction underpriced") {
+            // Detect and handle transaction underprice errors
+            if matches!(e, TransportError::ErrorResp(ref err) if err.code == -32000 && err.message.contains("replacement transaction underpriced"))
+            {
                 debug!(?tx, "underpriced transaction error - retrying tx with gas bump");
                 return Ok(ControlFlow::Retry);
             }
-            error!(error = %e, "Primary tx broadcast failed. Skipping transaction.");
+
+            // Unknown error, log and skip
+            error!(error = %e, "Primary tx broadcast failed");
             return Ok(ControlFlow::Skip);
         }
 
-        // Okay so the code gets all the way to this log
-        // but we don't see the tx hash in the logs or in the explorer,
-        // not even as a failed TX, just not at all.
         info!(
             tx_hash = %tx.tx_hash(),
             ru_chain_id = %resp.req.ru_chain_id,
@@ -339,10 +331,7 @@ impl SubmitTask {
 
             let inbound_result =
                 match self.handle_inbound(retries, block).instrument(span.clone()).await {
-                    Ok(control_flow) => {
-                        debug!(?control_flow, retries, "successfully handled inbound block");
-                        control_flow
-                    }
+                    Ok(control_flow) => control_flow,
                     Err(err) => {
                         // Delay until next slot if we get a 403 error
                         if err.to_string().contains("403 Forbidden") {
@@ -353,7 +342,6 @@ impl SubmitTask {
                             error!(error = %err, "error handling inbound block");
                         }
 
-                        retries += 1;
                         ControlFlow::Retry
                     }
                 };
@@ -437,7 +425,7 @@ impl SubmitTask {
             last_block_attempted = block.block_number();
             debug!(last_block_attempted, "resetting last block attempted");
 
-            if self.retrying_handle_inbound(&block, 20).await.is_err() {
+            if self.retrying_handle_inbound(&block, 3).await.is_err() {
                 debug!("error handling inbound block");
                 continue;
             };