feat: parse protocol param event

Author: matthias-wright

crates/evm/src/block/error.rs

@@ -80,6 +80,10 @@ pub enum BlockValidationError {
     /// [EIP-6110]: https://eips.ethereum.org/EIPS/eip-6110
     #[error("failed to decode deposit requests from receipts: {_0}")]
     DepositRequestDecode(String),
+    /// Error when decoding protocol param requests from receipts
+    ///
+    #[error("failed to decode protocol param requests from receipts: {_0}")]
+    ProtocolParamRequestDecode(String),
 }
 
 /// `BlockExecutor` Errors

crates/evm/src/eth/block.rs

@@ -1,7 +1,7 @@
 //! Ethereum block executor.
 
 use super::{
-    dao_fork, eip6110,
+    dao_fork, eip6110, protocol_params,
     receipt_builder::{AlloyReceiptBuilder, ReceiptBuilder, ReceiptBuilderCtx},
     spec::{EthExecutorSpec, EthSpec},
     EthEvmFactory,
@@ -165,12 +165,19 @@ where
             let deposit_requests =
                 eip6110::parse_deposits_from_receipts(&self.spec, &self.receipts)?;
 
+            // Collect all protocol param requests
+            let protocol_param_requests = protocol_params::parse_protocol_params_from_receipts(&self.receipts)?;
+
             let mut requests = Requests::default();
 
             if !deposit_requests.is_empty() {
                 requests.push_request_with_type(eip6110::DEPOSIT_REQUEST_TYPE, deposit_requests);
             }
 
+            if !protocol_param_requests.is_empty() {
+                requests.push_request_with_type(protocol_params::PROTOCOL_PARAM_REQUEST_TYPE, protocol_param_requests);
+            }
+
             requests.extend(self.system_caller.apply_post_execution_changes(&mut self.evm)?);
             requests
         } else {

crates/evm/src/eth/mod.rs

@@ -24,6 +24,7 @@ pub mod dao_fork;
 pub mod eip6110;
 pub mod receipt_builder;
 pub mod spec;
+pub mod protocol_params;
 
 /// The Ethereum EVM context type.
 pub type EthEvmContext<DB> = Context<BlockEnv, TxEnv, CfgEnv, DB>;

crates/evm/src/eth/protocol_params.rs

@@ -0,0 +1,109 @@
+//! Seismic protocol param requests parsing
+use crate::block::BlockValidationError;
+use alloc::{string::ToString, vec::Vec};
+use alloy_consensus::TxReceipt;
+use alloy_primitives::{Address, address, Bytes, Log};
+use alloy_sol_types::{sol, SolEvent};
+
+
+/// Protocol parameters contract address for Seismic chains.
+///
+/// This contract is deployed at genesis and stores network-wide protocol
+/// parameters that can be updated through governance or predefined schedules.
+///
+/// The same address is used across all Seismic networks (mainnet, dev, testnet).
+/// Address ends with "Params" in hex: 0x506172616D73
+pub const SEISMIC_PROTOCOL_PARAMS_CONTRACT: Address =
+    address!("0000000000000000000000000000506172616D73");
+
+/// The [EIP-7685](https://eips.ethereum.org/EIPS/eip-7685) request type for protocol param requests.
+pub const PROTOCOL_PARAM_REQUEST_TYPE: u8 = 0xFF;
+
+const PROTOCOL_PARAM_MAX_BYTES_SIZE: usize = 1 + 100;
+
+sol! {
+    #[allow(missing_docs)]
+    event ProtocolParamEvent(
+        uint8 param_id,
+        bytes param
+    );
+}
+
+/// Accumulate a protocol param request from a log. containing a [`ParamEvent`].
+pub fn accumulate_protocol_param_from_log(log: &Log<ProtocolParamEvent>, out: &mut Vec<u8>) {
+    //out.reserve(PROTOCOL_PARAM_MAX_BYTES_SIZE);
+    out.extend_from_slice(&[log.param_id]);
+    out.extend_from_slice(log.param.as_ref());
+}
+
+/// Accumulate protocol params from an iterator of logs.
+pub fn accumulate_protocol_params_from_logs<'a>(
+    address: Address,
+    logs: impl IntoIterator<Item = &'a Log>,
+    out: &mut Vec<u8>,
+) -> Result<(), BlockValidationError> {
+    logs.into_iter()
+        // filter logs by address
+        .filter(|log| log.address == address)
+        // explicitly filter logs by the ParamEvent's signature hash (first topic)
+        .filter(|log| {
+            // 0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5
+            log.topics().first() == Some(&ProtocolParamEvent::SIGNATURE_HASH)
+        })
+        .try_for_each(|log| {
+            // We assume that the log is valid because it was emitted by the
+            // protocol params contract.
+            let decoded_log =
+                ProtocolParamEvent::decode_log(log).map_err(|err: alloy_sol_types::Error| {
+                    BlockValidationError::ProtocolParamRequestDecode(err.to_string())
+                })?;
+            accumulate_protocol_param_from_log(&decoded_log, out);
+            Ok(())
+        })
+}
+
+/// Accumulate protocol params from a receipt. Iterates over the logs in the receipt
+/// and accumulates the protocol param request bytestrings.
+pub fn accumulate_protocol_params_from_receipt(
+    address: Address,
+    receipt: impl TxReceipt<Log = Log>,
+    out: &mut Vec<u8>,
+) -> Result<(), BlockValidationError> {
+    accumulate_protocol_params_from_logs(address, receipt.logs(), out)
+}
+
+/// Accumulate protocol params from a list of receipts. Iterates over the logs in the
+/// receipts and accumulates the param request bytestrings.
+pub fn accumulate_protocol_params_from_receipts<'a, I, R>(
+    address: Address,
+    receipts: I,
+    out: &mut Vec<u8>,
+) -> Result<(), BlockValidationError>
+where
+    I: IntoIterator<Item = &'a R>,
+    R: TxReceipt<Log = Log> + 'a,
+{
+    receipts
+        .into_iter()
+        .try_for_each(|receipt| accumulate_protocol_params_from_receipt(address, receipt, out))
+}
+
+/// Find protocol param logs in a list of receipts, and return the concatenated
+/// param request bytestring.
+///
+/// The address of the protocol params contract is taken from the chain spec.
+pub fn parse_protocol_params_from_receipts<'a, I, R>(
+    receipts: I,
+) -> Result<Bytes, BlockValidationError>
+where
+    I: IntoIterator<Item = &'a R>,
+    R: TxReceipt<Log = Log> + 'a,
+{
+    let mut out = Vec::new();
+    accumulate_protocol_params_from_receipts(
+        SEISMIC_PROTOCOL_PARAMS_CONTRACT,
+        receipts,
+        &mut out,
+    )?;
+    Ok(out.into())
+}