feat: share sparse trie pipeline with payload builder

Author: constbh

src/node/engine.rs

@@ -111,6 +111,91 @@ where
                 MiningConfig::from_env()
             };
 
+        // Register the sparse-trie state-root spawner, if enabled.
+        //
+        // We construct a long-lived `PayloadProcessor` keyed to a fresh `BscEvmConfig`
+        // (built from chain_spec — same source as the rest of the BSC pipeline). For
+        // each build job, the registered closure constructs a one-shot
+        // `OverlayStateProviderFactory` anchored at the parent block hash and calls
+        // `spawn_state_root` to get a `StateRootHandle`.
+        //
+        // `TreeConfig::default()` is used here as a workaround — the engine-launch
+        // `TreeConfig` (which honors `--engine.*` CLI flags) is not reachable from
+        // `BscPayloadServiceBuilder`. Default values are reasonable for the sparse-trie
+        // background task; revisit if performance testing shows we need CLI-tunable
+        // worker counts or cache sizes.
+        if mining_config.use_sparse_trie_state_root
+            && !rust_eth_triedb::triedb_manager::is_triedb_active()
+        {
+            use reth_engine_tree::tree::{
+                payload_processor::PayloadProcessor, precompile_cache::PrecompileCacheMap,
+                TreeConfig,
+            };
+            use reth_provider::providers::{OverlayBuilder, OverlayStateProviderFactory};
+            use reth_tasks::{Runtime, RuntimeBuilder, RuntimeConfig, TokioConfig};
+            use reth_trie_db::ChangesetCache;
+
+            let chain_spec = Arc::new(ctx.config().chain.clone().as_ref().clone());
+            let bsc_evm_config = crate::node::evm::config::BscEvmConfig::new(chain_spec);
+            let tree_config = Arc::new(TreeConfig::default());
+            let provider = ctx.provider().clone();
+
+            // Build a dedicated `reth_tasks::Runtime` for the sparse-trie pools,
+            // attached to the existing tokio handle so we don't spin up a second tokio
+            // executor. Rayon pools default to `available_parallelism()`, matching what
+            // the engine uses for its own PayloadProcessor.
+            //
+            // TODO: in a follow-up, share the engine's Runtime instead of constructing
+            // a parallel one — this currently means two sets of rayon pools competing
+            // for CPU. Acceptable for a first cut; revisit if perf testing shows
+            // contention.
+            let tokio_handle = ctx.task_executor().handle().clone();
+            let runtime = RuntimeBuilder::new(
+                RuntimeConfig::default().with_tokio(TokioConfig::existing_handle(tokio_handle)),
+            )
+            .build()
+            .map_err(|e| eyre::eyre!("failed to build sparse-trie Runtime: {e}"))?;
+            let _: &Runtime = &runtime; // type-check anchor
+
+            let payload_processor = std::sync::Arc::new(PayloadProcessor::new(
+                runtime,
+                bsc_evm_config,
+                tree_config.as_ref(),
+                PrecompileCacheMap::default(),
+            ));
+
+            let tree_config_for_closure = tree_config.clone();
+            let spawn_fn: crate::shared::SparseTrieSpawnFn = std::sync::Arc::new(
+                move |parent_hash: alloy_primitives::B256,
+                      parent_state_root: alloy_primitives::B256| {
+                    let overlay_factory = OverlayStateProviderFactory::new(
+                        provider.clone(),
+                        OverlayBuilder::<crate::BscPrimitives>::new(
+                            parent_hash,
+                            ChangesetCache::default(),
+                        ),
+                    );
+                    Some(payload_processor.spawn_state_root(
+                        overlay_factory,
+                        parent_state_root,
+                        false, // halve_workers
+                        tree_config_for_closure.as_ref(),
+                    ))
+                },
+            );
+
+            if crate::shared::set_sparse_trie_spawn_fn(spawn_fn).is_err() {
+                tracing::warn!(
+                    "Sparse-trie spawner already registered, keeping existing one"
+                );
+            } else {
+                info!(
+                    "Sparse-trie state-root spawner registered \
+                     (use_sparse_trie_state_root=true, triedb=inactive)"
+                );
+            }
+        }
+
         // Skip mining setup if disabled
         if !mining_config.is_mining_enabled() {
             info!("Mining is disabled in configuration");

src/node/evm/builder.rs

@@ -228,11 +228,21 @@ where
                 "Calculated state root using triedb"
             );
             (new_root, TrieUpdates::default(), Some(new_difflayer))
-        } else if let Some((root, updates)) = self.precomputed_state_root.take() {
+        } else if let Some((root, updates)) = self
+            .ctx
+            .state_root_precomputed_sink
+            .as_ref()
+            .and_then(|sink| sink.lock().unwrap().take())
+            .or_else(|| self.precomputed_state_root.take())
+        {
             // Fast path: sparse-trie background task already computed the root concurrently
             // with execution. See `crate::shared::spawn_sparse_trie_state_root` and reth 2.0
             // `--engine.share-sparse-trie-with-payload-builder` semantics for the upstream
             // mechanism we mirror.
+            //
+            // Preferred source is the sink on `self.ctx` (filled by the payload layer
+            // post-exec); the field on `Self` is a fallback that `fn finish` populates
+            // when callers route through the trait method.
             tracing::debug!(
                 target: "bsc::builder",
                 parent_hash = %self.parent.hash(),

src/node/evm/config.rs

@@ -69,6 +69,13 @@ pub struct BscNextBlockEnvAttributes {
     /// Sink for transporting `turn_length` from builder to payload layer without writing to
     /// TURN_LENGTH_CACHE prematurely.
     pub turn_length_sink: Option<Arc<Mutex<Option<u8>>>>,
+    /// Sink for precomputed `(state_root, trie_updates)` from a sparse-trie background
+    /// task. Filled by payload layer between exec and `finish_with_difflayer` so the
+    /// builder's MDBX branch can skip the blocking `state_root_with_updates` call. See
+    /// [`BscBlockExecutionCtx::state_root_precomputed_sink`] for full semantics.
+    pub state_root_precomputed_sink: Option<
+        Arc<Mutex<Option<(alloy_primitives::B256, reth_trie_common::updates::TrieUpdates)>>>,
+    >,
 }
 
 impl<H: BlockHeader> BuildPendingEnv<H> for BscNextBlockEnvAttributes {
@@ -79,6 +86,7 @@ impl<H: BlockHeader> BuildPendingEnv<H> for BscNextBlockEnvAttributes {
             triedb_prefetcher: None,
             validator_cache_sink: None,
             turn_length_sink: None,
+            state_root_precomputed_sink: None,
         }
     }
 }
@@ -135,6 +143,17 @@ pub struct BscBlockExecutionCtx<'a> {
     pub validator_cache_sink: Option<ValidatorCacheSink>,
     /// Sink for `turn_length` — same lifecycle as `validator_cache_sink`.
     pub turn_length_sink: Option<Arc<Mutex<Option<u8>>>>,
+    /// Sink for a precomputed `(state_root, trie_updates)` from a sparse-trie background
+    /// task (reth 2.0 mechanism).
+    ///
+    /// Write direction is **reversed** vs the other sinks: the payload layer fills this
+    /// **before** calling `finish_with_difflayer`, and the builder's MDBX branch reads
+    /// it to skip the synchronous `state_root_with_updates` call. `None` in the bid
+    /// simulator path and when the `--mining.use-sparse-trie-state-root` flag is off,
+    /// triggering the legacy state-root path.
+    pub state_root_precomputed_sink: Option<
+        Arc<Mutex<Option<(alloy_primitives::B256, reth_trie_common::updates::TrieUpdates)>>>,
+    >,
 }
 
 impl<'a> BscBlockExecutionCtx<'a> {
@@ -440,6 +459,7 @@ where
             triedb_prefetcher: None,
             validator_cache_sink: None,
             turn_length_sink: None,
+            state_root_precomputed_sink: None,
         })
     }
 
@@ -466,6 +486,7 @@ where
             triedb_prefetcher: attributes.triedb_prefetcher,
             validator_cache_sink: attributes.validator_cache_sink,
             turn_length_sink: attributes.turn_length_sink,
+            state_root_precomputed_sink: attributes.state_root_precomputed_sink,
         })
     }
 
@@ -541,6 +562,7 @@ where
             triedb_prefetcher: None,
             validator_cache_sink: None,
             turn_length_sink: None,
+            state_root_precomputed_sink: None,
         })
     }
 

src/node/miner/bid_simulator.rs

@@ -459,6 +459,9 @@ where
                     triedb_prefetcher,
                     validator_cache_sink: Some(bid_validator_cache_sink.clone()),
                     turn_length_sink: Some(bid_turn_length_sink.clone()),
+                    // Bid simulation does not run alongside a sparse-trie task —
+                    // builder will fall through to state_root_with_updates.
+                    state_root_precomputed_sink: None,
                 },
             )
             .map_err(PayloadBuilderError::other)

src/node/miner/bsc_miner.rs

@@ -733,6 +733,7 @@ where
             // Filled in by BscPayloadJob::start when sparse-trie state-root is enabled
             // and the engine has registered a spawner. Falls back to legacy path when None.
             state_root_precomputed: std::sync::Arc::new(std::sync::Mutex::new(None)),
+            trie_handle: std::sync::Arc::new(std::sync::Mutex::new(None)),
         };
 
         let parent_hash = mining_ctx.parent_header.hash();