fix: rebase conflicts

crates/optimism/bin/Cargo.toml

@@ -41,6 +41,7 @@ otlp = ["reth-optimism-cli/otlp"]
 
 js-tracer = [
     "reth-optimism-node/js-tracer",
+    "reth-node-builder/js-tracer",
 ]
 
 jemalloc = ["reth-cli-util/jemalloc", "reth-optimism-cli/jemalloc"]

crates/optimism/rpc/Cargo.toml

@@ -30,7 +30,6 @@ reth-node-builder.workspace = true
 reth-chainspec.workspace = true
 reth-chain-state.workspace = true
 reth-rpc-engine-api.workspace = true
-reth-rpc-convert.workspace = true
 reth-payload-util.workspace = true
 reth-provider.workspace = true
 

crates/optimism/rpc/src/debug.rs

@@ -186,11 +186,11 @@ where
                 let config = PayloadConfig { parent_header: Arc::new(parent_header), attributes };
                 let ctx = OpPayloadBuilderCtx {
                     evm_config: this.evm_config.clone(),
-                    da_config: Default::default(), // doesn't matter if no txpool
                     chain_spec: this.provider.chain_spec(),
                     config,
                     cancel: Default::default(),
                     best_payload: Default::default(),
+                    builder_config: Default::default(),
                 };
 
                 let state_provider = this

crates/optimism/trie/src/cursor_factory.rs

@@ -28,10 +28,16 @@ impl<'tx, S> TrieCursorFactory for OpProofsTrieCursorFactory<'tx, S>
 where
     S: OpProofsStore + 'tx,
 {
-    type AccountTrieCursor = OpProofsTrieCursor<S::AccountTrieCursor<'tx>>;
-    type StorageTrieCursor = OpProofsTrieCursor<S::StorageTrieCursor<'tx>>;
+    type AccountTrieCursor<'a>
+        = OpProofsTrieCursor<S::AccountTrieCursor<'a>>
+    where
+        Self: 'a;
+    type StorageTrieCursor<'a>
+        = OpProofsTrieCursor<S::StorageTrieCursor<'a>>
+    where
+        Self: 'a;
 
-    fn account_trie_cursor(&self) -> Result<Self::AccountTrieCursor, DatabaseError> {
+    fn account_trie_cursor(&self) -> Result<Self::AccountTrieCursor<'_>, DatabaseError> {
         Ok(OpProofsTrieCursor::new(
             self.storage
                 .account_trie_cursor(self.block_number)
@@ -42,7 +48,7 @@ where
     fn storage_trie_cursor(
         &self,
         hashed_address: B256,
-    ) -> Result<Self::StorageTrieCursor, DatabaseError> {
+    ) -> Result<Self::StorageTrieCursor<'_>, DatabaseError> {
         Ok(OpProofsTrieCursor::new(
             self.storage
                 .storage_trie_cursor(hashed_address, self.block_number)
@@ -70,17 +76,23 @@ impl<'tx, S> HashedCursorFactory for OpProofsHashedAccountCursorFactory<'tx, S>
 where
     S: OpProofsStore + 'tx,
 {
-    type AccountCursor = OpProofsHashedAccountCursor<S::AccountHashedCursor<'tx>>;
-    type StorageCursor = OpProofsHashedStorageCursor<S::StorageCursor<'tx>>;
+    type AccountCursor<'a>
+        = OpProofsHashedAccountCursor<S::AccountHashedCursor<'a>>
+    where
+        Self: 'a;
+    type StorageCursor<'a>
+        = OpProofsHashedStorageCursor<S::StorageCursor<'a>>
+    where
+        Self: 'a;
 
-    fn hashed_account_cursor(&self) -> Result<Self::AccountCursor, DatabaseError> {
+    fn hashed_account_cursor(&self) -> Result<Self::AccountCursor<'_>, DatabaseError> {
         Ok(OpProofsHashedAccountCursor::new(self.storage.account_hashed_cursor(self.block_number)?))
     }
 
     fn hashed_storage_cursor(
         &self,
         hashed_address: B256,
-    ) -> Result<Self::StorageCursor, DatabaseError> {
+    ) -> Result<Self::StorageCursor<'_>, DatabaseError> {
         Ok(OpProofsHashedStorageCursor::new(
             self.storage.storage_hashed_cursor(hashed_address, self.block_number)?,
         ))

crates/optimism/trie/src/db/store.rs

@@ -246,11 +246,10 @@ impl MdbxProofsStorage {
 
         let sorted_post_state = block_state_diff.post_state.into_sorted();
 
-        let sorted_accounts = sorted_post_state.accounts().accounts_sorted();
         let sorted_storage = sorted_post_state
             .account_storages()
             .iter()
-            .sorted_by_key(|(hashed_address, _)| *hashed_address)
+            .map(|(k, v)| (*k, v.clone()))
             .collect::<Vec<_>>();
 
         let storage_trie_len = sorted_storage_nodes.len();
@@ -265,7 +264,7 @@ impl MdbxProofsStorage {
         let hashed_account_keys = self.append_or_delete_dup_sorted(
             tx,
             block_number,
-            sorted_accounts.into_iter(),
+            sorted_post_state.accounts().iter().copied(),
             soft_delete,
         )?;
 
@@ -298,19 +297,19 @@ impl MdbxProofsStorage {
             if storage.is_wiped() {
                 // Yet to have any update for the current block number - So just using up to
                 // previous block number
-                let mut ro = self.storage_hashed_cursor(*hashed_address, block_number - 1)?;
-                let keys = self.wipe_storage(tx, block_number, *hashed_address, || ro.next())?;
+                let mut ro = self.storage_hashed_cursor(hashed_address, block_number - 1)?;
+                let keys = self.wipe_storage(tx, block_number, hashed_address, || ro.next())?;
                 hashed_storage_keys.extend(keys);
                 // Skip any further processing for this hashed_address
                 continue;
             }
-            let storage_items = storage.storage_slots_sorted().collect::<Vec<_>>();
             let keys = self.append_or_delete_dup_sorted(
                 tx,
                 block_number,
-                storage_items
-                    .into_iter()
-                    .map(|(key, val)| (*hashed_address, key, Some(StorageValue(val)))),
+                storage
+                    .storage_slots_ref()
+                    .iter()
+                    .map(|(key, val)| (hashed_address, *key, Some(StorageValue(*val)))),
                 soft_delete,
             )?;
             hashed_storage_keys.extend(keys);

crates/optimism/trie/tests/live.rs

@@ -10,7 +10,7 @@ use reth_db_common::init::init_genesis;
 use reth_ethereum_primitives::{Block, BlockBody, Receipt, TransactionSigned};
 use reth_evm::{execute::Executor, ConfigureEvm};
 use reth_evm_ethereum::EthEvmConfig;
-use reth_node_api::{FullNodePrimitives, NodeTypesWithDB};
+use reth_node_api::{NodePrimitives, NodeTypesWithDB};
 use reth_optimism_trie::{
     backfill::BackfillJob, in_memory::InMemoryProofsStorage, live::LiveTrieCollector,
     OpProofsStorage,
@@ -145,7 +145,7 @@ fn execute_block<N>(
 ) -> eyre::Result<reth_evm::execute::BlockExecutionOutput<Receipt>>
 where
     N: ProviderNodeTypes<
-            Primitives: FullNodePrimitives<Block = Block, BlockBody = BlockBody, Receipt = Receipt>,
+            Primitives: NodePrimitives<Block = Block, BlockBody = BlockBody, Receipt = Receipt>,
         > + NodeTypesWithDB,
 {
     let provider = provider_factory.provider()?;
@@ -172,7 +172,7 @@ fn commit_block_to_database<N>(
 ) -> eyre::Result<()>
 where
     N: ProviderNodeTypes<
-            Primitives: FullNodePrimitives<Block = Block, BlockBody = BlockBody, Receipt = Receipt>,
+            Primitives: NodePrimitives<Block = Block, BlockBody = BlockBody, Receipt = Receipt>,
         > + NodeTypesWithDB,
 {
     let execution_outcome = ExecutionOutcome {
@@ -210,7 +210,7 @@ async fn run_test_scenario<N>(
 ) -> eyre::Result<()>
 where
     N: ProviderNodeTypes<
-            Primitives: FullNodePrimitives<Block = Block, BlockBody = BlockBody, Receipt = Receipt>,
+            Primitives: NodePrimitives<Block = Block, BlockBody = BlockBody, Receipt = Receipt>,
         > + NodeTypesWithDB,
 {
     let genesis_hash = chain_spec.genesis_hash();

crates/storage/db-api/src/mock.rs

@@ -290,12 +290,18 @@ impl<T: Table> DbCursorRO<T> for CursorMock {
 }
 
 impl<T: DupSort> DbDupCursorRO<T> for CursorMock {
-    /// Moves to the next duplicate entry.
-    /// **Mock behavior**: Always returns `None`.
+    fn prev_dup(&mut self) -> PairResult<T> {
+        Ok(None)
+    }
+
     fn next_dup(&mut self) -> PairResult<T> {
         Ok(None)
     }
 
+    fn last_dup(&mut self) -> ValueOnlyResult<T> {
+        Ok(None)
+    }
+
     /// Moves to the next entry with a different key.
     /// **Mock behavior**: Always returns `None`.
     fn next_no_dup(&mut self) -> PairResult<T> {

crates/trie/common/src/updates.rs

@@ -432,9 +432,9 @@ pub struct TrieUpdatesSortedRef<'a> {
 pub struct TrieUpdatesSorted {
     /// Sorted collection of updated state nodes with corresponding paths. None indicates that a
     /// node was removed.
-    account_nodes: Vec<(Nibbles, Option<BranchNodeCompact>)>,
+    pub account_nodes: Vec<(Nibbles, Option<BranchNodeCompact>)>,
     /// Storage tries stored by hashed address of the account the trie belongs to.
-    storage_tries: B256Map<StorageTrieUpdatesSorted>,
+    pub storage_tries: B256Map<StorageTrieUpdatesSorted>,
 }
 
 impl TrieUpdatesSorted {