feat: alias oracle

Author: prestwich

crates/block-processor/src/alias.rs

@@ -0,0 +1,65 @@
+use alloy::{
+    consensus::constants::KECCAK_EMPTY,
+    primitives::{Address, map::HashSet},
+};
+use eyre::OptionExt;
+use reth::providers::{StateProvider, StateProviderFactory};
+
+/// Simple trait to allow checking if an address should be aliased.
+pub trait AliasOracle {
+    /// Returns true if the given address is an alias.
+    fn should_alias(&self, address: Address) -> eyre::Result<bool>;
+}
+
+impl AliasOracle for Box<dyn StateProvider> {
+    fn should_alias(&self, address: Address) -> eyre::Result<bool> {
+        let Some(acct) = self.basic_account(&address)? else { return Ok(false) };
+        let bch = match acct.bytecode_hash {
+            Some(hash) => hash,
+            None => return Ok(false),
+        };
+        if bch == KECCAK_EMPTY {
+            return Ok(false);
+        }
+        let code = self
+            .bytecode_by_hash(&bch)?
+            .ok_or_eyre("code not found. This indicates a corrupted database")?;
+
+        // Check for 7702 delegations.
+        if code.len() != 23 || !code.bytecode().starts_with(&[0xef, 0x01, 0x00]) {
+            return Ok(true);
+        }
+        Ok(false)
+    }
+}
+
+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.
+pub trait AliasOracleFactory: Send + Sync + 'static {
+    /// The [`AliasOracle`] type.
+    type Oracle<'a>: AliasOracle;
+
+    /// Create a new [`AliasOracle`].
+    fn create(&self, block_height: u64) -> eyre::Result<Self::Oracle<'_>>;
+}
+
+impl AliasOracleFactory for Box<dyn StateProviderFactory> {
+    type Oracle<'a> = Box<dyn StateProvider>;
+
+    fn create(&self, block_height: u64) -> eyre::Result<Self::Oracle<'_>> {
+        self.state_by_block_number_or_tag(block_height.into()).map_err(Into::into)
+    }
+}
+
+impl AliasOracleFactory for HashSet<Address> {
+    type Oracle<'a> = &'a HashSet<Address>;
+
+    fn create(&self, _block_height: u64) -> eyre::Result<Self::Oracle<'_>> {
+        Ok(self)
+    }
+}

crates/block-processor/src/lib.rs

@@ -13,6 +13,9 @@
 
 pub(crate) mod metrics;
 
+mod alias;
+pub use alias::{AliasOracle, AliasOracleFactory};
+
 mod v1;
 pub use v1::SignetBlockProcessor as SignetBlockProcessorV1;
 

crates/block-processor/src/v1/processor.rs

@@ -1,4 +1,4 @@
-use crate::{Chain, metrics};
+use crate::{AliasOracle, AliasOracleFactory, Chain, metrics};
 use alloy::{
     consensus::BlockHeader,
     primitives::{Address, B256, map::HashSet},
@@ -29,7 +29,7 @@ use trevm::revm::primitives::hardfork::SpecId;
 
 /// A block processor that listens to host chain commits and processes
 /// Signet blocks accordingly.
-pub struct SignetBlockProcessor<Db>
+pub struct SignetBlockProcessor<Db, Alias = Box<dyn StateProviderFactory>>
 where
     Db: NodeTypesDbTrait,
 {
@@ -43,7 +43,7 @@ where
     ru_provider: ProviderFactory<SignetNodeTypes<Db>>,
 
     /// A [`ProviderFactory`] instance to allow Host database access.
-    host_provider: Box<dyn StateProviderFactory>,
+    alias_oracle: Alias,
 
     /// The slot calculator.
     slot_calculator: SlotCalculator,
@@ -61,20 +61,21 @@ where
     }
 }
 
-impl<Db> SignetBlockProcessor<Db>
+impl<Db, Alias> SignetBlockProcessor<Db, Alias>
 where
     Db: NodeTypesDbTrait,
+    Alias: AliasOracleFactory,
 {
     /// Create a new [`SignetBlockProcessor`].
     pub const fn new(
         constants: SignetSystemConstants,
         chain_spec: Arc<ChainSpec>,
         ru_provider: ProviderFactory<SignetNodeTypes<Db>>,
-        host_provider: Box<dyn StateProviderFactory>,
+        alias_oracle: Alias,
         slot_calculator: SlotCalculator,
         blob_cacher: CacheHandle,
     ) -> Self {
-        Self { constants, chain_spec, ru_provider, host_provider, slot_calculator, blob_cacher }
+        Self { constants, chain_spec, ru_provider, alias_oracle, slot_calculator, blob_cacher }
     }
 
     /// Get the active spec id at the given timestamp.
@@ -111,9 +112,8 @@ where
     }
 
     /// Check if the given address should be aliased.
-    fn should_alias(&self, host_height: u64, address: Address) -> eyre::Result<bool> {
-        let state = self.host_provider.history_by_block_number(host_height)?;
-        state.account_code(&address).map(|code| code.is_some()).map_err(Into::into)
+    fn should_alias(&self, address: Address, host_height: u64) -> eyre::Result<bool> {
+        self.alias_oracle.create(host_height)?.should_alias(address)
     }
 
     /// Called when the host chain has committed a block or set of blocks.
@@ -263,10 +263,11 @@ where
             None => VecDeque::new(),
         };
 
+        // Determine which addresses need to be aliased.
         let mut to_alias: HashSet<Address> = Default::default();
         for transact in block_extracts.transacts() {
             let addr = transact.host_sender();
-            if self.should_alias(host_height, addr)? {
+            if !to_alias.contains(&addr) && self.should_alias(addr, host_height)? {
                 to_alias.insert(addr);
             }
         }

crates/node/src/node.rs

@@ -11,7 +11,8 @@ use reth::{
     providers::{
         BlockHashReader, BlockIdReader, BlockNumReader, BlockReader, CanonChainTracker,
         CanonStateNotification, CanonStateNotifications, CanonStateSubscriptions, HeaderProvider,
-        NodePrimitivesProvider, ProviderFactory, providers::BlockchainProvider,
+        NodePrimitivesProvider, ProviderFactory, StateProviderFactory,
+        providers::BlockchainProvider,
     },
     rpc::types::engine::ForkchoiceState,
 };
@@ -173,11 +174,13 @@ 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(),
-            Box::new(ctx.provider().clone()),
+            bdsp,
             config.slot_calculator(),
             blob_cacher,
         );