taler-rust

config.rs (7253B)

---

 /*
   This file is part of TALER
   Copyright (C) 2026 Taler Systems SA
 
   TALER 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.
 
   TALER 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
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::{str::FromStr as _, sync::LazyLock, time::Duration};
 
 use aws_lc_rs::signature::{ParsedPublicKey, RSA_PKCS1_2048_8192_SHA256};
 use compact_str::CompactString;
 use taler_api::{
     Serve,
     config::{ApiCfg, DbCfg},
 };
 use taler_common::{
     config::{CfgErr, Config},
     config_bail, map_config,
     types::{
         amount::Currency,
         payto::{ACH, BankID},
     },
 };
 use taler_macros::EnumMeta;
 use url::Url;
 
 use crate::payto::WiseAccount;
 
 #[derive(Debug, Clone, Copy)]
 pub enum AccountType {
     Exchange,
     Normal,
 }
 
 #[derive(Debug, Clone, Copy, EnumMeta)]
 #[allow(non_camel_case_types)]
 #[enum_meta(Str)]
 pub enum ApiEnv {
     production,
     sandbox,
 }
 
 impl ApiEnv {
     pub const fn api(self) -> &'static LazyLock<Url> {
         static PROD: LazyLock<Url> =
             LazyLock::new(|| Url::from_str("https://api.wise.com").unwrap());
         static SANDBOX: LazyLock<Url> =
             LazyLock::new(|| Url::from_str("https://api.wise-sandbox.com").unwrap());
         match self {
             ApiEnv::production => &PROD,
             ApiEnv::sandbox => &SANDBOX,
         }
     }
 
     pub fn public_key(self) -> ParsedPublicKey {
         let pem = match self {
             ApiEnv::production => {
                 "-----BEGIN PUBLIC KEY-----
 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvO8vXV+JksBzZAY6GhSO
 XdoTCfhXaaiZ+qAbtaDBiu2AGkGVpmEygFmWP4Li9m5+Ni85BhVvZOodM9epgW3F
 bA5Q1SexvAF1PPjX4JpMstak/QhAgl1qMSqEevL8cmUeTgcMuVWCJmlge9h7B1CS
 D4rtlimGZozG39rUBDg6Qt2K+P4wBfLblL0k4C4YUdLnpGYEDIth+i8XsRpFlogx
 CAFyH9+knYsDbR43UJ9shtc42Ybd40Afihj8KnYKXzchyQ42aC8aZ/h5hyZ28yVy
 Oj3Vos0VdBIs/gAyJ/4yyQFCXYte64I7ssrlbGRaco4nKF3HmaNhxwyKyJafz19e
 HwIDAQAB
 -----END PUBLIC KEY-----"
             }
             ApiEnv::sandbox => {
                 "-----BEGIN PUBLIC KEY-----
 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwpb91cEYuyJNQepZAVfP
 ZIlPZfNUefH+n6w9SW3fykqKu938cR7WadQv87oF2VuT+fDt7kqeRziTmPSUhqPU
 ys/V2Q1rlfJuXbE+Gga37t7zwd0egQ+KyOEHQOpcTwKmtZ81ieGHynAQzsn1We3j
 wt760MsCPJ7GMT141ByQM+yW1Bx+4SG3IGjXWyqOWrcXsxAvIXkpUD/jK/L958Cg
 nZEgz0BSEh0QxYLITnW1lLokSx/dTianWPFEhMC9BgijempgNXHNfcVirg1lPSyg
 z7KqoKUN0oHqWLr2U1A+7kqrl6O2nx3CKs1bj1hToT1+p4kcMoHXA7kA+VBLUpEs
 VwIDAQAB
 -----END PUBLIC KEY-----"
             }
         };
         let parsed = pem::parse(pem).unwrap();
         ParsedPublicKey::new(&RSA_PKCS1_2048_8192_SHA256, parsed.contents()).unwrap()
     }
 }
 
 pub fn parse_db_cfg(cfg: &Config) -> Result<DbCfg, CfgErr> {
     DbCfg::parse(cfg.section("wisedb-postgres"))
 }
 
 pub struct WiseBalance {
     pub id: u32,
     pub currency: Currency,
     pub payto: WiseAccount,
 }
 
 fn balances(cfg: &Config) -> Result<Vec<WiseBalance>, CfgErr> {
     let mut balances = Vec::new();
     let mut ids = std::collections::BTreeSet::new();
     for s in cfg
         .sections()
         .filter(|s| s.name.starts_with("wise-balance-"))
     {
         let id = s.number("ID").require()?;
         if !ids.insert(id) {
             return Err(s.invalid("ID", format!("duplicate balance ID {id}")));
         }
         balances.push(WiseBalance {
             id,
             currency: s.currency("CURRENCY").require()?,
             payto: map_config!(s, "payto type", "PAYTO_TYPE",
                 "iban" => {
                     WiseAccount::IBAN(BankID {
                         iban: s.parse("IBAN", "iban").require()?,
                         bic: s.parse("BIC", "bic").opt()?
                     })
                 },
                 "ach" => {
                     WiseAccount::ACH(ACH {
                         routing_number: s.parse("ACH routing number", "routing_number").require()?,
                         account_number: s.parse("ACH account_number", "account_number").require()?
                     })
                 },
             )
             .require()?,
         });
     }
     Ok(balances)
 }
 
 /// taler-wise setup config
 pub struct SetupCfg {
     pub api: ApiEnv,
     pub token: String,
     pub profile_id: Option<u64>,
     pub name: Option<CompactString>,
     pub balances: Vec<WiseBalance>,
 }
 
 impl SetupCfg {
     pub fn parse(cfg: &Config) -> Result<Self, CfgErr> {
         let ms = cfg.section("wise");
         let s = cfg.section("wise-worker");
         Ok(Self {
             api: ms.parse("env", "API_ENV").require()?,
             profile_id: ms.number("PROFILE_ID").opt()?,
             token: s.str("TOKEN").require()?,
             name: ms.cstr("NAME").opt()?,
             balances: balances(cfg)?,
         })
     }
 }
 
 /// taler-wise httpd config
 pub struct ServeCfg {
     pub api: ApiEnv,
     pub profile_id: u64,
     pub name: CompactString,
     pub serve: Serve,
     pub balances: Vec<WiseBalance>,
     pub wire_gateway: Option<ApiCfg>,
     pub revenue: Option<ApiCfg>,
     pub observability: Option<ApiCfg>,
 }
 
 impl ServeCfg {
     pub fn parse(cfg: &Config) -> Result<Self, CfgErr> {
         let s = cfg.section("wise");
         Ok(Self {
             api: s.parse("env", "API_ENV").require()?,
             profile_id: s.number("PROFILE_ID").require()?,
             name: s.cstr("NAME").require()?,
             serve: Serve::parse(&cfg.section("wise-httpd"))?,
             wire_gateway: ApiCfg::parse(cfg.section("wise-httpd-wire-gateway-api"))?,
             revenue: ApiCfg::parse(cfg.section("wise-httpd-revenue-api"))?,
             observability: ApiCfg::parse(cfg.section("wise-httpd-observability-api"))?,
             balances: balances(cfg)?,
         })
     }
 }
 
 /// taler-wise worker config
 pub struct WorkerCfg {
     pub api: ApiEnv,
     pub profile_id: u64,
     pub token: String,
     pub frequency: Duration,
     pub balances: Vec<WiseBalance>,
 }
 
 impl WorkerCfg {
     pub fn parse(cfg: &Config) -> Result<Self, CfgErr> {
         let ms = cfg.section("wise");
         let s = cfg.section("wise-worker");
         let cfg = Self {
             api: ms.parse("env", "API_ENV").require()?,
             profile_id: ms.number("PROFILE_ID").require()?,
             token: s.str("TOKEN").require()?,
             frequency: s.duration("FREQUENCY").require()?,
             balances: balances(cfg)?,
         };
         if cfg.balances.is_empty() {
             config_bail!("Missing configured balance in a section [wise-balance-*]");
         }
         if cfg.frequency.is_zero() {
             return Err(s.invalid("FREQUENCY", "must be positive"));
         }
         if cfg.token.is_empty()
             || hyper::header::HeaderValue::from_str(&format!("Bearer {}", cfg.token)).is_err()
         {
             return Err(s.invalid("TOKEN", "must be a nonempty valid HTTP header value"));
         }
         Ok(cfg)
     }
 }