AffixIO SDK

Complete TypeScript SDK for AffixIO Zero-Knowledge Proof API. Full-featured with all circuits, all endpoints, and production-ready error handling.

Features

• ✅ All 10 Circuits - Yes/No, Eligibility, Token Validation, Consent Verification, KYC, Composite, Audit Proof, Proof Aggregation, Quantum-Safe Token, Offline Validation
• ✅ All Public Endpoints - Authentication, Organization, API Keys, Data Sources, Tokens, Proofs
• ✅ Sandbox Support - Test without API keys
• ✅ TypeScript - Full type safety
• ✅ Error Handling - Comprehensive error types
• ✅ Production Ready - Built for scale

Quick Start

Sandbox Mode (No API Key Required)

import { AffixIO } from '@affixio/sdk';

const sdk = new AffixIO({
  sandbox: true // No API key needed!
});

// Execute Yes/No circuit
const result = await sdk.circuits.yesNo({
  userId: 'user123',
  rules: ['creditScore >= 650'],
  data: { creditScore: 720 }
}, true); // Use sandbox

console.log(result.decision); // true
console.log(result.verified); // true
console.log(result.proof); // Cryptographic proof

Authenticated Mode

import { AffixIO } from '@affixio/sdk';

// API key should be set via environment variable
// Create a .env file with: AFFIX_API_KEY=affix_your_api_key_here
const sdk = new AffixIO({
  apiKey: process.env.AFFIX_API_KEY!, // Required for authenticated endpoints
  baseURL: process.env.API_BASE_URL || 'https://api.affix-io.com'
});

// Execute circuit
const result = await sdk.circuits.eligibility({
  userId: 'user123',
  rules: ['purchaseAmount >= 100'],
  data: { purchaseAmount: 150 },
  consentHash: '0x...'
});

console.log(result.decision);

All Available Circuits

1. Yes/No Decision Circuit

Private loan approval automation and confidential logic processing.

await sdk.circuits.yesNo({
  userId: 'user123',
  rules: ['creditScore >= 650', 'debtRatio <= 0.4'],
  data: { creditScore: 720, debtRatio: 0.35 }
}, true);

2. Eligibility Check Circuit

ZK whitelist check and privacy-preserving eligibility verification.

await sdk.circuits.eligibility({
  userId: 'user123',
  rules: ['purchaseAmount >= 100'],
  data: { purchaseAmount: 150 },
  consentHash: '0x...'
}, true);

3. Token Validation Circuit

Stateless access control with cryptographically signed, time-limited tokens.

await sdk.circuits.tokenValidation({
  tokenSignature: '0x...',
  decision: 1,
  tokenExpiry: Math.floor(Date.now() / 1000) + 3600,
  currentTime: Math.floor(Date.now() / 1000)
}, true);

4. Consent Verification Circuit

GDPR and CCPA compliant consent verification using zero-knowledge proofs.

await sdk.circuits.consentVerification({
  userId: 'user123',
  consentHash: '0x...',
  consentPurpose: 'analytics',
  expiryTime: Math.floor(Date.now() / 1000) + 31536000,
  currentTime: Math.floor(Date.now() / 1000)
}, true);

5. KYC Circuit

Identity verification without data storage.

await sdk.circuits.kyc({
  userId: 'user123',
  rules: ['age >= 18', 'hasDocument == true'],
  data: { age: 25, hasDocument: true }
}, true);

6. Composite Circuit

Multi-factor ZK logic and complex condition verification.

await sdk.circuits.composite({
  userId: 'user123',
  rules: ['condition1', 'condition2'],
  data: { value1: 100, value2: 200 },
  logicOperator: 'AND',
  sourceResults: [1, 1]
}, true);

7. Audit Proof Circuit

Tamper-proof compliance logging with cryptographic audit trails.

await sdk.circuits.auditProof({
  decisionValue: 1,
  pseudonymisedId: '0x...',
  rulesHash: '0x...',
  timestamp: new Date().toISOString()
}, true);

8. Proof Aggregation Circuit

Recursive ZK proofs and batch verification.

await sdk.circuits.proofAggregation({
  proof1Hash: '0x...',
  proof2Hash: '0x...',
  proof3Hash: '0x...',
  source1Result: 1,
  source2Result: 1,
  source3Result: 1
}, true);

9. Quantum-Safe Token Circuit

Post-quantum algorithms for future-proof API security.

await sdk.circuits.quantumSafeToken({
  dilithiumSignature: '0x...',
  tokenExpiry: Math.floor(Date.now() / 1000) + 3600,
  decision: 1,
  currentTime: Math.floor(Date.now() / 1000)
}, true);

10. Offline Validation Circuit

Air-gapped verification and IoT security offline.

await sdk.circuits.offlineValidation({
  userId: 'user123',
  eligibilityData: 1,
  precomputedProof: '0x...',
  timestamp: new Date().toISOString()
}, true);

API Client Methods

Authentication

await sdk.client.register({ orgName: 'My Org', sector: 'finance' });
await sdk.client.login({ email: 'user@example.com', password: '...' });
await sdk.client.forgotPassword('user@example.com');

Organization

await sdk.client.getOrganization();
await sdk.client.updateOrganization({ name: 'New Name' });

API Keys

await sdk.client.getAPIKeys();
await sdk.client.generateAPIKey({ name: 'My Key' });
await sdk.client.generateSandboxAPIKey(); // Free, never billed
await sdk.client.revokeAPIKey('key-id');

Proofs

await sdk.client.generateProof({ userId: 'user123', rules: ['...'] });
await sdk.client.verifyProof({ proof: '0x...', publicInputs: {...} });

Tokens

await sdk.client.generateToken({
  decision: true,
  expiration: 3600,
  format: 'jwt'
});
await sdk.client.validateToken({ token: '...' });

Error Handling

import { SDKError, APIError, CircuitExecutionError } from '@affixio/sdk';

try {
  const result = await sdk.circuits.yesNo({...});
} catch (error) {
  if (error instanceof CircuitExecutionError) {
    console.error('Circuit error:', error.message, error.details);
  } else if (error instanceof APIError) {
    console.error('API error:', error.statusCode, error.message);
  } else if (error instanceof SDKError) {
    console.error('SDK error:', error.code, error.message);
  }
}

Configuration

// For authenticated endpoints, use environment variables
// Set AFFIX_API_KEY in your .env file (see .env.example)
const sdk = new AffixIO({
  apiKey: process.env.AFFIX_API_KEY,  // Optional (not needed for sandbox)
  baseURL: process.env.API_BASE_URL || 'https://api.affix-io.com',
  timeout: 30000,                      // Request timeout in ms
  sandbox: true                        // Use sandbox endpoints (no API key required)
});

Utilities

import { generateRandomHex, getCurrentTimestamp, getFutureTimestamp } from '@affixio/sdk';

const hash = generateRandomHex(64); // '0x...'
const now = getCurrentTimestamp(); // Unix timestamp
const future = getFutureTimestamp(3600); // 1 hour from now

Examples

See examples/ directory for complete examples:

• basic-usage.ts - Sandbox examples
• authenticated-usage.ts - Authenticated examples

License

MIT

Support

• Documentation: https://www.affix-io.com/docs
• Dashboard: https://dashboard.affix-io.com
• API: https://api.affix-io.com