libeufin

wire.rs (26202B)

---

 /*
 * 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::sync::Arc;
 
 use axum::{
     Json, Router,
     extract::State,
     response::{IntoResponse, NoContent, Response},
     routing::{get, post},
 };
 use jiff::Timestamp;
 use serde::Deserialize;
 use sqlx::PgPool;
 use taler_api::{
     api::Validation,
     constants::WIRE_GATEWAY_API_VERSION,
     error::{ApiResult, failure_code},
     extract::{Path, Query, Req},
     subject::{IncomingKey, fmt_in_subject},
 };
 use taler_common::{
     api::{
         params::{HistoryParams, Page, PageParams},
         wire::{
             AddIncomingRequest, AddIncomingResponse, AddKycauthRequest, AddMappedRequest,
             IncomingHistory, OutgoingHistory, TransferList, TransferRequest, TransferResponse,
             TransferState, WireConfig,
         },
     },
     error_code::ErrorCode,
     types::{amount::Amount, payto::PaytoURI},
 };
 
 use crate::{
     api::{BankState, IMPLEMENTATION},
     auth::{UserAdminAuth, WireRAuth, WireRWAuth},
     db::{
         account::check_info,
         exchange::{
             AddIncomingResult, TransferResult, add_incoming, incoming_history, outgoing_history,
             page_transfer, transfer, transfer_by_id,
         },
     },
     payto::BankPayto,
 };
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct TransferParams {
     #[serde(flatten)]
     pub page: PageParams,
     pub status: Option<TransferState>,
 }
 
 impl TransferParams {
     pub fn check(self) -> ApiResult<Transfer> {
         Ok(Transfer {
             page: self.page.check()?,
             status: self.status,
         })
     }
 }
 
 pub struct Transfer {
     pub page: Page,
     pub status: Option<TransferState>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct AccountCheckParams {
     pub account: BankPayto,
 }
 
 async fn admin_add_incoming(
     db: &PgPool,
     username: &str,
     amount: &Amount,
     debtor: &PaytoURI,
     metadata: &IncomingKey,
 ) -> ApiResult<Response> {
     let payto = BankPayto::try_from(debtor)?;
     match add_incoming(
         db,
         amount,
         &payto,
         &format!(
             "Admin incoming {}",
             fmt_in_subject(metadata.ty, &metadata.key)
         ),
         username,
         &Timestamp::now(),
         metadata,
     )
     .await?
     {
         AddIncomingResult::Success { id, timestamp, .. } => Ok(Json(AddIncomingResponse {
             row_id: id,
             timestamp: timestamp.into(),
         })
         .into_response()),
         AddIncomingResult::NotAnExchange => {
             Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE))
         }
         AddIncomingResult::UnknownExchange => Err(failure_code(ErrorCode::BANK_UNKNOWN_ACCOUNT)),
         AddIncomingResult::UnknownDebtor => Err(failure_code(ErrorCode::BANK_UNKNOWN_DEBTOR)),
         AddIncomingResult::BothPartyAreExchange => {
             Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_EXCHANGE))
         }
         AddIncomingResult::ReservePubReuse => {
             Err(failure_code(ErrorCode::BANK_DUPLICATE_RESERVE_PUB_SUBJECT))
         }
         AddIncomingResult::UnknownMapping => {
             Err(failure_code(ErrorCode::BANK_TRANSFER_MAPPING_UNKNOWN))
         }
         AddIncomingResult::MappingReuse => {
             Err(failure_code(ErrorCode::BANK_TRANSFER_MAPPING_REUSED))
         }
         AddIncomingResult::BalanceInsufficient => {
             Err(failure_code(ErrorCode::BANK_UNALLOWED_DEBIT))
         }
     }
 }
 
 pub fn wire_api() -> Router<Arc<BankState>> {
     Router::new()
         .route(
             "/accounts/{username}/taler-wire-gateway/config",
             get(async |State(state): State<Arc<BankState>>| {
                 Json(WireConfig {
                     name: (),
                     version: WIRE_GATEWAY_API_VERSION,
                     implementation: Some(IMPLEMENTATION),
                     currency: state.cfg.regional_currency,
                     support_account_check: true,
                 })
             }),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/transfer",
             post(
                 async |auth: WireRWAuth,
                        State(state): State<Arc<BankState>>,
                        Req(req): Req<TransferRequest>| {
                     req.check(&state.cfg.regional_currency)?;
                     let payto = BankPayto::try_from(&req.credit_account)?;
                     match transfer(
                         &state.db,
                         &auth.username,
                         &req,
                         &payto,
                         &Timestamp::now(),
                         state.cfg.fiat.is_some(),
                     )
                     .await?
                     {
                         TransferResult::Success { id, timestamp } => Ok(Json(TransferResponse {
                             timestamp: timestamp.into(),
                             row_id: id,
                         })),
                         TransferResult::NotAnExchange => {
                             Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE))
                         }
                         TransferResult::UnknownExchange => {
                             Err(failure_code(ErrorCode::BANK_UNKNOWN_ACCOUNT))
                         }
                         TransferResult::BothPartyAreExchange => {
                             Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_EXCHANGE))
                         }
                         TransferResult::BalanceInsufficient => {
                             Err(failure_code(ErrorCode::BANK_UNALLOWED_DEBIT))
                         }
                         TransferResult::ReserveUidReuse => {
                             Err(failure_code(ErrorCode::BANK_TRANSFER_REQUEST_UID_REUSED))
                         }
                         TransferResult::WtidReuse => {
                             Err(failure_code(ErrorCode::BANK_TRANSFER_WTID_REUSED))
                         }
                         TransferResult::AdminCreditor => {
                             Err(failure_code(ErrorCode::BANK_ADMIN_CREDITOR))
                         }
                     }
                 },
             ),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/transfers",
             get(
                 async |Query(params): Query<TransferParams>,
                        mut auth: WireRAuth,
                        State(state): State<Arc<BankState>>| {
                     let params = params.check()?;
                     let info = auth.bank_info(&state.db, &state.cfg.ctx).await?;
                     if !info.is_exchange {
                         return Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE));
                     }
                     let transfers = page_transfer(
                         &state.db,
                         &state.cfg.ctx,
                         &state.cfg.regional_currency,
                         &params.page,
                         info.bank_account_id,
                         params.status,
                     )
                     .await?;
                     if transfers.is_empty() {
                         ApiResult::Ok(NoContent.into_response())
                     } else {
                         Ok(Json(TransferList {
                             transfers,
                             debit_account: info.payto.as_uri(),
                         })
                         .into_response())
                     }
                 },
             ),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/transfers/{id}",
             get(
                 async |Path((_, id)): Path<((), u64)>,
                        mut auth: WireRAuth,
                        State(state): State<Arc<BankState>>| {
                     let info = auth.bank_info(&state.db, &state.cfg.ctx).await?;
                     if !info.is_exchange {
                         return Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE));
                     }
                     match transfer_by_id(
                         &state.db,
                         &state.cfg.ctx,
                         &state.cfg.regional_currency,
                         info.bank_account_id,
                         id,
                     )
                     .await?
                     {
                         Some(t) => Ok(Json(t)),
                         None => Err(failure_code(ErrorCode::BANK_TRANSACTION_NOT_FOUND)),
                     }
                 },
             ),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/history/incoming",
             get(
                 async |Query(params): Query<HistoryParams>,
                        mut auth: WireRAuth,
                        State(state): State<Arc<BankState>>| {
                     let params = params.check()?;
                     let info = auth.bank_info(&state.db, &state.cfg.ctx).await?;
                     if !info.is_exchange {
                         return Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE));
                     }
                     let incoming_transactions = incoming_history(
                         &state.db,
                         &state.cfg.ctx,
                         &state.taler_in_channel,
                         &state.cfg.regional_currency,
                         &params,
                         info.bank_account_id,
                     )
                     .await?;
                     if incoming_transactions.is_empty() {
                         ApiResult::Ok(NoContent.into_response())
                     } else {
                         Ok(Json(IncomingHistory {
                             credit_account: info.payto.as_uri(),
                             incoming_transactions,
                         })
                         .into_response())
                     }
                 },
             ),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/history/outgoing",
             get(
                 async |Query(params): Query<HistoryParams>,
                        mut auth: WireRAuth,
                        State(state): State<Arc<BankState>>| {
                     let params = params.check()?;
                     let info = auth.bank_info(&state.db, &state.cfg.ctx).await?;
                     if !info.is_exchange {
                         return Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE));
                     }
                     let outgoing_transactions = outgoing_history(
                         &state.db,
                         &state.cfg.ctx,
                         &state.taler_out_channel,
                         &state.cfg.regional_currency,
                         &params,
                         info.bank_account_id,
                     )
                     .await?;
                     if outgoing_transactions.is_empty() {
                         ApiResult::Ok(NoContent.into_response())
                     } else {
                         Ok(Json(OutgoingHistory {
                             debit_account: info.payto.as_uri(),
                             outgoing_transactions,
                         })
                         .into_response())
                     }
                 },
             ),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/admin/add-incoming",
             post(
                 async |auth: UserAdminAuth,
                        State(state): State<Arc<BankState>>,
                        Req(req): Req<AddIncomingRequest>| {
                     req.check(&state.cfg.regional_currency)?;
                     admin_add_incoming(
                         &state.db,
                         &auth.username,
                         &req.amount,
                         &req.debit_account,
                         &IncomingKey::reserve(req.reserve_pub),
                     )
                     .await
                 },
             ),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/admin/add-kycauth",
             post(
                 async |auth: UserAdminAuth,
                        State(state): State<Arc<BankState>>,
                        Req(req): Req<AddKycauthRequest>| {
                     req.check(&state.cfg.regional_currency)?;
                     admin_add_incoming(
                         &state.db,
                         &auth.username,
                         &req.amount,
                         &req.debit_account,
                         &IncomingKey::kyc(req.account_pub),
                     )
                     .await
                 },
             ),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/admin/add-mapped",
             post(
                 async |auth: UserAdminAuth,
                        State(state): State<Arc<BankState>>,
                        Req(req): Req<AddMappedRequest>| {
                     req.check(&state.cfg.regional_currency)?;
                     admin_add_incoming(
                         &state.db,
                         &auth.username,
                         &req.amount,
                         &req.debit_account,
                         &IncomingKey::map(req.authorization_pub),
                     )
                     .await
                 },
             ),
         )
         .route(
             "/accounts/{username}/taler-wire-gateway/account/check",
             get(
                 async |Query(params): Query<AccountCheckParams>,
                        mut auth: WireRAuth,
                        State(state): State<Arc<BankState>>| {
                     let info = auth.bank_info(&state.db, &state.cfg.ctx).await?;
                     if !info.is_exchange {
                         return Err(failure_code(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE));
                     }
                     match check_info(&state.db, &params.account).await? {
                         Some(t) => Ok(Json(t)),
                         None => Err(failure_code(ErrorCode::BANK_UNKNOWN_ACCOUNT)),
                     }
                 },
             ),
         )
 }
 
 #[cfg(test)]
 pub mod test {
     use axum::http::Method;
     use sqlx::postgres::PgConnectOptions;
     use taler_api::subject::fmt_out_subject;
     use taler_common::{
         api::{
             EddsaPublicKey, HashCode, ShortHashCode,
             wire::{AccountInfo, TransferResponse, TransferState, TransferStatus},
         },
         db::IncomingType,
         error_code::ErrorCode,
         types::amount::amount,
     };
     use taler_macros::db_test;
     use taler_test_utils::{
         json,
         routine::{
             admin_add_incoming_routine, in_history_routine, out_history_routine, transfer_routine,
         },
         server::TestServer as _,
         tasks,
     };
 
     use crate::api::test::{Auth, bank_setup};
 
     #[db_test(raw)]
     async fn transfer(db: PgConnectOptions) {
         let ctx = bank_setup(db).await;
 
         ctx.auth_routine(
             Method::POST,
             "/accounts/merchant/taler-wire-gateway/transfer",
             Auth::UserOnly,
         )
         .await;
         ctx.auth_routine(
             Method::GET,
             "/accounts/merchant/taler-wire-gateway/transfers/32",
             Auth::UserOnly,
         )
         .await;
         ctx.auth_routine(
             Method::GET,
             "/accounts/merchant/taler-wire-gateway/transfers",
             Auth::UserOnly,
         )
         .await;
 
         let req = json!({
             "request_uid": HashCode::rand(),
             "amount": "KUDOS:55",
             "exchange_base_url": "http://exchange.example.com/",
             "wtid": ShortHashCode::rand(),
             "credit_account": ctx.merchant_payto
         });
 
         ctx.posta("/accounts/exchange/taler-wire-gateway/transfer")
             .json(&req)
             .await
             .assert_error(ErrorCode::BANK_UNALLOWED_DEBIT);
 
         ctx.set_max_debt("exchange", "1000").await;
         transfer_routine(
             &ctx.admin_router()
                 .await
                 .prefix("/accounts/exchange/taler-wire-gateway"),
             TransferState::success,
             &ctx.customer_payto.as_uri(),
         )
         .await;
 
         let admin_req = json!(req + {
             "credit_account" : ctx.admin_payto
         });
 
         // Check conversion bounce
         for _ in 0..2 {
             ctx.posta("/accounts/exchange/taler-wire-gateway/transfer")
                 .json(&admin_req)
                 .await
                 .assert_ok();
         }
 
         let ctx = ctx.swap_cfg("test_no_conversion.conf").await;
         // Transfer works for common accounts
 
         let req = json!(req + {
             "request_uid": HashCode::rand(),
             "wtid": ShortHashCode::rand(),
         });
         for _ in 0..2 {
             ctx.posta("/accounts/exchange/taler-wire-gateway/transfer")
                 .json(&req)
                 .await
                 .assert_ok();
         }
         // But fails to admin accounts
         ctx.posta("/accounts/exchange/taler-wire-gateway/transfer")
             .json(json!(admin_req + {
                 "request_uid": HashCode::rand(),
                 "wtid": ShortHashCode::rand(),
             }))
             .await
             .assert_error(ErrorCode::BANK_ADMIN_CREDITOR);
 
         // Dot now fail for unknown account
         let res = ctx
             .posta("/accounts/exchange/taler-wire-gateway/transfer")
             .json(json!(req + {
                 "request_uid": HashCode::rand(),
                 "wtid": ShortHashCode::rand(),
                 "credit_account": ctx.unknown_payto
             }))
             .await
             .assert_ok_json::<TransferResponse>();
         let s: TransferStatus = ctx
             .geta(format!(
                 "/accounts/exchange/taler-wire-gateway/transfers/{}",
                 res.row_id
             ))
             .await
             .assert_ok_json();
         assert_eq!(
             TransferStatus {
                 status: TransferState::permanent_failure,
                 status_msg: Some("Unknown account".into()),
                 amount: amount("KUDOS:55"),
                 exchange_base_url: s.exchange_base_url.clone(),
                 metadata: None,
                 wtid: s.wtid,
                 credit_account: s.credit_account.clone(),
                 timestamp: s.timestamp,
             },
             s
         );
 
         // Not an exchange
         ctx.geta(format!(
             "/accounts/merchant/taler-wire-gateway/transfers/{}",
             res.row_id
         ))
         .await
         .assert_error(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE);
         // Another account
         ctx.patcha("/accounts/merchant")
             .json(json!({
                 "is_taler_exchange": true
             }))
             .await
             .assert_no_content();
         ctx.geta(format!(
             "/accounts/merchant/taler-wire-gateway/transfers/{}",
             res.row_id
         ))
         .await
         .assert_error(ErrorCode::BANK_TRANSACTION_NOT_FOUND);
     }
 
     #[db_test(raw)]
     async fn outgoing_history(db: PgConnectOptions) {
         let ctx = &bank_setup(db).await;
         ctx.auth_routine(
             Method::GET,
             "/accounts/merchant/taler-wire-gateway/history/outgoing",
             Auth::UserOnly,
         )
         .await;
         ctx.set_max_debt("exchange", "1000").await;
         out_history_routine(
             &ctx.admin_router()
                 .await
                 .prefix("/accounts/exchange/taler-wire-gateway"),
             tasks!(
                 // Transactions using clean add incoming logic
                 { ctx.transfer("10", &ctx.customer_payto, None).await },
                 // And with metadata
                 {
                     ctx.transfer("12", &ctx.customer_payto, Some("CON:ID".into()))
                         .await
                 }
             ),
             tasks!(
                 // // Failed transfer
                 { ctx.transfer("10", &ctx.unknown_payto, None).await },
                 // Ignore manual outgoing transaction
                 {
                     ctx.tx_s(
                         "exchange",
                         "10",
                         "merchant",
                         fmt_out_subject(
                             &ShortHashCode::rand(),
                             "https://exchange.example.com/",
                             None,
                         ),
                     )
                     .await
                 },
                 // Ignore malformed incoming transaction
                 { ctx.tx("merchant", "10", "exchange",).await },
                 // Ignore malformed outgoing transaction
                 { ctx.tx("exchange", "10", "merchant",).await },
             ),
         )
         .await;
     }
 
     #[db_test(raw)]
     async fn incoming_history(db: PgConnectOptions) {
         let ctx = &bank_setup(db).await;
         ctx.auth_routine(
             Method::GET,
             "/accounts/merchant/taler-wire-gateway/history/incoming",
             Auth::UserOnly,
         )
         .await;
         ctx.set_max_debt("customer", "1000").await;
         ctx.set_max_debt("merchant", "1000").await;
         let admin = ctx.admin_router().await;
         in_history_routine(
             &admin.prefix("/accounts/exchange/taler-wire-gateway"),
             &admin.prefix("/taler-prepared-transfer"),
             &ctx.customer_payto.as_uri(),
             &ctx.exchange_payto.as_uri(),
             tasks!(
                 // Reserve transactions using raw bank transaction logic
                 {
                     ctx.tx_s(
                         "merchant",
                         "10",
                         "exchange",
                         format!("history test with {} reserve pub", EddsaPublicKey::rand()),
                     )
                     .await
                 },
                 // Reserve transactions using withdraw logic
                 { ctx.withdrawal("9").await },
                 // KYC transactions using raw bank transaction logic
                 {
                     ctx.tx_s(
                         "merchant",
                         "10",
                         "exchange",
                         format!(
                             "history test with KYC:{} account pub",
                             EddsaPublicKey::rand()
                         ),
                     )
                     .await
                 }
             ),
             tasks!(
                 // Ignore malformed incoming transaction
                 { ctx.tx("merchant", "10", "exchange",).await },
                 // Ignore malformed outgoing transaction
                 { ctx.tx("exchange", "10", "merchant",).await },
             ),
         )
         .await;
     }
 
     #[db_test(raw)]
     async fn admin_add_incoming(db: PgConnectOptions) {
         let ctx = bank_setup(db).await;
         ctx.auth_routine(
             Method::GET,
             "/accounts/merchant/taler-wire-gateway/history/incoming",
             Auth::UserOnly,
         )
         .await;
         for ty in IncomingType::entries {
             let (path, key) = match ty {
                 IncomingType::reserve => ("incoming", "reserve_pub"),
                 IncomingType::kyc => ("kycauth", "account_pub"),
                 IncomingType::map => ("mapped", "authorization_pub"),
             };
             let path = format!("/accounts/exchange/taler-wire-gateway/admin/add-{path}");
             ctx.auth_routine(Method::POST, &path, Auth::Admin).await;
             let req = json!({
                 "amount": "KUDOS:44",
                 "debit_account": ctx.customer_payto,
                 key: EddsaPublicKey::rand(),
             });
 
             ctx.post_admin(path.replace("exchange", "merchant"))
                 .json(&req)
                 .await
                 .assert_error(ErrorCode::BANK_ACCOUNT_IS_NOT_EXCHANGE);
             ctx.post_admin(&path)
                 .json(json!(req + {
                     "debit_account": ctx.exchange_payto
                 }))
                 .await
                 .assert_error(ErrorCode::BANK_ACCOUNT_IS_EXCHANGE);
             if *ty != IncomingType::map {
                 ctx.post_admin(&path)
                     .json(json!(req + {
                          "amount": "KUDOS:44",
                     }))
                     .await
                     .assert_error(ErrorCode::BANK_UNALLOWED_DEBIT);
             }
         }
         ctx.set_max_debt("customer", "1000").await;
         let admin = ctx.admin_router().await;
         admin_add_incoming_routine(
             &admin.prefix("/accounts/exchange/taler-wire-gateway"),
             &admin.prefix("/taler-prepared-transfer"),
             &ctx.customer_payto.as_uri(),
             &ctx.exchange_payto.as_uri(),
         )
         .await;
     }
 
     #[db_test(raw)]
     async fn account_check(db: PgConnectOptions) {
         let ctx = bank_setup(db).await;
         ctx.geta("/accounts/exchange/taler-wire-gateway/account/check")
             .await
             .assert_error(ErrorCode::GENERIC_PARAMETER_MISSING);
         ctx.geta(format!(
             "/accounts/exchange/taler-wire-gateway/account/check?account={}",
             ctx.unknown_payto
         ))
         .await
         .assert_error(ErrorCode::BANK_UNKNOWN_ACCOUNT);
         ctx.geta(format!(
             "/accounts/exchange/taler-wire-gateway/account/check?account={}",
             ctx.merchant_payto
         ))
         .await
         .assert_ok_json::<AccountInfo>();
     }
 }