taler-rust

ach.rs (5535B)

---

 /*
   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::{fmt::Display, str::FromStr};
 
 use compact_str::CompactString;
 use serde_with::{DeserializeFromStr, SerializeDisplay};
 
 use crate::types::utils::{InlineAscii, InlineStr};
 
 const ROUTING_NB_SIZE: usize = 9;
 const MAX_ACCOUNT_NB_SIZE: usize = 17;
 
 /// ACH routing number
 #[derive(Clone, Copy, PartialEq, Eq, DeserializeFromStr, SerializeDisplay)]
 pub struct RoutingNumber(InlineAscii<ROUTING_NB_SIZE>);
 
 impl RoutingNumber {
     #[inline]
     pub fn checksum(s: &[u8; 9]) -> u8 {
         // Sum raw ASCII values directly using 16-bit registers
         let sum0 = s[0] as u16 + s[3] as u16 + s[6] as u16;
         let sum1 = s[1] as u16 + s[4] as u16 + s[7] as u16;
         let sum2 = s[2] as u16 + s[5] as u16 + s[8] as u16;
 
         //  Fold all 9 `b'0'` (48) ASCII subtractions into a single constant offset:
         // (3 * 3 + 7 * 3 + 1 * 3) * 48 = 33 * 48 = 1584
         let total = 3 * sum0 + 7 * sum1 + sum2 - 1584;
         (total % 10) as u8
     }
 
     pub fn federal_reserve_routine_symbol(&self) -> &str {
         // SAFETY len = 9
         unsafe { self.as_ref().get_unchecked(0..4) }
     }
 
     pub fn financial_institution_identifier(&self) -> &str {
         // SAFETY len = 8
         unsafe { self.as_ref().get_unchecked(4..8) }
     }
 }
 
 impl AsRef<str> for RoutingNumber {
     fn as_ref(&self) -> &str {
         self.0.as_ref()
     }
 }
 
 #[derive(Debug, PartialEq, Eq, thiserror::Error)]
 pub enum RoutineNumberErrKind {
     #[error("contains illegal characters (only 0-9 allowed)")]
     Invalid,
     #[error("invalid check digit")]
     Checksum,
     #[error("bad size expected {ROUTING_NB_SIZE} chars got {0}")]
     Size(usize),
 }
 
 #[derive(Debug, thiserror::Error)]
 #[error("ACH routing number '{routing_number}' {kind}")]
 pub struct ParseRoutingNumberErr {
     routing_number: CompactString,
     pub kind: RoutineNumberErrKind,
 }
 
 impl FromStr for RoutingNumber {
     type Err = ParseRoutingNumberErr;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let bytes: &[u8] = s.as_bytes();
         if let Ok(array) = <&[u8] as TryInto<[u8; ROUTING_NB_SIZE]>>::try_into(bytes) {
             if !array.iter().all(u8::is_ascii_digit) {
                 Err(RoutineNumberErrKind::Invalid)
             } else if Self::checksum(&array) != 0 {
                 Err(RoutineNumberErrKind::Checksum)
             } else {
                 Ok(Self(InlineAscii::from(array)))
             }
         } else {
             Err(RoutineNumberErrKind::Size(bytes.len()))
         }
         .map_err(|kind| ParseRoutingNumberErr {
             routing_number: s.into(),
             kind,
         })
     }
 }
 
 impl Display for RoutingNumber {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         Display::fmt(&self.as_ref(), f)
     }
 }
 
 impl std::fmt::Debug for RoutingNumber {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         Display::fmt(&self, f)
     }
 }
 
 /// ACH account number
 #[derive(Clone, Copy, PartialEq, Eq, DeserializeFromStr, SerializeDisplay)]
 pub struct AccountNumber(InlineStr<MAX_ACCOUNT_NB_SIZE>);
 
 impl AsRef<str> for AccountNumber {
     fn as_ref(&self) -> &str {
         self.0.as_ref()
     }
 }
 
 #[derive(Debug, PartialEq, Eq, thiserror::Error)]
 pub enum AccountNumberErrKind {
     #[error("contains illegal characters (only 0-9A-Z allowed)")]
     Invalid,
     #[error("bad size expected max {MAX_ACCOUNT_NB_SIZE} chars got {0}")]
     Size(usize),
 }
 
 #[derive(Debug, thiserror::Error)]
 #[error("ACH account number '{account_number}' {kind}")]
 pub struct ParseAccountNumberErr {
     account_number: CompactString,
     pub kind: AccountNumberErrKind,
 }
 impl FromStr for AccountNumber {
     type Err = ParseAccountNumberErr;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let bytes: &[u8] = s.as_bytes();
         let len = bytes.len();
         if len > MAX_ACCOUNT_NB_SIZE {
             Err(AccountNumberErrKind::Size(len))
         } else if !bytes.iter().all(u8::is_ascii_alphanumeric) {
             Err(AccountNumberErrKind::Invalid)
         } else {
             Ok(Self(
                 InlineStr::try_from_iter(bytes.iter().copied().map(|b| b.to_ascii_uppercase()))
                     .unwrap(),
             ))
         }
         .map_err(|kind| ParseAccountNumberErr {
             account_number: s.into(),
             kind,
         })
     }
 }
 
 impl Display for AccountNumber {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         Display::fmt(&self.as_ref(), f)
     }
 }
 
 impl std::fmt::Debug for AccountNumber {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         Display::fmt(&self, f)
     }
 }
 
 #[test]
 fn ach() {
     for nb in ["111000038", "021000021"] {
         let parsed = RoutingNumber::from_str(nb).unwrap();
         assert_eq!(parsed.to_string(), nb)
     }
 }