feat(coprocessor): implement additional stress-test scenarios

- add Transaction::ERC7984Transfer
- add a simplified variant of the auction::submitEncryptedBids
- add sample json data files

Author: goshawk-3

coprocessor/fhevm-engine/stress-test-generator/data/json/minitest_002_erc20.json

@@ -9,8 +9,8 @@
         "user_address": "0xa0534e99d86F081E8D3868A8C4732C8f65dfdB07",
         "scenario": [
             [
-                20.0,
-                120
+                1.0,
+                1
             ]
         ]
     }

coprocessor/fhevm-engine/stress-test-generator/src/bin/stress_generator.rs

@@ -9,7 +9,7 @@ use fhevm_engine_common::utils::DatabaseURL;
 use host_listener::database::tfhe_event_propagate::{Database as ListenerDatabase, Handle};
 
 use sqlx::Postgres;
-use std::io::Write;
+use std::{cmp::min, io::Write};
 use std::{collections::HashMap, fmt, sync::atomic::AtomicU64};
 use std::{
     ops::{Add, Sub},
@@ -19,16 +19,25 @@ use std::{
     sync::atomic::Ordering,
     time::{Duration, SystemTime},
 };
-use stress_test_generator::utils::{
-    default_dependence_cache_size, get_ciphertext_digests, Dependence, GeneratorKind, Transaction,
+use stress_test_generator::{
+    args::parse_args, dex::dex_swap_claim_transaction, utils::new_transaction_id,
+};
+use stress_test_generator::{
+    auction::batch_submit_encrypted_bids,
+    zk_gen::{generate_input_verification_transaction, get_inputs_vector},
 };
-use stress_test_generator::zk_gen::{generate_input_verification_transaction, get_inputs_vector};
-use stress_test_generator::{args::parse_args, dex::dex_swap_claim_transaction};
 use stress_test_generator::{
     dex::dex_swap_request_transaction,
     erc20::erc20_transaction,
     utils::{EnvConfig, Job, Scenario},
 };
+use stress_test_generator::{
+    erc7984,
+    utils::{
+        allow_handles, default_dependence_cache_size, get_ciphertext_digests, next_random_handle,
+        Dependence, GeneratorKind, Transaction, DEF_TYPE,
+    },
+};
 use stress_test_generator::{
     synthetics::{
         add_chain_transaction, generate_pub_decrypt_handles_types,
@@ -41,6 +50,7 @@ use tokio_util::sync::CancellationToken;
 use tracing::{error, info, warn};
 
 const MAX_RETRIES: usize = 500;
+const MAX_NUMBER_OF_BIDS: usize = 10;
 
 #[tokio::main]
 async fn main() {
@@ -56,6 +66,7 @@ async fn main() {
         args: args.clone(),
         ecfg: EnvConfig::new(),
         cancel_token: CancellationToken::new(),
+        inputs_pool: vec![],
     };
 
     if args.run_server {
@@ -584,7 +595,52 @@ async fn generate_transaction(
         },
     };
 
+    let mut new_ctx = ctx.clone();
+    new_ctx.inputs_pool = inputs.clone();
+    let ctx = &new_ctx;
+
     match scenario.transaction {
+        Transaction::BatchSubmitEncryptedBids => {
+            let batch_size = min(MAX_NUMBER_OF_BIDS, scenario.batch_size.unwrap_or(1));
+
+            // reuse the existing inputs as bids
+            let bids = inputs
+                .iter()
+                .take(batch_size)
+                .copied()
+                .collect::<Vec<Option<Handle>>>();
+
+            let e_total_payment = batch_submit_encrypted_bids(
+                ctx,
+                listener_event_to_db,
+                None, // Transaction ID
+                &scenario.contract_address,
+                &scenario.user_address,
+                &bids,
+            )
+            .await?;
+
+            // TODO: how to make dependent if needed?
+            Ok((e_total_payment, e_total_payment)) // TODO: return meaningful second handle
+        }
+        Transaction::BatchAllowHandles => {
+            let mut handles = Vec::new();
+            for _ in 0..scenario.batch_size.unwrap_or(1) {
+                handles.push(next_random_handle(DEF_TYPE).to_vec());
+            }
+
+            info!(target: "tool", batch_size = handles.len(), "Batch allowing handles");
+
+            allow_handles(
+                &handles,
+                fhevm_engine_common::types::AllowEvents::AllowedAccount,
+                scenario.user_address.to_string(),
+                pool,
+                true,
+            )
+            .await?;
+            Ok((Handle::default(), Handle::default()))
+        }
         Transaction::ERC20Transfer => {
             let (_, output_dependence) = erc20_transaction(
                 ctx,
@@ -712,5 +768,24 @@ async fn generate_transaction(
             .await?;
             Ok((output_dependence1, output_dependence2))
         }
+        Transaction::ERC7984Transfer => {
+            let transaction_id = new_transaction_id();
+            let e_amount = inputs
+                .first()
+                .unwrap()
+                .expect("should be at least one input available");
+
+            info!(target: "tool", "ERC7984 Transaction: tx_id: {:?}", transaction_id);
+            let e_total_paid = erc7984::confidential_transfer_from(
+                ctx,
+                transaction_id,
+                listener_event_to_db,
+                e_amount,
+                scenario.user_address.as_str(),
+            )
+            .await?;
+
+            Ok((e_total_paid, e_total_paid))
+        }
     }
 }

coprocessor/fhevm-engine/stress-test-generator/src/erc20.rs

@@ -7,8 +7,8 @@ use sqlx::Postgres;
 use tracing::{error, info};
 
 use crate::utils::{
-    allow_handle, insert_tfhe_event, next_random_handle, tfhe_event, Context, ERCTransferVariant,
-    FheType, DEF_TYPE,
+    allow_handle, insert_tfhe_event, new_transaction_id, next_random_handle, tfhe_event, Context,
+    ERCTransferVariant, FheType, DEF_TYPE,
 };
 use crate::zk_gen::generate_random_handle_amount_if_none;
 
@@ -26,7 +26,7 @@ pub async fn erc20_transaction(
     user_address: &String,
 ) -> Result<(Handle, Handle), Box<dyn std::error::Error>> {
     let caller = user_address.parse().unwrap();
-    let transaction_id = transaction_id.unwrap_or(next_random_handle(DEF_TYPE));
+    let transaction_id = transaction_id.unwrap_or(new_transaction_id());
 
     info!(target: "tool", "ERC20 Transaction: tx_id: {:?}", transaction_id);
 

coprocessor/fhevm-engine/stress-test-generator/src/lib.rs

@@ -1,5 +1,7 @@
+pub mod auction;
 pub mod dex;
 pub mod erc20;
+pub mod erc7984;
 pub mod synthetics;
 pub mod utils;
 pub mod zk_gen;

coprocessor/fhevm-engine/stress-test-generator/src/utils.rs

@@ -63,28 +63,46 @@ pub fn next_random_handle(ct_type: FheType) -> Handle {
     handle_hash.update(rand::rng().random::<u64>().to_be_bytes());
     let mut handle = handle_hash.finalize().to_vec();
     assert_eq!(handle.len(), 32);
+
+    // Mark it as a mocked handle
+    handle[0..3].copy_from_slice(&[0u8; 3]);
+
     // Handle from computation
     handle[21] = 255u8;
     handle[22..30].copy_from_slice(&ecfg.chain_id.to_be_bytes());
     handle[30] = ct_type as u8;
     handle[31] = 0u8;
     Handle::from_slice(&handle)
 }
+
+pub fn new_transaction_id() -> Handle {
+    let mut handle_hash = Keccak256::new();
+    handle_hash.update(rand::rng().random::<u64>().to_be_bytes());
+    let mut txn_id = handle_hash.finalize().to_vec();
+    assert_eq!(txn_id.len(), 32);
+    // Mark it as a mocked transaction id
+    txn_id[0..11].copy_from_slice(&[0u8; 11]);
+    Handle::from_slice(&txn_id)
+}
 pub fn default_dependence_cache_size() -> u16 {
     128
 }
 
 #[derive(Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, Clone)]
 pub enum Transaction {
     ERC20Transfer,
+    ERC7984Transfer,
     DEXSwapRequest,
     DEXSwapClaim,
     MULChain,
     ADDChain,
     InputVerif,
     GenPubDecHandles,
     GenUsrDecHandles,
+    BatchAllowHandles,
+    BatchSubmitEncryptedBids,
 }
+
 #[derive(Debug, serde::Deserialize, serde::Serialize, Eq, PartialEq, Clone)]
 pub enum ERCTransferVariant {
     Whitepaper,
@@ -118,6 +136,7 @@ pub struct Scenario {
     pub contract_address: String,
     pub user_address: String,
     pub scenario: Vec<(f64, u64)>,
+    pub batch_size: Option<usize>,
 }
 
 pub struct Job {
@@ -131,6 +150,8 @@ pub struct Context {
     pub args: Args,
     pub ecfg: EnvConfig,
     pub cancel_token: tokio_util::sync::CancellationToken,
+    // Pre-generated inputs pool
+    pub inputs_pool: Vec<Option<Handle>>,
 }
 
 #[allow(dead_code)]
@@ -174,6 +195,7 @@ pub async fn allow_handles(
     event_type: AllowEvents,
     account_address: String,
     pool: &sqlx::Pool<Postgres>,
+    disable_pbs_computations: bool,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let ecfg = EnvConfig::new();
     let tenant_id = vec![ecfg.tenant_id; handles.len()];
@@ -190,6 +212,10 @@ pub async fn allow_handles(
     )
     .execute(pool)
     .await?;
+
+    if disable_pbs_computations {
+        return Ok(());
+    }
     let _query = sqlx::query!(
         "INSERT INTO pbs_computations(tenant_id, handle)
                  SELECT * FROM UNNEST($1::INTEGER[], $2::BYTEA[]) 
@@ -423,3 +449,7 @@ pub async fn insert_tfhe_event(
     tracing::debug!(target: "tool", duration = ?started_at.elapsed(), "TFHE event, db_query");
     Ok(())
 }
+
+pub async fn pool(listener_event_to_db: &ListenerDatabase) -> sqlx::Pool<Postgres> {
+    listener_event_to_db.pool.clone().read().await.clone()
+}