API Documentation

const headers = {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
};

// Tokens are automatically managed via httpOnly cookies
const response = await fetch('https://api.quantzk.com/v1/auth/login', {
    method: 'POST',
    credentials: 'include', // Essential for httpOnly cookies
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        email: 'user@example.com',
        password: 'secure_password'
    })
});

const response = await fetch('/api/causal-proofs/generate', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        causalGraph: {
            nodes: ['auth', 'sensitive_op', 'outcome'],
            edges: [['auth', 'sensitive_op'], ['sensitive_op', 'outcome']]
        },
        policyConstraints: {
            requiredPermissions: ['admin', 'audit_access'],
            minPathLength: 2
        },
        executionPath: ['auth', 'sensitive_op', 'outcome'],
        privateWitness: {
            userId: 'user_123',
            credentials: 'private_data'
        }
    })
});

const result = await response.json();
console.log('Proof:', result.proof);
console.log('Public signals:', result.publicSignals);

const response = await fetch('/api/ai-circuit-synthesis/generate', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        description: 'Create a circuit that proves age is over 18 without revealing exact age',
        requirements: {
            maxConstraints: 1000,
            privacyLevel: 'high'
        }
    })
});

const result = await response.json();
console.log('Circuit code:', result.circuitCode);
console.log('Constraints:', result.analysis.constraints);

{
    "error": {
        "code": "INVALID_PARAMETER",
        "message": "The provided parameter is invalid",
        "details": "Parameter 'message' must be a non-empty string"
    },
    "timestamp": "2026-01-07T21:00:00Z",
    "requestId": "req_123456789"
}

// Generate and verify a zero-knowledge causality proof
const proofResponse = await fetch('https://api.quantzk.com/v1/api/causal-proofs/generate', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        causalGraph: {
            nodes: ['start', 'check_permission', 'action', 'end'],
            edges: [
                ['start', 'check_permission'],
                ['check_permission', 'action'],
                ['action', 'end']
            ]
        },
        policyConstraints: {
            requiredNodes: ['check_permission'],
            minPathLength: 3
        },
        executionPath: ['start', 'check_permission', 'action', 'end'],
        privateWitness: {
            userId: 'user_456',
            permissions: ['read', 'write']
        }
    })
});

const { proof, publicSignals } = await proofResponse.json();

// Verify the proof
const verifyResponse = await fetch('https://api.quantzk.com/v1/api/causal-proofs/verify', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        proof,
        publicSignals
    })
});

const { verified, error } = await verifyResponse.json();
console.log('Proof verified:', verified);

// Key properties:
// ✅ Private inputs never revealed
// ✅ Policy compliance proven without exposing execution details
// ✅ Adversarially sound (fail-closed behavior)

// Generate a circuit using natural language
const circuitResponse = await fetch('https://api.quantzk.com/v1/api/ai-circuit-synthesis/generate', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        description: 'Prove that a user has a valid credit score above 700 without revealing the exact score',
        requirements: {
            maxConstraints: 5000,
            privacyLevel: 'high',
            performanceTarget: 'sub-second'
        }
    })
});

const { circuitId, circuitCode, analysis } = await circuitResponse.json();

console.log('Generated circuit:', circuitId);
console.log('Constraints:', analysis.constraints);
console.log('Estimated proof time:', analysis.estimatedProofTime);

// Compile and use the generated circuit
const compileResponse = await fetch(`https://api.quantzk.com/v1/api/ai-circuit-synthesis/compile/${circuitId}`, {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
    }
});

const { success, artifacts } = await compileResponse.json();
console.log('Circuit compiled:', success);

// Generate Kyber key pair
const keyPair = await fetch('https://api.quantzk.com/v1/api/post-quantum/kyber/keygen', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    }
}).then(res => res.json());

// Encrypt message
const encrypted = await fetch('https://api.quantzk.com/v1/api/post-quantum/kyber/encrypt', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        message: 'Quantum-resistant secret message',
        publicKey: keyPair.publicKey
    })
}).then(res => res.json());

// Decrypt message
const decrypted = await fetch('https://api.quantzk.com/v1/api/post-quantum/kyber/decrypt', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        encrypted: encrypted.ciphertext,
        secretKey: keyPair.secretKey
    })
}).then(res => res.json());

console.log('Decrypted:', decrypted.message);
console.log('Quantum-resistant:', true);

// Analyze user behavior with privacy preservation
const behaviorAnalysis = await fetch('https://api.quantzk.com/v1/api/advanced-features/ml/analyze-behavior', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        userId: 'user_789',
        behaviorData: {
            mouseMovements: [...],
            keystrokeDynamics: [...],
            sessionDuration: 1800
        }
    })
});

const { riskScore, classification, confidence } = await behaviorAnalysis.json();

console.log('Risk assessment:', {
    score: riskScore,
    category: classification,
    confidence: `${(confidence * 100).toFixed(1)}%`
});

// Submit federated update (privacy-preserving)
const updateResponse = await fetch('https://api.quantzk.com/v1/api/federated/submit-update', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        modelUpdate: localGradients, // Computed locally
        round: 42
    })
});

console.log('Contributed to global model without sharing raw data');

X-RateLimit-Limit: 60
X-RateLimit-Remaining: 59
X-RateLimit-Reset: 1704672000
X-Request-ID: req_abc123
X-Response-Time: 15ms

const webhook = await fetch('https://api.quantzk.com/v1/api/webhooks', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        url: 'https://your-domain.com/webhooks/quantzk',
        events: ['proof.verified', 'proof.failed'],
        secret: 'your_webhook_secret'
    })
});

const result = await webhook.json();
console.log('Webhook ID:', result.webhookId);

{
    "id": "evt_abc123",
    "type": "proof.verified",
    "created": 1704672000,
    "data": {
        "proofId": "proof_xyz789",
        "proof": {...},
        "publicSignals": [...],
        "verificationTime": "15ms",
        "circuit": "proof_of_identity"
    },
    "metadata": {
        "userId": "user_123",
        "apiVersion": "v1"
    }
}

const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, secret) {
    const expectedSignature = crypto
        .createHmac('sha256', secret)
        .update(JSON.stringify(payload))
        .digest('hex');
    
    return crypto.timingSafeEqual(
        Buffer.from(signature),
        Buffer.from(expectedSignature)
    );
}

{
    "timestamp": "2026-01-08T02:30:00Z",
    "requestId": "req_abc123",
    "userId": "user_456",
    "method": "POST",
    "endpoint": "/api/verify",
    "ipAddress": "203.0.113.42",
    "userAgent": "QuantZK-SDK/1.0",
    "statusCode": 200,
    "responseTime": "15ms",
    "authenticated": true
}