Str 829 enable eoa flag

bin/strata-reth/src/main.rs

@@ -1,12 +1,13 @@
 mod db;
 
-use std::{fs, future::Future, path::PathBuf, sync::Arc};
+use std::{fs, future::Future, path::PathBuf, str::FromStr, sync::Arc};
 
 use alloy_genesis::Genesis;
 use clap::Parser;
 use reth::{
     args::LogArgs,
     builder::{NodeBuilder, WithLaunchContext},
+    revm::primitives::Address,
     CliRunner,
 };
 use reth_chainspec::ChainSpec;
@@ -39,8 +40,16 @@
     if let Err(err) = run(command, |builder, ext| async move {
         let datadir = builder.config().datadir().data_dir().to_path_buf();
 
+        let allowed_addrs: Vec<Address> = ext
+            .allowed_eoa_addrs
+            .into_iter()
+            .map(|x| Address::from_str(&x))
+            .collect::<Result<_, _>>()?; // TODO: better error messaging
+
         let node_args = StrataNodeArgs {
             sequencer_http: ext.sequencer_http.clone(),
+            allowed_eoa_addrs: allowed_addrs,
+            enable_eoa: ext.enable_eoa,
         };
 
         let mut node_builder = builder.node(StrataEthereumNode::new(node_args));
@@ -102,6 +111,14 @@
     /// Rpc of sequener's reth node to forward transactions to.
     #[arg(long, required = false)]
     pub sequencer_http: Option<String>,
+
+    /// To enable EOA txs or not.
+    #[arg(long, default_value_t = false)]
+    pub enable_eoa: bool,
+
+    /// Allowed EOA addresses, if `enable_eoa` is set to false.
+    #[arg(long, num_args(1..))]
+    pub allowed_eoa_addrs: Vec<String>,
 }
 
 #[derive(Debug, Clone, Default)]

crates/reth/node/src/args.rs

@@ -1,4 +1,8 @@
+use revm_primitives::Address;
+
 #[derive(Debug, Clone, Default)]
 pub struct StrataNodeArgs {
     pub sequencer_http: Option<String>,
+    pub enable_eoa: bool,
+    pub allowed_eoa_addrs: Vec<Address>,
 }

crates/reth/node/src/node.rs

@@ -19,7 +19,7 @@
 };
 use reth_transaction_pool::{PoolTransaction, TransactionPool};
 use revm_primitives::alloy_primitives;
-use strata_reth_rpc::{SequencerClient, StrataEthApi};
+use strata_reth_rpc::{EOAMode, SequencerClient, StrataEthApi};
 
 use crate::{
     args::StrataNodeArgs,
@@ -165,6 +165,10 @@
     fn add_ons(&self) -> Self::AddOns {
         Self::AddOns::builder()
             .with_sequencer(self.args.sequencer_http.clone())
+            .with_eoa_mode(EOAMode::new(
+                self.args.enable_eoa,
+                self.args.allowed_eoa_addrs.clone(),
+            ))
             .build()
     }
 }
@@ -257,6 +261,8 @@
     /// Sequencer client, configured to forward submitted transactions to sequencer of given OP
     /// network.
     sequencer_client: Option<SequencerClient>,
+    /// Whether EOA should be enabled or not.
+    eoa_mode: EOAMode,
 }
 
 impl StrataAddOnsBuilder {
@@ -265,6 +271,12 @@
         self.sequencer_client = sequencer_client.map(SequencerClient::new);
         self
     }
+
+    /// With [`EOAMode`] set to given value.
+    pub fn with_eoa_mode(mut self, eoa_mode: EOAMode) -> Self {
+        self.eoa_mode = eoa_mode;
+        self
+    }
 }
 
 impl StrataAddOnsBuilder {
@@ -273,13 +285,17 @@
     where
         N: FullNodeComponents<Types: NodeTypes<Primitives = StrataPrimitives>>,
     {
-        let Self { sequencer_client } = self;
+        let Self {
+            sequencer_client,
+            eoa_mode,
+        } = self;
 
         StrataAddOns {
             rpc_add_ons: RpcAddOns::new(
                 move |ctx| {
                     StrataEthApi::<N>::builder()
                         .with_sequencer(sequencer_client)
+                        .with_eoa_mode(eoa_mode)
                         .build(ctx)
                 },
                 Default::default(),

crates/reth/rpc/Cargo.toml

@@ -28,6 +28,7 @@ reth-network-api.workspace = true
 reth-node-api.workspace = true
 reth-node-builder.workspace = true
 reth-primitives.workspace = true
+reth-primitives-traits.workspace = true
 reth-provider.workspace = true
 reth-revm.workspace = true
 reth-rpc.workspace = true

crates/reth/rpc/src/eth/mod.rs

@@ -37,7 +37,7 @@
 };
 use reth_transaction_pool::TransactionPool;
 
-use crate::SequencerClient;
+use crate::{EOAMode, SequencerClient};
 
 /// Adapter for [`EthApiInner`], which holds all the data required to serve core `eth_` API.
 pub type EthApiNodeBackend<N> = EthApiInner<
@@ -268,20 +268,27 @@
     /// Sequencer client, configured to forward submitted transactions to sequencer of given OP
     /// network.
     sequencer_client: Option<SequencerClient>,
+    /// Whether EOA should be enabled or not.
+    eoa_mode: EOAMode,
 }
 
 #[derive(Default)]
 pub struct StrataEthApiBuilder {
     /// Sequencer client, configured to forward submitted transactions to sequencer of given OP
     /// network.
     sequencer_client: Option<SequencerClient>,
+    /// Whether EOA should be enabled or not.
+    eoa_mode: EOAMode,
 }
 
 impl StrataEthApiBuilder {
     /// Creates a [`StrataEthApiBuilder`] instance.
     pub const fn new() -> Self {
         Self {
             sequencer_client: None,
+            eoa_mode: EOAMode::Disabled {
+                allowed_eoa_addrs: Vec::new(),
+            },
         }
     }
 
@@ -290,6 +297,12 @@
         self.sequencer_client = sequencer_client;
         self
     }
+
+    /// With [`EOAMode`].
+    pub fn with_eoa_mode(mut self, eoa_mode: EOAMode) -> Self {
+        self.eoa_mode = eoa_mode;
+        self
+    }
 }
 
 impl StrataEthApiBuilder {
@@ -329,6 +342,7 @@
             inner: Arc::new(StrataEthApiInner {
                 eth_api,
                 sequencer_client: self.sequencer_client,
+                eoa_mode: self.eoa_mode,
             }),
         }
     }

crates/reth/rpc/src/eth/transaction.rs

@@ -5,6 +5,7 @@
 use alloy_rpc_types_eth::{Transaction, TransactionInfo, TransactionRequest};
 use reth_node_api::FullNodeComponents;
 use reth_primitives::{RecoveredTx, TransactionSigned};
+use reth_primitives_traits::SignedTransaction;
 use reth_provider::{
     BlockReader, BlockReaderIdExt, ProviderTx, ReceiptProvider, TransactionsProvider,
 };
@@ -15,7 +16,7 @@
 use reth_rpc_eth_types::{utils::recover_raw_transaction, EthApiError};
 use reth_transaction_pool::{PoolTransaction, TransactionOrigin, TransactionPool};
 
-use crate::{SequencerClient, StrataEthApi, StrataNodeCore};
+use crate::{EOAMode, SequencerClient, StrataEthApi, StrataNodeCore};
 
 impl<N> EthTransactions for StrataEthApi<N>
 where
@@ -30,9 +31,25 @@
     ///
     /// Returns the hash of the transaction.
     async fn send_raw_transaction(&self, tx: Bytes) -> Result<B256, Self::Error> {
-        let recovered = recover_raw_transaction(&tx)?;
+        let recovered: RecoveredTx<
+            <<Self::Pool as TransactionPool>::Transaction as PoolTransaction>::Pooled,
+        > = recover_raw_transaction(&tx)?;
+        let sender = recovered.recover_signer_unchecked();
         let pool_transaction = <Self::Pool as TransactionPool>::Transaction::from_pooled(recovered);
 
+        // Check if EOA disabled and if so the sender is in the allowed list
+        match &self.inner.eoa_mode {
+            EOAMode::Enabled => {}
+            EOAMode::Disabled { allowed_eoa_addrs } => {
+                if sender
+                    .map(|x| allowed_eoa_addrs.contains(&x))
+                    .unwrap_or(false)
+                {
+                    return Err(EthApiError::Unsupported("EOA txs are not allowed").into());
+                }
+            }
+        }
+
         // On Strata, transactions are forwarded directly to the sequencer to be included in
         // blocks that it builds.
         if let Some(client) = self.raw_tx_forwarder().as_ref() {

crates/reth/rpc/src/lib.rs

@@ -6,7 +6,7 @@
 
 pub use eth::{StrataEthApi, StrataNodeCore};
 use jsonrpsee::{core::RpcResult, proc_macros::rpc};
-use revm_primitives::alloy_primitives::B256;
+use revm_primitives::{alloy_primitives::B256, Address};
 pub use rpc::StrataRPC;
 pub use sequencer::SequencerClient;
 use serde::{Deserialize, Serialize};
@@ -31,3 +31,31 @@
     Raw(#[serde(with = "hex::serde")] Vec<u8>),
     Json(EvmBlockStfInput),
 }
+
+#[derive(Debug, Clone)]
+pub enum EOAMode {
+    Disabled { allowed_eoa_addrs: Vec<Address> }, // TODO: Maybe use NonEmptyVec like struct
+    // one element
+    Enabled,
+}
+
+impl EOAMode {
+    pub fn new(enable: bool, allowed_eoa_addrs: Vec<Address>) -> Self {
+        if enable {
+            if !allowed_eoa_addrs.is_empty() {
+                // TODO: possibly warn, but would be better if this happened around the boundary
+            }
+            Self::Enabled
+        } else {
+            Self::Disabled { allowed_eoa_addrs }
+        }
+    }
+}
+
+impl Default for EOAMode {
+    fn default() -> Self {
+        Self::Disabled {
+            allowed_eoa_addrs: Vec::new(),
+        }
+    }
+}