cleanup

Author: lukeiannucci

timeboost-utils/src/load_generation.rs

@@ -1,5 +1,3 @@
-use std::str::FromStr;
-
 use alloy::{
     consensus::{SignableTransaction, TxEip1559, TxEnvelope},
     network::TxSignerSync,
@@ -18,9 +16,14 @@ use timeboost_crypto::{
 };
 use timeboost_types::{Address, Bundle, BundleVariant, Epoch, PriorityBundle, SeqNo, Signer};
 
-// Private key from pre funded dev account on test node
-// https://docs.arbitrum.io/run-arbitrum-node/run-local-full-chain-simulation#default-endpoints-and-addresses
-const DEV_ACCT_PRIV_KEY: &str = "b6b15c8cb491557369f3c7d2c287b053eb229daa9c22138887752191c9520659";
+pub struct TxInfo {
+    pub chain_id: u64,
+    pub nonce: u64,
+    pub to: alloy::primitives::Address,
+    pub base_fee: u128,
+    pub gas_limit: u64,
+    pub signer: PrivateKeySigner,
+}
 
 pub fn make_bundle(pubkey: &ThresholdEncKeyCell) -> anyhow::Result<BundleVariant> {
     let mut rng = rand::thread_rng();
@@ -58,19 +61,15 @@ pub fn make_bundle(pubkey: &ThresholdEncKeyCell) -> anyhow::Result<BundleVariant
 
 pub fn make_dev_acct_bundle(
     pubkey: &ThresholdEncKeyCell,
-    chain_id: u64,
-    nonce: u64,
-    to: alloy::primitives::Address,
-    gas_limit: u64,
-    max_base_fee: u128,
+    txn: TxInfo,
 ) -> anyhow::Result<BundleVariant> {
     let mut rng = rand::thread_rng();
     let mut v = [0; 256];
     rng.fill(&mut v);
     let mut u = Unstructured::new(&v);
 
     let max_seqno = 10;
-    let mut bundle = create_dev_acct_txn_bundle(chain_id, nonce, to, gas_limit, max_base_fee)?;
+    let mut bundle = create_dev_acct_txn_bundle(txn)?;
 
     if let Some(pubkey) = &*pubkey.get_ref()
         && rng.gen_bool(0.5)
@@ -97,34 +96,25 @@ pub fn make_dev_acct_bundle(
     }
 }
 
-pub fn create_dev_acct_txn_bundle(
-    chain_id: u64,
-    nonce: u64,
-    to: alloy::primitives::Address,
-    gas_limit: u64,
-    max_fee_per_gas: u128,
-) -> anyhow::Result<Bundle> {
+pub fn create_dev_acct_txn_bundle(tx_info: TxInfo) -> anyhow::Result<Bundle> {
     let mut tx = TxEip1559 {
-        chain_id,
-        nonce,
-        max_fee_per_gas,
-        gas_limit,
-        to: TxKind::Call(to),
+        chain_id: tx_info.chain_id,
+        nonce: tx_info.nonce,
+        max_fee_per_gas: tx_info.base_fee,
+        gas_limit: tx_info.gas_limit,
+        to: TxKind::Call(tx_info.to),
         value: U256::from(1),
         ..Default::default()
     };
 
-    // Private key from pre funded dev account on test node
-    // https://docs.arbitrum.io/run-arbitrum-node/run-local-full-chain-simulation#default-endpoints-and-addresses
-    let signer = PrivateKeySigner::from_str(DEV_ACCT_PRIV_KEY)?;
-    let sig = signer.sign_transaction_sync(&mut tx)?;
+    let sig = tx_info.signer.sign_transaction_sync(&mut tx)?;
     let signed_tx = tx.into_signed(sig);
     let env = TxEnvelope::Eip1559(signed_tx);
     let mut rlp = Vec::new();
     env.encode(&mut rlp);
 
     let encoded = ssz::ssz_encode(&vec![&rlp]);
-    let b = Bundle::new(chain_id.into(), Epoch::now(), encoded.into(), false);
+    let b = Bundle::new(tx_info.chain_id.into(), Epoch::now(), encoded.into(), false);
 
     Ok(b)
 }

yapper/src/config.rs

@@ -13,4 +13,6 @@ pub(crate) struct YapperConfig {
     pub(crate) nitro_url: String,
     /// Limit on the number of transactions we want to send
     pub(crate) txn_limit: u64,
+    /// Chain id for l2 chain
+    pub(crate) chain_id: u64,
 }

yapper/src/main.rs

@@ -49,6 +49,11 @@ struct Cli {
     #[clap(long, default_value_t = 20)]
     nitro_txn_limit: u64,
 
+    /// Chain id for l2 chain
+    /// default: https://docs.arbitrum.io/run-arbitrum-node/run-local-full-chain-simulation#default-endpoints-and-addresses
+    #[clap(long, default_value_t = 412346)]
+    chain_id: u64,
+
     /// How many txns to send before terminating yapper
     #[clap(long, default_value = "http://localhost:8547")]
     nitro_url: String,
@@ -82,6 +87,7 @@ async fn main() -> Result<()> {
         .tps(cli.tps)
         .txn_limit(cli.nitro_txn_limit)
         .nitro_url(cli.nitro_url)
+        .chain_id(cli.chain_id)
         .build();
     let yapper = Yapper::new(config).await?;
 

yapper/src/yapper.rs

@@ -1,16 +1,17 @@
-use std::time::Duration;
+use std::{str::FromStr, time::Duration};
 
 use alloy::{
     network::{Ethereum, TransactionBuilder},
     primitives::{Address, U256, address},
     providers::{Provider, RootProvider},
     rpc::types::TransactionRequest,
+    signers::local::PrivateKeySigner,
 };
 use anyhow::{Context, Result};
 use futures::future::join_all;
 use reqwest::{Client, Url};
 use timeboost::types::BundleVariant;
-use timeboost_utils::load_generation::{make_bundle, make_dev_acct_bundle, tps_to_millis};
+use timeboost_utils::load_generation::{TxInfo, make_bundle, make_dev_acct_bundle, tps_to_millis};
 use tokio::time::interval;
 use tracing::warn;
 
@@ -20,6 +21,10 @@ use crate::{config::YapperConfig, enc_key::ThresholdEncKeyCellAccumulator};
 /// https://docs.arbitrum.io/run-arbitrum-node/run-local-full-chain-simulation#default-endpoints-and-addresses
 const DEV_ACCT_ADDRESS: Address = address!("0x3f1Eae7D46d88F08fc2F8ed27FCb2AB183EB2d0E");
 
+/// Private key from pre funded dev account on test node
+/// https://docs.arbitrum.io/run-arbitrum-node/run-local-full-chain-simulation#default-endpoints-and-addresses
+const DEV_ACCT_PRIV_KEY: &str = "b6b15c8cb491557369f3c7d2c287b053eb229daa9c22138887752191c9520659";
+
 /// This is the address of validator for the chain
 /// https://docs.arbitrum.io/run-arbitrum-node/run-local-full-chain-simulation#default-endpoints-and-addresses
 const VALIDATOR_ADDRESS: Address = address!("0x6A568afe0f82d34759347bb36F14A6bB171d2CBe");
@@ -34,15 +39,16 @@ pub(crate) struct Yapper {
     urls: Vec<ApiUrls>,
     client: Client,
     interval: Duration,
+    chain_id: u64,
     provider: Option<RootProvider>,
     txn_limit: Option<u64>,
 }
 
 impl Yapper {
-    pub(crate) async fn new(config: YapperConfig) -> Result<Self> {
+    pub(crate) async fn new(cfg: YapperConfig) -> Result<Self> {
         let mut urls = Vec::new();
 
-        for addr in config.addresses {
+        for addr in cfg.addresses {
             let regular_url = Url::parse(&format!("http://{addr}/v0/submit-regular"))
                 .with_context(|| format!("parsing {addr} into a url"))?;
             let priority_url = Url::parse(&format!("http://{addr}/v0/submit-priority"))
@@ -57,23 +63,24 @@ impl Yapper {
             });
         }
         let client = Client::builder().timeout(Duration::from_secs(1)).build()?;
-        let (provider, interval, txn_limit) = if config.nitro_integration {
+        let (provider, interval, txn_limit) = if cfg.nitro_integration {
             (
-                Some(RootProvider::<Ethereum>::connect(&config.nitro_url).await?),
+                Some(RootProvider::<Ethereum>::connect(&cfg.nitro_url).await?),
                 Duration::from_secs(1),
                 // For nitro running in ci, avoid race conditions with block height by setting txn
                 // limit
-                Some(config.txn_limit),
+                Some(cfg.txn_limit),
             )
         } else {
-            (None, Duration::from_millis(tps_to_millis(config.tps)), None)
+            (None, Duration::from_millis(tps_to_millis(cfg.tps)), None)
         };
         Ok(Self {
             urls,
             interval,
             client,
             provider,
             txn_limit,
+            chain_id: cfg.chain_id,
         })
     }
 
@@ -89,40 +96,17 @@ impl Yapper {
         let mut txn_sent = 0;
         loop {
             let b = if let Some(ref p) = self.provider {
-                let nonce = p.get_transaction_count(DEV_ACCT_ADDRESS).await?;
-                // Chain id from l2 chain
-                // https://docs.arbitrum.io/run-arbitrum-node/run-local-full-chain-simulation#default-endpoints-and-addresses
-                let chain_id = 412346;
-                let tx = TransactionRequest::default()
-                    .with_chain_id(chain_id)
-                    .with_nonce(nonce)
-                    .with_from(DEV_ACCT_ADDRESS)
-                    .with_to(VALIDATOR_ADDRESS)
-                    .with_value(U256::from(1));
-
-                let Ok(estimate) = p.estimate_gas(tx).await else {
-                    warn!("failed to get estimate");
-                    continue;
-                };
-                let Ok(price) = p.get_gas_price().await else {
-                    warn!("failed to get gas price");
+                // For testing just send from the dev account to the validator address
+                let Ok(txn) = Self::prepare_txn(p, self.chain_id).await else {
+                    warn!("failed to prepare txn");
                     continue;
                 };
-                // For testing just send from the dev account to the validator address
-                let Ok(b) = make_dev_acct_bundle(
-                    acc.enc_key().await,
-                    chain_id,
-                    nonce,
-                    VALIDATOR_ADDRESS,
-                    estimate,
-                    price,
-                ) else {
+                let Ok(b) = make_dev_acct_bundle(acc.enc_key().await, txn) else {
                     warn!("failed to generate dev account bundle");
                     continue;
                 };
                 b
             } else {
-                // create a bundle for next `interval.tick()`, then send this bundle to each node
                 let Ok(b) = make_bundle(acc.enc_key().await) else {
                     warn!("failed to generate bundle");
                     continue;
@@ -145,6 +129,36 @@ impl Yapper {
         }
     }
 
+    async fn prepare_txn(p: &RootProvider, chain_id: u64) -> Result<TxInfo> {
+        let nonce = p.get_transaction_count(DEV_ACCT_ADDRESS).await?;
+        let tx = TransactionRequest::default()
+            .with_chain_id(chain_id)
+            .with_nonce(nonce)
+            .with_from(DEV_ACCT_ADDRESS)
+            // Just choosing an address that already exists on the chain
+            .with_to(VALIDATOR_ADDRESS)
+            .with_value(U256::from(1));
+
+        let gas_limit = p
+            .estimate_gas(tx)
+            .await
+            .with_context(|| "failed to estimate gas")?;
+
+        let base_fee = p
+            .get_gas_price()
+            .await
+            .with_context(|| "failed to get gas price")?;
+
+        Ok(TxInfo {
+            chain_id,
+            nonce,
+            to: VALIDATOR_ADDRESS,
+            gas_limit,
+            base_fee,
+            signer: PrivateKeySigner::from_str(DEV_ACCT_PRIV_KEY)?,
+        })
+    }
+
     async fn send_bundle_to_node(
         &self,
         bundle: &BundleVariant,