taler-rust

lib.rs (6911B)

---

 /*
   This file is part of TALER
   Copyright (C) 2025 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::{borrow::Cow, str::FromStr, sync::Arc};
 
 use sqlx::PgPool;
 use taler_api::api::{Router, TalerRouter as _};
 use taler_common::{
     config::Config,
     types::{
         iban::{Country, IBAN, IbanErrorKind, ParseIbanError},
         payto::{FullPayto, IbanPayto, Payto, PaytoErr, PaytoImpl, PaytoURI, TransferPayto},
     },
 };
 
 use crate::{api::MagnetApi, config::ServeCfg};
 
 pub mod api;
 pub mod config;
 pub mod constants;
 pub mod db;
 pub mod dev;
 pub mod magnet_api;
 pub mod setup;
 pub mod worker;
 
 pub async fn run_serve(cfg: &Config, pool: PgPool) -> anyhow::Result<()> {
     let cfg = ServeCfg::parse(cfg)?;
     let api = Arc::new(MagnetApi::start(pool, cfg.payto).await);
     let mut router = Router::new();
     if let Some(cfg) = cfg.wire_gateway {
         router = router.wire_gateway(api.clone(), cfg.auth.method());
     }
     if let Some(cfg) = cfg.revenue {
         router = router.revenue(api, cfg.auth.method());
     }
     router.serve(cfg.serve, None).await?;
     Ok(())
 }
 
 #[derive(
     Debug, Clone, PartialEq, Eq, serde_with::DeserializeFromStr, serde_with::SerializeDisplay,
 )]
 pub struct HuIban(IBAN);
 
 impl HuIban {
     #[allow(clippy::identity_op)]
     pub fn checksum(b: &[u8]) -> Result<(), (u8, u8)> {
         let expected_digit = b[7] - b'0';
         let sum = ((b[0] - b'0') * 9) as u16
             + ((b[1] - b'0') * 7) as u16
             + ((b[2] - b'0') * 3) as u16
             + ((b[3] - b'0') * 1) as u16
             + ((b[4] - b'0') * 9) as u16
             + ((b[5] - b'0') * 7) as u16
             + ((b[6] - b'0') * 3) as u16;
         let modulo = ((10 - (sum % 10)) % 10) as u8;
         if expected_digit != modulo {
             Err((expected_digit, modulo))
         } else {
             Ok(())
         }
     }
 
     fn check_bban(bban: &str) -> Result<(), HuIbanErr> {
         let bban = bban.as_bytes();
         if bban.len() != 16 && bban.len() != 24 {
             return Err(HuIbanErr::BbanSize(bban.len()));
         } else if !bban.iter().all(u8::is_ascii_digit) {
             return Err(HuIbanErr::Invalid);
         }
         Self::checksum(&bban[..8]).map_err(|e| HuIbanErr::checksum("bank-branch number", e))?;
         if bban.len() == 16 {
             Self::checksum(&bban[8..]).map_err(|e| HuIbanErr::checksum("account number", e))?;
         } else {
             Self::checksum(&bban[8..16])
                 .map_err(|e| HuIbanErr::checksum("account number first group", e))?;
             Self::checksum(&bban[16..])
                 .map_err(|e| HuIbanErr::checksum("account number second group", e))?;
         }
         Ok(())
     }
 
     pub fn from_bban(bban: &str) -> Result<Self, HuIbanErr> {
         Self::check_bban(bban)?;
         let full_bban = if bban.len() == 16 {
             Cow::Owned(format!("{bban}00000000"))
         } else {
             Cow::Borrowed(bban)
         };
         let iban = IBAN::from_parts(Country::HU, &full_bban);
         Ok(Self(iban))
     }
 
     pub fn bban(&self) -> &str {
         let bban = self.0.bban();
         bban.strip_suffix("00000000").unwrap_or(bban)
     }
 
     pub fn iban(&self) -> &str {
         self.0.as_ref()
     }
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum HuIbanErr {
     #[error("contains illegal characters (only 0-9 allowed)")]
     Invalid,
     #[error("expected an hungarian IBAN starting with HU got {0}")]
     Country(Country),
     #[error("invalid length expected 16 or 24 chars got {0}")]
     BbanSize(usize),
     #[error("invalid checksum for {0} expected {1} got {2}")]
     Checksum(&'static str, u8, u8),
     #[error(transparent)]
     Iban(IbanErrorKind),
 }
 
 impl From<ParseIbanError> for HuIbanErr {
     fn from(value: ParseIbanError) -> Self {
         Self::Iban(value.kind)
     }
 }
 
 impl HuIbanErr {
     fn checksum(part: &'static str, (expected, checksum): (u8, u8)) -> Self {
         Self::Checksum(part, expected, checksum)
     }
 }
 
 impl TryFrom<IBAN> for HuIban {
     type Error = HuIbanErr;
 
     fn try_from(iban: IBAN) -> Result<Self, Self::Error> {
         let country = iban.country();
         if country != Country::HU {
             return Err(HuIbanErr::Country(country));
         }
 
         Self::check_bban(iban.bban())?;
 
         Ok(Self(iban))
     }
 }
 
 impl PaytoImpl for HuIban {
     fn as_payto(&self) -> PaytoURI {
         PaytoURI::from_parts("iban", format_args!("/{}", self.0))
     }
 
     fn parse(raw: &PaytoURI) -> Result<Self, PaytoErr> {
         let iban_payto = IbanPayto::try_from(raw).map_err(PaytoErr::custom)?;
         HuIban::try_from(iban_payto.into_inner().iban).map_err(PaytoErr::custom)
     }
 }
 
 impl FromStr for HuIban {
     type Err = HuIbanErr;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let iban: IBAN = s.parse()?;
         Self::try_from(iban)
     }
 }
 
 impl std::fmt::Display for HuIban {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.0.fmt(f)
     }
 }
 
 /// Parse a magnet payto URI, panic if malformed
 pub fn magnet_payto(url: impl AsRef<str>) -> FullHuPayto {
     url.as_ref().parse().expect("invalid magnet payto")
 }
 
 pub type HuPayto = Payto<HuIban>;
 pub type FullHuPayto = FullPayto<HuIban>;
 pub type TransferHuPayto = TransferPayto<HuIban>;
 
 #[cfg(test)]
 mod test {
     use taler_common::types::{
         iban::IBAN,
         payto::{Payto, PaytoImpl, payto},
     };
 
     use crate::HuIban;
 
     #[test]
     fn hu_iban() {
         for (valid, account) in [
             (
                 payto("payto://iban/HU30162000031000163100000000"),
                 "1620000310001631",
             ),
             (
                 payto("payto://iban/HU02162000031000164800000000"),
                 "1620000310001648",
             ),
             (
                 payto("payto://iban/HU60162000101006446300000000"),
                 "1620001010064463",
             ),
         ] {
             // Parsing
             let iban_payto: Payto<IBAN> = (&valid).try_into().unwrap();
             let hu_payto: HuIban = iban_payto.into_inner().try_into().unwrap();
             assert_eq!(hu_payto.bban(), account);
             // Roundtrip
             let iban = HuIban::from_bban(&account).unwrap();
             let payto = iban.as_payto();
             assert_eq!(payto, valid);
         }
     }
 }