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

package/dist/adapters/onnx.js

@@ -0,0 +1,171 @@
+import * as ort from 'onnxruntime-web';
+export class ONNXAgeEstimator {
+    constructor() {
+        Object.defineProperty(this, "session", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "inputName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'input_1'
+        });
+    }
+    async load(modelUrl) {
+        try {
+            // Set WASM paths to point to root (where vite-plugin-static-copy puts them)
+            // In a worker, self.location is available.
+            const isWorker = typeof self.importScripts === 'function';
+            const origin = isWorker ? self.location.origin : (typeof window !== 'undefined' ? window.location.origin : '');
+            ort.env.wasm.wasmPaths = origin + '/';
+            console.log(`ONNX: Loading model from ${modelUrl}...`);
+            this.session = await ort.InferenceSession.create(modelUrl, {
+                executionProviders: ['wasm', 'webgl']
+            });
+            this.inputName = this.session.inputNames[0];
+            console.log(`ONNX: Model loaded successfully. Input: ${this.inputName}`);
+        }
+        catch (e) {
+            console.error('ONNX: Failed to load model', e);
+            // If WebGL fails, try WASM only as fallback
+            if (e.message && (e.message.includes('WebGL') || e.message.includes('backend'))) {
+                try {
+                    console.log('ONNX: Retrying with WASM-only backend...');
+                    this.session = await ort.InferenceSession.create(modelUrl, {
+                        executionProviders: ['wasm']
+                    });
+                    this.inputName = this.session.inputNames[0];
+                    return;
+                }
+                catch (e2) {
+                    console.error('ONNX: WASM fallback also failed', e2);
+                }
+            }
+            throw e;
+        }
+    }
+    async estimateAge(faceCanvas) {
+        if (!this.session)
+            return { age: 0, confidence: 0 };
+        try {
+            // 1. Preprocess: Resize to 64x64 (typical for genderage.onnx) and NCHW
+            const inputTensor = await this.preprocess(faceCanvas);
+            // 2. Run Inference
+            const feeds = {};
+            feeds[this.inputName] = inputTensor;
+            const results = await this.session.run(feeds);
+            // 3. Postprocess: Get Age
+            // Model typically outputs: [gender_prob, age_score] or similar
+            // For yakyo/genderage.onnx, output is often:
+            // Output 0: Gender (1x2)
+            // Output 1: Age (1x1)? Or 1x100 (distribution)? 
+            // We'll inspect standard usage: typically it's a regression or classification
+            // Let's assume standard output for now and log it to debug if needed
+            // If it's the specific 'genderage.onnx' from yakyo:
+            // It has 'dense_1' (gender) and 'dense_2' (age)
+            const outputNames = this.session.outputNames;
+            // Assuming one of them is age. Usually the second one for multi-task models.
+            // But let's look for "age" keyword or "dense_2"
+            // Simple heuristic for now: find output with bigger shape or just take the explicit one if known
+            // yakyo model: output 0 is gender, output 1 is age * 100? or age class?
+            // Actually yakyo model outputs age as a regression value (0-1) * 100?
+            let ageVal = 25;
+            let confVal = 0.5;
+            for (const name of outputNames) {
+                const tensor = results[name];
+                const data = tensor.data;
+                const isLikelyAge = name.toLowerCase().includes('age') || name.includes('dense_2');
+                // If single value, likely regression
+                if (data.length === 1) {
+                    const val = data[0];
+                    console.log(`ONNX: Raw regression output (${name}):`, val);
+                    // If it's 0-1, it's likely normalized age / 100
+                    // Higher probability of being normalized if < 1.0 but some models use 0.0-1.0 to map to 0-80 or 0-100
+                    ageVal = val < 1.0 ? val * 100 : val;
+                    confVal = 0.85;
+                    if (isLikelyAge)
+                        break; // Found it!
+                }
+                // If vector ~100 length, likely distribution (Softmax expectation)
+                else if (data.length >= 80 && data.length <= 110) {
+                    console.log(`ONNX: Distribution output (${name}), size ${data.length}`);
+                    let expectedAge = 0;
+                    // ... (rest of logic remains same but we check summing)
+                    // Check if it's already softmaxed (sums to ~1)
+                    let sum = 0;
+                    for (let i = 0; i < data.length; i++)
+                        sum += data[i];
+                    let probs = data;
+                    if (Math.abs(sum - 1.0) > 0.1) {
+                        // Needs Softmax
+                        const expData = Array.from(data).map(v => Math.exp(v));
+                        const expSum = expData.reduce((a, b) => a + b, 0);
+                        probs = new Float32Array(expData.map(v => v / expSum));
+                    }
+                    for (let i = 0; i < probs.length; i++) {
+                        expectedAge += i * probs[i];
+                    }
+                    // Confidence is the max probability (peakiness)
+                    confVal = Math.max(...Array.from(probs));
+                    ageVal = expectedAge;
+                    if (isLikelyAge)
+                        break;
+                }
+            }
+            return {
+                age: Math.max(1, Math.min(100, ageVal)),
+                confidence: confVal
+            };
+        }
+        catch (e) {
+            console.warn('ONNX Inference failed:', e);
+            return { age: 0, confidence: 0 };
+        }
+    }
+    async preprocess(canvas) {
+        // Create a temporary implementation for resizing and normalization
+        // This expects 64x64 input usually
+        const width = 64;
+        const height = 64;
+        // Resize logic (using OffscreenCanvas or temp canvas)
+        let ctx;
+        // Simple resize using a temp canvas
+        let tempCanvas;
+        if (typeof OffscreenCanvas !== 'undefined') {
+            tempCanvas = new OffscreenCanvas(width, height);
+            ctx = tempCanvas.getContext('2d');
+        }
+        else {
+            tempCanvas = document.createElement('canvas');
+            tempCanvas.width = width;
+            tempCanvas.height = height;
+            ctx = tempCanvas.getContext('2d');
+        }
+        if (!ctx)
+            throw new Error('No context');
+        ctx.drawImage(canvas, 0, 0, width, height);
+        const imageData = ctx.getImageData(0, 0, width, height);
+        const { data } = imageData; // RGBA
+        // Convert to Float32 NCHW [1, 3, 64, 64]
+        const float32Data = new Float32Array(1 * 3 * width * height);
+        for (let i = 0; i < width * height; i++) {
+            // Normalize: (x - mean) / std ? Or just 0-1?
+            // Common for these models: 0-1 or -1 to 1
+            // yakyo model usually checks for 0-1
+            const r = data[i * 4] / 255.0;
+            const g = data[i * 4 + 1] / 255.0;
+            const b = data[i * 4 + 2] / 255.0;
+            // NCHW
+            // R plane
+            float32Data[i] = r;
+            // G plane
+            float32Data[width * height + i] = g;
+            // B plane
+            float32Data[2 * width * height + i] = b;
+        }
+        return new ort.Tensor('float32', float32Data, [1, 3, height, width]);
+    }
+}

package/dist/camera.d.ts

@@ -0,0 +1,15 @@
+export declare class Camera {
+    private stream;
+    private video;
+    private canvas;
+    private ctx;
+    constructor(videoElement?: HTMLVideoElement);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    captureFrame(): {
+        data: Uint8ClampedArray;
+        width: number;
+        height: number;
+        timestamp: number;
+    };
+}

package/dist/camera.js

@@ -0,0 +1,76 @@
+export class Camera {
+    constructor(videoElement) {
+        Object.defineProperty(this, "stream", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "video", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        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
+        });
+        this.video = videoElement || document.createElement('video');
+        this.video.setAttribute('playsinline', 'true');
+        this.video.style.display = videoElement ? 'block' : 'none';
+        this.canvas = document.createElement('canvas');
+        const ctx = this.canvas.getContext('2d');
+        if (!ctx)
+            throw new Error('Could not get 2D context');
+        this.ctx = ctx;
+    }
+    async start() {
+        if (this.stream)
+            return;
+        this.stream = await navigator.mediaDevices.getUserMedia({
+            video: {
+                width: { ideal: 640 },
+                height: { ideal: 480 },
+                facingMode: 'user'
+            },
+            audio: false
+        });
+        this.video.srcObject = this.stream;
+        await new Promise((resolve) => {
+            this.video.onloadedmetadata = () => {
+                this.video.play();
+                resolve();
+            };
+        });
+        this.canvas.width = this.video.videoWidth;
+        this.canvas.height = this.video.videoHeight;
+    }
+    async stop() {
+        if (this.stream) {
+            this.stream.getTracks().forEach(track => track.stop());
+            this.stream = null;
+        }
+        this.video.srcObject = null;
+    }
+    captureFrame() {
+        if (!this.stream)
+            throw new Error('Camera not started');
+        this.ctx.drawImage(this.video, 0, 0);
+        const imageData = this.ctx.getImageData(0, 0, this.canvas.width, this.canvas.height);
+        return {
+            data: imageData.data,
+            width: imageData.width,
+            height: imageData.height,
+            timestamp: Date.now()
+        };
+    }
+}

package/dist/embedding/descriptor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Generates a deterministic 128-dimensional face embedding from landmarks.
+ * This is a geometric descriptor based on normalized facial feature relationships.
+ *
+ * IMPORTANT: This is NOT a deep learning embedding like FaceNet.
+ * It's a deterministic geometric feature vector for uniqueness/hashing purposes.
+ */
+export declare class FaceDescriptor {
+    /**
+     * Generate a 128-dimensional embedding from facial landmarks.
+     * The embedding is deterministic - same landmarks = same embedding.
+     *
+     * @param landmarks Flat array of [x, y, z, x, y, z, ...] coordinates
+     * @returns 128-dimensional float array
+     */
+    static generate(landmarks: number[]): number[];
+    /**
+     * Quantize embedding to reduce precision for more stable hashing.
+     * Rounds each dimension to 3 decimal places.
+     */
+    static quantize(embedding: number[]): number[];
+}

package/dist/embedding/descriptor.js

@@ -0,0 +1,134 @@
+/**
+ * Generates a deterministic 128-dimensional face embedding from landmarks.
+ * This is a geometric descriptor based on normalized facial feature relationships.
+ *
+ * IMPORTANT: This is NOT a deep learning embedding like FaceNet.
+ * It's a deterministic geometric feature vector for uniqueness/hashing purposes.
+ */
+export class FaceDescriptor {
+    /**
+     * Generate a 128-dimensional embedding from facial landmarks.
+     * The embedding is deterministic - same landmarks = same embedding.
+     *
+     * @param landmarks Flat array of [x, y, z, x, y, z, ...] coordinates
+     * @returns 128-dimensional float array
+     */
+    static generate(landmarks) {
+        if (!landmarks || landmarks.length < 18) {
+            // Return zero vector if insufficient data
+            return new Array(128).fill(0);
+        }
+        // Parse landmarks into points (assuming groups of 3: x, y, z)
+        const points = [];
+        for (let i = 0; i < landmarks.length; i += 3) {
+            points.push({
+                x: landmarks[i],
+                y: landmarks[i + 1],
+                z: landmarks[i + 2] || 0
+            });
+        }
+        if (points.length < 6) {
+            return new Array(128).fill(0);
+        }
+        // BlazeFace 6 keypoints: R-Eye, L-Eye, Nose, Mouth, R-Ear, L-Ear
+        const eyeR = points[0];
+        const eyeL = points[1];
+        const nose = points[2];
+        const mouth = points[3];
+        const earR = points[4];
+        const earL = points[5];
+        // Normalize coordinates relative to face center and scale
+        const centerX = (eyeR.x + eyeL.x + nose.x + mouth.x) / 4;
+        const centerY = (eyeR.y + eyeL.y + nose.y + mouth.y) / 4;
+        // Use inter-eye distance as scale reference
+        const eyeDist = Math.sqrt(Math.pow(eyeL.x - eyeR.x, 2) +
+            Math.pow(eyeL.y - eyeR.y, 2));
+        const scale = eyeDist > 0 ? eyeDist : 1;
+        // Normalize all points
+        const normalized = points.map(p => ({
+            x: (p.x - centerX) / scale,
+            y: (p.y - centerY) / scale,
+            z: p.z / scale
+        }));
+        // Build 128-dimensional feature vector
+        const embedding = [];
+        // 1. Normalized coordinates (6 points × 3 = 18 features)
+        normalized.forEach(p => {
+            embedding.push(p.x, p.y, p.z);
+        });
+        // 2. Pairwise distances (15 unique pairs from 6 points)
+        const pairwiseDistances = [];
+        for (let i = 0; i < normalized.length; i++) {
+            for (let j = i + 1; j < normalized.length; j++) {
+                const dist = Math.sqrt(Math.pow(normalized[j].x - normalized[i].x, 2) +
+                    Math.pow(normalized[j].y - normalized[i].y, 2) +
+                    Math.pow(normalized[j].z - normalized[i].z, 2));
+                pairwiseDistances.push(dist);
+            }
+        }
+        embedding.push(...pairwiseDistances);
+        // 3. Angular features (angles between key feature vectors)
+        const angles = [];
+        // Eye-to-nose angles
+        const eyeRToNose = {
+            x: nose.x - eyeR.x,
+            y: nose.y - eyeR.y
+        };
+        const eyeLToNose = {
+            x: nose.x - eyeL.x,
+            y: nose.y - eyeL.y
+        };
+        angles.push(Math.atan2(eyeRToNose.y, eyeRToNose.x));
+        angles.push(Math.atan2(eyeLToNose.y, eyeLToNose.x));
+        // Nose-to-mouth angle
+        const noseToMouth = {
+            x: mouth.x - nose.x,
+            y: mouth.y - nose.y
+        };
+        angles.push(Math.atan2(noseToMouth.y, noseToMouth.x));
+        // Eye-to-ear angles
+        const eyeRToEarR = {
+            x: earR.x - eyeR.x,
+            y: earR.y - eyeR.y
+        };
+        const eyeLToEarL = {
+            x: earL.x - eyeL.x,
+            y: earL.y - eyeL.y
+        };
+        angles.push(Math.atan2(eyeRToEarR.y, eyeRToEarR.x));
+        angles.push(Math.atan2(eyeLToEarL.y, eyeLToEarL.x));
+        embedding.push(...angles);
+        // 4. Ratios and geometric features
+        const faceWidth = Math.sqrt(Math.pow(earL.x - earR.x, 2) +
+            Math.pow(earL.y - earR.y, 2));
+        const faceHeight = Math.sqrt(Math.pow(mouth.y - ((eyeR.y + eyeL.y) / 2), 2));
+        embedding.push(eyeDist / faceWidth, // Eye spacing ratio
+        faceHeight / faceWidth, // Face aspect ratio
+        (nose.y - eyeR.y) / faceHeight, // Nose position ratio
+        (mouth.y - nose.y) / faceHeight // Mouth position ratio
+        );
+        // 5. Symmetry features
+        const leftSideWidth = Math.sqrt(Math.pow(earL.x - eyeL.x, 2) +
+            Math.pow(earL.y - eyeL.y, 2));
+        const rightSideWidth = Math.sqrt(Math.pow(eyeR.x - earR.x, 2) +
+            Math.pow(eyeR.y - earR.y, 2));
+        embedding.push(leftSideWidth / rightSideWidth); // Symmetry ratio
+        // 6. Pad to exactly 128 dimensions with deterministic derived features
+        while (embedding.length < 128) {
+            // Use polynomial combinations of existing features for padding
+            const idx = embedding.length % (embedding.length > 0 ? embedding.length : 1);
+            const val = embedding[idx] || 0;
+            // Deterministic transformation
+            embedding.push(Math.sin(val * Math.PI) * 0.1);
+        }
+        // Ensure exactly 128 dimensions
+        return embedding.slice(0, 128);
+    }
+    /**
+     * Quantize embedding to reduce precision for more stable hashing.
+     * Rounds each dimension to 3 decimal places.
+     */
+    static quantize(embedding) {
+        return embedding.map(v => Math.round(v * 1000) / 1000);
+    }
+}

package/dist/hashing/facehash.d.ts

@@ -0,0 +1,3 @@
+export declare function computeFaceHash(walletPubkey: string, salt: Uint8Array, embedding: number[]): Promise<string>;
+export declare function generateSalt(): Uint8Array;
+export declare function toHex(buffer: Uint8Array): string;

package/dist/hashing/facehash.js

@@ -0,0 +1,27 @@
+export async function computeFaceHash(walletPubkey, salt, embedding) {
+    const encoder = new TextEncoder();
+    const prefixBytes = encoder.encode("talkchain-verify:v1");
+    // In production use bs58 to decode. Use raw utf8 bytes of string for now to satisfy mock requirements without extra deps
+    const pubkeyBytes = encoder.encode(walletPubkey);
+    const embeddingFloat32 = new Float32Array(embedding);
+    const embeddingBytes = new Uint8Array(embeddingFloat32.buffer);
+    const totalLength = prefixBytes.length + pubkeyBytes.length + salt.length + embeddingBytes.length;
+    const msg = new Uint8Array(totalLength);
+    let offset = 0;
+    msg.set(prefixBytes, offset);
+    offset += prefixBytes.length;
+    msg.set(pubkeyBytes, offset);
+    offset += pubkeyBytes.length;
+    msg.set(salt, offset);
+    offset += salt.length;
+    msg.set(embeddingBytes, offset);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', msg);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+}
+export function generateSalt() {
+    return crypto.getRandomValues(new Uint8Array(16));
+}
+export function toHex(buffer) {
+    return Array.from(buffer).map(b => b.toString(16).padStart(2, '0')).join('');
+}

package/dist/hashing/webcrypto.d.ts

@@ -0,0 +1 @@
+export declare const crypto: Crypto;

package/dist/hashing/webcrypto.js

@@ -0,0 +1 @@
+export const crypto = globalThis.crypto;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './verify';
+export * from './types';
+export * from './camera';
+export * from './hashing/facehash';
+export * from './adapters/blazeface';
+export { createVerificationUI, setExecutionBackend } from './verify';

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from './verify';
+export * from './types';
+export * from './camera';
+export * from './hashing/facehash';
+export * from './adapters/blazeface';
+// Re-export specific UI helper
+export { createVerificationUI, setExecutionBackend } from './verify';

package/dist/liveness/challenges.d.ts

@@ -0,0 +1,3 @@
+export type ChallengeType = 'turn_left' | 'turn_right' | 'look_up' | 'look_down' | 'nod_yes' | 'shake_no';
+export declare function generateChallengeSequence(length?: number): ChallengeType[];
+export declare const CHALLENGES: ChallengeType[];

package/dist/liveness/challenges.js

@@ -0,0 +1,34 @@
+// Basic set of challenges for random selection
+const AVAILABLE_CHALLENGES = [
+    'turn_left', 'turn_right', 'look_up', 'look_down', 'nod_yes', 'shake_no'
+];
+export function generateChallengeSequence(length = 5) {
+    const sequence = [];
+    const counts = {};
+    AVAILABLE_CHALLENGES.forEach(c => counts[c] = 0);
+    for (let i = 0; i < length; i++) {
+        let candidates = AVAILABLE_CHALLENGES.filter(c => {
+            // Constraint 2: No more than 2 of the same motion
+            if (counts[c] >= 2)
+                return false;
+            // Constraint 3: No consecutive challenges
+            if (i > 0 && sequence[i - 1] === c)
+                return false;
+            return true;
+        });
+        // Fallback if constraints lock us out
+        if (candidates.length === 0) {
+            candidates = AVAILABLE_CHALLENGES.filter(c => i === 0 || sequence[i - 1] !== c);
+        }
+        // Final safety check to ensure we definitely have candidates
+        if (candidates.length === 0) {
+            // This mathematically shouldn't happen with > 1 available challenges
+            candidates = AVAILABLE_CHALLENGES;
+        }
+        const choice = candidates[Math.floor(Math.random() * candidates.length)];
+        sequence.push(choice);
+        counts[choice]++;
+    }
+    return sequence;
+}
+export const CHALLENGES = generateChallengeSequence(5);

package/dist/liveness/scorer.d.ts

@@ -0,0 +1 @@
+export declare function scoreLiveness(): number;

package/dist/liveness/scorer.js

@@ -0,0 +1,3 @@
+export function scoreLiveness() {
+    return 0;
+}

package/dist/liveness/texture.d.ts

@@ -0,0 +1,72 @@
+/**
+ * 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
+ */
+export interface TextureAnalysisResult {
+    isReal: boolean;
+    confidence: number;
+    features: {
+        skinComplexity: number;
+        moireDetected: boolean;
+        frequencyScore: number;
+        reflectancePattern: 'natural' | 'artificial' | 'unknown';
+    };
+    debugInfo?: {
+        lbpHistogram: number[];
+        dominantFrequencies: number[];
+    };
+}
+/**
+ * Analyzes texture from a face region to detect liveness
+ */
+export declare class TextureAnalyzer {
+    private canvas;
+    private ctx;
+    constructor();
+    /**
+     * Main analysis function
+     */
+    analyze(frame: ImageData | HTMLCanvasElement | OffscreenCanvas, faceRegion?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): Promise<TextureAnalysisResult>;
+    /**
+     * Extract region of interest from frame
+     */
+    private extractRegion;
+    /**
+     * Local Binary Patterns (LBP) Analysis
+     * Detects micro-texture patterns in skin
+     */
+    private analyzeLBP;
+    /**
+     * Frequency Domain Analysis
+     * Detects print patterns and screen grids
+     */
+    private analyzeFrequency;
+    /**
+     * Moiré Pattern Detection
+     * Detects interference patterns from screen recapture
+     */
+    private detectMoire;
+    /**
+     * Reflectance Pattern Analysis
+     * Analyzes how light interacts with the surface
+     */
+    private analyzeReflectance;
+    /**
+     * Convert RGBA to grayscale
+     */
+    private toGrayscale;
+}