Merge branch 'scroll' into feat-forward-tx-to-sequencer

Author: yiweichi

Cargo.lock

@@ -45,7 +45,7 @@ async fn maintain_txpool_stale_eviction() -> eyre::Result<()> {
             .build(),
     );
     let node_config = NodeConfig::test()
-        .with_chain(chain_spec)
+        .with_chain(chain_spec.clone())
         .with_unused_ports()
         .with_rpc(RpcServerArgs::default().with_unused_ports().with_http());
     let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config.clone())
@@ -67,6 +67,7 @@ async fn maintain_txpool_stale_eviction() -> eyre::Result<()> {
         "txpool maintenance task",
         reth_transaction_pool::maintain::maintain_transaction_pool_future(
             node.inner.provider.clone(),
+            chain_spec,
             txpool.clone(),
             node.inner.provider.clone().canonical_state_stream(),
             executor.clone(),
@@ -120,7 +121,7 @@ async fn maintain_txpool_reorg() -> eyre::Result<()> {
     );
     let genesis_hash = chain_spec.genesis_hash();
     let node_config = NodeConfig::test()
-        .with_chain(chain_spec)
+        .with_chain(chain_spec.clone())
         .with_unused_ports()
         .with_rpc(RpcServerArgs::default().with_unused_ports().with_http());
     let NodeHandle { node, node_exit_future: _ } = NodeBuilder::new(node_config.clone())
@@ -139,6 +140,7 @@ async fn maintain_txpool_reorg() -> eyre::Result<()> {
         "txpool maintenance task",
         reth_transaction_pool::maintain::maintain_transaction_pool_future(
             node.inner.provider.clone(),
+            chain_spec,
             txpool.clone(),
             node.inner.provider.clone().canonical_state_stream(),
             executor.clone(),
@@ -269,6 +271,7 @@ async fn maintain_txpool_commit() -> eyre::Result<()> {
         "txpool maintenance task",
         reth_transaction_pool::maintain::maintain_transaction_pool_future(
             node.inner.provider.clone(),
+            MAINNET.clone(),
             txpool.clone(),
             node.inner.provider.clone().canonical_state_stream(),
             executor.clone(),

crates/ethereum/node/tests/e2e/pool.rs

@@ -1,16 +1,17 @@
 //! Pool component for the node builder.
 
+use crate::{BuilderContext, FullNodeTypes};
+
 use alloy_primitives::Address;
 use reth_chain_state::CanonStateSubscriptions;
+use reth_chainspec::ChainSpecProvider;
 use reth_node_api::TxTy;
 use reth_transaction_pool::{
     blobstore::DiskFileBlobStore, CoinbaseTipOrdering, PoolConfig, PoolTransaction, SubPoolLimit,
     TransactionPool, TransactionValidationTaskExecutor, TransactionValidator,
 };
 use std::{collections::HashSet, future::Future};
 
-use crate::{BuilderContext, FullNodeTypes};
-
 /// A type that knows how to build the transaction pool.
 pub trait PoolBuilder<Node: FullNodeTypes>: Send {
     /// The transaction pool to build.
@@ -241,11 +242,13 @@ where
 {
     let chain_events = ctx.provider().canonical_state_stream();
     let client = ctx.provider().clone();
+    let chain_spec = client.chain_spec();
 
     ctx.task_executor().spawn_critical(
         "txpool maintenance task",
         reth_transaction_pool::maintain::maintain_transaction_pool_future(
             client,
+            chain_spec,
             pool,
             chain_events,
             ctx.task_executor().clone(),

crates/node/builder/src/components/pool.rs

@@ -42,17 +42,17 @@ const FEYNMAN_L1_GAS_PRICE_ORACLE_STORAGE: [(U256, U256); 3] = [
 pub(super) fn apply_feynman_hard_fork<DB: Database>(
     state: &mut State<DB>,
 ) -> Result<(), DB::Error> {
-    let oracle = state.load_cache_account(L1_GAS_PRICE_ORACLE_ADDRESS)?;
-
     // No-op if already applied.
     // Note: This requires a storage read for every Feynman block, and it means this
     // read needs to be included in the execution witness. Unfortunately, there is no
     // other reliable way to apply the change only at the transition block, since
     // `ScrollBlockExecutor` does not have access to the parent timestamp.
-    if matches!(oracle.storage_slot(IS_FEYNMAN_SLOT), Some(val) if val == IS_FEYNMAN) {
+    if state.storage(L1_GAS_PRICE_ORACLE_ADDRESS, IS_FEYNMAN_SLOT)? == IS_FEYNMAN {
         return Ok(())
     }
 
+    let oracle = state.load_cache_account(L1_GAS_PRICE_ORACLE_ADDRESS)?;
+
     // compute the code hash
     let bytecode = Bytecode::new_raw(FEYNMAN_L1_GAS_PRICE_ORACLE_BYTECODE);
     let code_hash = bytecode.hash_slow();
@@ -94,7 +94,7 @@ mod tests {
     use revm::{
         database::{
             states::{bundle_state::BundleRetention, plain_account::PlainStorage, StorageSlot},
-            EmptyDB, State,
+            CacheDB, EmptyDB, State,
         },
         primitives::{keccak256, U256},
         state::{AccountInfo, Bytecode},
@@ -195,4 +195,70 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_apply_feynman_fork_only_once() -> eyre::Result<()> {
+        let bytecode = Bytecode::new_raw(FEYNMAN_L1_GAS_PRICE_ORACLE_BYTECODE);
+
+        let oracle_account = AccountInfo {
+            code_hash: bytecode.hash_slow(),
+            code: Some(bytecode),
+            ..Default::default()
+        };
+
+        let oracle_storage = PlainStorage::from_iter([
+            // owner
+            (U256::ZERO, U256::from_str("0x13d24a7ff6f5ec5ff0e9c40fc3b8c9c01c65437b")?),
+            // l1BaseFee
+            (U256::from(1), U256::from(0x15f50e5e)),
+            // overhead
+            (U256::from(2), U256::from(0x38)),
+            // scalar
+            (U256::from(3), U256::from(0x3e95ba80)),
+            // whitelist
+            (U256::from(4), U256::from_str("0x5300000000000000000000000000000000000003")?),
+            // l1BlobBaseFee
+            (U256::from(5), U256::from(0x15f50e5e)),
+            // commitScalar
+            (U256::from(6), U256::from(0x3e95ba80)),
+            // blobScalar
+            (U256::from(7), U256::from(0x3e95ba80)),
+            // isCurie
+            (U256::from(8), U256::from(1)),
+            // penaltyThreshold
+            (U256::from(9), U256::from(1_100_000_000u64)),
+            // penaltyFactor
+            (U256::from(10), U256::from(3_000_000_000u64)),
+            // isFeynman
+            (U256::from(11), U256::from(1)),
+        ]);
+
+        // init state,
+        // we write to db directly to make sure we do not have account storage in cache
+        let mut db = CacheDB::new(EmptyDB::default());
+
+        db.insert_account_info(L1_GAS_PRICE_ORACLE_ADDRESS, oracle_account);
+
+        for (slot, value) in oracle_storage {
+            db.insert_account_storage(L1_GAS_PRICE_ORACLE_ADDRESS, slot, value).unwrap();
+        }
+
+        let mut state =
+            State::builder().with_database(db).with_bundle_update().without_state_clear().build();
+
+        // make sure account is in cache
+        state.load_cache_account(L1_GAS_PRICE_ORACLE_ADDRESS)?;
+
+        // apply feynman fork
+        apply_feynman_hard_fork(&mut state)?;
+
+        // merge transitions
+        state.merge_transitions(BundleRetention::Reverts);
+        let bundle = state.take_bundle();
+
+        // isFeynman is already set, apply_feynman_hard_fork should be a no-op
+        assert_eq!(bundle.state.get(&L1_GAS_PRICE_ORACLE_ADDRESS), None);
+
+        Ok(())
+    }
 }

crates/scroll/alloy/evm/src/block/feynman.rs

@@ -5,14 +5,15 @@ use alloy_eips::{Encodable2718, Typed2718};
 use alloy_evm::{IntoTxEnv, RecoveredTx};
 use alloy_primitives::{Address, Bytes, TxKind, U256};
 use revm::context::TxEnv;
-use revm_scroll::l1block::TX_L1_FEE_PRECISION_U256;
 use scroll_alloy_consensus::{ScrollTxEnvelope, TxL1Message};
 pub use zstd_compression::compute_compression_ratio;
 
 #[cfg(feature = "zstd_compression")]
 mod zstd_compression {
     use super::*;
     use std::io::Write;
+
+    use revm_scroll::l1block::TX_L1_FEE_PRECISION_U256;
     use zstd::{
         stream::Encoder,
         zstd_safe::{CParameter, ParamSwitch},

crates/scroll/alloy/evm/src/tx/compression.rs

@@ -37,7 +37,7 @@ impl ScrollHardfork {
             (Self::Euclid, ForkCondition::Timestamp(1744815600)),
             (Self::EuclidV2, ForkCondition::Timestamp(1745305200)),
             // TODO: update
-            (Self::Feynman, ForkCondition::Timestamp(u64::MAX)),
+            (Self::Feynman, ForkCondition::Timestamp(6000000000)),
         ]
     }
 
@@ -51,8 +51,7 @@ impl ScrollHardfork {
             (Self::DarwinV2, ForkCondition::Timestamp(1724832000)),
             (Self::Euclid, ForkCondition::Timestamp(1741680000)),
             (Self::EuclidV2, ForkCondition::Timestamp(1741852800)),
-            // TODO: update
-            (Self::Feynman, ForkCondition::Timestamp(u64::MAX)),
+            (Self::Feynman, ForkCondition::Timestamp(1753167600)),
         ]
     }
 }

crates/scroll/alloy/hardforks/src/hardfork.rs

@@ -35,6 +35,8 @@ impl Transaction {
             // For l1 messages, we set the `gasPrice` field to 0 in rpc
             0
         } else {
+            // TODO: should we get the pool base fee in the case where the transaction is a pending
+            // transaction here?
             base_fee
                 .map(|base_fee| {
                     tx.effective_tip_per_gas(base_fee).unwrap_or_default() + base_fee as u128

crates/scroll/alloy/rpc-types/src/transaction.rs

@@ -36,6 +36,7 @@ serde_json = { workspace = true, default-features = false }
 serde = { workspace = true, default-features = false, features = ["derive"] }
 
 # misc
+auto_impl.workspace = true
 derive_more = { workspace = true, default-features = false }
 once_cell = { workspace = true, default-features = false }
 

crates/scroll/chainspec/Cargo.toml

@@ -3,6 +3,7 @@
     "timestamp": "0x6490fdd2",
     "extraData": "0x",
     "gasLimit": "0x1c9c380",
+    "baseFeePerGas": "0x0",
     "difficulty": "0x0",
     "mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "coinbase": "0x0000000000000000000000000000000000000000",
@@ -83,4 +84,4 @@
     "number": "0x0",
     "gasUsed": "0x0",
     "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
-}
+}

crates/scroll/chainspec/res/genesis/dev.json

@@ -1,14 +1,24 @@
 use crate::genesis::L1Config;
+use alloy_eips::eip1559::BaseFeeParams;
 use alloy_primitives::{address, b256, Address, B256};
 
 /// The transaction fee recipient on the L2.
 pub const SCROLL_FEE_VAULT_ADDRESS: Address = address!("5300000000000000000000000000000000000005");
 
+/// The system contract on L2 mainnet.
+pub const SCROLL_MAINNET_L2_SYSTEM_CONFIG_CONTRACT_ADDRESS: Address =
+    address!("331A873a2a85219863d80d248F9e2978fE88D0Ea");
+
 /// The L1 message queue address for Scroll mainnet.
 /// <https://etherscan.io/address/0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B>.
 pub const SCROLL_MAINNET_L1_MESSAGE_QUEUE_ADDRESS: Address =
     address!("0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B");
 
+/// The L1 message queue v2 address for Scroll mainnet.
+/// <https://etherscan.io/address/0x56971da63A3C0205184FEF096E9ddFc7A8C2D18a>.
+pub const SCROLL_MAINNET_L1_MESSAGE_QUEUE_V2_ADDRESS: Address =
+    address!("56971da63A3C0205184FEF096E9ddFc7A8C2D18a");
+
 /// The L1 proxy address for Scroll mainnet.
 /// <https://etherscan.io/address/0xa13BAF47339d63B743e7Da8741db5456DAc1E556>.
 pub const SCROLL_MAINNET_L1_PROXY_ADDRESS: Address =
@@ -21,6 +31,8 @@ pub const SCROLL_MAINNET_MAX_L1_MESSAGES: u64 = 10;
 pub const SCROLL_MAINNET_L1_CONFIG: L1Config = L1Config {
     l1_chain_id: alloy_chains::NamedChain::Mainnet as u64,
     l1_message_queue_address: SCROLL_MAINNET_L1_MESSAGE_QUEUE_ADDRESS,
+    l1_message_queue_v2_address: SCROLL_MAINNET_L1_MESSAGE_QUEUE_V2_ADDRESS,
+    l2_system_config_address: SCROLL_MAINNET_L2_SYSTEM_CONFIG_CONTRACT_ADDRESS,
     scroll_chain_address: SCROLL_MAINNET_L1_PROXY_ADDRESS,
     num_l1_messages_per_block: SCROLL_MAINNET_MAX_L1_MESSAGES,
 };
@@ -29,11 +41,20 @@ pub const SCROLL_MAINNET_L1_CONFIG: L1Config = L1Config {
 pub const SCROLL_MAINNET_GENESIS_HASH: B256 =
     b256!("bbc05efd412b7cd47a2ed0e5ddfcf87af251e414ea4c801d78b6784513180a80");
 
+/// The system contract on L2 sepolia.
+pub const SCROLL_SEPOLIA_L2_SYSTEM_CONFIG_CONTRACT_ADDRESS: Address =
+    address!("F444cF06A3E3724e20B35c2989d3942ea8b59124");
+
 /// The L1 message queue address for Scroll sepolia.
 /// <https://sepolia.etherscan.io/address/0xF0B2293F5D834eAe920c6974D50957A1732de763>.
 pub const SCROLL_SEPOLIA_L1_MESSAGE_QUEUE_ADDRESS: Address =
     address!("F0B2293F5D834eAe920c6974D50957A1732de763");
 
+/// The L1 message queue address v2 for Scroll sepolia.
+/// <https://sepolia.etherscan.io/address/0xA0673eC0A48aa924f067F1274EcD281A10c5f19F>.
+pub const SCROLL_SEPOLIA_L1_MESSAGE_QUEUE_V2_ADDRESS: Address =
+    address!("A0673eC0A48aa924f067F1274EcD281A10c5f19F");
+
 /// The L1 proxy address for Scroll sepolia.
 /// <https://sepolia.etherscan.io/address/0x2D567EcE699Eabe5afCd141eDB7A4f2D0D6ce8a0>
 pub const SCROLL_SEPOLIA_L1_PROXY_ADDRESS: Address =
@@ -46,14 +67,24 @@ pub const SCROLL_SEPOLIA_MAX_L1_MESSAGES: u64 = 10;
 pub const SCROLL_SEPOLIA_L1_CONFIG: L1Config = L1Config {
     l1_chain_id: alloy_chains::NamedChain::Sepolia as u64,
     l1_message_queue_address: SCROLL_SEPOLIA_L1_MESSAGE_QUEUE_ADDRESS,
+    l1_message_queue_v2_address: SCROLL_SEPOLIA_L1_MESSAGE_QUEUE_V2_ADDRESS,
+    l2_system_config_address: SCROLL_SEPOLIA_L2_SYSTEM_CONFIG_CONTRACT_ADDRESS,
     scroll_chain_address: SCROLL_SEPOLIA_L1_PROXY_ADDRESS,
     num_l1_messages_per_block: SCROLL_SEPOLIA_MAX_L1_MESSAGES,
 };
 
+/// The system contract on devnet.
+pub const SCROLL_DEV_L2_SYSTEM_CONFIG_CONTRACT_ADDRESS: Address =
+    address!("0000000000000000000000000000000000000000");
+
 /// The L1 message queue address for Scroll dev.
 pub const SCROLL_DEV_L1_MESSAGE_QUEUE_ADDRESS: Address =
     address!("0000000000000000000000000000000000000000");
 
+/// The L1 message queue v2 address for Scroll dev.
+pub const SCROLL_DEV_L1_MESSAGE_QUEUE_V2_ADDRESS: Address =
+    address!("0000000000000000000000000000000000000000");
+
 /// The L1 proxy address for Scroll dev.
 pub const SCROLL_DEV_L1_PROXY_ADDRESS: Address =
     address!("0000000000000000000000000000000000000000");
@@ -65,10 +96,24 @@ pub const SCROLL_DEV_MAX_L1_MESSAGES: u64 = 10;
 pub const SCROLL_DEV_L1_CONFIG: L1Config = L1Config {
     l1_chain_id: alloy_chains::NamedChain::Goerli as u64,
     l1_message_queue_address: SCROLL_DEV_L1_MESSAGE_QUEUE_ADDRESS,
+    l1_message_queue_v2_address: SCROLL_DEV_L1_MESSAGE_QUEUE_V2_ADDRESS,
     scroll_chain_address: SCROLL_DEV_L1_PROXY_ADDRESS,
+    l2_system_config_address: SCROLL_DEV_L2_SYSTEM_CONFIG_CONTRACT_ADDRESS,
     num_l1_messages_per_block: SCROLL_DEV_MAX_L1_MESSAGES,
 };
 
 /// The Scroll Sepolia genesis hash
 pub const SCROLL_SEPOLIA_GENESIS_HASH: B256 =
     b256!("aa62d1a8b2bffa9e5d2368b63aae0d98d54928bd713125e3fd9e5c896c68592c");
+
+/// The base fee params for Feynman.
+pub const SCROLL_BASE_FEE_PARAMS_FEYNMAN: BaseFeeParams = BaseFeeParams::new(
+    SCROLL_EIP1559_BASE_FEE_MAX_CHANGE_DENOMINATOR_FEYNMAN,
+    SCROLL_EIP1559_DEFAULT_ELASTICITY_MULTIPLIER_FEYNMAN,
+);
+
+/// The scroll EIP1559 max change denominator for Feynman.
+pub const SCROLL_EIP1559_BASE_FEE_MAX_CHANGE_DENOMINATOR_FEYNMAN: u128 = 8;
+
+/// The scroll EIP1559 default elasticity multiplier for Feynman.
+pub const SCROLL_EIP1559_DEFAULT_ELASTICITY_MULTIPLIER_FEYNMAN: u128 = 2;