chore: remove block height arg and add test

Author: prestwich

Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.package]
-version = "0.12.4"
+version = "0.13.0"
 edition = "2024"
 rust-version = "1.88"
 authors = ["init4"]

crates/block-processor/src/alias.rs

@@ -12,25 +12,32 @@ pub trait AliasOracle {
     fn should_alias(&self, address: Address) -> eyre::Result<bool>;
 }
 
+/// Default implementation of [`AliasOracle`] for any type implementing
+/// [`StateProvider`]. This implementation checks if the address has bytecode
+/// associated with it, and if so, whether that bytecode matches the pattern
+/// for a 7702 delegation contract. If it is a delegation contract, it is not
+/// aliased; otherwise, it is aliased.
 impl AliasOracle for Box<dyn StateProvider> {
     fn should_alias(&self, address: Address) -> eyre::Result<bool> {
+        // No account at this address.
         let Some(acct) = self.basic_account(&address)? else { return Ok(false) };
+        // Get the bytecode hash for this account.
         let bch = match acct.bytecode_hash {
             Some(hash) => hash,
+            // No bytecode hash; not a contract.
             None => return Ok(false),
         };
+        // No code at this address.
         if bch == KECCAK_EMPTY {
             return Ok(false);
         }
+        // Fetch the code associated with this bytecode hash.
         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)
+        // If not a 7702 delegation contract, alias it.
+        Ok(!code.is_eip7702())
     }
 }
 
@@ -62,6 +69,13 @@ impl AliasOracleFactory for Box<dyn StateProviderFactory> {
     type Oracle = Box<dyn StateProvider>;
 
     fn create(&self) -> eyre::Result<Self::Oracle> {
+        // NB: This becomes a problem if anyone ever birthday attacks a
+        // contract/EOA pair (c.f. EIP-3607). In practice this is unlikely to
+        // happen for the foreseeable future, and if it does we can revisit
+        // this decision.
+        // We considered taking the host height as an argument to this method,
+        // but this would require all nodes to be archive nodes in order to
+        // sync, which is less than ideal
         self.state_by_block_number_or_tag(alloy::eips::BlockNumberOrTag::Latest).map_err(Into::into)
     }
 }

crates/node-tests/src/context.rs

@@ -1,7 +1,7 @@
 use crate::{
     HostBlockSpec, NotificationSpec, NotificationWithSidecars, RuBlockSpec,
-    aliases::{CtxProvider, Log, TestCounterInstance, TestErc20Instance, TestLogInstance},
     convert::ToRethPrimitive,
+    types::{CtxProvider, Log, TestCounterInstance, TestErc20Instance, TestLogInstance},
     utils::create_test_provider_factory_with_chain_spec,
 };
 use alloy::{
@@ -481,6 +481,7 @@ impl<'a> NonceChecks<'a> {
     }
 
     /// Assert that the nonce of the address has increased.
+    #[track_caller]
     pub fn assert_increase_by(&mut self, amount: u64) {
         let old_nonce = self.update_nonce();
         let expected = old_nonce + amount;
@@ -496,6 +497,7 @@ impl<'a> NonceChecks<'a> {
     }
 
     /// Assert that the nonce of the address has increased by 1.
+    #[track_caller]
     pub fn assert_incremented(&mut self) {
         self.assert_increase_by(1);
     }

crates/node-tests/src/lib.rs

@@ -11,9 +11,6 @@
 #![deny(unused_must_use, rust_2018_idioms)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
-/// Test aliases and type definitions.
-pub mod aliases;
-
 /// Test constants.
 pub mod constants;
 
@@ -28,6 +25,9 @@ pub mod convert;
 pub mod rpc;
 pub use rpc::rpc_test;
 
+/// Test aliases and type definitions.
+pub mod types;
+
 /// Utility functions and test harnesses.
 pub mod utils;
 pub use utils::run_test;

crates/node-tests/src/rpc.rs

@@ -1,4 +1,4 @@
-use crate::{aliases::TestCounterInstance, context::SignetTestContext, utils::run_test};
+use crate::{context::SignetTestContext, types::TestCounterInstance, utils::run_test};
 
 /// A test helper that sets up a Signet test context, deploys the Counter
 /// contract, and then runs the provided async function `f` with the context and

crates/node-tests/src/aliases.rs renamed to crates/node-tests/src/types.rs

@@ -14,13 +14,16 @@ use serial_test::serial;
 use signet_db::{DbSignetEvent, SignetEvents};
 use signet_node_tests::{
     HostBlockSpec, SignetTestContext,
-    aliases::{Counter, TestCounterInstance},
     constants::{DEFAULT_REWARD_ADDRESS, TEST_CONSTANTS},
     run_test,
+    types::{Counter, TestCounterInstance},
     utils::{adjust_usd_decimals, adjust_usd_decimals_u256},
 };
 use signet_test_utils::{chain::USDC_RECORD, contracts::counter::COUNTER_BYTECODE};
-use signet_types::constants::{HostPermitted, RollupPermitted};
+use signet_types::{
+    constants::{HostPermitted, RollupPermitted},
+    unalias_address,
+};
 use signet_zenith::{MINTER_ADDRESS, Passage, Transactor, mintCall};
 
 alloy::sol! {
@@ -207,31 +210,44 @@ async fn test_transact() {
     run_test(|ctx| async move {
         // set up user
         let user = ctx.addresses[0];
+
+        // Getting a little cute here. We ensure that the ALIASED version is
+        // one of the standard test addresses, so we don't have to set up any
+        // extra accounts.
+        let aliased = ctx.addresses[1];
+        let host_contract = unalias_address(aliased);
+
+        // Indicate to the block processor that this address should be aliased
+        ctx.set_should_alias(host_contract, true);
+
         let mut user_nonce = ctx.track_nonce(user, Some("user"));
         let mut user_bal = ctx.track_balance(user, Some("user"));
 
+        let mut aliased_nonce = ctx.track_nonce(aliased, Some("aliased"));
+        let mut aliased_bal = ctx.track_balance(aliased, Some("aliased"));
+
         // Deploy a contract to interact with
-        let deployer = ctx.addresses[1];
+        let deployer = ctx.addresses[2];
 
         // Assert that the counter is zero
         let contract = ctx.deploy_counter(deployer).await;
         let contract_addr = *contract.address();
         assert_eq!(contract.count().call().await.unwrap(), U256::ZERO);
 
         // Transact that calls the context and increments it.
-        let block = HostBlockSpec::new(ctx.constants()).simple_transact(
-            user,
-            contract_addr,
-            Counter::incrementCall::SELECTOR,
-            0,
-        );
+        let block = HostBlockSpec::new(ctx.constants())
+            .simple_transact(user, contract_addr, Counter::incrementCall::SELECTOR, 0)
+            .simple_transact(host_contract, contract_addr, Counter::incrementCall::SELECTOR, 0);
 
         ctx.process_block(block).await.unwrap();
 
         user_nonce.assert_incremented();
         user_bal.assert_decrease();
 
-        assert_eq!(contract.count().call().await.unwrap(), U256::from(1));
+        aliased_nonce.assert_incremented();
+        aliased_bal.assert_decrease();
+
+        assert_eq!(contract.count().call().await.unwrap(), U256::from(2));
 
         // check the RPC response
         let block = ctx
@@ -258,6 +274,20 @@ async fn test_transact() {
         assert_eq!(transact_tx.to().unwrap(), contract_addr);
         assert_eq!(transact_tx.value(), U256::ZERO);
         assert_eq!(transact_tx.input(), &Bytes::from(Counter::incrementCall::SELECTOR));
+
+        let aliased_transact_tx = &txns[1];
+        assert_eq!(aliased_transact_tx.from(), aliased);
+        assert_eq!(aliased_transact_tx.to().unwrap(), contract_addr);
+        assert_eq!(aliased_transact_tx.value(), U256::ZERO);
+        assert_eq!(aliased_transact_tx.input(), &Bytes::from(Counter::incrementCall::SELECTOR));
+
+        let aliased_tx_hash = aliased_transact_tx.tx_hash();
+        let aliased_transact_tx =
+            ctx.alloy_provider.get_transaction_by_hash(aliased_tx_hash).await.unwrap().unwrap();
+        assert_eq!(aliased_transact_tx.from(), aliased);
+        assert_eq!(aliased_transact_tx.to().unwrap(), contract_addr);
+        assert_eq!(aliased_transact_tx.value(), U256::ZERO);
+        assert_eq!(aliased_transact_tx.input(), &Bytes::from(Counter::incrementCall::SELECTOR));
     })
     .await;
 }

crates/node-tests/tests/host_events.rs

@@ -8,9 +8,8 @@ use alloy::{
 };
 use serial_test::serial;
 use signet_node_tests::{
-    HostBlockSpec, RuBlockSpec, SignetTestContext,
-    aliases::{Erc20, TestErc20Instance},
-    run_test,
+    HostBlockSpec, RuBlockSpec, SignetTestContext, run_test,
+    types::{Erc20, TestErc20Instance},
 };
 use signet_types::constants::HostPermitted;
 use signet_zenith::RollupOrders;

crates/node-tests/tests/orders.rs

@@ -17,9 +17,9 @@ use reth::providers::{BlockNumReader, BlockReader, TransactionsProvider};
 use serial_test::serial;
 use signet_node_tests::{
     SignetTestContext,
-    aliases::{Counter, TestCounterInstance},
     constants::TEST_CONSTANTS,
     rpc_test,
+    types::{Counter, TestCounterInstance},
 };
 use signet_test_utils::contracts::counter::{COUNTER_BYTECODE, COUNTER_DEPLOY_CODE};
 use tokio::try_join;

crates/node-tests/tests/rpc.rs

@@ -4,7 +4,7 @@ use reth::{
     rpc::types::trace::geth::{CallConfig, GethDebugTracingOptions},
 };
 use serial_test::serial;
-use signet_node_tests::{aliases::Counter::incrementCall, rpc::rpc_test};
+use signet_node_tests::{rpc::rpc_test, types::Counter::incrementCall};
 use signet_test_utils::specs::{HostBlockSpec, RuBlockSpec};
 
 #[serial]