add builder tx in standard builder

Author: avalonche

crates/op-rbuilder/src/builders/builder_tx.rs

@@ -59,7 +59,7 @@ impl From<BuilderTransactionError> for PayloadBuilderError {
     }
 }
 
-pub trait BuilderTransactions {
+pub trait BuilderTransactions: Debug {
     fn simulate_builder_txs<DB, Extra: Debug + Default>(
         &self,
         info: &mut ExecutionInfo<Extra>,
@@ -132,7 +132,7 @@ pub trait BuilderTransactions {
 
 // Scaffolding for how to construct the end of block builder transaction
 // This will be the regular end of block transaction without the TEE key
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct StandardBuilderTx {
     #[allow(dead_code)]
     pub signer: Option<Signer>,

crates/op-rbuilder/src/builders/flashblocks/service.rs

@@ -71,7 +71,6 @@ where
         pool: Pool,
         _: OpEvmConfig,
     ) -> eyre::Result<PayloadBuilderHandle<<Node::Types as NodeTypes>::Payload>> {
-        tracing::debug!("Spawning flashblocks payload builder service");
         let signer = self.0.builder_signer;
         if self.0.flashtestations_config.flashtestations_enabled {
             let flashtestations_builder_tx = match bootstrap_flashtestations(
@@ -83,7 +82,7 @@ where
             {
                 Ok(service) => service,
                 Err(e) => {
-                    tracing::warn!(error = %e, "Failed to spawn flashtestations service, falling back to standard builder tx");
+                    tracing::warn!(error = %e, "Failed to bootstrap flashtestations, falling back to standard builder tx");
                     return self.spawn_payload_builder_service(
                         ctx,
                         pool,

crates/op-rbuilder/src/builders/standard/mod.rs

@@ -1,11 +1,12 @@
-use payload::StandardPayloadBuilderBuilder;
-use reth_node_builder::components::BasicPayloadServiceBuilder;
-
-use crate::traits::{NodeBounds, PoolBounds};
+use crate::{
+    builders::standard::service::StandardServiceBuilder,
+    traits::{NodeBounds, PoolBounds},
+};
 
 use super::BuilderConfig;
 
 mod payload;
+mod service;
 
 /// Block building strategy that builds blocks using the standard approach by
 /// producing blocks every chain block time.
@@ -15,7 +16,7 @@ impl super::PayloadBuilder for StandardBuilder {
     type Config = ();
 
     type ServiceBuilder<Node, Pool>
-        = BasicPayloadServiceBuilder<StandardPayloadBuilderBuilder>
+        = StandardServiceBuilder
     where
         Node: NodeBounds,
         Pool: PoolBounds;
@@ -27,8 +28,6 @@ impl super::PayloadBuilder for StandardBuilder {
         Node: NodeBounds,
         Pool: PoolBounds,
     {
-        Ok(BasicPayloadServiceBuilder::new(
-            StandardPayloadBuilderBuilder(config),
-        ))
+        Ok(StandardServiceBuilder(config))
     }
 }

crates/op-rbuilder/src/builders/standard/payload.rs

@@ -1,12 +1,8 @@
 use crate::{
-    builders::{
-        builder_tx::StandardBuilderTx, generator::BuildArguments, BuilderConfig,
-        BuilderTransactions,
-    },
-    flashtestations::service::bootstrap_flashtestations,
+    builders::{generator::BuildArguments, BuilderConfig, BuilderTransactions},
     metrics::OpRBuilderMetrics,
     primitives::reth::ExecutionInfo,
-    traits::{ClientBounds, NodeBounds, PayloadTxsBounds, PoolBounds},
+    traits::{ClientBounds, PayloadTxsBounds, PoolBounds},
 };
 use alloy_consensus::{
     constants::EMPTY_WITHDRAWALS, proofs, BlockBody, Header, EMPTY_OMMER_ROOT_HASH,
@@ -18,7 +14,6 @@ use reth_basic_payload_builder::{BuildOutcome, BuildOutcomeKind, MissingPayloadB
 use reth_chain_state::{ExecutedBlock, ExecutedBlockWithTrieUpdates, ExecutedTrieUpdates};
 use reth_evm::{execute::BlockBuilder, ConfigureEvm};
 use reth_node_api::{Block, PayloadBuilderError};
-use reth_node_builder::{components::PayloadBuilderBuilder, BuilderContext};
 use reth_optimism_consensus::{calculate_receipt_root_no_memo_optimism, isthmus};
 use reth_optimism_evm::{OpEvmConfig, OpNextBlockEnvAttributes};
 use reth_optimism_forks::OpHardforks;
@@ -41,64 +36,6 @@ use tracing::{error, info, warn};
 
 use super::super::context::OpPayloadBuilderCtx;
 
-pub struct StandardPayloadBuilderBuilder(pub BuilderConfig<()>);
-
-impl<Node, Pool> PayloadBuilderBuilder<Node, Pool, OpEvmConfig> for StandardPayloadBuilderBuilder
-where
-    Node: NodeBounds,
-    Pool: PoolBounds,
-{
-    type PayloadBuilder = StandardOpPayloadBuilder<Pool, Node::Provider, StandardBuilderTx>;
-
-    async fn build_payload_builder(
-        self,
-        ctx: &BuilderContext<Node>,
-        pool: Pool,
-        _evm_config: OpEvmConfig,
-    ) -> eyre::Result<Self::PayloadBuilder> {
-        let signer = self.0.builder_signer;
-        if self.0.flashtestations_config.flashtestations_enabled {
-            let _flashtestation_builder_tx = match bootstrap_flashtestations(
-                self.0.flashtestations_config.clone(),
-                ctx,
-                signer,
-            )
-            .await
-            {
-                Ok(flashtestation_builder_tx) => flashtestation_builder_tx,
-                Err(e) => {
-                    tracing::warn!(error = %e, "Failed to spawn flashtestations service, falling back to standard builder tx");
-                    return Ok(StandardOpPayloadBuilder::new(
-                        OpEvmConfig::optimism(ctx.chain_spec()),
-                        pool,
-                        ctx.provider().clone(),
-                        self.0.clone(),
-                        StandardBuilderTx::new(self.0.builder_signer),
-                    ));
-                }
-            };
-
-            if self.0.flashtestations_config.enable_block_proofs {
-                // return Ok(StandardOpPayloadBuilder::new(
-                //     OpEvmConfig::optimism(ctx.chain_spec()),
-                //     pool,
-                //     ctx.provider().clone(),
-                //     self.0.clone(),
-                //     flashtestation_builder_tx,
-                // ));
-            }
-        }
-
-        Ok(StandardOpPayloadBuilder::new(
-            OpEvmConfig::optimism(ctx.chain_spec()),
-            pool,
-            ctx.provider().clone(),
-            self.0.clone(),
-            StandardBuilderTx::new(self.0.builder_signer),
-        ))
-    }
-}
-
 /// Optimism's payload builder
 #[derive(Debug, Clone)]
 pub struct StandardOpPayloadBuilder<Pool, Client, BuilderTx, Txs = ()> {

crates/op-rbuilder/src/builders/standard/service.rs

@@ -0,0 +1,107 @@
+use reth_basic_payload_builder::{BasicPayloadJobGenerator, BasicPayloadJobGeneratorConfig};
+use reth_node_api::NodeTypes;
+use reth_node_builder::{components::PayloadServiceBuilder, BuilderContext};
+use reth_optimism_evm::OpEvmConfig;
+use reth_payload_builder::{PayloadBuilderHandle, PayloadBuilderService};
+use reth_provider::CanonStateSubscriptions;
+
+use crate::{
+    builders::{
+        standard::payload::StandardOpPayloadBuilder, BuilderConfig, BuilderTransactions,
+        StandardBuilderTx,
+    },
+    flashtestations::service::bootstrap_flashtestations,
+    traits::{NodeBounds, PoolBounds},
+};
+
+pub struct StandardServiceBuilder(pub BuilderConfig<()>);
+
+impl StandardServiceBuilder {
+    pub fn spawn_payload_builder_service<Node, Pool, BuilderTx>(
+        self,
+        evm_config: OpEvmConfig,
+        ctx: &BuilderContext<Node>,
+        pool: Pool,
+        builder_tx: BuilderTx,
+    ) -> eyre::Result<PayloadBuilderHandle<<Node::Types as NodeTypes>::Payload>>
+    where
+        Node: NodeBounds,
+        Pool: PoolBounds,
+        BuilderTx: BuilderTransactions + Unpin + Clone + Send + Sync + 'static,
+    {
+        let payload_builder = StandardOpPayloadBuilder::new(
+            evm_config,
+            pool,
+            ctx.provider().clone(),
+            self.0.clone(),
+            builder_tx,
+        );
+
+        let conf = ctx.config().builder.clone();
+
+        let payload_job_config = BasicPayloadJobGeneratorConfig::default()
+            .interval(conf.interval)
+            .deadline(conf.deadline)
+            .max_payload_tasks(conf.max_payload_tasks);
+
+        let payload_generator = BasicPayloadJobGenerator::with_builder(
+            ctx.provider().clone(),
+            ctx.task_executor().clone(),
+            payload_job_config,
+            payload_builder,
+        );
+        let (payload_service, payload_service_handle) =
+            PayloadBuilderService::new(payload_generator, ctx.provider().canonical_state_stream());
+
+        ctx.task_executor()
+            .spawn_critical("payload builder service", Box::pin(payload_service));
+
+        Ok(payload_service_handle)
+    }
+}
+
+impl<Node, Pool> PayloadServiceBuilder<Node, Pool, OpEvmConfig> for StandardServiceBuilder
+where
+    Node: NodeBounds,
+    Pool: PoolBounds,
+{
+    async fn spawn_payload_builder_service(
+        self,
+        ctx: &BuilderContext<Node>,
+        pool: Pool,
+        evm_config: OpEvmConfig,
+    ) -> eyre::Result<PayloadBuilderHandle<<Node::Types as NodeTypes>::Payload>> {
+        let signer = self.0.builder_signer;
+        if self.0.flashtestations_config.flashtestations_enabled {
+            let flashtestation_builder_tx = match bootstrap_flashtestations(
+                self.0.flashtestations_config.clone(),
+                ctx,
+                signer,
+            )
+            .await
+            {
+                Ok(flashtestation_builder_tx) => flashtestation_builder_tx,
+                Err(e) => {
+                    tracing::warn!(error = %e, "Failed to bootstrap flashtestations, falling back to standard builder tx");
+                    return self.spawn_payload_builder_service(
+                        evm_config,
+                        ctx,
+                        pool,
+                        StandardBuilderTx::new(signer),
+                    );
+                }
+            };
+
+            if self.0.flashtestations_config.enable_block_proofs {
+                return self.spawn_payload_builder_service(
+                    evm_config,
+                    ctx,
+                    pool,
+                    flashtestation_builder_tx,
+                );
+            }
+        }
+
+        self.spawn_payload_builder_service(evm_config, ctx, pool, StandardBuilderTx::new(signer))
+    }
+}

crates/op-rbuilder/src/flashtestations/builder_tx.rs

@@ -43,7 +43,7 @@ pub struct FlashtestationsBuilderTxArgs {
     pub registered: bool,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct FlashtestationsBuilderTx {
     // Attestation for the builder
     attestation: Vec<u8>,