benchmark tool injecting the native tokens txs bypassing the json-rpc

Cargo.toml

@@ -20,6 +20,7 @@ exclude = ["neard"]
 [workspace]
 resolver = "2"
 members = [
+    "benchmarks/transactions-generator",
     "chain/chain",
     "chain/chunks",
     "chain/client",
@@ -270,6 +271,7 @@ near-schema-checker-macro = { path = "core/schema-checker/schema-checker-macro"
 near-schema-checker-core = { path = "core/schema-checker/schema-checker-core" }
 near-schema-checker-lib = { path = "core/schema-checker/schema-checker-lib" }
 near-store = { path = "core/store" }
+near-transactions-generator = { path = "benchmarks/transactions-generator"}
 near-telemetry = { path = "chain/telemetry" }
 near-test-contracts = { path = "runtime/near-test-contracts" }
 near-time = { path = "core/time" }

benchmarks/transactions-generator/.gitignore

@@ -0,0 +1,3 @@
+.near/
+neard
+user-data/

benchmarks/transactions-generator/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "near-transactions-generator"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[features]
+default = ["with_actix"]
+with_actix = ["near-async", "near-network", "actix"]
+
+[dependencies]
+actix = { workspace = true, optional = true }
+anyhow.workspace = true
+near-async = {workspace = true, optional = true }
+near-crypto = { workspace = true }
+near-network = { workspace = true, optional = true }
+near-primitives = { workspace = true, features = ["clock", "test_utils"] }
+near-client.workspace = true
+near-client-primitives.workspace = true
+
+rand.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+tokio = { workspace = true, features = ["full"] }
+tracing = { workspace = true, features = ["std"] }
+
+
+[lints]
+workspace = true

benchmarks/transactions-generator/justfile

@@ -0,0 +1,23 @@
+script_dir := `pwd`
+neard := script_dir / "./neard"
+near_localnet_home := script_dir / ".near/"
+rpc_url := "http://127.0.0.1:3030"
+
+init_localnet:
+    rm -rf {{near_localnet_home}} && {{neard}} --home {{near_localnet_home}} init --chain-id localnet
+
+run_localnet:
+    {{neard}} --home {{near_localnet_home}} run
+
+create_sub_accounts:
+    RUST_LOG=info \
+    ../synth-bm/target/release/near-synth-bm create-sub-accounts \
+        --rpc-url {{rpc_url}} \
+        --signer-key-path {{near_localnet_home}}/validator_key.json \
+        --nonce 1 \
+        --sub-account-prefix 'a' \
+        --num-sub-accounts 100 \
+        --deposit 953060601875000000010000 \
+        --channel-buffer-size 1200 \
+        --requests-per-second 1250 \
+        --user-data-dir user-data

benchmarks/transactions-generator/src/account.rs

@@ -0,0 +1,72 @@
+use near_primitives::types::AccountId;
+use near_crypto::{PublicKey, SecretKey, InMemorySigner, Signer};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::Path;
+use anyhow::Context;
+
+
+#[derive(Serialize, Deserialize, Clone, Debug) ]
+pub struct Account {
+    #[serde(rename = "account_id")]
+    pub id: AccountId,
+    pub public_key: PublicKey,
+    pub secret_key: SecretKey,
+    // New transaction must have a nonce bigger than this.
+    pub nonce: u64,
+}
+
+impl Account {
+    pub fn new(id: AccountId, secret_key: SecretKey, nonce: u64) -> Self {
+        Self { id, public_key: secret_key.public_key(), secret_key, nonce }
+    }
+
+    pub fn from_file(path: &Path) -> anyhow::Result<Account> {
+        let content = fs::read_to_string(path)?;
+        let account = serde_json::from_str(&content)
+            .with_context(|| format!("failed reading file {path:?} as 'Account'"))?;
+        Ok(account)
+    }
+
+    pub fn write_to_dir(&self, dir: &Path) -> anyhow::Result<()> {
+        if !dir.exists() {
+            std::fs::create_dir(dir)?;
+        }
+
+        let json = serde_json::to_string(self)?;
+        let mut file_name = self.id.to_string();
+        file_name.push_str(".json");
+        let file_path = dir.join(file_name);
+        fs::write(file_path, json)?;
+        Ok(())
+    }
+
+    pub fn as_signer(&self) -> Signer {
+        Signer::from(InMemorySigner::from_secret_key(self.id.clone(), self.secret_key.clone()))
+    }
+} // impl Account
+
+/// Tries to deserialize all json files in `dir` as [`Account`].
+pub fn accounts_from_dir(dir: &Path) -> anyhow::Result<Vec<Account>> {
+    if !dir.is_dir() {
+        anyhow::bail!("{:?} is not a directory", dir);
+    }
+
+    let mut accounts = vec![];
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let file_type = entry.file_type()?;
+        if !file_type.is_file() {
+            continue;
+        }
+        let path = entry.path();
+        let file_extension = path.extension();
+        if file_extension.is_none() || file_extension.unwrap() != "json" {
+            continue;
+        }
+        let account = Account::from_file(&path)?;
+        accounts.push(account);
+    }
+
+    Ok(accounts)
+}

benchmarks/transactions-generator/src/actix_actor.rs

@@ -0,0 +1,51 @@
+use crate::{TxGenerator, TxGeneratorConfig, ClientSender, ViewClientSender};
+
+use actix::Actor;
+use near_async::actix_wrapper::ActixWrapper;
+use near_async::futures::DelayedActionRunner;
+use near_async::messaging::{self};
+
+
+pub type TxGeneratorActor = ActixWrapper<GeneratorActorImpl>;
+
+pub struct GeneratorActorImpl {
+    tx_generator: TxGenerator,
+}
+
+impl messaging::Actor for GeneratorActorImpl {
+    fn start_actor(&mut self, ctx: &mut dyn DelayedActionRunner<Self>){
+        self.start(ctx)
+    }
+}
+
+impl GeneratorActorImpl {
+    pub fn start(&mut self, _ctx: &mut dyn DelayedActionRunner<Self>){
+        match self.tx_generator.start() {
+            Err(err) => {
+                tracing::error!(target: "transaction-generator", "Error: {err}");
+            },
+            Ok(_) => {
+                tracing::info!(target: "transaction-generator",
+                    tps=self.tx_generator.params.tps, "Started");
+            }
+        };
+    }
+}
+
+pub fn start_tx_generator(
+    config: TxGeneratorConfig,
+    client_sender: ClientSender,
+    view_client_sender: ViewClientSender,
+)-> actix::Addr<TxGeneratorActor> 
+{
+    let arbiter = actix::Arbiter::new();
+    let tx_generator = TxGenerator::new(config, client_sender, view_client_sender).unwrap();
+    TxGeneratorActor::start_in_arbiter(&arbiter.handle(),
+        move |_| {
+            let actor_impl = GeneratorActorImpl {
+                tx_generator,
+            };
+            ActixWrapper::new(actor_impl)
+        }
+    )
+}