validation.lei

export function validateLei(value: string): LeiCheck

/** The result of checking an LEI. Every string is null when valid is false; reason is null when it is true. */
export interface LeiCheck {
  readonly valid: boolean;
  /** upper case, no spaces, 20 characters */
  readonly normalised: string | null;
  /** the first four characters, which identify the issuing organisation (LOU) */
  readonly louPrefix: string | null;
  /** empty, bad-character, bad-length, bad-format or bad-check-digit */
  readonly reason: string | null;
}

import { validateLei } from "#fune/validation.lei@^1";

import { type LeiCheck } from "./validation_lei_types.ts";

function invalid(reason: string): LeiCheck {
  return { valid: false, normalised: null, louPrefix: null, reason };
}

function isDigit(ch: string): boolean {
  return ch >= "0" && ch <= "9";
}

/**
 * ISO 7064 MOD 97-10 over the whole LEI, letters read as A = 10 ... Z = 35.
 *
 * The expansion is up to 40 digits, past any 64-bit integer, so the remainder
 * is carried one character at a time. A letter contributes two digits and so
 * multiplies the running remainder by 100; the largest intermediate is
 * 96 * 100 + 35.
 */
function mod97(lei: string): number {
  let remainder = 0;
  for (let i = 0; i < lei.length; i++) {
    const code = lei.charCodeAt(i);
    remainder = code <= 57 ? (remainder * 10 + (code - 48)) % 97 : (remainder * 100 + (code - 55)) % 97;
  }
  return remainder;
}

/**
 * Check a Legal Entity Identifier's format and ISO 17442 check digits.
 *
 * Well formed is not issued: only GLEIF says whether an LEI is current.
 * Validators answer rather than throw.
 */
export function validateLei(value: string): LeiCheck {
  if (typeof value !== "string") return invalid("empty");

  let lei = "";
  for (const ch of value) {
    if (ch === " ") continue;
    // Folded by hand: toUpperCase() is Unicode-aware and Rust's ASCII fold is not.
    lei += ch >= "a" && ch <= "z" ? String.fromCharCode(ch.charCodeAt(0) - 32) : ch;
  }
  if (lei.length === 0) return invalid("empty");
  for (const ch of lei) {
    if (!isDigit(ch) && !(ch >= "A" && ch <= "Z")) return invalid("bad-character");
  }
  if (lei.length !== 20) return invalid("bad-length");
  if (!isDigit(lei[18]) || !isDigit(lei[19])) return invalid("bad-format");
  // The remainder must be 1, not 0: the check digits are chosen so that it is.
  if (mod97(lei) !== 1) return invalid("bad-check-digit");

  return { valid: true, normalised: lei, louPrefix: lei.slice(0, 4), reason: null };
}

Install

fune build

With that line in your source, in a TypeScript project (language typescript in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the TypeScript package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add validation.lei

The manifest, vectors and README with only the TypeScript implementation. Install it without the registry with fune add ./validation.lei-1.0.0-typescript.fune, or fetch it from a terminal with fune pull validation.lei@1.0.0:typescript.

The whole function, every language, is one file too: validation.lei-1.0.0.fune, 13,996 bytes, sha256 fde9af0883131cea8a51a63bf4bfb2b0bf9f39bd4aca36513ebfebb722d46a54. It installs into a project of any language.

// fune: before validation.lei

// fune: after validation.lei

// fune: step validation.lei after <n|label>

More from the author

THE CHECK is ISO 7064 MOD 97-10, the same arithmetic as an IBAN's: read each letter as a number (A = 10 ... Z = 35), keep digits as they are, and the whole 20-character number must leave a remainder of 1 when divided by 97. A remainder of 0 is wrong, which is the mistake a validator written from memory makes. The expanded number is up to 40 digits long, too long for a 64-bit integer, so all three implementations carry the remainder along one character at a time.

This is the same arithmetic `validation.iban` uses, but that capability keeps its mod-97 routine private (nothing to import), and a level-0 capability cannot require another, so the dozen lines are written out here.

A PASSING LEI IS WELL FORMED, NOT NECESSARILY ISSUED OR CURRENT. LEIs lapse if not renewed each year; only the GLEIF database (https://search.gleif.org) says whether one is issued, lapsed or retired, and whose it is.

ACCEPTED INPUT: letters in either case (folded to upper case) and digits, with ASCII spaces ignored anywhere ("5493 001K ..."). Anything else is refused.

| reason | meaning | |-------------------|----------------------------------------------------------| | `empty` | nothing but spaces, or not a string at all | | `bad-character` | anything other than A-Z, a-z, 0-9 and spaces | | `bad-length` | not exactly 20 characters | | `bad-format` | the last two characters are not both digits | | `bad-check-digit` | the MOD 97-10 remainder is not 1 |

The checks run in that order; the first failure is the reason. Validators answer rather than throw.

Sources: ISO 17442-1:2020 "Financial services - Legal entity identifier (LEI)"; ISO/IEC 7064:2003 MOD 97-10; GLEIF, "LEI in detail" (https://www.gleif.org/en/about-lei/iso-17442-the-lei-code-structure).

Files