US routing numbers

use aba_routing.qweruse aba_check, aba_valid from aba_routing      // Quillo 0.6: only these

serde_json = { version = "1", features = ["preserve_order"] }

// Direct deposit set-up for a payroll app: the routing number an employee types checked before// the first payday, a scanned check's MICR line read, and Canadian employees' bank numbers.////   quillo run aba_routing.qwe      then open http://localhost:8080/check/021000021 and http://localhost:8080/demouse "aba_routing.qwer"route GET /check/:routing = aba_check(routing)route GET /demo = {    chase_ny: aba_check("021000021"),    credit_union: aba_check("322271627").kind,    typo: aba_check("021000022").error,    check_digit: aba_check_digit("02100002")?,    // A personal check, as a scanner typed it, and a business check with the check number first.    personal: aba_micr("T121000358T 3255 0172 5O 1042")?,    business: aba_micr("⑈001042⑈ ⑆026009593⑆ 4471 0026 63⑈")?,    canada: aba_canada("12345", "003")?,}

//! US bank routing numbers (ABA RTN) checked by their check digit and read for the Federal Reserve district and kind of institution, the routing, account and check numbers taken from a check's MICR line, and Canadian transit and institution numbers written in their electronic form.//! version: 1.0.0//!//! [dependencies]//! serde_json = { version = "1", features = ["preserve_order"] }use serde_json::{json, Value};const DISTRICTS: [&str; 12] = ["Boston", "New York", "Philadelphia", "Cleveland", "Richmond", "Atlanta", "Chicago", "St. Louis", "Minneapolis", "Kansas City", "Dallas", "San Francisco"];fn digits(s: &str) -> String {    s.chars().filter(|c| c.is_ascii_digit()).collect()}fn check_digit(first8: &[u32]) -> u32 {    let s = 3 * (first8[0] + first8[3] + first8[6]) + 7 * (first8[1] + first8[4] + first8[7]) + (first8[2] + first8[5]);    (10 - s % 10) % 10}/// A routing number read: `{ valid, routing, kind, district, fed_bank, formatted, error }`. `kind` is "bank", "thrift" (savings/// banks and credit unions), "electronic" (ACH only), "government" or "traveler's checks"; `fed_bank` the Federal Reserve Bank/// that serves it. Spaces and dashes are ignored.pub fn aba_check(routing: &str) -> Value {    let s = digits(routing);    if s.len() != 9 || routing.chars().any(|c| c.is_ascii_alphabetic()) {        return json!({ "valid": false, "routing": s, "error": "a routing number has 9 digits" });    }    let d: Vec<u32> = s.chars().map(|c| c.to_digit(10).unwrap()).collect();    if check_digit(&d[..8]) != d[8] {        return json!({ "valid": false, "routing": s, "error": "the check digit does not match: a typo" });    }    let p: usize = s[..2].parse().unwrap_or(99);    let (kind, district) = match p {        0 => ("government", None),        1..=12 => ("bank", Some(p)),        21..=32 => ("thrift", Some(p - 20)),        61..=72 => ("electronic", Some(p - 60)),        80 => ("traveler's checks", None),        _ => return json!({ "valid": false, "routing": s, "error": format!("no routing number starts with {:02}", p) }),    };    json!({        "valid": true,        "routing": s,        "kind": kind,        "district": district,        "fed_bank": district.map(|n| format!("Federal Reserve Bank of {}", DISTRICTS[n - 1])),        "formatted": format!("{}-{}-{}", &s[..4], &s[4..8], &s[8..]),        "error": null,    })}/// Whether `routing` is a valid ABA routing number.pub fn aba_valid(routing: &str) -> bool {    aba_check(routing)["valid"] == json!(true)}/// The ninth digit for the first eight of a routing number, for test data.pub fn aba_check_digit(first8: &str) -> Result<i64, String> {    let s = digits(first8);    if s.len() != 8 {        return Err("give the first 8 digits".into());    }    let d: Vec<u32> = s.chars().map(|c| c.to_digit(10).unwrap()).collect();    Ok(check_digit(&d) as i64)}/// A check's MICR line (the E-13B numbers along its bottom) read into `{ routing, account, check_number, amount, routing_valid }`./// Takes the symbols as printed (⑆ transit, ⑈ on-us, ⑉ amount, ⑇ dash) or as scanners type them: `T` or `A` for transit, `U`,/// `O` or `C` for on-us, `$` or `B` for amount, `-` or `D` for dash. The check number is the on-us field's short part, or the/// auxiliary on-us field on business checks.pub fn aba_micr(line: &str) -> Result<Value, String> {    // Map every spelling to one symbol: t transit, o on-us, a amount.    let norm: String = line.chars().map(|c| match c {        '⑆' | 'T' | 'A' | 't' | 'a' => 't',        '⑈' | 'U' | 'O' | 'C' | 'u' | 'o' | 'c' => 'o',        '⑉' | '$' | 'B' | 'b' => '$',        '⑇' | 'D' | 'd' | '-' => '-',        c if c.is_ascii_digit() => c,        _ => ' ',    }).collect();    let first = norm.find('t').ok_or("no transit symbol (⑆ or T) before the routing number")?;    let rest = &norm[first + 1..];    let end = rest.find('t').ok_or("the routing number has no closing transit symbol")?;    let routing: String = rest[..end].chars().filter(|c| c.is_ascii_digit()).collect();    let aux: String = norm[..first].chars().filter(|c| c.is_ascii_digit()).collect();    let after = &rest[end + 1..];    let (onus, amount_part) = match after.find('$') { Some(i) => (&after[..i], &after[i..]), None => (after, "") };    // On-us: account and, on personal checks, the check number after the on-us symbol.    let parts: Vec<String> = onus.split('o').map(|p| p.chars().filter(|c| c.is_ascii_digit() || *c == '-').collect::<String>().trim_matches('-').to_string()).filter(|p| !p.is_empty()).collect();    let (account, check) = match (parts.len(), aux.is_empty()) {        (0, _) => return Err("no account number after the routing number".into()),        (1, false) => (parts[0].clone(), Some(aux.clone())),        (1, true) => (parts[0].clone(), None),        (_, false) => (parts[0].clone(), Some(aux.clone())),        (_, true) => {            // The shorter field is the check number.            if parts[0].len() <= parts[1].len() { (parts[1].clone(), Some(parts[0].clone())) } else { (parts[0].clone(), Some(parts[1].clone())) }        }    };    let amount: String = amount_part.chars().filter(|c| c.is_ascii_digit()).collect();    Ok(json!({        "routing": routing,        "account": account.replace('-', ""),        "check_number": check.map(|c| c.trim_start_matches('0').to_string()),        "amount": amount.parse::<u64>().ok().map(|n| format!("{}.{:02}", n / 100, n % 100)),        "routing_valid": aba_valid(&routing),    }))}/// A Canadian bank's routing number from its 5-digit transit (branch) and 3-digit institution numbers: `{ electronic, micr,/// institution_name }`, `electronic` the 9 digits for direct deposits and EFT (`0` + institution + transit), `micr` as printed on cheques.pub fn aba_canada(transit: &str, institution: &str) -> Result<Value, String> {    let (t, i) = (digits(transit), digits(institution));    if t.len() != 5 || i.len() != 3 {        return Err("a transit number has 5 digits and an institution number 3".into());    }    let name = match i.as_str() {        "001" => "Bank of Montreal", "002" => "Scotiabank", "003" => "Royal Bank of Canada", "004" => "TD Canada Trust", "006" => "National Bank of Canada",        "010" => "CIBC", "016" => "HSBC Bank Canada", "030" => "Canadian Western Bank", "039" => "Laurentian Bank", "177" => "Bank of Canada", "219" => "ATB Financial",        "260" => "Citibank Canada", "614" => "Tangerine", "815" => "Desjardins", "828" => "Central 1 (credit unions)", "837" => "Meridian", _ => "",    };    Ok(json!({ "electronic": format!("0{}{}", i, t), "micr": format!("{}-{}", t, i), "institution_name": if name.is_empty() { Value::Null } else { json!(name) } }))}