chore(workspace): metering refactor

Author: refcell

Cargo.lock

@@ -42,6 +42,7 @@ serde.workspace = true
 base-reth-test-utils.workspace = true
 reth-db = { workspace = true, features = ["test-utils"] }
 reth-db-common.workspace = true
+reth-e2e-test-utils.workspace = true
 reth-optimism-node.workspace = true
 reth-testing-utils.workspace = true
 reth-transaction-pool = { workspace = true, features = ["test-utils"] }

crates/client/metering/Cargo.toml

@@ -2,94 +2,48 @@
 
 use std::sync::Arc;
 
-use alloy_consensus::crypto::secp256k1::public_key_to_address;
 use alloy_eips::Encodable2718;
-use alloy_genesis::GenesisAccount;
-use alloy_primitives::{Address, B256, Bytes, U256, keccak256};
+use alloy_primitives::{Address, B256, Bytes, U256, hex::FromHex, keccak256};
 use base_bundles::{Bundle, ParsedBundle};
 use base_reth_metering::meter_bundle;
-use base_reth_test_utils::create_provider_factory;
+use base_reth_test_utils::{TestAccounts, create_provider_factory, load_genesis};
 use eyre::Context;
 use op_alloy_consensus::OpTxEnvelope;
-use rand::{SeedableRng, rngs::StdRng};
 use reth::{api::NodeTypesWithDBAdapter, chainspec::EthChainSpec};
 use reth_db::{DatabaseEnv, test_utils::TempDatabase};
-use reth_optimism_chainspec::{BASE_MAINNET, OpChainSpec, OpChainSpecBuilder};
+use reth_optimism_chainspec::{OpChainSpec, OpChainSpecBuilder};
 use reth_optimism_node::OpNode;
 use reth_optimism_primitives::OpTransactionSigned;
 use reth_primitives_traits::SealedHeader;
 use reth_provider::{HeaderProvider, StateProviderFactory, providers::BlockchainProvider};
-use reth_testing_utils::generators::generate_keys;
 use reth_transaction_pool::test_utils::TransactionBuilder;
 
 type NodeTypes = NodeTypesWithDBAdapter<OpNode, Arc<TempDatabase<DatabaseEnv>>>;
 
-#[derive(Eq, PartialEq, Debug, Hash, Clone, Copy)]
-enum User {
-    Alice,
-    Bob,
-}
-
 #[derive(Debug, Clone)]
 struct TestHarness {
     provider: BlockchainProvider<NodeTypes>,
     header: SealedHeader,
     chain_spec: Arc<OpChainSpec>,
-    user_to_address: std::collections::HashMap<User, Address>,
-    user_to_private_key: std::collections::HashMap<User, B256>,
+    accounts: TestAccounts,
 }
 
 impl TestHarness {
-    fn address(&self, u: User) -> Address {
-        self.user_to_address[&u]
+    fn alice_signer(&self) -> B256 {
+        B256::from_hex(self.accounts.alice.private_key).expect("valid hex-encoded key")
     }
 
-    fn signer(&self, u: User) -> B256 {
-        self.user_to_private_key[&u]
+    fn bob_signer(&self) -> B256 {
+        B256::from_hex(self.accounts.bob.private_key).expect("valid hex-encoded key")
     }
 }
 
-fn create_chain_spec(
-    seed: u64,
-) -> (
-    Arc<OpChainSpec>,
-    std::collections::HashMap<User, Address>,
-    std::collections::HashMap<User, B256>,
-) {
-    let keys = generate_keys(&mut StdRng::seed_from_u64(seed), 2);
-
-    let mut addresses = std::collections::HashMap::new();
-    let mut private_keys = std::collections::HashMap::new();
-
-    let alice_key = keys[0];
-    let alice_address = public_key_to_address(alice_key.public_key());
-    let alice_secret = B256::from(alice_key.secret_bytes());
-    addresses.insert(User::Alice, alice_address);
-    private_keys.insert(User::Alice, alice_secret);
-
-    let bob_key = keys[1];
-    let bob_address = public_key_to_address(bob_key.public_key());
-    let bob_secret = B256::from(bob_key.secret_bytes());
-    addresses.insert(User::Bob, bob_address);
-    private_keys.insert(User::Bob, bob_secret);
-
-    let genesis = BASE_MAINNET
-        .genesis
-        .clone()
-        .extend_accounts(vec![
-            (alice_address, GenesisAccount::default().with_balance(U256::from(1_000_000_000_u64))),
-            (bob_address, GenesisAccount::default().with_balance(U256::from(1_000_000_000_u64))),
-        ])
-        .with_gas_limit(100_000_000);
-
-    let spec =
+fn setup_harness() -> eyre::Result<TestHarness> {
+    let accounts = TestAccounts::new();
+    let genesis = load_genesis();
+    let chain_spec =
         Arc::new(OpChainSpecBuilder::base_mainnet().genesis(genesis).isthmus_activated().build());
 
-    (spec, addresses, private_keys)
-}
-
-fn setup_harness() -> eyre::Result<TestHarness> {
-    let (chain_spec, user_to_address, user_to_private_key) = create_chain_spec(1337);
     let factory = create_provider_factory::<OpNode>(chain_spec.clone());
 
     reth_db_common::init::init_genesis(&factory).context("initializing genesis state")?;
@@ -100,7 +54,7 @@ fn setup_harness() -> eyre::Result<TestHarness> {
         .context("fetching genesis header")?
         .expect("genesis header exists");
 
-    Ok(TestHarness { provider, header, chain_spec, user_to_address, user_to_private_key })
+    Ok(TestHarness { provider, header, chain_spec, accounts })
 }
 
 fn envelope_from_signed(tx: &OpTransactionSigned) -> eyre::Result<OpTxEnvelope> {
@@ -155,7 +109,7 @@ fn meter_bundle_single_transaction() -> eyre::Result<()> {
 
     let to = Address::random();
     let signed_tx = TransactionBuilder::default()
-        .signer(harness.signer(User::Alice))
+        .signer(harness.alice_signer())
         .chain_id(harness.chain_spec.chain_id())
         .nonce(0)
         .to(to)
@@ -185,7 +139,7 @@ fn meter_bundle_single_transaction() -> eyre::Result<()> {
     let result = &results[0];
     assert!(total_execution_time > 0);
 
-    assert_eq!(result.from_address, harness.address(User::Alice));
+    assert_eq!(result.from_address, harness.accounts.alice.address);
     assert_eq!(result.to_address, Some(to));
     assert_eq!(result.tx_hash, tx_hash);
     assert_eq!(result.gas_price, U256::from(10));
@@ -213,7 +167,7 @@ fn meter_bundle_multiple_transactions() -> eyre::Result<()> {
 
     // Create first transaction
     let signed_tx_1 = TransactionBuilder::default()
-        .signer(harness.signer(User::Alice))
+        .signer(harness.alice_signer())
         .chain_id(harness.chain_spec.chain_id())
         .nonce(0)
         .to(to_1)
@@ -229,7 +183,7 @@ fn meter_bundle_multiple_transactions() -> eyre::Result<()> {
 
     // Create second transaction
     let signed_tx_2 = TransactionBuilder::default()
-        .signer(harness.signer(User::Bob))
+        .signer(harness.bob_signer())
         .chain_id(harness.chain_spec.chain_id())
         .nonce(0)
         .to(to_2)
@@ -263,7 +217,7 @@ fn meter_bundle_multiple_transactions() -> eyre::Result<()> {
 
     // Check first transaction
     let result_1 = &results[0];
-    assert_eq!(result_1.from_address, harness.address(User::Alice));
+    assert_eq!(result_1.from_address, harness.accounts.alice.address);
     assert_eq!(result_1.to_address, Some(to_1));
     assert_eq!(result_1.tx_hash, tx_hash_1);
     assert_eq!(result_1.gas_price, U256::from(10));
@@ -272,7 +226,7 @@ fn meter_bundle_multiple_transactions() -> eyre::Result<()> {
 
     // Check second transaction
     let result_2 = &results[1];
-    assert_eq!(result_2.from_address, harness.address(User::Bob));
+    assert_eq!(result_2.from_address, harness.accounts.bob.address);
     assert_eq!(result_2.to_address, Some(to_2));
     assert_eq!(result_2.tx_hash, tx_hash_2);
     assert_eq!(result_2.gas_price, U256::from(15));

crates/client/metering/tests/meter.rs

@@ -2,79 +2,48 @@
 
 use std::sync::Arc;
 
-use alloy_consensus::{BlockHeader, Header, crypto::secp256k1::public_key_to_address};
-use alloy_genesis::GenesisAccount;
-use alloy_primitives::{Address, B256, U256};
+use alloy_consensus::{BlockHeader, Header};
+use alloy_primitives::{Address, B256, hex::FromHex};
 use base_reth_metering::meter_block;
-use base_reth_test_utils::create_provider_factory;
+use base_reth_test_utils::{TestAccounts, create_provider_factory, load_genesis};
 use eyre::Context;
-use rand::{SeedableRng, rngs::StdRng};
 use reth::{api::NodeTypesWithDBAdapter, chainspec::EthChainSpec};
 use reth_db::{DatabaseEnv, test_utils::TempDatabase};
-use reth_optimism_chainspec::{BASE_MAINNET, OpChainSpec, OpChainSpecBuilder};
+use reth_optimism_chainspec::{OpChainSpec, OpChainSpecBuilder};
 use reth_optimism_node::OpNode;
 use reth_optimism_primitives::{OpBlock, OpBlockBody, OpTransactionSigned};
 use reth_primitives_traits::Block as BlockT;
 use reth_provider::{HeaderProvider, providers::BlockchainProvider};
-use reth_testing_utils::generators::generate_keys;
 use reth_transaction_pool::test_utils::TransactionBuilder;
 
 type NodeTypes = NodeTypesWithDBAdapter<OpNode, Arc<TempDatabase<DatabaseEnv>>>;
 
-#[derive(Eq, PartialEq, Debug, Hash, Clone, Copy)]
-enum User {
-    Alice,
-    Bob,
-}
-
 #[derive(Debug, Clone)]
 struct TestHarness {
     provider: BlockchainProvider<NodeTypes>,
     genesis_header_hash: B256,
     genesis_header_number: u64,
     genesis_header_timestamp: u64,
     chain_spec: Arc<OpChainSpec>,
-    user_to_private_key: std::collections::HashMap<User, B256>,
+    accounts: TestAccounts,
 }
 
 impl TestHarness {
-    fn signer(&self, u: User) -> B256 {
-        self.user_to_private_key[&u]
+    fn alice_signer(&self) -> B256 {
+        B256::from_hex(self.accounts.alice.private_key).expect("valid hex-encoded key")
     }
-}
-
-fn create_chain_spec(seed: u64) -> (Arc<OpChainSpec>, std::collections::HashMap<User, B256>) {
-    let keys = generate_keys(&mut StdRng::seed_from_u64(seed), 2);
-
-    let mut private_keys = std::collections::HashMap::new();
-
-    let alice_key = keys[0];
-    let alice_address = public_key_to_address(alice_key.public_key());
-    let alice_secret = B256::from(alice_key.secret_bytes());
-    private_keys.insert(User::Alice, alice_secret);
-
-    let bob_key = keys[1];
-    let bob_address = public_key_to_address(bob_key.public_key());
-    let bob_secret = B256::from(bob_key.secret_bytes());
-    private_keys.insert(User::Bob, bob_secret);
 
-    let genesis = BASE_MAINNET
-        .genesis
-        .clone()
-        .extend_accounts(vec![
-            (alice_address, GenesisAccount::default().with_balance(U256::from(1_000_000_000_u64))),
-            (bob_address, GenesisAccount::default().with_balance(U256::from(1_000_000_000_u64))),
-        ])
-        .with_gas_limit(100_000_000);
-
-    let spec =
-        Arc::new(OpChainSpecBuilder::base_mainnet().genesis(genesis).isthmus_activated().build());
-
-    (spec, private_keys)
+    fn bob_signer(&self) -> B256 {
+        B256::from_hex(self.accounts.bob.private_key).expect("valid hex-encoded key")
+    }
 }
 
 fn setup_harness() -> eyre::Result<TestHarness> {
-    let (chain_spec, user_to_private_key) = create_chain_spec(1337);
+    let accounts = TestAccounts::new();
+    let genesis = load_genesis();
+    let chain_spec =
+        Arc::new(OpChainSpecBuilder::base_mainnet().genesis(genesis).isthmus_activated().build());
+
     let factory = create_provider_factory::<OpNode>(chain_spec.clone());
 
     reth_db_common::init::init_genesis(&factory).context("initializing genesis state")?;
@@ -91,7 +60,7 @@ fn setup_harness() -> eyre::Result<TestHarness> {
         genesis_header_number: header.number(),
         genesis_header_timestamp: header.timestamp(),
         chain_spec,
-        user_to_private_key,
+        accounts,
     })
 }
 
@@ -144,7 +113,7 @@ fn meter_block_single_transaction() -> eyre::Result<()> {
 
     let to = Address::random();
     let signed_tx = TransactionBuilder::default()
-        .signer(harness.signer(User::Alice))
+        .signer(harness.alice_signer())
         .chain_id(harness.chain_spec.chain_id())
         .nonce(0)
         .to(to)
@@ -191,7 +160,7 @@ fn meter_block_multiple_transactions() -> eyre::Result<()> {
 
     // Create first transaction from Alice
     let signed_tx_1 = TransactionBuilder::default()
-        .signer(harness.signer(User::Alice))
+        .signer(harness.alice_signer())
         .chain_id(harness.chain_spec.chain_id())
         .nonce(0)
         .to(to_1)
@@ -208,7 +177,7 @@ fn meter_block_multiple_transactions() -> eyre::Result<()> {
 
     // Create second transaction from Bob
     let signed_tx_2 = TransactionBuilder::default()
-        .signer(harness.signer(User::Bob))
+        .signer(harness.bob_signer())
         .chain_id(harness.chain_spec.chain_id())
         .nonce(0)
         .to(to_2)
@@ -268,7 +237,7 @@ fn meter_block_timing_consistency() -> eyre::Result<()> {
 
     // Create a block with one transaction
     let signed_tx = TransactionBuilder::default()
-        .signer(harness.signer(User::Alice))
+        .signer(harness.alice_signer())
         .chain_id(harness.chain_spec.chain_id())
         .nonce(0)
         .to(Address::random())