noah-avalanche-sdk 0.1.2

package/src/utils/mrz.ts

@@ -0,0 +1,113 @@
+export interface MRZData {
+    documentType: string;
+    issuingState: string;
+    lastName: string;
+    firstName: string;
+    passportNumber: string;
+    nationality: string;
+    dateOfBirth: Date;
+    gender: string;
+    expiryDate: Date;
+    personalNumber: string;
+    age: number;
+}
+
+export function validateCheckDigit(str: string, checkDigit: string): boolean {
+    const weights = [7, 3, 1];
+    let sum = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        let value = 0;
+        if (char === '<') {
+            value = 0;
+        } else if (/[0-9]/.test(char)) {
+            value = parseInt(char);
+        } else if (/[A-Z]/.test(char)) {
+            value = char.charCodeAt(0) - 65 + 10;
+        }
+        sum += value * weights[i % 3];
+    }
+    return (sum % 10) === parseInt(checkDigit);
+}
+
+function parseDate(str: string, isDOB: boolean = false): Date {
+    const yearStr = str.substring(0, 2);
+    const month = parseInt(str.substring(2, 4)) - 1;
+    const day = parseInt(str.substring(4, 6));
+
+    let year = parseInt(yearStr);
+    const currentYear = new Date().getFullYear() % 100;
+
+    if (isDOB) {
+        if (year > currentYear) {
+            year += 1900;
+        } else {
+            year += 2000;
+        }
+    } else {
+        // For expiry date, assume 20xx
+        year += 2000;
+    }
+
+    return new Date(year, month, day);
+}
+
+export function parseTD3(line1: string, line2: string): MRZData {
+    if (line1.length !== 44 || line2.length !== 44) {
+        throw new Error('Invalid TD3 MRZ length');
+    }
+
+    const documentType = line1.substring(0, 2).replace(/</g, '');
+    const issuingState = line1.substring(2, 5).replace(/</g, '');
+
+    const namesPart = line1.substring(5);
+    const [lastNamePart, firstNamePart] = namesPart.split('<<');
+    const lastName = lastNamePart.replace(/</g, ' ').trim();
+    const firstName = (firstNamePart || '').replace(/</g, ' ').trim();
+
+    const passportNumber = line2.substring(0, 9).replace(/</g, '');
+    const passportCheck = line2.substring(9, 10);
+    if (!validateCheckDigit(line2.substring(0, 9), passportCheck)) {
+        throw new Error('Invalid passport number check digit');
+    }
+
+    const nationality = line2.substring(10, 13).replace(/</g, '');
+    const dobStr = line2.substring(13, 19);
+    const dobCheck = line2.substring(19, 20);
+    if (!validateCheckDigit(dobStr, dobCheck)) {
+        throw new Error('Invalid date of birth check digit');
+    }
+    const dateOfBirth = parseDate(dobStr, true);
+
+    const gender = line2.substring(20, 21);
+    const expiryStr = line2.substring(21, 27);
+    const expiryCheck = line2.substring(27, 28);
+    if (!validateCheckDigit(expiryStr, expiryCheck)) {
+        throw new Error('Invalid expiry date check digit');
+    }
+    const expiryDate = parseDate(expiryStr, false);
+
+    const personalNumber = line2.substring(28, 42).replace(/</g, '');
+
+    // Calculate age
+    const today = new Date();
+    let age = today.getFullYear() - dateOfBirth.getFullYear();
+    const m = today.getMonth() - dateOfBirth.getMonth();
+    if (m < 0 || (m === 0 && today.getDate() < dateOfBirth.getDate())) {
+        age--;
+    }
+
+    return {
+        documentType,
+        issuingState,
+        lastName,
+        firstName,
+        passportNumber,
+        nationality,
+        dateOfBirth,
+        gender,
+        expiryDate,
+        personalNumber,
+        age,
+    };
+}

package/src/utils/ocr.ts

@@ -0,0 +1,84 @@
+import { createWorker, type Worker } from 'tesseract.js';
+
+export interface OCROutput {
+    rawText: string;
+    mrzLines: string[];
+    confidence: number;
+}
+
+/**
+ * OCR Extractor for processing identity documents in the browser
+ */
+export class OCRExtractor {
+    private worker: Worker | null = null;
+    private initialized: boolean = false;
+
+    /**
+     * Initialize the Tesseract worker
+     */
+    async initialize() {
+        if (this.initialized) return;
+
+        this.worker = await createWorker('eng'); // MRZ is always Latin characters
+        this.initialized = true;
+    }
+
+    /**
+     * Extract MRZ data from an image
+     * @param imageSource - URL, File, or Blob of the document image
+     * @returns Extracted text and MRZ lines
+     */
+    async extractMRZ(imageSource: string | File | Blob): Promise<OCROutput> {
+        await this.initialize();
+
+        if (!this.worker) {
+            throw new Error('OCR Worker not initialized');
+        }
+
+        // Set parameters to optimize for MRZ
+        // MRZ uses a specific OCR-B font, but standard 'eng' is usually sufficient
+        // We can restrict characters to A-Z, 0-9, and '<'
+        await this.worker.setParameters({
+            tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789<',
+        });
+
+        const { data: { text, confidence } } = await this.worker.recognize(imageSource);
+
+        const mrzLines = this.filterMRZLines(text);
+
+        return {
+            rawText: text,
+            mrzLines,
+            confidence,
+        };
+    }
+
+    /**
+     * Filter and clean MRZ lines from raw OCR text
+     */
+    private filterMRZLines(text: string): string[] {
+        const lines = text.split('\n').map(l => l.trim().replace(/\s/g, ''));
+
+        // TD3 MRZ (Passport) is 2 lines of 44 characters
+        // TD1 (ID Card) is 3 lines of 30 characters
+        // We look for lines containing multiple '<' characters
+        return lines.filter(line => {
+            const charCount = line.length;
+            const chevronCount = (line.match(/</g) || []).length;
+
+            // Heuristic: MRZ lines are long and have many chevrons
+            return (charCount >= 30 && chevronCount >= 2);
+        });
+    }
+
+    /**
+     * Terminate the worker to free resources
+     */
+    async terminate() {
+        if (this.worker) {
+            await this.worker.terminate();
+            this.worker = null;
+            this.initialized = false;
+        }
+    }
+}

package/src/utils/types.ts

@@ -0,0 +1,144 @@
+import type { 
+  Provider, 
+  ContractTransactionReceipt,
+  EventLog,
+  Log
+} from 'ethers';
+
+/**
+ * Contract addresses configuration
+ */
+export interface ContractAddresses {
+  CredentialRegistry: string;
+  ZKVerifier: string;
+  ProtocolAccessControl: string;
+}
+
+/**
+ * Protocol requirements structure
+ */
+export interface Requirements {
+  minAge: number;
+  allowedJurisdictions: string[];
+  requireAccredited: boolean;
+  isSet?: boolean;
+}
+
+/**
+ * Issuer information structure
+ */
+export interface IssuerInfo {
+  isTrusted: boolean;
+  name: string;
+}
+
+/**
+ * ZK Proof structure (Groth16 format)
+ */
+export interface Proof {
+  a: [string, string];
+  b: [[string, string], [string, string]];
+  c: [string, string];
+}
+
+/**
+ * ZK Proof structure (alias for compatibility)
+ */
+export type ZKProof = Proof;
+
+/**
+ * Transaction result
+ */
+export interface TransactionResult {
+  transactionHash: string;
+  receipt: ContractTransactionReceipt | null;
+}
+
+/**
+ * Contract client configuration options
+ */
+export interface ContractClientConfig {
+  provider?: Provider;
+  contractAddresses?: ContractAddresses;
+  rpcUrl?: string;
+}
+
+/**
+ * Protocol client configuration
+ */
+export interface ProtocolClientConfig {
+  protocolAccessControlAddress?: string;
+  provider?: Provider;
+}
+
+/**
+ * Set requirements parameters
+ */
+export interface SetRequirementsParams {
+  minAge: number;
+  jurisdictions: string[] | number[];
+  requireAccredited: boolean;
+}
+
+/**
+ * Verify user access parameters
+ */
+export interface VerifyUserAccessParams {
+  userAddress: string;
+  proof: Proof;
+  publicSignals: string[] | number[];
+  credentialHash: string;
+}
+
+/**
+ * Credential issued event payload
+ */
+export interface CredentialIssuedEvent {
+  user: string;
+  credentialHash: string;
+  issuer: string;
+  timestamp: bigint;
+}
+
+/**
+ * Access granted event payload
+ */
+export interface AccessGrantedEvent {
+  user: string;
+  protocol: string;
+  credentialHash: string;
+  timestamp: bigint;
+}
+
+/**
+ * Contract event listener callback type
+ */
+export type EventCallback<T = any> = (
+  ...args: T[]
+) => void | Promise<void>;
+
+/**
+ * Contract event payload type
+ */
+export type ContractEventPayload = EventLog | Log;
+
+/**
+ * Credential data structure for hash generation
+ */
+export interface CredentialData {
+  userAddress: string;
+  age: number;
+  jurisdiction: string;
+  accredited: boolean;
+  timestamp?: number;
+}
+
+/**
+ * Credential hash generation result
+ */
+export interface CredentialHashResult {
+  credentialHash: string;
+  jurisdictionHash: string;
+  credentialData: string;
+  timestamp: number;
+}