fix: resolve rebase conflicts against main after base-execution-primitives flatten and crate renames

- Replace base-execution-primitives with base-alloy-consensus throughout
- Replace base-alloy-rpc-types with base-common-rpc-types (post-rename)
- Rename BaseBlockExecutionCtx/Factory/Executor to Op* to match commit intent
- Replace OpBlock with BaseBlock (current main alias for Block<OpTxEnvelope>)
- Replace OpAttributesWithParent with AttributesWithParent (base_protocol)
- Remove base-execution-primitives from Cargo.toml deps across workspace

Author: refcell

Cargo.lock

@@ -12,12 +12,12 @@ use alloy_signer::SignerSync;
 use alloy_signer_local::PrivateKeySigner;
 use alloy_trie::{EMPTY_ROOT_HASH, TrieAccount, root::state_root_unhashed};
 use base_alloy_chains::BaseUpgrade;
-use base_alloy_consensus::{EIP1559ParamError, OpBlock, OpTxEnvelope};
+use base_alloy_consensus::{BaseBlock, EIP1559ParamError, OpTxEnvelope};
 use base_alloy_rpc_types_engine::{OpExecutionPayload, OpNetworkPayloadEnvelope, PayloadHash};
 use base_consensus_genesis::{RollupConfig, SystemConfig};
 use base_evm::{OpEvmConfig, OpTransaction};
 use base_execution_chainspec::OpChainSpecBuilder;
-use base_protocol::{BlockInfo, L1BlockInfoTx, L2BlockInfo, OpAttributesWithParent};
+use base_protocol::{AttributesWithParent, BlockInfo, L1BlockInfoTx, L2BlockInfo};
 use reth_evm::{ConfigureEvm, Evm as _, FromRecoveredTx};
 use revm::{
     DatabaseCommit,
@@ -140,13 +140,13 @@ pub enum L2SequencerError {
     Evm(String),
 }
 
-/// A pre-built queue of [`OpBlock`]s for the batcher to drain.
+/// A pre-built queue of [`BaseBlock`]s for the batcher to drain.
 ///
 /// Tests push fully-formed blocks into the source, which the batcher
 /// consumes one at a time via [`L2BlockProvider::next_block`].
 #[derive(Debug, Default)]
 pub struct ActionL2Source {
-    blocks: VecDeque<OpBlock>,
+    blocks: VecDeque<BaseBlock>,
 }
 
 impl ActionL2Source {
@@ -156,7 +156,7 @@ impl ActionL2Source {
     }
 
     /// Push a block to the back of the queue.
-    pub fn push(&mut self, block: OpBlock) {
+    pub fn push(&mut self, block: BaseBlock) {
         self.blocks.push_back(block);
     }
 
@@ -172,7 +172,7 @@ impl ActionL2Source {
 }
 
 impl L2BlockProvider for ActionL2Source {
-    fn next_block(&mut self) -> Option<OpBlock> {
+    fn next_block(&mut self) -> Option<BaseBlock> {
         self.blocks.pop_front()
     }
 }
@@ -240,7 +240,7 @@ impl SharedBlockHashRegistry {
     }
 }
 
-/// Builds real [`OpBlock`]s for use in action tests.
+/// Builds real [`BaseBlock`]s for use in action tests.
 ///
 /// Each block contains:
 /// - A correct L1-info deposit transaction (type `0x7E`) as the first
@@ -373,7 +373,7 @@ impl L2Sequencer {
     /// validation.
     ///
     /// [`set_supervised_p2p`]: L2Sequencer::set_supervised_p2p
-    pub fn broadcast_unsafe_block(&self, block: &OpBlock) {
+    pub fn broadcast_unsafe_block(&self, block: &BaseBlock) {
         let Some(p2p) = &self.supervised_p2p else { return };
         let block_hash = block.header.hash_slow();
         let (execution_payload, _) = OpExecutionPayload::from_block_unchecked(block_hash, block);
@@ -397,12 +397,12 @@ impl L2Sequencer {
     /// Panics if the block cannot be built (e.g. missing L1 block data).
     ///
     /// [`build_next_block`]: L2Sequencer::build_next_block
-    pub fn build_empty_block(&mut self) -> OpBlock {
+    pub fn build_empty_block(&mut self) -> BaseBlock {
         self.build_next_block_with_transactions(vec![])
     }
 
     /// Build the next L2 block with a single transaction.
-    pub fn build_next_block_with_single_transaction(&mut self) -> OpBlock {
+    pub fn build_next_block_with_single_transaction(&mut self) -> BaseBlock {
         let tx = {
             let mut account = self.test_account.lock().expect("test account lock poisoned");
             account.create_eip1559_tx(self.rollup_config.l2_chain_id.id())
@@ -412,7 +412,7 @@ impl L2Sequencer {
 
     /// Build the next L2 block and advance the internal head.
     ///
-    /// Returns a fully-formed [`OpBlock`] containing the L1-info deposit and
+    /// Returns a fully-formed [`BaseBlock`] containing the L1-info deposit and
     /// any configured user transactions, with a real state root and block hash.
     ///
     /// # Panics
@@ -425,7 +425,7 @@ impl L2Sequencer {
     pub fn build_next_block_with_transactions(
         &mut self,
         transactions: Vec<OpTxEnvelope>,
-    ) -> OpBlock {
+    ) -> BaseBlock {
         self.try_build_next_block_with_transactions(transactions)
             .unwrap_or_else(|e| panic!("L2Sequencer::build_next_block failed: {e}"))
     }
@@ -439,7 +439,7 @@ impl L2Sequencer {
     pub fn try_build_next_block_with_transactions(
         &mut self,
         transactions: Vec<OpTxEnvelope>,
-    ) -> Result<OpBlock, L2SequencerError> {
+    ) -> Result<BaseBlock, L2SequencerError> {
         let mut transactions = transactions;
         let next_number = self.head.block_info.number + 1;
         let next_timestamp = self.head.block_info.timestamp + self.rollup_config.block_time;
@@ -508,7 +508,7 @@ impl L2Sequencer {
 
         let block_hash = header.hash_slow();
 
-        let block = OpBlock {
+        let block = BaseBlock {
             header,
             body: alloy_consensus::BlockBody { transactions, ommers: vec![], withdrawals: None },
         };
@@ -578,7 +578,7 @@ pub fn compute_state_root(db: &InMemoryDB) -> B256 {
 }
 
 impl L2BlockProvider for L2Sequencer {
-    fn next_block(&mut self) -> Option<OpBlock> {
+    fn next_block(&mut self) -> Option<BaseBlock> {
         Some(self.build_next_block_with_single_transaction())
     }
 }
@@ -641,7 +641,7 @@ impl StatefulL2Executor {
     /// mirror the sequencer's block-by-block execution.
     pub fn execute_attrs(
         &mut self,
-        attrs: &OpAttributesWithParent,
+        attrs: &AttributesWithParent,
         block_number: u64,
         parent_hash: B256,
     ) -> Result<B256, L2SequencerError> {

actions/harness/src/l2.rs

@@ -8,9 +8,8 @@ use ExecutionMeteringLimitExceeded::{
     BlockStateRootGas, FlashblockExecutionTime, TransactionExecutionTime,
 };
 use alloy_primitives::{Address, U256};
-use base_alloy_consensus::OpReceipt;
+use base_alloy_consensus::{OpReceipt, OpTransactionSigned};
 use base_evm::OpTransactionError;
-use base_execution_primitives::OpTransactionSigned;
 use derive_more::Display;
 use thiserror::Error;
 

crates/builder/core/src/execution.rs

@@ -11,11 +11,10 @@ use alloy_primitives::{B256, BlockHash, Bytes, U256};
 use alloy_rpc_types_eth::Withdrawals;
 use base_access_lists::FBALBuilderDb;
 use base_alloy_chains::BaseUpgrades;
-use base_alloy_consensus::{OpDepositReceipt, OpReceipt, OpTxType};
+use base_alloy_consensus::{OpDepositReceipt, OpReceipt, OpTransactionSigned, OpTxType};
 use base_evm::{L1BlockInfo, OpEvmConfig, OpNextBlockEnvAttributes, OpReceiptBuilder, OpSpecId};
 use base_execution_chainspec::OpChainSpec;
 use base_execution_payload_builder::{OpPayloadBuilderAttributes, error::OpPayloadBuilderError};
-use base_execution_primitives::OpTransactionSigned;
 use base_txpool::{
     BundleTransaction, TimestampedTransaction, estimated_da_size::DataAvailabilitySized,
 };

crates/builder/core/src/flashblocks/context.rs

@@ -4,7 +4,7 @@ use std::{sync::Arc, time::Instant};
 
 use alloy_consensus::{BlockHeader, Header, transaction::SignerRecoverable};
 use alloy_primitives::B256;
-use base_alloy_consensus::OpBlock;
+use base_alloy_consensus::BaseBlock;
 use base_evm::{OpEvmConfig, OpNextBlockEnvAttributes};
 use base_execution_chainspec::OpChainSpec;
 use eyre::{Result as EyreResult, eyre};
@@ -37,7 +37,7 @@ use crate::types::{MeterBlockResponse, MeterBlockTransactions};
 pub fn meter_block<P>(
     provider: P,
     chain_spec: Arc<OpChainSpec>,
-    block: &OpBlock,
+    block: &BaseBlock,
 ) -> EyreResult<MeterBlockResponse>
 where
     P: StateProviderFactory + HeaderProvider<Header = Header>,
@@ -137,7 +137,7 @@ where
 mod tests {
     use alloy_consensus::TxEip1559;
     use alloy_primitives::{Address, Signature};
-    use base_execution_primitives::{OpBlockBody, OpTransactionSigned};
+    use base_alloy_consensus::{BaseBlockBody, OpTransactionSigned};
     use base_node_runner::test_utils::{Account, TestHarness};
     use reth_primitives_traits::Block as _;
     use reth_transaction_pool::test_utils::TransactionBuilder;
@@ -147,7 +147,7 @@ mod tests {
     fn create_block_with_transactions(
         harness: &TestHarness,
         transactions: Vec<OpTransactionSigned>,
-    ) -> OpBlock {
+    ) -> BaseBlock {
         let latest = harness.latest_block();
         let header = Header {
             parent_hash: latest.hash(),
@@ -161,9 +161,9 @@ mod tests {
             ..Default::default()
         };
 
-        let body = OpBlockBody { transactions, ommers: vec![], withdrawals: None };
+        let body = BaseBlockBody { transactions, ommers: vec![], withdrawals: None };
 
-        OpBlock::new(header, body)
+        BaseBlock::new(header, body)
     }
 
     #[tokio::test]
@@ -384,8 +384,8 @@ mod tests {
             ..Default::default()
         };
 
-        let body = OpBlockBody { transactions: vec![], ommers: vec![], withdrawals: None };
-        let block = OpBlock::new(header, body);
+        let body = BaseBlockBody { transactions: vec![], ommers: vec![], withdrawals: None };
+        let block = BaseBlock::new(header, body);
 
         let result = meter_block(harness.blockchain_provider(), harness.chain_spec(), &block);
 

crates/client/metering/src/block.rs

@@ -75,7 +75,7 @@ where
 
         let components = |spec: Arc<OpChainSpec>| {
             (
-                BaseExecutorProvider::optimism(Arc::clone(&spec)),
+                OpExecutorProvider::optimism(Arc::clone(&spec)),
                 Arc::new(OpBeaconConsensus::new(spec)),
             )
         };

crates/execution/cli/src/app.rs

@@ -111,7 +111,7 @@ impl<TxResult> CachedExecutionProvider<TxResult> for NoopCachedExecutionProvider
 /// Executor that fetches cached execution results for transactions.
 #[derive(Debug)]
 pub struct CachedExecutor<E, C> {
-    executor: BaseBlockExecutor<E, OpRethReceiptBuilder, Arc<OpChainSpec>>,
+    executor: OpBlockExecutor<E, OpRethReceiptBuilder, Arc<OpChainSpec>>,
     cached_execution_provider: C,
     txs: Vec<B256>,
     position_by_hash: HashMap<B256, usize>,
@@ -122,7 +122,7 @@ pub struct CachedExecutor<E, C> {
 impl<E, C> CachedExecutor<E, C> {
     /// Creates a new [`CachedExecutor`].
     pub fn new(
-        executor: BaseBlockExecutor<E, OpRethReceiptBuilder, Arc<OpChainSpec>>,
+        executor: OpBlockExecutor<E, OpRethReceiptBuilder, Arc<OpChainSpec>>,
         cached_execution_provider: C,
         txs: Vec<B256>,
         parent_block_hash: B256,