feat: update block data hint (#253)

* feat: update BlockDataHint struct

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

* fix: lints

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

* feat: skip book tests (issue 250)

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

* feat: bump revm

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

* feat: add gas limit to ScrollPayloadAttributes

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

* feat: validate state root using consensus

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

* feat: log attributes on validation error

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

* chore: clean

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

* feat: using `HeaderValidator::validate_state_root` where possible

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

---------

Signed-off-by: Gregory Edison <gregory.edison1993@gmail.com>

Author: greged93

Cargo.lock

@@ -76,6 +76,7 @@ where
             transactions: None,
             no_tx_pool: false,
             block_data_hint: None,
+            gas_limit: None,
         }
     }
 }

crates/engine/local/src/payload.rs

@@ -2287,7 +2287,7 @@ where
                         let elapsed = execution_finish.elapsed();
                         info!(target: "engine::tree", ?state_root, ?elapsed, "State root task finished");
                         // we double check the state root here for good measure
-                        if state_root == block.header().state_root() {
+                        if self.consensus.validate_state_root(block.header(), state_root).is_ok() {
                             maybe_state_root = Some((state_root, trie_updates, elapsed))
                         } else {
                             warn!(
@@ -2347,7 +2347,7 @@ where
         debug!(target: "engine::tree", ?root_elapsed, block=?block_num_hash, "Calculated state root");
 
         // ensure state root matches
-        if state_root != block.header().state_root() {
+        if self.consensus.validate_state_root(block.header(), state_root).is_err() {
             // call post-block hook
             self.on_invalid_block(&parent_block, &block, &output, Some((&trie_output, state_root)));
             return Err((

crates/engine/tree/src/tree/mod.rs

@@ -15,7 +15,7 @@ use core::fmt;
 use jsonrpsee::core::RpcResult;
 use jsonrpsee_types::error::ErrorObject;
 use reth_chainspec::{ChainSpecProvider, EthereumHardforks};
-use reth_consensus::{Consensus, FullConsensus};
+use reth_consensus::{Consensus, FullConsensus, HeaderValidator};
 use reth_engine_primitives::PayloadValidator;
 use reth_errors::{BlockExecutionError, ConsensusError, ProviderError};
 use reth_evm::{execute::Executor, ConfigureEvm};
@@ -207,7 +207,7 @@ where
         let state_root =
             state_provider.state_root(state_provider.hashed_post_state(&output.state))?;
 
-        if state_root != block.header().state_root() {
+        if self.consensus.validate_state_root(block.header(), state_root).is_err() {
             return Err(ConsensusError::BodyStateRootDiff(
                 GotExpected { got: state_root, expected: block.header().state_root() }.into(),
             )

crates/rpc/rpc/src/validation.rs

@@ -23,6 +23,7 @@ serde = { workspace = true, optional = true }
 arbitrary = { workspace = true, optional = true }
 
 [dev-dependencies]
+alloy-primitives = { workspace = true, features = ["getrandom"] }
 serde_json.workspace = true
 
 [features]

crates/scroll/alloy/rpc-types-engine/Cargo.toml

@@ -1,7 +1,7 @@
 //! Scroll-specific payload attributes.
 
 use alloc::vec::Vec;
-use alloy_primitives::{Bytes, U256};
+use alloy_primitives::{Address, Bytes, B256, U256};
 use alloy_rpc_types_engine::PayloadAttributes;
 
 /// The payload attributes for block building tailored for Scroll.
@@ -18,6 +18,8 @@ pub struct ScrollPayloadAttributes {
     /// The pre-Euclid block data hint, necessary for the block builder to derive the correct block
     /// hash.
     pub block_data_hint: Option<BlockDataHint>,
+    /// The gas limit for the block building task.
+    pub gas_limit: Option<u64>,
 }
 
 /// Block data provided as a hint to the payload attributes.
@@ -27,14 +29,26 @@ pub struct ScrollPayloadAttributes {
 pub struct BlockDataHint {
     /// The extra data for the block.
     pub extra_data: Bytes,
+    /// The state root for the block.
+    pub state_root: B256,
+    /// The optional coinbase for the block.
+    pub coinbase: Option<Address>,
+    /// The optional nonce for the block.
+    pub nonce: Option<u64>,
     /// The difficulty for the block.
     pub difficulty: U256,
 }
 
 #[cfg(feature = "arbitrary")]
 impl<'a> arbitrary::Arbitrary<'a> for BlockDataHint {
     fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
-        Ok(Self { extra_data: Bytes::arbitrary(u)?, difficulty: U256::arbitrary(u)? })
+        Ok(Self {
+            extra_data: Bytes::arbitrary(u)?,
+            state_root: B256::arbitrary(u)?,
+            coinbase: Some(Address::arbitrary(u)?),
+            nonce: Some(u64::arbitrary(u)?),
+            difficulty: U256::arbitrary(u)?,
+        })
     }
 }
 
@@ -52,6 +66,7 @@ impl<'a> arbitrary::Arbitrary<'a> for ScrollPayloadAttributes {
             transactions: Some(Vec::arbitrary(u)?),
             no_tx_pool: bool::arbitrary(u)?,
             block_data_hint: Some(BlockDataHint::arbitrary(u)?),
+            gas_limit: Some(u64::arbitrary(u)?),
         })
     }
 }
@@ -76,8 +91,12 @@ mod test {
             no_tx_pool: true,
             block_data_hint: Some(BlockDataHint {
                 extra_data: b"world".into(),
+                state_root: B256::random(),
+                coinbase: Some(Address::random()),
+                nonce: Some(0x12345),
                 difficulty: U256::from(10),
             }),
+            gas_limit: Some(10_000_000),
         };
 
         let ser = serde_json::to_string(&attributes).unwrap();

crates/scroll/alloy/rpc-types-engine/src/attributes.rs

@@ -26,6 +26,8 @@ pub struct ScrollPayloadBuilderAttributes {
     /// The pre-Euclid block data hint, necessary for the block builder to derive the correct block
     /// hash.
     pub block_data_hint: Option<BlockDataHint>,
+    /// The gas limit for the generated payload.
+    pub gas_limit: Option<u64>,
 }
 
 impl PayloadBuilderAttributes for ScrollPayloadBuilderAttributes {
@@ -70,6 +72,7 @@ impl PayloadBuilderAttributes for ScrollPayloadBuilderAttributes {
             no_tx_pool: attributes.no_tx_pool,
             transactions,
             block_data_hint: attributes.block_data_hint,
+            gas_limit: attributes.gas_limit,
         })
     }
 
@@ -144,9 +147,20 @@ pub(crate) fn payload_id_scroll(
 
     if let Some(block_data) = &attributes.block_data_hint {
         hasher.update(&block_data.extra_data);
+        hasher.update(block_data.state_root.0);
+        if let Some(coinbase) = block_data.coinbase {
+            hasher.update(coinbase);
+        }
+        if let Some(nonce) = block_data.nonce {
+            hasher.update(nonce.to_be_bytes());
+        }
         hasher.update(block_data.difficulty.to_be_bytes::<32>());
     }
 
+    if let Some(gas_limit) = attributes.gas_limit {
+        hasher.update(gas_limit.to_be_bytes());
+    }
+
     let mut out = hasher.finalize();
     out[0] = payload_version;
     PayloadId::new(out.as_slice()[..8].try_into().expect("sufficient length"))
@@ -169,7 +183,7 @@ mod tests {
     #[test]
     fn test_payload_id() {
         let expected =
-            PayloadId::new(FixedBytes::<8>::from_str("0x0322b5f17cf26e85").unwrap().into());
+            PayloadId::new(FixedBytes::<8>::from_str("0x036369370c155d4c").unwrap().into());
         let attrs = ScrollPayloadAttributes {
             payload_attributes: PayloadAttributes {
                 timestamp: 1728933301,
@@ -180,7 +194,14 @@ mod tests {
             },
             transactions: Some([bytes!("7ef8f8a0dc19cfa777d90980e4875d0a548a881baaa3f83f14d1bc0d3038bc329350e54194deaddeaddeaddeaddeaddeaddeaddeaddead00019442000000000000000000000000000000000000158080830f424080b8a4440a5e20000f424000000000000000000000000300000000670d6d890000000000000125000000000000000000000000000000000000000000000000000000000000000700000000000000000000000000000000000000000000000000000000000000014bf9181db6e381d4384bbf69c48b0ee0eed23c6ca26143c6d2544f9d39997a590000000000000000000000007f83d659683caf2767fd3c720981d51f5bc365bc")].into()),
             no_tx_pool: false,
-            block_data_hint: Some(BlockDataHint{ extra_data: bytes!("476574682f76312e302e302f6c696e75782f676f312e342e32"), difficulty: U256::from(10) } ),
+            block_data_hint: Some(BlockDataHint{
+                extra_data: bytes!("476574682f76312e302e302f6c696e75782f676f312e342e32"),
+                state_root: b256!("0x000000000000000000000000000000000000000000000000000000000000dead"),
+                coinbase: Some(address!("0x000000000000000000000000000000000000dead")),
+                nonce: Some(u64::MAX),
+                difficulty: U256::from(10)
+            }),
+            gas_limit: Some(10_000_000),
         };
 
         assert_eq!(

crates/scroll/engine-primitives/src/payload/attributes.rs

@@ -79,5 +79,6 @@ pub fn scroll_payload_attributes(timestamp: u64) -> ScrollPayloadBuilderAttribut
         transactions: vec![],
         no_tx_pool: false,
         block_data_hint: None,
+        gas_limit: None,
     }
 }

crates/scroll/node/src/test_utils.rs

@@ -262,12 +262,19 @@ impl<Txs> ScrollBuilder<'_, Txs> {
         let BlockBuilderOutcome { execution_result, hashed_state, trie_updates, mut block } =
             builder.finish(state_provider)?;
 
-        // set the block extra data and difficulty fields using the payload attributes.
+        // set the block fields using the hints from the payload attributes.
         if let Some(block_data) = &ctx.config.attributes.block_data_hint {
             let (mut scroll_block, senders) = block.split();
             scroll_block = scroll_block.map_header(|mut header| {
                 header.extra_data = block_data.extra_data.clone();
+                header.state_root = block_data.state_root;
                 header.difficulty = block_data.difficulty;
+                if let Some(coinbase) = block_data.coinbase {
+                    header.beneficiary = coinbase;
+                }
+                if let Some(nonce) = block_data.nonce {
+                    header.nonce = nonce.into();
+                }
                 header
             });
             block = RecoveredBlock::new_unhashed(scroll_block, senders)
@@ -387,7 +394,7 @@ where
                 ScrollNextBlockEnvAttributes {
                     timestamp: self.attributes().timestamp(),
                     suggested_fee_recipient: self.attributes().suggested_fee_recipient(),
-                    gas_limit: builder_config.gas_limit,
+                    gas_limit: self.attributes().gas_limit.unwrap_or(builder_config.gas_limit),
                     base_fee,
                 },
             )