Spaces:
Running
Running
| /** | |
| * CUSIP Check-Digit Validator and Calculation Utilities | |
| * | |
| * Implements the standard CUSIP check-digit algorithm as detailed in | |
| * Chapter 43 of "Rights, Genomes, and Algorithms" and ANSI X9.6 standard: | |
| * - Positions 1-6: Issuer alphanumeric code | |
| * - Positions 7-8: Issue alphanumeric code | |
| * - Position 9: Check digit calculated via modified Luhn algorithm | |
| * (Letters mapped to ordinals: A=10, B=11 ... Z=35; odd positions x1, even positions x2; sum digits of products; mod 10) | |
| */ | |
| export interface CusipValidationResult { | |
| isValid: boolean; | |
| normalizedCusip: string; | |
| issuerCode: string; | |
| issueCode: string; | |
| actualCheckDigit: number | null; | |
| expectedCheckDigit: number | null; | |
| errorMessage?: string; | |
| } | |
| /** | |
| * Calculates the standard CUSIP check digit for an 8-character CUSIP stem. | |
| * Returns null if the stem is invalid. | |
| */ | |
| export function calculateCusipCheckDigit(stem: string): number | null { | |
| if (!stem) return null; | |
| const cleanStem = stem.toUpperCase().replace(/[^0-9A-Z*@#]/g, ''); | |
| if (cleanStem.length < 8) return null; | |
| let sum = 0; | |
| for (let i = 0; i < 8; i++) { | |
| const char = cleanStem[i]; | |
| let val = 0; | |
| if (char >= '0' && char <= '9') { | |
| val = parseInt(char, 10); | |
| } else if (char >= 'A' && char <= 'Z') { | |
| val = char.charCodeAt(0) - 55; // 'A' -> 10, 'B' -> 11, etc. | |
| } else if (char === '*') { | |
| val = 36; | |
| } else if (char === '@') { | |
| val = 37; | |
| } else if (char === '#') { | |
| val = 38; | |
| } else { | |
| return null; | |
| } | |
| // Even index in 0-indexed loop corresponds to odd position (1st, 3rd, 5th, 7th) -> weight 1 | |
| // Odd index in 0-indexed loop corresponds to even position (2nd, 4th, 6th, 8th) -> weight 2 | |
| let product = (i % 2 === 1) ? val * 2 : val * 1; | |
| // Sum the decimal digits of the product | |
| while (product > 0) { | |
| sum += product % 10; | |
| product = Math.floor(product / 10); | |
| } | |
| } | |
| return (10 - (sum % 10)) % 10; | |
| } | |
| /** | |
| * Validates a 9-character CUSIP or 8-character stem. | |
| */ | |
| export function validateCusip(rawCusip: string): CusipValidationResult { | |
| if (!rawCusip) { | |
| return { | |
| isValid: false, | |
| normalizedCusip: '', | |
| issuerCode: '', | |
| issueCode: '', | |
| actualCheckDigit: null, | |
| expectedCheckDigit: null, | |
| errorMessage: 'CUSIP cannot be empty.' | |
| }; | |
| } | |
| const cleaned = rawCusip.toUpperCase().replace(/[^0-9A-Z*@#]/g, ''); | |
| if (cleaned.length < 8) { | |
| return { | |
| isValid: false, | |
| normalizedCusip: cleaned, | |
| issuerCode: cleaned.slice(0, 6), | |
| issueCode: cleaned.slice(6), | |
| actualCheckDigit: null, | |
| expectedCheckDigit: null, | |
| errorMessage: `CUSIP stem must be at least 8 characters (current: ${cleaned.length}).` | |
| }; | |
| } | |
| const stem = cleaned.slice(0, 8); | |
| const expectedCheckDigit = calculateCusipCheckDigit(stem); | |
| if (expectedCheckDigit === null) { | |
| return { | |
| isValid: false, | |
| normalizedCusip: cleaned, | |
| issuerCode: stem.slice(0, 6), | |
| issueCode: stem.slice(6, 8), | |
| actualCheckDigit: null, | |
| expectedCheckDigit: null, | |
| errorMessage: 'Invalid characters in CUSIP stem.' | |
| }; | |
| } | |
| if (cleaned.length === 8) { | |
| // 8-character stem provided: compute and propose full 9-char CUSIP | |
| return { | |
| isValid: false, | |
| normalizedCusip: `${stem}${expectedCheckDigit}`, | |
| issuerCode: stem.slice(0, 6), | |
| issueCode: stem.slice(6, 8), | |
| actualCheckDigit: null, | |
| expectedCheckDigit: expectedCheckDigit, | |
| errorMessage: `8-character stem provided. Check digit should be ${expectedCheckDigit}.` | |
| }; | |
| } | |
| const actualCheckDigit = parseInt(cleaned[8], 10); | |
| if (isNaN(actualCheckDigit)) { | |
| return { | |
| isValid: false, | |
| normalizedCusip: cleaned.slice(0, 9), | |
| issuerCode: stem.slice(0, 6), | |
| issueCode: stem.slice(6, 8), | |
| actualCheckDigit: null, | |
| expectedCheckDigit, | |
| errorMessage: '9th character must be a numeric check digit (0-9).' | |
| }; | |
| } | |
| const isValid = actualCheckDigit === expectedCheckDigit; | |
| return { | |
| isValid, | |
| normalizedCusip: cleaned.slice(0, 9), | |
| issuerCode: stem.slice(0, 6), | |
| issueCode: stem.slice(6, 8), | |
| actualCheckDigit, | |
| expectedCheckDigit, | |
| errorMessage: isValid | |
| ? undefined | |
| : `Check digit mismatch: got ${actualCheckDigit}, expected ${expectedCheckDigit} (Luhn mod-10).` | |
| }; | |
| } | |
| /** | |
| * Format CUSIP with standard spacing (e.g., "917292 AA 1" or "917292-AA-1") | |
| */ | |
| export function formatCusipSpaced(raw: string): string { | |
| const clean = raw.toUpperCase().replace(/[^0-9A-Z*@#]/g, ''); | |
| if (clean.length <= 6) return clean; | |
| if (clean.length <= 8) return `${clean.slice(0, 6)} ${clean.slice(6)}`; | |
| return `${clean.slice(0, 6)} ${clean.slice(6, 8)} ${clean.slice(8, 9)}`; | |
| } | |