fix: tests pass again

Author: prestwich

crates/block-processor/src/alias.rs

@@ -4,6 +4,7 @@ use alloy::{
 };
 use eyre::OptionExt;
 use reth::providers::{StateProvider, StateProviderFactory};
+use std::sync::{Arc, Mutex};
 
 /// Simple trait to allow checking if an address should be aliased.
 pub trait AliasOracle {
@@ -33,33 +34,67 @@ impl AliasOracle for Box<dyn StateProvider> {
     }
 }
 
-impl AliasOracle for &HashSet<Address> {
+impl AliasOracle for HashSet<Address> {
     fn should_alias(&self, address: Address) -> eyre::Result<bool> {
         Ok(self.contains(&address))
     }
 }
 
 /// Factory trait to create new [`AliasOracle`] instances.
+///
+/// The default implementation on `Box<dyn StateProviderFactory>` creates
+/// [`AliasOracle`] instances backed by the state provider for a given block
+/// height. It will error if that state provider cannot be obtained.
+///
+/// This trait is primarily intended to allow injecting test implementations
+/// of [`AliasOracle`] into the Signet Node for testing purposes. The test
+/// implementation on [`HashSet<Address>`] allows specifying a fixed set of
+/// addresses to be aliased.
 pub trait AliasOracleFactory: Send + Sync + 'static {
     /// The [`AliasOracle`] type.
-    type Oracle<'a>: AliasOracle;
+    type Oracle: AliasOracle;
 
     /// Create a new [`AliasOracle`].
-    fn create(&self, block_height: u64) -> eyre::Result<Self::Oracle<'_>>;
+    fn create(&self, block_height: u64) -> eyre::Result<Self::Oracle>;
 }
 
 impl AliasOracleFactory for Box<dyn StateProviderFactory> {
-    type Oracle<'a> = Box<dyn StateProvider>;
+    type Oracle = Box<dyn StateProvider>;
 
-    fn create(&self, block_height: u64) -> eyre::Result<Self::Oracle<'_>> {
+    fn create(&self, block_height: u64) -> eyre::Result<Self::Oracle> {
         self.state_by_block_number_or_tag(block_height.into()).map_err(Into::into)
     }
 }
 
+/// This implementation is primarily for testing purposes.
 impl AliasOracleFactory for HashSet<Address> {
-    type Oracle<'a> = &'a HashSet<Address>;
+    type Oracle = HashSet<Address>;
 
-    fn create(&self, _block_height: u64) -> eyre::Result<Self::Oracle<'_>> {
-        Ok(self)
+    fn create(&self, _block_height: u64) -> eyre::Result<Self::Oracle> {
+        Ok(self.clone())
+    }
+}
+
+impl<T> AliasOracleFactory for Mutex<T>
+where
+    T: AliasOracleFactory,
+{
+    type Oracle = T::Oracle;
+
+    fn create(&self, block_height: u64) -> eyre::Result<Self::Oracle> {
+        let guard =
+            self.lock().map_err(|_| eyre::eyre!("failed to lock AliasOracleFactory mutex"))?;
+        guard.create(block_height)
+    }
+}
+
+impl<T> AliasOracleFactory for Arc<T>
+where
+    T: AliasOracleFactory,
+{
+    type Oracle = T::Oracle;
+
+    fn create(&self, block_height: u64) -> eyre::Result<Self::Oracle> {
+        self.as_ref().create(block_height)
     }
 }

crates/node-tests/src/context.rs

@@ -8,7 +8,7 @@ use alloy::{
     consensus::{BlockHeader, TxEnvelope, constants::ETH_TO_WEI},
     genesis::{Genesis, GenesisAccount},
     network::{Ethereum, EthereumWallet, TransactionBuilder as _},
-    primitives::{Address, I256, Sign, U256, keccak256},
+    primitives::{Address, I256, Sign, U256, keccak256, map::HashSet},
     providers::{
         Provider as _, ProviderBuilder, SendableTx,
         fillers::{BlobGasFiller, SimpleNonceManager},
@@ -31,7 +31,7 @@ use signet_test_utils::contracts::counter::COUNTER_DEPLOY_CODE;
 use signet_types::constants::{HostPermitted, RollupPermitted, SignetSystemConstants};
 use signet_zenith::{HostOrders::OrdersInstance, RollupPassage::RollupPassageInstance};
 use std::sync::{
-    Arc,
+    Arc, Mutex,
     atomic::{AtomicU64, Ordering},
 };
 use tokio::{sync::watch, task::JoinHandle};
@@ -74,7 +74,10 @@ pub struct SignetTestContext {
     /// The current host block height
     pub height: AtomicU64,
 
-    /// Test addreses, copied from [`signet_types::test_utils::TEST_USERS`] for
+    /// The alias oracle used by the Signet Node instance.
+    pub alias_oracle: Arc<Mutex<HashSet<Address>>>,
+
+    /// Test addresses, copied from [`signet_types::test_utils::TEST_USERS`] for
     /// convenience
     pub addresses: [Address; 10],
 }
@@ -99,9 +102,17 @@ impl SignetTestContext {
 
         let factory = create_test_provider_factory_with_chain_spec(chain_spec.clone());
 
+        let alias_oracle: Arc<Mutex<HashSet<Address>>> = Arc::new(Mutex::new(HashSet::default()));
+
         // instantiate Signet Node, booting rpc
-        let (node, mut node_status) =
-            SignetNode::new(ctx, cfg.clone(), factory.clone(), Default::default()).unwrap();
+        let (node, mut node_status) = SignetNode::new(
+            ctx,
+            cfg.clone(),
+            factory.clone(),
+            Arc::clone(&alias_oracle),
+            Default::default(),
+        )
+        .unwrap();
 
         // Spawn the node, and wait for it to indicate RPC readiness.
         let node = tokio::spawn(node.start());
@@ -152,12 +163,24 @@ impl SignetTestContext {
             constants,
             height: AtomicU64::new(cfg.constants().unwrap().host_deploy_height()),
 
+            alias_oracle,
             addresses,
         };
 
         (this, node)
     }
 
+    /// Set whether an address should be aliased. This will be propagated to
+    /// the running node.
+    pub fn set_should_alias(&self, address: Address, should_alias: bool) {
+        let mut guard = self.alias_oracle.lock().expect("failed to lock alias oracle mutex");
+        if should_alias {
+            guard.insert(address);
+        } else {
+            guard.remove(&address);
+        }
+    }
+
     /// Clone the Signet system constants
     pub fn constants(&self) -> SignetSystemConstants {
         self.constants.clone()

crates/node-tests/tests/db.rs

@@ -1,4 +1,4 @@
-use alloy::primitives::hex;
+use alloy::primitives::{Address, hex, map::HashSet};
 use reth::providers::BlockReader;
 use serial_test::serial;
 use signet_node::SignetNode;
@@ -17,7 +17,14 @@ async fn test_genesis() {
     assert_eq!(chain_spec.genesis().config.chain_id, consts.unwrap().ru_chain_id());
 
     let factory = create_test_provider_factory_with_chain_spec(chain_spec.clone());
-    let (_, _) = SignetNode::new(ctx, cfg.clone(), factory.clone(), Default::default()).unwrap();
+    let (_, _) = SignetNode::<_, _, HashSet<Address>>::new(
+        ctx,
+        cfg.clone(),
+        factory.clone(),
+        Default::default(),
+        Default::default(),
+    )
+    .unwrap();
 
     let genesis_block = factory.provider().unwrap().block_by_number(0).unwrap().unwrap();
 

crates/node/src/node.rs

@@ -22,7 +22,7 @@ use reth_db_common::init;
 use reth_exex::{ExExContext, ExExEvent, ExExHead, ExExNotificationsStream};
 use reth_node_api::{FullNodeComponents, FullNodeTypes, NodeTypes};
 use signet_blobber::BlobFetcher;
-use signet_block_processor::SignetBlockProcessorV1;
+use signet_block_processor::{AliasOracleFactory, SignetBlockProcessorV1};
 use signet_db::{DbProviderExt, RuChain, RuWriter};
 use signet_node_config::SignetNodeConfig;
 use signet_node_types::{NodeStatus, NodeTypesDbTrait, SignetNodeTypes};
@@ -42,7 +42,7 @@ type ExExNotification<Host> = reth_exex::ExExNotification<PrimitivesOf<Host>>;
 type Chain<Host> = reth::providers::Chain<PrimitivesOf<Host>>;
 
 /// Signet context and configuration.
-pub struct SignetNode<Host, Db>
+pub struct SignetNode<Host, Db, AliasOracle = Box<dyn StateProviderFactory>>
 where
     Host: FullNodeComponents,
     Host::Types: NodeTypes<Primitives = EthPrimitives>,
@@ -72,13 +72,13 @@ where
     pub(crate) status: watch::Sender<NodeStatus>,
 
     /// The block processor
-    pub(crate) processor: SignetBlockProcessorV1<Db>,
+    pub(crate) processor: SignetBlockProcessorV1<Db, AliasOracle>,
 
     /// A reqwest client, used by the blob fetch and the tx cache forwarder.
     pub(crate) client: reqwest::Client,
 }
 
-impl<Host, Db> fmt::Debug for SignetNode<Host, Db>
+impl<Host, Db, AliasOracle> fmt::Debug for SignetNode<Host, Db, AliasOracle>
 where
     Host: FullNodeComponents,
     Host::Types: NodeTypes<Primitives = EthPrimitives>,
@@ -89,7 +89,7 @@ where
     }
 }
 
-impl<Host, Db> NodePrimitivesProvider for SignetNode<Host, Db>
+impl<Host, Db, AliasOracle> NodePrimitivesProvider for SignetNode<Host, Db, AliasOracle>
 where
     Host: FullNodeComponents,
     Host::Types: NodeTypes<Primitives = EthPrimitives>,
@@ -98,22 +98,24 @@ where
     type Primitives = EthPrimitives;
 }
 
-impl<Host, Db> CanonStateSubscriptions for SignetNode<Host, Db>
+impl<Host, Db, AliasOracle> CanonStateSubscriptions for SignetNode<Host, Db, AliasOracle>
 where
     Host: FullNodeComponents,
     Host::Types: NodeTypes<Primitives = EthPrimitives>,
     Db: NodeTypesDbTrait,
+    AliasOracle: AliasOracleFactory,
 {
     fn subscribe_to_canonical_state(&self) -> CanonStateNotifications<Self::Primitives> {
         self.bp.subscribe_to_canonical_state()
     }
 }
 
-impl<Host, Db> SignetNode<Host, Db>
+impl<Host, Db, AliasOracle> SignetNode<Host, Db, AliasOracle>
 where
     Host: FullNodeComponents,
     Host::Types: NodeTypes<Primitives = EthPrimitives>,
     Db: NodeTypesDbTrait,
+    AliasOracle: AliasOracleFactory,
 {
     /// Create a new Signet instance.
     ///
@@ -124,6 +126,7 @@ where
         ctx: ExExContext<Host>,
         config: SignetNodeConfig,
         factory: ProviderFactory<SignetNodeTypes<Db>>,
+        alias_oracle: AliasOracle,
         client: reqwest::Client,
     ) -> eyre::Result<(Self, tokio::sync::watch::Receiver<NodeStatus>)> {
         let constants =
@@ -174,13 +177,11 @@ where
             .wrap_err("failed to create blob cacher")?
             .spawn();
 
-        let bdsp: Box<dyn StateProviderFactory> = Box::new(ctx.provider().clone());
-
         let processor = SignetBlockProcessorV1::new(
             constants.clone(),
             config.chain_spec().clone(),
             factory.clone(),
-            bdsp,
+            alias_oracle,
             config.slot_calculator(),
             blob_cacher,
         );

crates/node/src/rpc.rs

@@ -1,16 +1,18 @@
 use crate::SignetNode;
 use reth::{primitives::EthPrimitives, rpc::builder::config::RethRpcServerConfig};
 use reth_node_api::{FullNodeComponents, NodeTypes};
+use signet_block_processor::AliasOracleFactory;
 use signet_node_types::NodeTypesDbTrait;
 use signet_rpc::{RpcCtx, RpcServerGuard, ServeConfig};
 use signet_tx_cache::client::TxCache;
 use tracing::info;
 
-impl<Host, Db> SignetNode<Host, Db>
+impl<Host, Db, AliasOracle> SignetNode<Host, Db, AliasOracle>
 where
     Host: FullNodeComponents,
     Host::Types: NodeTypes<Primitives = EthPrimitives>,
     Db: NodeTypesDbTrait,
+    AliasOracle: AliasOracleFactory,
 {
     /// Start the RPC server.
     pub async fn start_rpc(&mut self) -> eyre::Result<()> {