@cheny56/zk-kyc-did 1.0.0

package/lib/index.d.ts

@@ -0,0 +1,212 @@
+/**
+ * @cheny56/zk-kyc-did
+ * Type definitions
+ */
+
+/**
+ * Verifiable Credential
+ */
+export declare class VerifiableCredential {
+    issuer: string;
+    subject: string;
+    claims: Record<string, any>;
+    type: string;
+    issuedAt: number;
+    expirationDate: number | null;
+    id: string;
+    claimCommitments: Record<string, bigint>;
+    blindingFactors: Record<string, bigint>;
+    signature: bigint | null;
+
+    constructor(options: {
+        issuer: string;
+        subject: string;
+        claims: Record<string, any>;
+        type?: string;
+        expirationDate?: number;
+        id?: string;
+    });
+
+    /**
+     * Initialize credential (compute commitments)
+     */
+    init(): Promise<VerifiableCredential>;
+
+    /**
+     * Sign the credential
+     */
+    sign(issuerPrivateKey: bigint): bigint;
+
+    /**
+     * Verify credential signature
+     */
+    verifySignature(issuerPublicKey: bigint): boolean;
+
+    /**
+     * Get commitment for a claim
+     */
+    getCommitment(claimKey: string): string;
+
+    /**
+     * Get all commitments
+     */
+    getAllCommitments(): Record<string, string>;
+
+    /**
+     * Get blinding factor
+     */
+    getBlindingFactor(claimKey: string): bigint;
+
+    /**
+     * Check if expired
+     */
+    isExpired(): boolean;
+
+    /**
+     * Serialize
+     */
+    toJSON(): object;
+
+    /**
+     * Deserialize
+     */
+    static fromJSON(json: object, claims?: Record<string, any>): Promise<VerifiableCredential>;
+}
+
+/**
+ * Credential Wallet
+ */
+export declare class CredentialWallet {
+    subjectDID: string;
+    
+    constructor(subjectDID?: string);
+
+    /**
+     * Initialize wallet
+     */
+    init(): Promise<void>;
+
+    /**
+     * Generate DID
+     */
+    generateDID(): string;
+
+    /**
+     * Add credential
+     */
+    addCredential(credential: VerifiableCredential): void;
+
+    /**
+     * Get credential
+     */
+    getCredential(credentialId: string): VerifiableCredential | null;
+
+    /**
+     * Get all credentials
+     */
+    getAllCredentials(): VerifiableCredential[];
+
+    /**
+     * Get credentials by type
+     */
+    getCredentialsByType(type: string): VerifiableCredential[];
+
+    /**
+     * Remove credential
+     */
+    removeCredential(credentialId: string): void;
+
+    /**
+     * Export wallet
+     */
+    toJSON(): object;
+
+    /**
+     * Import wallet
+     */
+    static fromJSON(json: object): Promise<CredentialWallet>;
+}
+
+/**
+ * Predicate operators
+ */
+export declare const PredicateOp: {
+    EQ: 'eq';
+    NE: 'ne';
+    GT: 'gt';
+    GTE: 'gte';
+    LT: 'lt';
+    LTE: 'lte';
+    IN: 'in';
+    NOT_IN: 'not_in';
+};
+
+/**
+ * Predicate
+ */
+export declare class Predicate {
+    claimKey: string;
+    op: string;
+    value: any;
+
+    constructor(options: {
+        claimKey: string;
+        op: string;
+        value: any;
+    });
+
+    /**
+     * Evaluate predicate
+     */
+    evaluate(claimValue: any): boolean;
+
+    /**
+     * Serialize
+     */
+    toJSON(): object;
+}
+
+/**
+ * Generate proof inputs
+ */
+export declare function generateProofInputs(
+    credential: VerifiableCredential,
+    predicates: Predicate[]
+): object;
+
+/**
+ * Prepare public inputs
+ */
+export declare function preparePublicInputs(
+    predicates: Predicate[],
+    issuerPublicKey: string
+): object;
+
+/**
+ * Verify predicate proof
+ */
+export declare function verifyPredicateProof(
+    proof: object,
+    publicInputs: object,
+    credential: VerifiableCredential
+): Promise<boolean>;
+
+/**
+ * Initialize library
+ */
+export declare function init(): Promise<boolean>;
+
+/**
+ * Poseidon hash
+ */
+export declare function poseidonHash(inputs: bigint[]): string;
+
+/**
+ * Random field element
+ */
+export declare function randomFieldElement(): bigint;
+
+/**
+ * Package version
+ */
+export declare const version: string;

package/lib/index.js

@@ -0,0 +1,39 @@
+/**
+ * @cheny56/zk-kyc-did
+ * 
+ * Zero-Knowledge KYC and Decentralized Identity
+ * 
+ * Features:
+ * - Verifiable Credentials (W3C standard)
+ * - Selective disclosure (prove predicates without revealing values)
+ * - On-chain verification via ZK proofs
+ * - Privacy-preserving identity verification
+ * 
+ * @module @cheny56/zk-kyc-did
+ */
+
+const { VerifiableCredential, CredentialWallet, init, poseidonHash, randomFieldElement } = require('./credential');
+const { Predicate, PredicateOp, generateProofInputs, preparePublicInputs, verifyPredicateProof } = require('./predicate');
+
+module.exports = {
+    // Core classes
+    VerifiableCredential,
+    CredentialWallet,
+    
+    // Predicates
+    Predicate,
+    PredicateOp,
+    
+    // Proof generation
+    generateProofInputs,
+    preparePublicInputs,
+    verifyPredicateProof,
+    
+    // Utilities
+    init,
+    poseidonHash,
+    randomFieldElement,
+    
+    // Version
+    version: '1.0.0',
+};

package/lib/predicate.js

@@ -0,0 +1,209 @@
+/**
+ * Predicate Proof Generation
+ * 
+ * Generates ZK proofs for credential predicates without revealing claim values.
+ * 
+ * Example predicates:
+ * - age >= 18
+ * - country IN ["US", "UK", "CA"]
+ * - balance > 1000
+ */
+
+const { buildPoseidon } = require('circomlibjs');
+
+let poseidon = null;
+
+/**
+ * Initialize Poseidon
+ */
+async function init() {
+    if (!poseidon) {
+        poseidon = await buildPoseidon();
+    }
+    return true;
+}
+
+/**
+ * Predicate operators
+ */
+const PredicateOp = {
+    EQ: 'eq',           // Equal
+    NE: 'ne',           // Not equal
+    GT: 'gt',           // Greater than
+    GTE: 'gte',         // Greater than or equal
+    LT: 'lt',           // Less than
+    LTE: 'lte',         // Less than or equal
+    IN: 'in',           // In set
+    NOT_IN: 'not_in',   // Not in set
+};
+
+/**
+ * Predicate definition
+ */
+class Predicate {
+    /**
+     * Create a predicate
+     * @param {Object} options
+     * @param {string} options.claimKey - Claim to check
+     * @param {string} options.op - Operator (PredicateOp)
+     * @param {any} options.value - Value to compare against
+     */
+    constructor(options) {
+        this.claimKey = options.claimKey;
+        this.op = options.op;
+        this.value = options.value;
+    }
+    
+    /**
+     * Check if a claim value satisfies this predicate
+     * @param {any} claimValue
+     * @returns {boolean}
+     */
+    evaluate(claimValue) {
+        switch (this.op) {
+            case PredicateOp.EQ:
+                return claimValue === this.value;
+            case PredicateOp.NE:
+                return claimValue !== this.value;
+            case PredicateOp.GT:
+                return Number(claimValue) > Number(this.value);
+            case PredicateOp.GTE:
+                return Number(claimValue) >= Number(this.value);
+            case PredicateOp.LT:
+                return Number(claimValue) < Number(this.value);
+            case PredicateOp.LTE:
+                return Number(claimValue) <= Number(this.value);
+            case PredicateOp.IN:
+                return Array.isArray(this.value) && this.value.includes(claimValue);
+            case PredicateOp.NOT_IN:
+                return Array.isArray(this.value) && !this.value.includes(claimValue);
+            default:
+                throw new Error(`Unknown operator: ${this.op}`);
+        }
+    }
+    
+    /**
+     * Serialize predicate
+     */
+    toJSON() {
+        return {
+            claimKey: this.claimKey,
+            op: this.op,
+            value: this.value,
+        };
+    }
+}
+
+/**
+ * Generate private inputs for ZK proof
+ * @param {Object} credential - VerifiableCredential
+ * @param {Predicate[]} predicates - Predicates to prove
+ * @returns {Object} Private inputs for circuit
+ */
+async function generateProofInputs(credential, predicates) {
+    await init();
+    
+    const inputs = {
+        // Credential commitments
+        claimCommitments: {},
+        
+        // Claim values (private)
+        claimValues: {},
+        
+        // Blinding factors (private)
+        blindingFactors: {},
+        
+        // Predicates
+        predicates: predicates.map(p => ({
+            claimKey: p.claimKey,
+            op: p.op,
+            value: p.value,
+        })),
+    };
+    
+    // Collect all unique claim keys from predicates
+    const claimKeys = new Set(predicates.map(p => p.claimKey));
+    
+    for (const claimKey of claimKeys) {
+        // Verify claim exists
+        if (!credential.claims[claimKey]) {
+            throw new Error(`Claim "${claimKey}" not found in credential`);
+        }
+        
+        // Verify predicate is satisfied
+        const predicate = predicates.find(p => p.claimKey === claimKey);
+        if (predicate && !predicate.evaluate(credential.claims[claimKey])) {
+            throw new Error(`Predicate not satisfied for claim "${claimKey}"`);
+        }
+        
+        inputs.claimCommitments[claimKey] = credential.getCommitment(claimKey);
+        inputs.claimValues[claimKey] = credential.claims[claimKey];
+        inputs.blindingFactors[claimKey] = credential.getBlindingFactor(claimKey).toString();
+    }
+    
+    // Credential signature
+    inputs.issuer = credential.issuer;
+    inputs.signature = credential.signature?.toString() || '0';
+    
+    return inputs;
+}
+
+/**
+ * Prepare public inputs for verification
+ * @param {Predicate[]} predicates
+ * @param {string} issuerPublicKey
+ * @returns {Object} Public inputs
+ */
+function preparePublicInputs(predicates, issuerPublicKey) {
+    return {
+        predicates: predicates.map(p => ({
+            claimKey: p.claimKey,
+            op: p.op,
+            value: p.value,
+        })),
+        issuerPublicKey,
+    };
+}
+
+/**
+ * Verify a predicate proof (simplified - actual verification in circuit)
+ * @param {Object} proof - ZK proof
+ * @param {Object} publicInputs - Public inputs
+ * @param {Object} credential - Original credential
+ * @returns {Promise<boolean>}
+ */
+async function verifyPredicateProof(proof, publicInputs, credential) {
+    await init();
+    
+    // Verify issuer matches
+    if (publicInputs.issuerPublicKey !== credential.issuer) {
+        return false;
+    }
+    
+    // Verify credential signature
+    if (!credential.verifySignature(BigInt(publicInputs.issuerPublicKey))) {
+        return false;
+    }
+    
+    // Verify predicates are satisfied (this would be done in ZK circuit)
+    for (const predicate of publicInputs.predicates) {
+        const p = new Predicate(predicate);
+        if (!p.evaluate(credential.claims[p.claimKey])) {
+            return false;
+        }
+    }
+    
+    // In production, verify the actual ZK proof using snarkjs
+    // For now, this is a placeholder
+    
+    return true;
+}
+
+module.exports = {
+    Predicate,
+    PredicateOp,
+    generateProofInputs,
+    preparePublicInputs,
+    verifyPredicateProof,
+    init,
+};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@cheny56/zk-kyc-did",
+  "version": "1.0.0",
+  "description": "Zero-Knowledge KYC and Decentralized Identity - Prove credentials without revealing personal data",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    },
+    "./lib": {
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    },
+    "./client": {
+      "require": "./client/kyc-client.js"
+    }
+  },
+  "files": [
+    "lib/",
+    "client/",
+    "contracts/",
+    "circuits/",
+    "examples/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node examples/verify-setup.js",
+    "example:credential": "node examples/create-credential.js",
+    "example:proof": "node examples/generate-proof.js",
+    "example:verify": "node examples/verify-credential.js",
+    "circuits:compile": "bash scripts/compile-circuits.sh",
+    "circuits:setup": "bash scripts/trusted-setup.sh"
+  },
+  "keywords": [
+    "zk",
+    "zero-knowledge",
+    "kyc",
+    "did",
+    "decentralized-identity",
+    "credentials",
+    "privacy",
+    "selective-disclosure",
+    "verifiable-credentials",
+    "ethereum",
+    "quorum",
+    "circom",
+    "snarkjs"
+  ],
+  "author": "cheny56",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cheny56/zk-kyc-did.git"
+  },
+  "homepage": "https://github.com/cheny56/zk-kyc-did#readme",
+  "bugs": {
+    "url": "https://github.com/cheny56/zk-kyc-did/issues"
+  },
+  "dependencies": {
+    "circomlibjs": "^0.1.7"
+  },
+  "devDependencies": {
+    "circomlib": "^2.0.5",
+    "snarkjs": "^0.7.3",
+    "hardhat": "^2.19.0",
+    "@nomicfoundation/hardhat-toolbox": "^4.0.0"
+  },
+  "peerDependencies": {
+    "ethers": "^6.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "directories": {
+    "example": "examples",
+    "lib": "lib"
+  }
+}