chore: remove block height arg and add test

Author: prestwich

crates/block-processor/src/alias.rs

@@ -62,6 +62,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]

crates/node-tests/tests/rpc_debug.rs

@@ -6,9 +6,7 @@ use alloy::{
     rpc::types::eth::TransactionRequest,
 };
 use serial_test::serial;
-use signet_node_tests::{
-    HostBlockSpec, RuBlockSpec, aliases::TestCounterInstance, utils::run_test,
-};
+use signet_node_tests::{HostBlockSpec, RuBlockSpec, types::TestCounterInstance, utils::run_test};
 use signet_test_utils::contracts::counter::{COUNTER_BYTECODE, COUNTER_DEPLOY_CODE};
 
 const USER_A: Address = Address::repeat_byte(0x39);