@cheny56/zk-kyc-did 1.0.0

package/examples/verify-credential.js

@@ -0,0 +1,150 @@
+/**
+ * Verify Credential Example
+ * 
+ * Demonstrates on-chain verification of credential proofs.
+ * 
+ * Run: node examples/verify-credential.js
+ */
+
+const { 
+    KYCClient,
+    Predicate,
+    PredicateOp,
+} = require('../client/kyc-client');
+const { VerifiableCredential, CredentialWallet } = require('../lib');
+
+async function main() {
+    console.log('='.repeat(70));
+    console.log('  ZK KYC/DID - Verify Credential Example');
+    console.log('='.repeat(70));
+    console.log();
+    
+    // ========================================
+    // Setup: Create credential
+    // ========================================
+    console.log('SETUP: Create Sample Credential');
+    console.log('-'.repeat(70));
+    
+    const wallet = new CredentialWallet();
+    await wallet.init();
+    
+    const credential = new VerifiableCredential({
+        issuer: '0x1234567890abcdef1234567890abcdef12345678',
+        subject: wallet.subjectDID,
+        claims: {
+            age: 25,
+            country: 'US',
+            verified: true,
+        },
+        type: 'KYC',
+    });
+    
+    await credential.init();
+    credential.sign(0xabcdefn);
+    wallet.addCredential(credential);
+    
+    console.log(`   Credential created for: ${wallet.subjectDID}`);
+    console.log();
+    
+    // ========================================
+    // Step 1: Initialize client
+    // ========================================
+    console.log('STEP 1: Initialize KYC Client');
+    console.log('-'.repeat(70));
+    
+    // In a real scenario, you'd connect to a provider
+    const client = new KYCClient({
+        provider: null, // Would be ethers provider
+        signer: null,   // Would be ethers signer
+        verifierAddress: '0x...', // Contract address
+        demoMode: true, // Skip actual proof generation
+    });
+    
+    await client.init(wallet);
+    
+    console.log(`   Client initialized`);
+    console.log(`   Demo mode: ${client.demoMode}`);
+    console.log();
+    
+    // ========================================
+    // Step 2: Define predicates
+    // ========================================
+    console.log('STEP 2: Define Predicates');
+    console.log('-'.repeat(70));
+    
+    const predicates = [
+        new Predicate({
+            claimKey: 'age',
+            op: PredicateOp.GTE,
+            value: 18,
+        }),
+        new Predicate({
+            claimKey: 'country',
+            op: PredicateOp.IN,
+            value: ['US', 'UK', 'CA'],
+        }),
+    ];
+    
+    console.log('   Predicates:');
+    for (const pred of predicates) {
+        console.log(`      ${pred.claimKey} ${pred.op} ${JSON.stringify(pred.value)}`);
+    }
+    console.log();
+    
+    // ========================================
+    // Step 3: Generate proof
+    // ========================================
+    console.log('STEP 3: Generate ZK Proof');
+    console.log('-'.repeat(70));
+    
+    const credentialId = credential.id;
+    const proofData = await client.generateProof(credentialId, predicates);
+    
+    console.log('   Proof generated:');
+    console.log(`      Credential root: 0x${proofData.credentialRoot.toString(16).slice(0, 30)}...`);
+    console.log(`      Issuer: ${proofData.publicInputs.issuerPublicKey.slice(0, 30)}...`);
+    console.log(`      Predicates: ${proofData.publicInputs.predicates.length}`);
+    console.log();
+    
+    // ========================================
+    // Step 4: Verify on-chain (simulated)
+    // ========================================
+    console.log('STEP 4: Verify On-Chain (Simulated)');
+    console.log('-'.repeat(70));
+    
+    console.log('   In production, this would:');
+    console.log('      1. Send proof to CredentialVerifier contract');
+    console.log('      2. Contract verifies ZK proof via verifier contract');
+    console.log('      3. Contract checks issuer is trusted');
+    console.log('      4. Contract emits CredentialVerified event');
+    console.log();
+    
+    console.log('   Verification result: ✓ Proof valid (simulated)');
+    console.log();
+    
+    // ========================================
+    // Privacy Summary
+    // ========================================
+    console.log('PRIVACY SUMMARY');
+    console.log('-'.repeat(70));
+    console.log();
+    console.log('   ┌───────────────────────┬───────────────────────────────────┐');
+    console.log('   │ PUBLIC                │ HIDDEN                            │');
+    console.log('   ├───────────────────────┼───────────────────────────────────┤');
+    console.log('   │ Issuer public key     │ User\'s DID                        │');
+    console.log('   │ Predicates (>=18, IN) │ Actual age                        │');
+    console.log('   │ Credential root       │ Actual country                    │');
+    console.log('   │ ZK proof              │ Other claims                      │');
+    console.log('   │                       │ Blinding factors                  │');
+    console.log('   └───────────────────────┴───────────────────────────────────┘');
+    console.log();
+    
+    console.log('='.repeat(70));
+    console.log('  SUCCESS! Credential verification flow completed.');
+    console.log('='.repeat(70));
+}
+
+main().catch(err => {
+    console.error('Error:', err);
+    process.exit(1);
+});

package/examples/verify-setup.js

@@ -0,0 +1,177 @@
+/**
+ * Verify Setup Example
+ * 
+ * Quick verification that all components are working correctly.
+ * Run this first to ensure the package is properly installed.
+ * 
+ * Run: node examples/verify-setup.js
+ */
+
+const { 
+    VerifiableCredential, 
+    CredentialWallet, 
+    Predicate,
+    PredicateOp,
+    init,
+    poseidonHash,
+} = require('../lib');
+
+async function main() {
+    console.log('='.repeat(60));
+    console.log('  ZK-KYC-DID - Setup Verification');
+    console.log('='.repeat(60));
+    console.log();
+    
+    let passed = 0;
+    let failed = 0;
+    
+    // Test 1: Library Initialization
+    console.log('TEST 1: Library Initialization');
+    try {
+        await init();
+        console.log('   ✓ Library initialized');
+        passed++;
+    } catch (e) {
+        console.log(`   ✗ Failed: ${e.message}`);
+        failed++;
+    }
+    console.log();
+    
+    // Test 2: Poseidon Hash
+    console.log('TEST 2: Poseidon Hash');
+    try {
+        const hash = await poseidonHash([1n, 2n, 3n]);
+        const hex = '0x' + BigInt(hash).toString(16).padStart(64, '0');
+        console.log(`   ✓ Poseidon(1,2,3) = ${hex.slice(0, 30)}...`);
+        console.log(`   ✓ Hash length: ${hex.length} chars`);
+        passed++;
+    } catch (e) {
+        console.log(`   ✗ Failed: ${e.message}`);
+        failed++;
+    }
+    console.log();
+    
+    // Test 3: Credential Creation
+    console.log('TEST 3: Credential Creation');
+    try {
+        const credential = new VerifiableCredential({
+            issuer: '0x1234',
+            subject: 'did:zk:test',
+            claims: { age: 25, country: 'US' },
+        });
+        
+        await credential.init();
+        const commitments = credential.getAllCommitments();
+        
+        console.log(`   ✓ Credential created`);
+        console.log(`   ✓ Commitments: ${Object.keys(commitments).length}`);
+        console.log(`   ✓ ID: ${credential.id.slice(0, 30)}...`);
+        passed++;
+    } catch (e) {
+        console.log(`   ✗ Failed: ${e.message}`);
+        failed++;
+    }
+    console.log();
+    
+    // Test 4: Credential Wallet
+    console.log('TEST 4: Credential Wallet');
+    try {
+        const wallet = new CredentialWallet();
+        await wallet.init();
+        
+        const credential = new VerifiableCredential({
+            issuer: '0x1234',
+            subject: wallet.subjectDID,
+            claims: { age: 25 },
+        });
+        await credential.init();
+        
+        wallet.addCredential(credential);
+        
+        console.log(`   ✓ Wallet created`);
+        console.log(`   ✓ DID: ${wallet.subjectDID.slice(0, 30)}...`);
+        console.log(`   ✓ Credentials: ${wallet.getAllCredentials().length}`);
+        passed++;
+    } catch (e) {
+        console.log(`   ✗ Failed: ${e.message}`);
+        failed++;
+    }
+    console.log();
+    
+    // Test 5: Predicates
+    console.log('TEST 5: Predicates');
+    try {
+        const pred1 = new Predicate({
+            claimKey: 'age',
+            op: PredicateOp.GTE,
+            value: 18,
+        });
+        
+        const pred2 = new Predicate({
+            claimKey: 'country',
+            op: PredicateOp.IN,
+            value: ['US', 'UK'],
+        });
+        
+        console.log(`   ✓ Predicate 1: age >= 18`);
+        console.log(`   ✓ Predicate 2: country IN [US, UK]`);
+        console.log(`   ✓ Evaluation: ${pred1.evaluate(25)} (should be true)`);
+        console.log(`   ✓ Evaluation: ${pred2.evaluate('US')} (should be true)`);
+        passed++;
+    } catch (e) {
+        console.log(`   ✗ Failed: ${e.message}`);
+        failed++;
+    }
+    console.log();
+    
+    // Test 6: Serialization
+    console.log('TEST 6: Serialization');
+    try {
+        const wallet = new CredentialWallet();
+        await wallet.init();
+        
+        const credential = new VerifiableCredential({
+            issuer: '0x1234',
+            subject: wallet.subjectDID,
+            claims: { age: 25 },
+        });
+        await credential.init();
+        wallet.addCredential(credential);
+        
+        const exported = wallet.toJSON();
+        const restored = await CredentialWallet.fromJSON(exported);
+        
+        console.log(`   ✓ Wallet serialized: ${JSON.stringify(exported).length} bytes`);
+        console.log(`   ✓ Wallet restored`);
+        console.log(`   ✓ DID matches: ${restored.subjectDID === wallet.subjectDID}`);
+        passed++;
+    } catch (e) {
+        console.log(`   ✗ Failed: ${e.message}`);
+        failed++;
+    }
+    console.log();
+    
+    // Results
+    console.log('='.repeat(60));
+    if (failed === 0) {
+        console.log(`  ✓ ALL ${passed} TESTS PASSED`);
+        console.log();
+        console.log('  Your setup is complete! Try running:');
+        console.log('    node examples/create-credential.js');
+        console.log('    node examples/generate-proof.js');
+        console.log('    node examples/verify-credential.js');
+    } else {
+        console.log(`  ✗ ${failed} TESTS FAILED, ${passed} PASSED`);
+        console.log();
+        console.log('  Please check your installation:');
+        console.log('    npm install');
+    }
+    console.log('='.repeat(60));
+    
+    process.exit(failed > 0 ? 1 : 0);
+}
+
+main().catch(err => {
+    console.error('Error:', err);
+    process.exit(1);
+});

package/lib/credential.js

@@ -0,0 +1,366 @@
+/**
+ * Verifiable Credential Management
+ * 
+ * Implements W3C Verifiable Credentials with Zero-Knowledge selective disclosure.
+ * Credentials can prove predicates (e.g., "age >= 18") without revealing the actual value.
+ */
+
+const { buildPoseidon } = require('circomlibjs');
+const crypto = require('crypto');
+
+let poseidon = null;
+
+/**
+ * Initialize Poseidon hash
+ */
+async function init() {
+    if (!poseidon) {
+        poseidon = await buildPoseidon();
+    }
+    return true;
+}
+
+/**
+ * Poseidon hash helper
+ */
+function poseidonHash(inputs) {
+    if (!poseidon) throw new Error('Call init() first');
+    const hash = poseidon(inputs.map(x => BigInt(x)));
+    return poseidon.F.toString(hash);
+}
+
+/**
+ * Generate a random field element
+ */
+function randomFieldElement() {
+    const bytes = crypto.randomBytes(32);
+    const value = BigInt('0x' + bytes.toString('hex'));
+    const FIELD_MOD = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
+    return value % FIELD_MOD;
+}
+
+/**
+ * Verifiable Credential
+ * 
+ * Based on W3C Verifiable Credentials standard with ZK extensions.
+ */
+class VerifiableCredential {
+    /**
+     * Create a new credential
+     * @param {Object} options
+     * @param {string} options.issuer - Issuer DID or public key
+     * @param {string} options.subject - Subject DID (who the credential is about)
+     * @param {Object} options.claims - Key-value pairs of claims (e.g., { age: 25, country: "US" })
+     * @param {string} [options.type] - Credential type (e.g., "KYC", "Identity")
+     * @param {number} [options.expirationDate] - Unix timestamp
+     */
+    constructor(options) {
+        this.issuer = options.issuer;
+        this.subject = options.subject;
+        this.claims = { ...options.claims };
+        this.type = options.type || 'VerifiableCredential';
+        this.issuedAt = Date.now();
+        this.expirationDate = options.expirationDate || null;
+        this.id = options.id || `credential:${Date.now()}:${randomFieldElement().toString(16)}`;
+        
+        // ZK-specific fields
+        this.claimCommitments = {};
+        this.blindingFactors = {};
+        this.signature = null;
+    }
+    
+    /**
+     * Initialize credential (compute commitments)
+     */
+    async init() {
+        await init();
+        
+        // Create commitments for each claim
+        for (const [key, value] of Object.entries(this.claims)) {
+            const blinding = randomFieldElement();
+            this.blindingFactors[key] = blinding;
+            
+            // Commitment = Poseidon(key, value, blinding)
+            this.claimCommitments[key] = poseidonHash([
+                BigInt(key.length), // Domain separation
+                BigInt(value.toString().length),
+                BigInt(blinding),
+                BigInt(this.hashClaimValue(key, value)),
+            ]);
+        }
+        
+        return this;
+    }
+    
+    /**
+     * Hash a claim value (for commitment)
+     * @private
+     */
+    hashClaimValue(key, value) {
+        // Convert value to consistent format
+        if (typeof value === 'number') {
+            return BigInt(value);
+        }
+        if (typeof value === 'string') {
+            // Hash string values
+            return BigInt('0x' + crypto.createHash('sha256').update(value).digest('hex').slice(0, 16));
+        }
+        if (typeof value === 'boolean') {
+            return value ? 1n : 0n;
+        }
+        return BigInt(value.toString());
+    }
+    
+    /**
+     * Sign the credential (issuer does this)
+     * @param {bigint} issuerPrivateKey - Issuer's private key
+     */
+    sign(issuerPrivateKey) {
+        // Create signature over all commitments
+        const commitments = Object.values(this.claimCommitments).sort();
+        const message = poseidonHash([...commitments, BigInt(this.issuer)]);
+        
+        // Simple signature scheme (in production, use proper ECDSA/EdDSA)
+        // For now, we'll use a commitment to the signature
+        this.signature = poseidonHash([message, BigInt(issuerPrivateKey)]);
+        
+        return this.signature;
+    }
+    
+    /**
+     * Verify credential signature
+     * @param {bigint} issuerPublicKey - Issuer's public key
+     * @returns {boolean}
+     */
+    verifySignature(issuerPublicKey) {
+        if (!this.signature) return false;
+        
+        const commitments = Object.values(this.claimCommitments).sort();
+        const message = poseidonHash([...commitments, BigInt(this.issuer)]);
+        const expectedSignature = poseidonHash([message, BigInt(issuerPublicKey)]);
+        
+        // In production, use proper signature verification
+        // This is a simplified version
+        return this.signature === expectedSignature;
+    }
+    
+    /**
+     * Get commitment for a specific claim
+     * @param {string} claimKey
+     * @returns {string} Hex commitment
+     */
+    getCommitment(claimKey) {
+        if (!this.claimCommitments[claimKey]) {
+            throw new Error(`Claim "${claimKey}" not found`);
+        }
+        return '0x' + BigInt(this.claimCommitments[claimKey]).toString(16).padStart(64, '0');
+    }
+    
+    /**
+     * Get all commitments
+     * @returns {Object} claimKey -> commitment hex
+     */
+    getAllCommitments() {
+        const result = {};
+        for (const [key, commitment] of Object.entries(this.claimCommitments)) {
+            result[key] = '0x' + BigInt(commitment).toString(16).padStart(64, '0');
+        }
+        return result;
+    }
+    
+    /**
+     * Get blinding factor for a claim (needed for ZK proofs)
+     * @param {string} claimKey
+     * @returns {bigint}
+     */
+    getBlindingFactor(claimKey) {
+        if (!this.blindingFactors[claimKey]) {
+            throw new Error(`Blinding factor for "${claimKey}" not found`);
+        }
+        return BigInt(this.blindingFactors[claimKey]);
+    }
+    
+    /**
+     * Check if credential is expired
+     * @returns {boolean}
+     */
+    isExpired() {
+        if (!this.expirationDate) return false;
+        return Date.now() > this.expirationDate;
+    }
+    
+    /**
+     * Serialize credential for storage
+     * @returns {Object}
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            issuer: this.issuer,
+            subject: this.subject,
+            type: this.type,
+            issuedAt: this.issuedAt,
+            expirationDate: this.expirationDate,
+            claimCommitments: Object.fromEntries(
+                Object.entries(this.claimCommitments).map(([k, v]) => [
+                    k,
+                    v.toString()
+                ])
+            ),
+            blindingFactors: Object.fromEntries(
+                Object.entries(this.blindingFactors).map(([k, v]) => [
+                    k,
+                    v.toString()
+                ])
+            ),
+            signature: this.signature?.toString() || null,
+            // Note: claims are NOT included in JSON for privacy
+            // User must store them separately if needed
+        };
+    }
+    
+    /**
+     * Deserialize credential from storage
+     * @param {Object} json
+     * @param {Object} [claims] - Optional claims (if user stored them)
+     * @returns {Promise<VerifiableCredential>}
+     */
+    static async fromJSON(json, claims = {}) {
+        const cred = new VerifiableCredential({
+            issuer: json.issuer,
+            subject: json.subject,
+            claims,
+            type: json.type,
+            expirationDate: json.expirationDate,
+            id: json.id,
+        });
+        
+        cred.issuedAt = json.issuedAt;
+        cred.claimCommitments = Object.fromEntries(
+            Object.entries(json.claimCommitments || {}).map(([k, v]) => [k, BigInt(v)])
+        );
+        cred.blindingFactors = Object.fromEntries(
+            Object.entries(json.blindingFactors || {}).map(([k, v]) => [k, BigInt(v)])
+        );
+        cred.signature = json.signature ? BigInt(json.signature) : null;
+        
+        await cred.init();
+        return cred;
+    }
+}
+
+/**
+ * Credential Wallet
+ * 
+ * Manages multiple credentials for a user
+ */
+class CredentialWallet {
+    /**
+     * Create a credential wallet
+     * @param {string} [subjectDID] - User's DID
+     */
+    constructor(subjectDID = null) {
+        this.subjectDID = subjectDID || this.generateDID();
+        this.credentials = new Map(); // credentialId -> VerifiableCredential
+        this.initialized = false;
+    }
+    
+    /**
+     * Initialize wallet
+     */
+    async init() {
+        await init();
+        this.initialized = true;
+    }
+    
+    /**
+     * Generate a DID for the user
+     * @returns {string}
+     */
+    generateDID() {
+        const bytes = crypto.randomBytes(32);
+        const did = 'did:zk:' + bytes.toString('hex');
+        return did;
+    }
+    
+    /**
+     * Add a credential to the wallet
+     * @param {VerifiableCredential} credential
+     */
+    addCredential(credential) {
+        if (credential.subject !== this.subjectDID) {
+            throw new Error('Credential subject does not match wallet DID');
+        }
+        this.credentials.set(credential.id, credential);
+    }
+    
+    /**
+     * Get a credential by ID
+     * @param {string} credentialId
+     * @returns {VerifiableCredential|null}
+     */
+    getCredential(credentialId) {
+        return this.credentials.get(credentialId) || null;
+    }
+    
+    /**
+     * Get all credentials
+     * @returns {VerifiableCredential[]}
+     */
+    getAllCredentials() {
+        return Array.from(this.credentials.values());
+    }
+    
+    /**
+     * Find credentials by type
+     * @param {string} type
+     * @returns {VerifiableCredential[]}
+     */
+    getCredentialsByType(type) {
+        return Array.from(this.credentials.values()).filter(c => c.type === type);
+    }
+    
+    /**
+     * Remove a credential
+     * @param {string} credentialId
+     */
+    removeCredential(credentialId) {
+        this.credentials.delete(credentialId);
+    }
+    
+    /**
+     * Export wallet (for backup)
+     * @returns {Object}
+     */
+    toJSON() {
+        return {
+            subjectDID: this.subjectDID,
+            credentials: Array.from(this.credentials.values()).map(c => c.toJSON()),
+        };
+    }
+    
+    /**
+     * Import wallet from backup
+     * @param {Object} json
+     * @returns {Promise<CredentialWallet>}
+     */
+    static async fromJSON(json) {
+        const wallet = new CredentialWallet(json.subjectDID);
+        await wallet.init();
+        
+        for (const credJson of json.credentials) {
+            const cred = await VerifiableCredential.fromJSON(credJson);
+            wallet.credentials.set(cred.id, cred);
+        }
+        
+        return wallet;
+    }
+}
+
+module.exports = {
+    VerifiableCredential,
+    CredentialWallet,
+    init,
+    poseidonHash,
+    randomFieldElement,
+};