thing: thing thing the thing

Author: prestwich

Cargo.lock

@@ -56,6 +56,7 @@ tokio = { version = "1.36.0", features = ["full", "macros", "rt-multi-thread"] }
 tokio-stream = "0.1.17"
 url = "2.5.4"
 thiserror = "2.0.17"
+futures-util = "0.3.31"
 
 [dev-dependencies]
 alloy-hardforks = "0.4.0"

Cargo.toml

@@ -25,13 +25,23 @@ pub enum QuinceyError {
 
     /// Error contacting the remote quincey API.
     #[error("Error contacting quincey API: {0}")]
-    Remote(#[from] reqwest::Error),
+    Remote(reqwest::Error),
 
     /// Error with the owned signet.
     #[error("Error with owned signet: {0}")]
     Owned(#[from] eyre::Report),
 }
 
+impl From<reqwest::Error> for QuinceyError {
+    fn from(err: reqwest::Error) -> Self {
+        if err.status() == Some(reqwest::StatusCode::FORBIDDEN) {
+            QuinceyError::NotOurSlot
+        } else {
+            QuinceyError::Remote(err)
+        }
+    }
+}
+
 /// A quincey client for making requests to the Quincey API.
 #[derive(Debug, Clone)]
 pub enum Quincey {
@@ -89,23 +99,9 @@ impl Quincey {
 
         let token = token.secret().await?;
 
-        let resp = client
-            .post(url.clone())
-            .json(sig_request)
-            .bearer_auth(token)
-            .send()
-            .await
-            .map_err(QuinceyError::Remote)?;
-
-        if resp.status() == reqwest::StatusCode::FORBIDDEN {
-            return Err(QuinceyError::NotOurSlot);
-        }
+        let resp = client.post(url.clone()).json(sig_request).bearer_auth(token).send().await?;
 
-        resp.error_for_status()
-            .map_err(QuinceyError::Remote)?
-            .json::<SignResponse>()
-            .await
-            .map_err(QuinceyError::Remote)
+        resp.error_for_status()?.json::<SignResponse>().await.map_err(QuinceyError::Remote)
     }
 
     /// Get a signature for the provided request, by either using the owned

src/quincey.rs

@@ -112,6 +112,7 @@ impl FlashbotsTask {
         );
 
         let tx = prep.prep_transaction(sim_result.prev_host()).await?;
+
         let sendable = self
             .host_provider()
             .fill(tx.into_request())

src/tasks/submit/flashbots.rs

@@ -11,6 +11,7 @@ use alloy::{
     rpc::types::TransactionRequest,
     sol_types::SolCall,
 };
+use futures_util::FutureExt;
 use init4_bin_base::deps::metrics::counter;
 use signet_sim::BuiltBlock;
 use signet_types::{SignRequest, SignResponse};
@@ -103,14 +104,13 @@ impl<'a> SubmitPrep<'a> {
     }
 
     /// Encodes the rollup block into a sidecar.
+    #[instrument(skip(self), level = "debug")]
     async fn build_sidecar(&self) -> eyre::Result<BlobTransactionSidecar> {
-        let sidecar = self.block.encode_blob::<SimpleCoder>().build()?;
-
-        Ok(sidecar)
+        self.block.encode_blob::<SimpleCoder>().build().map_err(Into::into)
     }
 
     /// Build a signature and header input for the host chain transaction.
-    async fn build_input(&self) -> eyre::Result<Vec<u8>> {
+    async fn build_input(&self) -> eyre::Result<Bytes> {
         let (v, r, s) = self.quincey_signature().await?;
 
         let header = Zenith::BlockHeader {
@@ -120,19 +120,21 @@ impl<'a> SubmitPrep<'a> {
             rewardAddress: self.sig_request().ru_reward_address,
             blockDataHash: *self.block.contents_hash(),
         };
-        debug!(?header.hostBlockNumber, "built zenith block header");
-
-        let data = Zenith::submitBlockCall { header, v, r, s, _4: Bytes::new() }.abi_encode();
+        let call = Zenith::submitBlockCall { header, v, r, s, _4: Bytes::new() };
 
-        Ok(data)
+        Ok(call.abi_encode().into())
     }
 
     /// Create a new transaction request for the host chain.
     async fn new_tx_request(&self) -> eyre::Result<TransactionRequest> {
-        let nonce =
-            self.provider.get_transaction_count(self.provider.default_signer_address()).await?;
+        let nonce_fut = self
+            .provider
+            .get_transaction_count(self.provider.default_signer_address())
+            .into_future()
+            .map(|res| res.map_err(Into::into));
 
-        let (sidecar, input) = try_join!(self.build_sidecar(), self.build_input())?;
+        let (nonce, sidecar, input) =
+            try_join!(nonce_fut, self.build_sidecar(), self.build_input())?;
 
         let tx = TransactionRequest::default()
             .with_blob_sidecar(sidecar)
@@ -144,7 +146,6 @@ impl<'a> SubmitPrep<'a> {
     }
 
     /// Prepares a transaction for submission to the host chain.
-    #[instrument(skip_all, level = "debug")]
     pub async fn prep_transaction(self, prev_host: &Header) -> eyre::Result<Bumpable> {
         let req = self.new_tx_request().in_current_span().await?;
         Ok(Bumpable::new(req, prev_host))