libeufin

bench.rs (20838B)

---

 /*
 * This file is part of LibEuFin.
 * Copyright (C) 2026 Taler Systems S.A.
 
 * LibEuFin is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation; either version 3, or
 * (at your option) any later version.
 
 * LibEuFin is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General
 * Public License for more details.
 
 * You should have received a copy of the GNU Affero General Public
 * License along with LibEuFin; see the file COPYING.  If not, see
 * <http://www.gnu.org/licenses/>
 */
 
 use std::fmt::Write as _;
 
 use aws_lc_rs::signature::{Ed25519KeyPair, KeyPair as _};
 use axum::http::header::AUTHORIZATION;
 use compact_str::{CompactString, format_compact};
 use jiff::{Timestamp, Zoned, tz::TimeZone};
 use sqlx::postgres::PgConnectOptions;
 use taler_common::{
     api::{
         EddsaPublicKey, EddsaSignature, HashCode, ShortHashCode,
         prepared::{PublicKeyAlg, RegistrationRequest, TransferType, Unregistration},
         wire::TransferResponse,
     },
     bench::{Bench, h16, h32, h64},
     encoding::hex,
     error_code::ErrorCode,
     types::{
         amount::{Amount, Currency},
         time::TalerTimestamp,
     },
 };
 use taler_macros::db_test;
 use taler_test_utils::{json, server::TestServer};
 use uuid::Uuid;
 
 use crate::{
     api::{
         account::RegisterAccountResponse,
         cashout::CashoutResponse,
         conversion::ConversionRateClassResponse,
         tan::ChallengeResponse,
         test::{bank_setup, tan_code},
         token::TokenSuccessResponse,
         tx::TransactionCreateResponse,
         withdrawal::BankAccountCreateWithdrawalResponse,
     },
     db::gc::collect,
     pw::PwCrypto,
 };
 
 #[db_test(raw)]
 pub async fn bench_db(db: PgConnectOptions) {
     let mut ctx = bank_setup(db).await;
     let mut b = Bench::new(&ctx.state.db);
     // Skip 4 accounts created by bank_setup
     let skip = 4;
     // Customer account will be used in tests so we want to generate more data for him
     let customer = 3;
     let exchange = 2;
     // In general half of the data is for generated account and half is for customer
     let mid = b.amount / 2;
 
     let password = PwCrypto::Bcrypt { cost: 4 }.hashpw("password");
     let accounts_pubs: Vec<_> = (0..b.amount * 2)
         .map(|_| {
             let key_pair = Ed25519KeyPair::generate().unwrap();
             let pub_key = EddsaPublicKey::try_from(key_pair.public_key().as_ref()).unwrap();
             (key_pair, pub_key)
         })
         .collect();
 
     b.table(
         "customers(username, name, password_hash, cashout_payto)",
         |f, i| {
             writeln!(
                 f,
                 "account_{i}\t{password}\tMr n°{i}\t{}",
                 ctx.unknown_payto
             )
         },
     )
     .await;
     b.table("conversion_rate_classes(name)", |f, i| {
         writeln!(f, "Class n°{i}")
     })
     .await;
     b.table(
         "bank_accounts(internal_payto,owning_customer_id,is_public,conversion_rate_class_id)",
         |f, i| {
             let id = match i % 5 {
                 0 => "\\N",
                 1 | 2 => "1",
                 3 => "2",
                 _ => &(i % 10).to_string(),
             };
             writeln!(
                 f,
                 "payto://x-taler-bank/localhost/account_{i}\t{}\t{}\t{id}",
                 i + skip,
                 i % 3 == 0
             )
         },
     )
     .await;
     b.table(
         "bearer_tokens(content, creation_time, expiration_time, scope, is_refreshable, bank_customer, description, last_access)",
         |f, i| {
             let account =  if i > mid { customer} else {i+4};
             writeln!(
                 f,
                 "\\\\x{}\t0\t0\treadonly\tfalse\t{account}\t\\N\t0",
                h32(),
             )
         },
     )
     .await;
     b.table(
         "bank_account_transactions(creditor_payto, creditor_name, debtor_payto, debtor_name, subject, amount, transaction_date, direction, bank_account_id)",
         |f, i| {
                    let account =  if i > mid { customer} else {i+4};
             writeln!(
                 f,
                 "{}\tcreditor_name\t{}\tdebtor_name\tsubject\t(42,0)\t0\tcredit\t{exchange}",
                 ctx.unknown_payto, ctx.unknown_payto
             )?;
             writeln!(
                 f,
                 "{}\tcreditor_name\t{}\tdebtor_name\tsubject\t(42,0)\t0\tdebit\t{account}",
                 ctx.unknown_payto, ctx.unknown_payto
             )
         },
     )
     .await;
     b.table("bank_transaction_operations", |f, i| {
         writeln!(f, "\\\\x{}\t{i}", h32())
     })
     .await;
     b.table("tan_challenges(uuid, hbody, salt, op, code, creation_date, expiration_date, retry_counter, customer, tan_channel, tan_info)", |f, i| {
          let account =  if i > mid { customer} else {i+4};
                 writeln!(f, "{}\t\\\\x{}\t\\\\x{}\taccount_reconfig\tcode\t0\t0\t0\t{account}\tsms\tinfo",  Uuid::new_v4(),  h64(), h16())
     })
     .await;
     b.table("taler_withdrawal_operations(withdrawal_uuid, wallet_bank_account, reserve_pub, creation_date)", |f, i| {
          let account =  if i > mid { customer} else {i+4};
                 writeln!(f, "{}\t{account}\t\\\\x{}\t0",  Uuid::new_v4(),  h32())
     })
     .await;
     b.table("prepared_transfers(type, account_pub, authorization_pub, authorization_sig, recurrent, registered_at, bank_transaction_id)", |f, i| {
         let ty = if i%2==0 {"reserve"} else {"kyc"};
         let recurrent = if i%3 == 0 {"true" } else {"false"};
         let incoming_transaction_id = if i % 5 == 0 { CompactString::const_new("\\N") }else {format_compact!("{}", i*2)};
 
         let key = hex::encode( accounts_pubs[i].1.as_ref());
         let sig =  h64();
         writeln!(f, "{ty}\t\\\\x{key}\t\\\\x{key}\t\\\\x{sig}\t{recurrent}\t0\t{incoming_transaction_id}")
     }).await;
     b.table(
         "pending_recurrent_incoming_transactions(bank_transaction_id, debtor_account_id, authorization_pub)",
         |f, i| {
             let key = hex::encode(accounts_pubs[i].1.as_ref());
             writeln!(f, "{}\t{i}\t\\\\x{key}", i * 2)
         },
     )
     .await;
     b.table("taler_exchange_outgoing(bank_transaction)", |f, i| {
         writeln!(f, "{}", i * 2 - 1)
     })
     .await;
     b.table("transfer_operations(wtid, request_uid, amount, exchange_base_url, exchange_outgoing_id, exchange_id, transfer_date, creditor_payto, status, status_msg)", |f, i| {
         if i % 2 == 0 {
             writeln!(f, "\\\\x{}\t\\\\x{}\t(42, 0)\thttps://url\t{i}\t{i}\t0\tpayto://x-taler-bank/localhost/10\tsuccess\t\\N", h32(), h64())
         } else {
             writeln!(f, "\\\\x{}\t\\\\x{}\t(42, 0)\thttps://url\t\\N\t{i}\t0\tpayto://x-taler-bank/localhost/10\tpermanent_failure\tfailure", h32(), h64())
         }
     })
     .await;
     b.table(
         "taler_exchange_incoming(type, metadata, bank_transaction)",
         |f, i| {
             let hex = h32();
             let ty = if i % 2 == 0 { "reserve" } else { "kyc" };
             writeln!(f, "{ty}\t\\\\x{hex}\t{}", i * 2)
         },
     )
     .await;
     b.table("bank_stats(timeframe, start_time)", |f, i| {
         writeln!(
             f,
             "day\t{}",
             Zoned::new(Timestamp::from_second(i as i64).unwrap(), TimeZone::UTC).datetime()
         )
     })
     .await;
     b.table("cashout_operations(request_uid,amount_debit,amount_credit,subject,creation_time,bank_account,local_transaction)", |f, i| {
            let account =  if i > mid { customer} else {i+4};
         writeln!(f, "\\\\x{}\t(0,0)\t(0,0)\tsubject\t0\t{account}\t{i}", h32())
     })
     .await;
 
     // Prepare customer accounts
     ctx.fill_cashout_info("customer").await;
     ctx.set_max_debt("customer", "1000000").await;
 
     // Accounts
     let mut names = Vec::new();
     b.measure("account_create", async |i| {
         let username = format!("account_bench_{i}");
         ctx.post("/accounts")
             .json(json!({
                 "username": username,
                 "password": format!("account_bench_{i}-password"),
                 "name": format!("Bench Account {i}")
             }))
             .await
             .assert_ok_json::<RegisterAccountResponse>();
         names.push(username);
     })
     .await;
     ctx.client
         .cache_tokens(&names.iter().map(|it| it.as_str()).collect::<Vec<_>>())
         .await;
     b.measure("account_reconfig", async |i| {
         ctx.patcha(format!("/accounts/account_bench_{i}"))
             .json(json!({
                 "name": format!("New Bench Account {i}")
             }))
             .await
             .assert_no_content();
     })
     .await;
     b.measure("account_reconfig_auth", async |i| {
         ctx.patcha(format!("/accounts/account_bench_{i}/auth"))
             .json(json!({
                 "old_password": format!("account_bench_{i}-password"),
                 "new_password": format!("account_bench_{i}-password"),
             }))
             .await
             .assert_no_content();
     })
     .await;
     b.measure("account_list", async |_| {
         ctx.get_admin("/accounts").await.assert_ok()
     })
     .await;
     b.measure("account_list_class", async |i| {
         ctx.get_admin(format!("/accounts?conversion_rate_class={}", i % 10))
             .await
             .assert_ok()
     })
     .await;
     b.measure("account_list_name", async |_| {
         ctx.get_admin("/accounts?name=Mr").await.assert_ok()
     })
     .await;
     b.measure("account_list_public", async |_| {
         ctx.get("/public-accounts").await.assert_ok()
     })
     .await;
     b.measure("account_get", async |i| {
         ctx.geta(format!("/accounts/account_bench_{i}"))
             .await
             .assert_ok()
     })
     .await;
 
     // Token
     let mut t = Vec::new();
     b.measure("token_create", async |_| {
         t.push(
             ctx.postpw("/accounts/customer/token")
                 .json(json!({
                     "scope": "readonly",
                     "refreshable": true
                 }))
                 .await
                 .assert_ok_json::<TokenSuccessResponse>()
                 .access_token,
         )
     })
     .await;
     b.measure("token_refresh", async |i| {
         ctx.post("/accounts/customer/token")
             .header(AUTHORIZATION, format!("Bearer {}", t[i]))
             .json(json!({
                 "scope": "readonly"
             }))
             .await
             .assert_ok()
     })
     .await;
     b.measure("token_list", async |_| {
         ctx.geta("/accounts/customer/tokens").await.assert_ok()
     })
     .await;
     b.measure("token_delete", async |i| {
         ctx.delete("/accounts/customer/token")
             .header(AUTHORIZATION, format!("Bearer {}", t[i]))
             .await
             .assert_no_content();
     })
     .await;
 
     // Conversion rate classes
     let mut c = Vec::new();
     b.measure("class_create", async |i| {
         c.push(
             ctx.post_admin("/conversion-rate-classes")
                 .json(json!({
                     "name": format!("Gen class {i}")
                 }))
                 .await
                 .assert_ok_json::<ConversionRateClassResponse>()
                 .conversion_rate_class_id,
         )
     })
     .await;
     b.measure("class_patch", async |i| {
         ctx.patch_admin(format!("/conversion-rate-classes/{}", c[i]))
             .json(json!({
                 "name": format!("Gen class {i}"),
                 "description": format!("test {i}")
             }))
             .await
             .assert_no_content()
     })
     .await;
     b.measure("class_get", async |i| {
         ctx.get_admin(format!("/conversion-rate-classes/{}", c[i]))
             .await
             .assert_ok()
     })
     .await;
     b.measure("class_list", async |_| {
         ctx.get_admin("/conversion-rate-classes").await.assert_ok()
     })
     .await;
     b.measure("class_delete", async |i| {
         ctx.delete_admin(format!("/conversion-rate-classes/{}", c[i]))
             .await
             .assert_no_content()
     })
     .await;
 
     // Transaction
     let mut tx = Vec::new();
     b.measure("transaction_create", async |_| {
         tx.push(
             ctx.posta("/accounts/customer/transactions")
                 .json(json!({
                     "payto_uri": format!("{}?receiver-name=Test&message=payout", ctx.merchant_payto),
                     "amount": "KUDOS:0.001"
                 }))
                 .await
                 .assert_ok_json::<TransactionCreateResponse>()
                 .row_id,
         )
     })
     .await;
     b.measure("transaction_get", async |i| {
         ctx.geta(format!("/accounts/customer/transactions/{}", tx[i]))
             .await
             .assert_ok()
     })
     .await;
     b.measure("transaction_history", async |_| {
         ctx.geta("/accounts/customer/transactions")
             .await
             .assert_ok()
     })
     .await;
     b.measure("transaction_revenue", async |_| {
         ctx.geta("/accounts/merchant/taler-revenue/history")
             .await
             .assert_ok()
     })
     .await;
 
     // Withdrawal
     let mut w = Vec::new();
     b.measure("withdrawal_create", async |_| {
         w.push(
             ctx.posta("/accounts/customer/withdrawals")
                 .json(json!({
                     "amount": "KUDOS:0.0001"
                 }))
                 .await
                 .assert_ok_json::<BankAccountCreateWithdrawalResponse>()
                 .withdrawal_id,
         )
     })
     .await;
     b.measure("withdrawal_get", async |i| {
         ctx.get(format!("/withdrawals/{}", w[i])).await.assert_ok()
     })
     .await;
     b.measure("withdrawal_status", async |i| {
         ctx.get(format!("/taler-integration/withdrawal-operation/{}", w[i]))
             .await
             .assert_ok()
     })
     .await;
     b.measure("withdrawal_select", async |i| {
         ctx.post(format!("/taler-integration/withdrawal-operation/{}", w[i]))
             .json(json!({
                 "reserve_pub": &EddsaPublicKey::rand(),
                 "selected_exchange": &ctx.exchange_payto
             }))
             .await
             .assert_ok()
     })
     .await;
     b.measure("withdrawal_confirm", async |i| {
         ctx.posta(format!("/accounts/customer/withdrawals/{}/confirm", w[i]))
             .json(json!({}))
             .await
             .assert_no_content()
     })
     .await;
     b.measure("withdrawal_abort", async |i| {
         ctx.posta(format!("/accounts/customer/withdrawals/{}/abort", w[i]))
             .await
             .assert_error(ErrorCode::BANK_ABORT_CONFIRM_CONFLICT);
     })
     .await;
 
     // Cashout
     let mut c = Vec::new();
     b.measure("cashout_create", async |_| {
         c.push(
             ctx.posta("/accounts/customer/cashouts")
                 .json(json!({
                     "request_uid":  ShortHashCode::rand(),
                     "amount_debit": "KUDOS:0.1",
                     "amount_credit": &ctx.convert("KUDOS:0.1").await
                 }))
                 .await
                 .assert_ok_json::<CashoutResponse>()
                 .cashout_id,
         )
     })
     .await;
     b.measure("cashout_get", async |i| {
         ctx.geta(format!("/accounts/customer/cashouts/{}", c[i]))
             .await
             .assert_ok()
     })
     .await;
     b.measure("cashout_history", async |_| {
         ctx.geta("/accounts/customer/cashouts").await.assert_ok()
     })
     .await;
     b.measure("cashout_history_admin", async |_| {
         ctx.get_admin("/cashouts").await.assert_ok()
     })
     .await;
 
     // Wire gateway
     let mut t = Vec::new();
     b.measure("wg_transfer", async |_| {
         t.push(
             ctx.posta("/accounts/exchange/taler-wire-gateway/transfer")
                 .json(json!({
                     "request_uid": HashCode::rand(),
                     "amount": "KUDOS:0.0001",
                     "exchange_base_url": "http://exchange.example.com/",
                     "wtid": ShortHashCode::rand(),
                     "credit_account": &ctx.customer_payto
                 }))
                 .await
                 .assert_ok_json::<TransferResponse>()
                 .row_id,
         )
     })
     .await;
     b.measure("wg_transfer_get", async |i| {
         ctx.geta(format!(
             "/accounts/exchange/taler-wire-gateway/transfers/{}",
             t[i]
         ))
         .await
         .assert_ok()
     })
     .await;
     b.measure("wg_transfer_page", async |_| {
         ctx.geta("/accounts/exchange/taler-wire-gateway/transfers")
             .await
             .assert_ok()
     })
     .await;
     b.measure("wg_transfer_page_filter", async |_| {
         ctx.geta("/accounts/exchange/taler-wire-gateway/transfers?status=success")
             .await
             .assert_ok()
     })
     .await;
     b.measure("wg_add", async |_| {
         ctx.posta("/accounts/exchange/taler-wire-gateway/admin/add-incoming")
             .json(json!({
                 "amount": "KUDOS:0.0001",
                 "reserve_pub": EddsaPublicKey::rand(),
                 "debit_account": &ctx.customer_payto
             }))
             .await
             .assert_ok()
     })
     .await;
     b.measure("wg_incoming", async |_| {
         ctx.geta("/accounts/exchange/taler-wire-gateway/history/incoming")
             .await
             .assert_ok()
     })
     .await;
     b.measure("wg_outgoing", async |_| {
         ctx.geta("/accounts/exchange/taler-wire-gateway/history/outgoing")
             .await
             .assert_ok()
     })
     .await;
 
     // TAN challenges
     let mut c = Vec::new();
     b.measure("tan_send", async |i| {
         let res = ctx
             .patcha(format!("/accounts/account_bench_{i}"))
             .json(json!({
                 "contact_data" : {
                     "phone": "+99",
                     "email": "email@example.com"
                 },
                 "tan_channel": "sms"
             }))
             .await
             .assert_accepted_json::<ChallengeResponse>();
         let challenge = &res.challenges[0];
         ctx.posta(format!(
             "/accounts/account_bench_{i}/challenge/{}",
             challenge.challenge_id
         ))
         .await
         .assert_ok();
         let code = tan_code(&challenge.tan_info);
         c.push((challenge.challenge_id.clone(), code))
     })
     .await;
     b.measure("tan_confirm", async |i| {
         let (id, code) = &c[i];
         ctx.posta(format!(
             "/accounts/account_bench_{i}/challenge/{id}/confirm"
         ))
         .json(json!({
             "tan": code
         }))
         .await
         .assert_no_content();
     })
     .await;
 
     // Revenue api
     b.measure("transaction_revenue", async |_| {
         ctx.geta("/accounts/exchange/taler-revenue/history")
             .await
             .assert_ok()
     })
     .await;
 
     // Wire transfer
     b.measure("wt_register", async |i| {
         let (pair, key) = &accounts_pubs[i];
         let req = RegistrationRequest {
             credit_account: ctx.exchange_payto.as_uri(),
             r#type: TransferType::reserve,
             recurrent: false,
             credit_amount: Amount::new(&Currency::KUDOS, 55, 0),
             alg: PublicKeyAlg::EdDSA,
             account_pub: *key,
             authorization_pub: *key,
             authorization_sig: EddsaSignature::ZEROED,
         }
         .signed(pair);
         for _ in 0..2 {
             ctx.post("/taler-prepared-transfer/registration")
                 .json(&req)
                 .await
                 .assert_ok()
         }
     })
     .await;
     b.measure("wt_unregister", async |i| {
         let (pair, key) = &accounts_pubs[i];
         let req = Unregistration {
             timestamp: TalerTimestamp::Timestamp(Timestamp::now()),
             authorization_pub: *key,
             authorization_sig: EddsaSignature::ZEROED,
         }
         .signed(pair);
         ctx.post("/taler-prepared-transfer/unregistration")
             .json(&req)
             .await
             .assert_no_content();
         ctx.post("/taler-prepared-transfer/unregistration")
             .json(&req)
             .await
             .assert_error(ErrorCode::BANK_TRANSACTION_NOT_FOUND);
     })
     .await;
 
     // Delete accounts
     b.measure("account_delete", async |i| {
         ctx.deletea(format!("/accounts/account_bench_{i}"))
             .await
             .assert_no_content()
     })
     .await;
 
     // Other
     b.measure("monitor", async |_| {
         ctx.get_admin("/monitor").await.assert_ok();
     })
     .await;
     let now = Timestamp::MIN;
     collect(&ctx.state.db, &now, &now, &now).await.unwrap();
     b.measure("gc", async |_| {
         collect(&ctx.state.db, &now, &now, &now).await.unwrap();
     })
     .await;
 }