bin: txspammer (#236)

Author: BrycePy

based/Cargo.lock

@@ -0,0 +1,37 @@
+[package]
+edition.workspace = true
+name = "txspammer"
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+alloy-eips.workspace = true
+alloy-primitives.workspace = true
+alloy-rpc-types.workspace = true
+alloy-signer.workspace = true
+alloy-signer-local.workspace = true
+alloy-provider.workspace = true
+alloy-consensus.workspace = true
+
+bop-common.workspace = true
+bop-metrics.workspace = true
+clap.workspace = true
+eyre.workspace = true
+futures.workspace = true
+jsonrpsee.workspace = true
+op-alloy-rpc-types.workspace = true
+op-alloy-rpc-types-engine.workspace = true
+parking_lot.workspace = true
+reqwest.workspace = true
+reth-rpc-layer.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+tower.workspace = true
+tower-http.workspace = true
+tracing.workspace = true
+rand.workspace = true
+tokio-websockets = { version = "0.12.1", features = ["client", "openssl", "rand", "server"] }
+futures-util = "0.3.31"
+http.workspace = true

based/bin/txspammer/Cargo.toml

@@ -0,0 +1,121 @@
+use alloy_consensus::{SignableTransaction, TxEip1559, TxEnvelope};
+use alloy_eips::eip2718::Encodable2718;
+use alloy_primitives::{B256, Bytes, U256};
+use alloy_provider::{Provider, RootProvider};
+use alloy_rpc_types::AccessList;
+use alloy_signer::SignerSync;
+use alloy_signer_local::PrivateKeySigner;
+
+pub struct AccountGenerator {
+    current: U256,
+}
+
+impl AccountGenerator {
+    pub fn new(start: U256) -> Self {
+        Self { current: start }
+    }
+
+    pub fn next(&mut self) -> PrivateKeySigner {
+        let temp = self.current;
+        self.current += U256::from(1);
+        PrivateKeySigner::from_slice(temp.as_le_slice()).expect("something wrong with U256 to bytes conversion")
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TxSpec {
+    pub chain_id: u64,
+    pub gas_limit: u64,
+    pub max_fee_per_gas: u128,
+    pub max_priority_fee_per_gas: u128,
+    pub value: U256,
+}
+
+#[derive(Clone, Debug)]
+pub struct Account {
+    pub signer: PrivateKeySigner,
+    pub nonce: u64,
+    pub balance: U256,
+}
+
+impl Account {
+    pub fn new(signer: PrivateKeySigner) -> Self {
+        Self { signer, nonce: 0, balance: U256::ZERO }
+    }
+
+    pub async fn refresh_balance(&mut self, provider: &RootProvider) -> eyre::Result<U256> {
+        self.balance = provider.get_balance(self.signer.address()).await?;
+        Ok(self.balance)
+    }
+
+    pub async fn refresh_nonce(&mut self, provider: &RootProvider) -> eyre::Result<u64> {
+        self.nonce = provider.get_transaction_count(self.signer.address()).await?;
+        Ok(self.nonce)
+    }
+
+    pub async fn refresh(&mut self, provider: &RootProvider) -> eyre::Result<u64> {
+        self.refresh_balance(provider).await?;
+        self.refresh_nonce(provider).await?;
+        Ok(self.nonce)
+    }
+
+    pub async fn transfer(
+        &mut self,
+        to: &mut Account,
+        spec: &TxSpec,
+        provider: &RootProvider,
+        sequencer: &Option<RootProvider>,
+    ) -> eyre::Result<B256> {
+        let tx = TxEip1559 {
+            chain_id: spec.chain_id,
+            nonce: self.nonce,
+            gas_limit: spec.gas_limit,
+            max_fee_per_gas: spec.max_fee_per_gas,
+            max_priority_fee_per_gas: spec.max_priority_fee_per_gas,
+            to: to.signer.address().into(),
+            value: spec.value,
+            access_list: AccessList::default(),
+            input: Bytes::new(),
+        };
+
+        let sig = self.signer.sign_hash_sync(&tx.signature_hash()).unwrap();
+        let tx: TxEnvelope = tx.into_signed(sig).into();
+        let encoded = tx.encoded_2718();
+        let provider_to_use = sequencer.as_ref().unwrap_or(provider);
+        let _pending_tx = provider_to_use.send_raw_transaction(&encoded).await.unwrap();
+        self.nonce += 1;
+        self.balance -= spec.value + U256::from(spec.gas_limit) * U256::from(spec.max_fee_per_gas);
+        to.balance += spec.value;
+
+        Ok(*tx.tx_hash())
+    }
+
+    pub async fn _self_transfer(
+        &mut self,
+        spec: &TxSpec,
+        provider: &RootProvider,
+        sequencer: &Option<RootProvider>,
+    ) -> eyre::Result<B256> {
+        let tx = TxEip1559 {
+            chain_id: spec.chain_id,
+            nonce: self.nonce,
+            gas_limit: spec.gas_limit,
+            max_fee_per_gas: spec.max_fee_per_gas,
+            max_priority_fee_per_gas: spec.max_priority_fee_per_gas,
+            to: self.signer.address().into(),
+            value: spec.value,
+            access_list: AccessList::default(),
+            input: Bytes::new(),
+        };
+
+        let sig = self.signer.sign_hash_sync(&tx.signature_hash()).unwrap();
+        let tx: TxEnvelope = tx.into_signed(sig).into();
+        let encoded = tx.encoded_2718();
+        let provider_to_use = sequencer.as_ref().unwrap_or(provider);
+        let _pending_tx = provider_to_use.send_raw_transaction(&encoded).await.unwrap();
+        self.nonce += 1;
+        self.balance -= U256::from(spec.gas_limit) * U256::from(spec.max_fee_per_gas);
+
+        Ok(*tx.tx_hash())
+    }
+}

based/bin/txspammer/src/account.rs

@@ -0,0 +1,85 @@
+use std::path::PathBuf;
+
+use bop_common::config::{LoggingConfig, LoggingFlags};
+use clap::{Parser, command};
+use tracing::level_filters::LevelFilter;
+
+#[derive(Parser, Debug, Clone)]
+#[command(version, about, name = "based-txproxy")]
+pub struct TxSpammerArgs {
+    /// Root wallet private key
+    #[arg(
+        long = "root.private_key",
+        default_value = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+    )]
+    pub root_private_key: String,
+    /// Number of accounts to generate
+    #[arg(long = "num_accounts", default_value_t = 100)]
+    pub num_accounts: usize,
+    /// Throughput (tx/s)
+    #[arg(long = "throughput", default_value_t = 300)]
+    pub throughput: usize,
+    /// Funding amount per account (in ether)
+    #[arg(long = "funding_amount", default_value_t = 0.01)]
+    pub funding_amount: f64,
+
+    /// Value to transfer per transaction (in ether)
+    #[arg(long = "tx_value", default_value_t = 0.0000000000000001)]
+    pub tx_value: f64,
+    /// Gas limit per transaction
+    #[arg(long = "gas_limit", default_value_t = 21_000)]
+    pub gas_limit: u64,
+    /// Max fee per gas (in wei)
+    #[arg(long = "max_fee_per_gas", default_value_t = 1_000_000_000)]
+    pub max_fee_per_gas: u128,
+    /// Max priority fee per gas (in wei)
+    #[arg(long = "max_priority_fee_per_gas", default_value_t = 20)]
+    pub max_priority_fee_per_gas: u128,
+
+    /// Eth rpc url (http/ws)
+    #[arg(long = "eth_rpc.url", default_value = "http://127.0.0.1:8545")]
+    pub eth_rpc_url: String,
+    /// Sequencer URL (if specified, eth_sendRawTransaction will be sent to this URL)
+    #[arg(long = "sequencer.url")]
+    pub sequencer_url: Option<String>,
+    /// Frag stream URL (if specified, we can measure the e2e latency via the frag stream). Poll receipt using eth rpc
+    /// if not specified.
+    #[arg(long = "fragstream.url")]
+    pub fragstream_url: Option<String>,
+
+    /// Enable debug logging
+    #[arg(long)]
+    pub debug: bool,
+    /// Enable trace logging
+    #[arg(long)]
+    pub trace: bool,
+    /// Enable file logging
+    #[arg(long = "log.disable_file_logging", action = clap::ArgAction::SetFalse, default_value_t = true)]
+    pub file_logging: bool,
+    /// Prefix of log files
+    #[arg(long = "log.prefix", default_value = "bop-txproxy.log")]
+    pub log_prefix: String,
+    /// Path for log files
+    #[arg(long = "log.dir", default_value = "/tmp")]
+    pub log_dir: PathBuf,
+    /// Maximum number of log files
+    #[arg(long = "log.max_files", default_value_t = 100)]
+    pub log_max_files: usize,
+}
+
+impl From<&TxSpammerArgs> for LoggingConfig {
+    fn from(args: &TxSpammerArgs) -> Self {
+        Self {
+            level: args
+                .trace
+                .then_some(LevelFilter::TRACE)
+                .or(args.debug.then_some(LevelFilter::DEBUG))
+                .unwrap_or(LevelFilter::INFO),
+            flags: if args.file_logging { LoggingFlags::all() } else { LoggingFlags::StdOut },
+            prefix: args.file_logging.then(|| args.log_prefix.clone()),
+            max_files: args.log_max_files,
+            path: args.log_dir.clone(),
+            filters: None,
+        }
+    }
+}