chore: use new transaction builders for building the EIP-7594 sidecar tx

Author: Evalir

src/config.rs

@@ -214,7 +214,7 @@ impl BuilderConfig {
 
         Ok(ProviderBuilder::new_with_network()
             .disable_recommended_fillers()
-            .filler(BlobGasFiller)
+            .filler(BlobGasFiller::default())
             .with_gas_estimation()
             .with_nonce_management(SimpleNonceManager::default())
             .fetch_chain_id()

src/tasks/submit/flashbots.rs

@@ -6,20 +6,16 @@ use crate::{
     tasks::{block::sim::SimResult, submit::SubmitPrep},
 };
 use alloy::{
-    consensus::{EthereumTxEnvelope, TxEip4844Variant},
-    eips::{Encodable2718, eip7594::BlobTransactionSidecarEip7594},
+    consensus::TxEnvelope,
+    eips::Encodable2718,
     primitives::{Bytes, TxHash},
     providers::ext::MevApi,
     rpc::types::mev::EthSendBundle,
 };
-use eyre::Context;
 use init4_bin_base::{deps::metrics::counter, utils::signer::LocalOrAws};
 use tokio::{sync::mpsc, task::JoinHandle};
 use tracing::{Instrument, debug, debug_span, error, instrument};
 
-/// Type alias for a EIP 7594 compatible blob sidecar transaction envelope.
-type TxEnvelope7594 = EthereumTxEnvelope<TxEip4844Variant<BlobTransactionSidecarEip7594>>;
-
 /// Handles preparation and submission of simulated rollup blocks to the
 /// Flashbots relay as MEV bundles.
 #[derive(Debug)]
@@ -100,10 +96,7 @@ impl FlashbotsTask {
     /// Creates a `SubmitPrep` instance to build the transaction, then fills
     /// and signs it using the host provider.
     #[instrument(skip_all, level = "debug")]
-    async fn prepare_signed_transaction(
-        &self,
-        sim_result: &SimResult,
-    ) -> eyre::Result<TxEnvelope7594> {
+    async fn prepare_signed_transaction(&self, sim_result: &SimResult) -> eyre::Result<TxEnvelope> {
         let prep = SubmitPrep::new(
             &sim_result.block,
             self.host_provider(),
@@ -119,8 +112,7 @@ impl FlashbotsTask {
             .instrument(tracing::debug_span!("fill_tx").or_current())
             .await?;
 
-        let tx_envelope =
-            sendable.try_into_envelope()?.try_into_7594().wrap_err("failed to map 4844 to 7594")?;
+        let tx_envelope = sendable.try_into_envelope()?;
         debug!(tx_hash = ?tx_envelope.hash(), "prepared signed rollup block transaction envelope");
 
         Ok(tx_envelope)
@@ -130,7 +122,7 @@ impl FlashbotsTask {
     ///
     /// Sends the transaction hash to the outbound channel for monitoring.
     /// Logs a debug message if the channel is closed.
-    fn track_outbound_tx(&self, envelope: &TxEnvelope7594) {
+    fn track_outbound_tx(&self, envelope: &TxEnvelope) {
         counter!("signet.builder.flashbots.").increment(1);
         let hash = *envelope.tx_hash();
         if self.outbound.send(hash).is_err() {

src/tasks/submit/prep.rs

@@ -4,8 +4,9 @@ use crate::{
     utils,
 };
 use alloy::{
-    consensus::{BlobTransactionSidecar, Header, SimpleCoder},
-    network::{TransactionBuilder, TransactionBuilder4844},
+    consensus::{Header, SimpleCoder},
+    eips::eip7594::BlobTransactionSidecarEip7594,
+    network::{TransactionBuilder, TransactionBuilder7594},
     primitives::{B256, Bytes, U256},
     providers::{Provider, WalletProvider},
     rpc::types::TransactionRequest,
@@ -103,10 +104,10 @@ impl<'a> SubmitPrep<'a> {
         self.quincey_resp().await.map(|resp| &resp.sig).map(utils::extract_signature_components)
     }
 
-    /// Encodes the rollup block into a sidecar.
+    /// Encodes the rollup block into an EIP-7594 sidecar.
     #[instrument(skip(self), level = "debug")]
-    async fn build_sidecar(&self) -> eyre::Result<BlobTransactionSidecar> {
-        self.block.encode_blob::<SimpleCoder>().build().map_err(Into::into)
+    async fn build_sidecar(&self) -> eyre::Result<BlobTransactionSidecarEip7594> {
+        self.block.encode_blob::<SimpleCoder>().build_7594().map_err(Into::into)
     }
 
     /// Build a signature and header input for the host chain transaction.