solana-age-verify-sdk 2.0.0-beta.2

package/dist/liveness/texture.js

@@ -0,0 +1,266 @@
+/**
+ * Texture Analysis for Passive Liveness Detection
+ *
+ * This module analyzes the surface characteristics of a face to distinguish between:
+ * - Real human faces (3D, natural skin texture, pores, wrinkles)
+ * - Spoofing attempts (2D photos, screens, masks)
+ *
+ * Techniques used:
+ * 1. Local Binary Patterns (LBP) - Detects local texture patterns
+ * 2. Frequency Analysis - Identifies print/screen artifacts
+ * 3. Moiré Pattern Detection - Detects screen recapture
+ * 4. Reflectance Analysis - Analyzes light interaction with surface
+ */
+/**
+ * Analyzes texture from a face region to detect liveness
+ */
+export class TextureAnalyzer {
+    constructor() {
+        Object.defineProperty(this, "canvas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Use OffscreenCanvas in worker, HTMLCanvasElement in main thread
+        if (typeof OffscreenCanvas !== 'undefined') {
+            this.canvas = new OffscreenCanvas(256, 256);
+            this.ctx = this.canvas.getContext('2d');
+        }
+        else {
+            this.canvas = document.createElement('canvas');
+            this.canvas.width = 256;
+            this.canvas.height = 256;
+            this.ctx = this.canvas.getContext('2d');
+        }
+    }
+    /**
+     * Main analysis function
+     */
+    async analyze(frame, faceRegion) {
+        // Extract face region or use entire frame
+        const imageData = this.extractRegion(frame, faceRegion);
+        // Run parallel analyses
+        const [lbpScore, freqScore, moireDetected, reflectance] = await Promise.all([
+            this.analyzeLBP(imageData),
+            this.analyzeFrequency(imageData),
+            this.detectMoire(imageData),
+            this.analyzeReflectance(imageData)
+        ]);
+        // Combine scores
+        const skinComplexity = lbpScore;
+        const frequencyScore = freqScore;
+        // Decision logic: Real if complexity is high AND no moiré AND natural reflectance
+        const complexityThreshold = 0.3;
+        const frequencyThreshold = 0.35;
+        const isReal = skinComplexity > complexityThreshold &&
+            frequencyScore > frequencyThreshold &&
+            !moireDetected &&
+            reflectance !== 'artificial';
+        // Confidence based on how far from thresholds
+        const complexityDist = Math.abs(skinComplexity - complexityThreshold);
+        const freqDist = Math.abs(frequencyScore - frequencyThreshold);
+        const confidence = Math.min(1.0, (complexityDist + freqDist) / 2 + 0.5);
+        return {
+            isReal,
+            confidence,
+            features: {
+                skinComplexity,
+                moireDetected,
+                frequencyScore,
+                reflectancePattern: reflectance
+            }
+        };
+    }
+    /**
+     * Extract region of interest from frame
+     */
+    extractRegion(frame, region) {
+        // Draw to canvas
+        if (frame instanceof ImageData) {
+            this.ctx.putImageData(frame, 0, 0);
+        }
+        else {
+            this.ctx.drawImage(frame, 0, 0, this.canvas.width, this.canvas.height);
+        }
+        // Extract region if specified
+        if (region) {
+            const { x, y, width, height } = region;
+            return this.ctx.getImageData(x, y, width, height);
+        }
+        return this.ctx.getImageData(0, 0, this.canvas.width, this.canvas.height);
+    }
+    /**
+     * Local Binary Patterns (LBP) Analysis
+     * Detects micro-texture patterns in skin
+     */
+    async analyzeLBP(imageData) {
+        const { data, width, height } = imageData;
+        const grayscale = this.toGrayscale(data, width, height);
+        // LBP histogram (256 bins for uniform LBP)
+        const histogram = new Array(256).fill(0);
+        // Calculate LBP for each pixel (excluding borders)
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                const center = grayscale[y * width + x];
+                let lbpValue = 0;
+                // 8 neighbors in clockwise order
+                const neighbors = [
+                    grayscale[(y - 1) * width + (x - 1)], // top-left
+                    grayscale[(y - 1) * width + x], // top
+                    grayscale[(y - 1) * width + (x + 1)], // top-right
+                    grayscale[y * width + (x + 1)], // right
+                    grayscale[(y + 1) * width + (x + 1)], // bottom-right
+                    grayscale[(y + 1) * width + x], // bottom
+                    grayscale[(y + 1) * width + (x - 1)], // bottom-left
+                    grayscale[y * width + (x - 1)] // left
+                ];
+                // Build LBP code
+                for (let i = 0; i < 8; i++) {
+                    if (neighbors[i] >= center) {
+                        lbpValue |= (1 << i);
+                    }
+                }
+                histogram[lbpValue]++;
+            }
+        }
+        // Normalize histogram
+        const totalPixels = (width - 2) * (height - 2);
+        const normalizedHist = histogram.map(v => v / totalPixels);
+        // Calculate entropy (measure of texture complexity)
+        let entropy = 0;
+        for (const p of normalizedHist) {
+            if (p > 0) {
+                entropy -= p * Math.log2(p);
+            }
+        }
+        // Normalize entropy to 0-1 range (max entropy for 256 bins is 8)
+        const normalizedEntropy = entropy / 8;
+        // Real skin has moderate-to-high entropy (complex texture)
+        // Photos/screens have lower entropy (uniform patterns)
+        return normalizedEntropy;
+    }
+    /**
+     * Frequency Domain Analysis
+     * Detects print patterns and screen grids
+     */
+    async analyzeFrequency(imageData) {
+        const { data, width, height } = imageData;
+        const grayscale = this.toGrayscale(data, width, height);
+        // Simple frequency analysis using gradient magnitude
+        let totalGradient = 0;
+        let highFreqCount = 0;
+        for (let y = 1; y < height - 1; y++) {
+            for (let x = 1; x < width - 1; x++) {
+                // Sobel gradients
+                const gx = -grayscale[(y - 1) * width + (x - 1)] +
+                    grayscale[(y - 1) * width + (x + 1)] +
+                    -2 * grayscale[y * width + (x - 1)] +
+                    2 * grayscale[y * width + (x + 1)] +
+                    -grayscale[(y + 1) * width + (x - 1)] +
+                    grayscale[(y + 1) * width + (x + 1)];
+                const gy = -grayscale[(y - 1) * width + (x - 1)] +
+                    -2 * grayscale[(y - 1) * width + x] +
+                    -grayscale[(y - 1) * width + (x + 1)] +
+                    grayscale[(y + 1) * width + (x - 1)] +
+                    2 * grayscale[(y + 1) * width + x] +
+                    grayscale[(y + 1) * width + (x + 1)];
+                const magnitude = Math.sqrt(gx * gx + gy * gy);
+                totalGradient += magnitude;
+                // Count high-frequency components (sharp edges)
+                if (magnitude > 50) {
+                    highFreqCount++;
+                }
+            }
+        }
+        const avgGradient = totalGradient / ((width - 2) * (height - 2));
+        const highFreqRatio = highFreqCount / ((width - 2) * (height - 2));
+        // Real skin has moderate gradients with natural variation
+        // Printed images have either too uniform or too sharp edges
+        // Score based on "naturalness" of gradient distribution
+        const naturalGradientRange = avgGradient > 5 && avgGradient < 30;
+        const naturalFreqRatio = highFreqRatio > 0.01 && highFreqRatio < 0.15;
+        return (naturalGradientRange && naturalFreqRatio) ? 0.7 : 0.3;
+    }
+    /**
+     * Moiré Pattern Detection
+     * Detects interference patterns from screen recapture
+     */
+    async detectMoire(imageData) {
+        const { data, width, height } = imageData;
+        // Look for periodic patterns that indicate moiré
+        // Simple approach: check for regular oscillations in intensity
+        let periodicityScore = 0;
+        const sampleRows = 10;
+        for (let i = 0; i < sampleRows; i++) {
+            const y = Math.floor((height / sampleRows) * i);
+            const rowData = [];
+            for (let x = 0; x < width; x++) {
+                const idx = (y * width + x) * 4;
+                const gray = (data[idx] + data[idx + 1] + data[idx + 2]) / 3;
+                rowData.push(gray);
+            }
+            // Count zero-crossings (sign changes in derivative)
+            let crossings = 0;
+            for (let x = 1; x < rowData.length - 1; x++) {
+                const diff1 = rowData[x] - rowData[x - 1];
+                const diff2 = rowData[x + 1] - rowData[x];
+                if (diff1 * diff2 < 0)
+                    crossings++;
+            }
+            // High crossing count indicates periodic pattern
+            const crossingRatio = crossings / width;
+            if (crossingRatio > 0.3)
+                periodicityScore++;
+        }
+        // Moiré detected if multiple rows show high periodicity
+        return periodicityScore > sampleRows * 0.5;
+    }
+    /**
+     * Reflectance Pattern Analysis
+     * Analyzes how light interacts with the surface
+     */
+    async analyzeReflectance(imageData) {
+        const { data } = imageData;
+        // Analyze brightness distribution
+        const brightnesses = [];
+        for (let i = 0; i < data.length; i += 4) {
+            const brightness = (data[i] + data[i + 1] + data[i + 2]) / 3;
+            brightnesses.push(brightness);
+        }
+        // Calculate statistics
+        const mean = brightnesses.reduce((a, b) => a + b, 0) / brightnesses.length;
+        const variance = brightnesses.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / brightnesses.length;
+        const stdDev = Math.sqrt(variance);
+        // Real skin has moderate variance (natural shadows and highlights)
+        // Photos/screens tend to have either too uniform or too high contrast
+        const coefficientOfVariation = stdDev / (mean + 1); // +1 to avoid division by zero
+        if (coefficientOfVariation > 0.15 && coefficientOfVariation < 0.5) {
+            return 'natural';
+        }
+        else if (coefficientOfVariation < 0.1 || coefficientOfVariation > 0.7) {
+            return 'artificial';
+        }
+        return 'unknown';
+    }
+    /**
+     * Convert RGBA to grayscale
+     */
+    toGrayscale(data, width, height) {
+        const grayscale = new Uint8Array(width * height);
+        for (let i = 0; i < grayscale.length; i++) {
+            const idx = i * 4;
+            // Luminance formula
+            grayscale[i] = Math.floor(0.299 * data[idx] +
+                0.587 * data[idx + 1] +
+                0.114 * data[idx + 2]);
+        }
+        return grayscale;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,86 @@
+export interface VerifyHost18PlusOptions {
+    walletPubkeyBase58: string;
+    videoElement?: HTMLVideoElement;
+    uiMountEl?: HTMLElement;
+    signal?: AbortSignal;
+    config?: Partial<VerifyConfig>;
+    onChallenge?: (challenge: string) => void;
+    modelPath?: string;
+    workerFactory?: () => Worker;
+    connection?: any;
+    wallet?: {
+        publicKey: any;
+        signTransaction: (tx: any) => Promise<any>;
+    };
+}
+export interface VerifyConfig {
+    challenges: string[];
+    minLivenessScore: number;
+    minAgeConfidence: number;
+    minAgeEstimate: number;
+    timeoutMs: number;
+    maxRetries: number;
+    cooldownMinutes: number;
+}
+export declare const DEFAULT_CONFIG: VerifyConfig;
+export interface ChallengeResult {
+    type: string;
+    passed: boolean;
+    score: number;
+}
+export interface VerifyResult {
+    over18: boolean;
+    facehash: string;
+    description: string;
+    verifiedAt: string;
+    protocolFeePaid?: boolean;
+    protocolFeeTxId?: string;
+    evidence: {
+        ageEstimate: number;
+        ageConfidence: number;
+        livenessScore: number;
+        textureScore?: number;
+        textureFeatures?: TextureFeatures;
+        ageMethod?: string;
+        challenges: ChallengeResult[];
+        modelVersions: Record<string, string>;
+        saltHex: string;
+        sessionNonceHex: string;
+    };
+}
+export interface FrameData {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+    timestamp: number;
+}
+export interface WorkerResponse {
+    type: 'RESULT' | 'ERROR' | 'LOADED';
+    payload?: any;
+    error?: string;
+}
+export interface WorkerRequest {
+    type: 'PROCESS_FRAME' | 'LOAD_MODELS';
+    payload?: any;
+}
+export interface TextureFeatures {
+    skinComplexity: number;
+    moireDetected: boolean;
+    frequencyScore: number;
+    reflectancePattern: 'natural' | 'artificial' | 'unknown';
+}
+export interface DetectionResult {
+    faceFound: boolean;
+    landmarks?: number[];
+    ageEstimate?: number;
+    embedding?: number[];
+    confidence?: number;
+    textureScore?: number;
+    textureFeatures?: TextureFeatures;
+    ageConfidence?: number;
+    ageMethod?: 'onnx' | 'geometric' | 'unknown';
+}
+export interface FaceModelAdapter {
+    load(basePath?: string): Promise<void>;
+    detect(frame: ImageData | HTMLCanvasElement | OffscreenCanvas): Promise<DetectionResult>;
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+export const DEFAULT_CONFIG = {
+    challenges: [],
+    minLivenessScore: 0.85,
+    minAgeConfidence: 0.65,
+    minAgeEstimate: 18,
+    timeoutMs: 90000,
+    maxRetries: 3,
+    cooldownMinutes: 15
+};

package/dist/verify.d.ts

@@ -0,0 +1,4 @@
+import { VerifyHost18PlusOptions, VerifyResult } from './types';
+export declare function verifyHost18Plus(options: VerifyHost18PlusOptions): Promise<VerifyResult>;
+export declare function createVerificationUI(): HTMLElement;
+export declare function setExecutionBackend(backend: 'tfjs' | 'onnx'): void;