arc-rbuilder: source chain spec from the node; E2E-verified block building

- rbuilder now uses the node's chain spec instead of the config 'chain'
  value (a mismatch made every order fail simulation with InvalidChainId)
- log failed order simulations (trace) and non-critically discarded
  engine-payload blocks (debug) — both were previously silent
- sim-path regression test executing a signed tx through the ctx EVM

Verified end-to-end against arc-localdev driving the engine API like
Malachite: FCU(attrs) -> rbuilder builds (mempool txs + payout) ->
getPayload returns rbuilder's block -> newPayload validates it VALID
(arc executor re-checks state root, ADR-004 extra_data base fee,
SystemAccounting gas values) -> head advances to rbuilder's block.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: SozinM

crates/arc-rbuilder/config-arc-example.toml

@@ -18,9 +18,9 @@ error_storage_path = "/tmp/rbuilder.error.sqlite"
 # env: COINBASE_SECRET_KEY
 coinbase_secret_key = "env:COINBASE_SECRET_KEY"
 
-# chain is unused by arc-rbuilder itself (the node's --chain flag wins) but
-# must parse; use the same network here.
-chain = "arc-testnet"
+# arc-rbuilder always builds for the chain the node runs (--chain flag); this
+# value only needs to parse. Keep it matching the node anyway.
+chain = "arc-localdev"
 
 full_telemetry_server_port = 6060
 redacted_telemetry_server_port = 6061
@@ -36,6 +36,10 @@ simulation_threads = 4
 
 live_builders = ["mp-ordering", "mgp-ordering"]
 
+# Required: sparse trie root hash (parallel impl currently disallowed).
+root_hash_use_sparse_trie = true
+root_hash_compare_sparse_trie = false
+
 [[builders]]
 name = "mgp-ordering"
 algo = "ordering-builder"

crates/arc-rbuilder/src/main.rs

@@ -154,7 +154,7 @@ fn spawn_rbuilder<P, V, T, S>(
                           + StorageSettingsCache,
         > + reth_provider::StateProviderFactory
         + HeaderProvider<Header = Header>
-        + reth_provider::ChainSpecProvider
+        + reth_provider::ChainSpecProvider<ChainSpec = rbuilder::chain::ChainSpec>
         + Clone
         + 'static,
     <P as ChainSpecProvider>::ChainSpec: EthereumHardforks,
@@ -196,7 +196,7 @@ where
                           + StorageSettingsCache,
         > + reth_provider::StateProviderFactory
         + HeaderProvider<Header = Header>
-        + reth_provider::ChainSpecProvider
+        + reth_provider::ChainSpecProvider<ChainSpec = rbuilder::chain::ChainSpec>
         + Clone
         + 'static,
     <P as ChainSpecProvider>::ChainSpec: EthereumHardforks,
@@ -228,6 +228,10 @@ where
 
     let blocklist_provider = base_config.blocklist_provider(cancel.clone()).await?;
 
+    // The chain spec must be the node's: rbuilder simulates and builds for the
+    // chain the node runs, regardless of what the rbuilder config says.
+    let node_chain_spec = reth_provider::ChainSpecProvider::chain_spec(&provider);
+
     let state_provider_factory = StateProviderFactoryFromRethProvider::new(
         provider,
         base_config.live_root_hash_config()?,
@@ -250,7 +254,8 @@ where
         config.live_builders()?,
         base_config.max_order_execution_duration_warning(),
     );
-    let live_builder = live_builder.with_builders(builders);
+    let mut live_builder = live_builder.with_builders(builders);
+    live_builder.chain_chain_spec = node_chain_spec;
 
     live_builder.connect_to_transaction_pool(pool).await?;
     live_builder

crates/rbuilder/src/building/arc_support.rs

@@ -274,6 +274,71 @@ fn base_fee(ctx: &BlockBuildingContext) -> u64 {
     ctx.evm_env.block_env.basefee
 }
 
+#[cfg(test)]
+pub(crate) mod tests_helpers {
+    use super::*;
+    use crate::{
+        building::{builders::mock_block_building_helper::MockRootHasher, BlockBuildingContext},
+        live_builder::order_input::mempool_txs_detector::MempoolTxsDetector,
+        utils::Signer,
+    };
+    use alloy_primitives::{Address, U256};
+    use alloy_rpc_types_beacon::events::{PayloadAttributesData, PayloadAttributesEvent};
+    use alloy_rpc_types_engine::PayloadAttributes;
+    use std::sync::Arc;
+
+    /// BlockBuildingContext for block 1 on the arc localdev chain with a
+    /// parent extra_data encoded base fee of 12_345.
+    pub(crate) fn make_arc_ctx() -> (BlockBuildingContext, Signer) {
+        let chain_spec = chain::chain_spec_for_testing();
+        let mut parent = chain::inner_chain_spec(&chain_spec)
+            .sealed_genesis_header()
+            .header()
+            .clone();
+        parent.extra_data = encode_base_fee_to_bytes(12_345);
+        let parent_hash = parent.hash_slow();
+
+        let attributes = PayloadAttributesEvent {
+            version: "arc".to_string(),
+            data: PayloadAttributesData {
+                proposal_slot: 1,
+                parent_block_root: Default::default(),
+                parent_block_number: parent.number,
+                parent_block_hash: parent_hash,
+                proposer_index: 0,
+                payload_attributes: PayloadAttributes {
+                    timestamp: parent.timestamp + 1,
+                    prev_randao: Default::default(),
+                    suggested_fee_recipient: Address::random(),
+                    withdrawals: Some(vec![]),
+                    parent_beacon_block_root: Some(parent_hash),
+                },
+            },
+        };
+
+        let signer = Signer::random();
+        let ctx = BlockBuildingContext::from_attributes(
+            attributes,
+            &parent,
+            signer.clone(),
+            chain_spec,
+            Default::default(),
+            Some(55_000_000),
+            vec![],
+            None,
+            Arc::new(MockRootHasher {}),
+            0,
+            false,
+            true,
+            U256::ZERO,
+            Default::default(),
+            Arc::new(MempoolTxsDetector::new()),
+        )
+        .unwrap();
+        (ctx, signer)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -358,6 +423,7 @@ mod tests {
 
         assert_eq!(ctx.evm_env.block_env.basefee, 12_345);
         assert_eq!(ctx.evm_env.block_env.gas_limit, 55_000_000);
+        assert_eq!(ctx.evm_env.cfg_env.chain_id, 1337);
     }
 
     /// A plain value transfer through the rbuilder EVM factory must emit the
@@ -414,3 +480,52 @@ mod tests {
         );
     }
 }
+
+#[cfg(test)]
+mod sim_repro_tests {
+    use super::tests_helpers::make_arc_ctx;
+    use crate::building::evm::EvmFactory as _;
+    use alloy_consensus::TxEip1559;
+    use alloy_primitives::{Address, TxKind, U256};
+    use revm::{
+        database::{CacheDB, EmptyDB},
+        state::AccountInfo,
+    };
+
+    /// Replicates the live simulation path: a signed EIP-1559 tx executed
+    /// through ctx.evm_factory with the ctx evm_env.
+    #[test]
+    fn signed_tx_executes_through_ctx_evm() {
+        let (ctx, signer) = make_arc_ctx();
+        let recipient = Address::random();
+
+        let tx = signer
+            .sign_tx(reth_primitives::Transaction::Eip1559(TxEip1559 {
+                chain_id: 1337,
+                nonce: 0,
+                gas_limit: 21_000,
+                max_fee_per_gas: 3_000_000_000,
+                max_priority_fee_per_gas: 1_000_000_000,
+                to: TxKind::Call(recipient),
+                value: U256::from(1),
+                ..Default::default()
+            }))
+            .unwrap();
+
+        let mut db = CacheDB::new(EmptyDB::default());
+        db.insert_account_info(
+            signer.address,
+            AccountInfo {
+                balance: U256::from(10).pow(U256::from(18)),
+                ..Default::default()
+            },
+        );
+
+        let mut evm = ctx.evm_factory.create_evm(&mut db, ctx.evm_env.clone());
+        let res = reth_evm::Evm::transact(&mut evm, &tx);
+        match res {
+            Ok(r) => assert!(r.result.is_success(), "tx failed: {:?}", r.result),
+            Err(err) => panic!("transact error: {err:?}"),
+        }
+    }
+}

crates/rbuilder/src/live_builder/block_output/engine_payload_sink.rs

@@ -153,6 +153,8 @@ impl UnfinishedBlockBuildingSink for EnginePayloadSink {
             Err(err) => {
                 if err.is_critical() {
                     error!(?err, "Failed to finalize block for engine payload");
+                } else {
+                    tracing::debug!(?err, "Discarded block for engine payload");
                 }
                 return;
             }

crates/rbuilder/src/live_builder/simulation/sim_worker.rs

@@ -107,7 +107,10 @@ pub fn run_sim_worker<P>(
 
                                 true
                             }
-                            OrderSimResult::Failed(_) => false,
+                            OrderSimResult::Failed(err) => {
+                                tracing::trace!(?order_id, ?err, "Order simulation failed");
+                                false
+                            }
                         };
                         telemetry::inc_simulated_orders(sim_ok);
                         telemetry::inc_simulation_gas_used(sim_result.gas_used);