fix: update to eip 7594 blob handling (#202)

* fix: update to eip 7954 blob handling

* logs

* moar logs

* clippy

* deps: unpin and update alloy to 1.0.40

* address reviews

* comments

* deps: bump builder version to 1.0.0-rc.0

Author: dylanlott

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "builder"
-version = "0.6.2"
+version = "1.0.0-rc.0"
 description = "signet builder example"
 
 edition = "2024"
@@ -30,7 +30,7 @@ signet-genesis = { git = "https://github.com/init4tech/node-components", tag = "
 
 trevm = { version = "0.31.2", features = ["concurrent-db", "test-utils"] }
 
-alloy = { version = "=1.0.35", features = [
+alloy = { version = "1.0.40", features = [
     "full",
     "json-rpc",
     "signer-aws",

Cargo.toml

@@ -6,16 +6,20 @@ use crate::{
     tasks::{block::sim::SimResult, submit::SubmitPrep},
 };
 use alloy::{
-    eips::Encodable2718,
+    consensus::{EthereumTxEnvelope, TxEip4844Variant},
+    eips::{Encodable2718, eip7594::BlobTransactionSidecarEip7594},
     primitives::{Bytes, TxHash},
     providers::ext::MevApi,
     rpc::types::mev::EthSendBundle,
 };
-use eyre::OptionExt;
+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)]
@@ -84,7 +88,6 @@ impl FlashbotsTask {
         let txs = self.build_bundle_body(sim_result, tx_bytes);
 
         // Create the MEV bundle (valid only in the specific host block)
-
         Ok(EthSendBundle {
             txs,
             block_number: sim_result.host_block_number(),
@@ -100,7 +103,7 @@ impl FlashbotsTask {
     async fn prepare_signed_transaction(
         &self,
         sim_result: &SimResult,
-    ) -> eyre::Result<alloy::consensus::TxEnvelope> {
+    ) -> eyre::Result<TxEnvelope7594> {
         let prep = SubmitPrep::new(
             &sim_result.block,
             self.host_provider(),
@@ -115,14 +118,18 @@ impl FlashbotsTask {
             .instrument(tracing::debug_span!("fill_tx").or_current())
             .await?;
 
-        sendable.as_envelope().ok_or_eyre("failed to get envelope from filled tx").cloned()
+        let tx_envelope =
+            sendable.try_into_envelope()?.try_into_7594().wrap_err("failed to map 4844 to 7594")?;
+        debug!(tx_hash = ?tx_envelope.hash(), "prepared signed rollup block transaction envelope");
+
+        Ok(tx_envelope)
     }
 
     /// Tracks the outbound transaction hash and increments submission metrics.
     ///
     /// 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: &alloy::consensus::TxEnvelope) {
+    fn track_outbound_tx(&self, envelope: &TxEnvelope7594) {
         counter!("signet.builder.flashbots.").increment(1);
         let hash = *envelope.tx_hash();
         if self.outbound.send(hash).is_err() {

src/tasks/submit/flashbots.rs

@@ -4,7 +4,7 @@ use crate::{
     utils,
 };
 use alloy::{
-    consensus::{Header, SimpleCoder},
+    consensus::{BlobTransactionSidecar, Header, SimpleCoder},
     network::{TransactionBuilder, TransactionBuilder4844},
     primitives::{B256, Bytes, U256},
     providers::{Provider, WalletProvider},
@@ -15,6 +15,7 @@ use init4_bin_base::deps::metrics::counter;
 use signet_sim::BuiltBlock;
 use signet_types::{SignRequest, SignResponse};
 use signet_zenith::Zenith;
+use tokio::try_join;
 use tracing::{Instrument, debug, error, instrument, warn};
 
 /// Preparation logic for transactions issued to the host chain by the
@@ -101,8 +102,15 @@ impl<'a> SubmitPrep<'a> {
         self.quincey_resp().await.map(|resp| &resp.sig).map(utils::extract_signature_components)
     }
 
-    /// Encodes the sidecar and then builds the 4844 blob transaction from the provided header and signature values.
-    async fn build_blob_tx(&self) -> eyre::Result<TransactionRequest> {
+    /// Encodes the rollup block into a sidecar.
+    async fn build_sidecar(&self) -> eyre::Result<BlobTransactionSidecar> {
+        let sidecar = self.block.encode_blob::<SimpleCoder>().build()?;
+
+        Ok(sidecar)
+    }
+
+    /// Build a signature and header input for the host chain transaction.
+    async fn build_input(&self) -> eyre::Result<Vec<u8>> {
         let (v, r, s) = self.quincey_signature().await?;
 
         let header = Zenith::BlockHeader {
@@ -116,21 +124,19 @@ impl<'a> SubmitPrep<'a> {
 
         let data = Zenith::submitBlockCall { header, v, r, s, _4: Bytes::new() }.abi_encode();
 
-        let sidecar = self.block.encode_blob::<SimpleCoder>().build()?;
-
-        Ok(TransactionRequest::default().with_blob_sidecar(sidecar).with_input(data))
+        Ok(data)
     }
 
+    /// 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?;
 
-        debug!(nonce, "assigned nonce to rollup block transaction");
+        let (sidecar, input) = try_join!(self.build_sidecar(), self.build_input())?;
 
-        // Create a blob transaction with the blob header and signature values and return it
-        let tx = self
-            .build_blob_tx()
-            .await?
+        let tx = TransactionRequest::default()
+            .with_blob_sidecar(sidecar)
+            .with_input(input)
             .with_to(self.config.constants.host_zenith())
             .with_nonce(nonce);