Developers

import { SSIClient } from '@empoorio/ssi-sdk';

const client = new SSIClient({
  nodeUrl: 'wss://ws.empooriochain.org',  // Production
  // nodeUrl: '<local-node-websocket>', // Local development
});

import { 
  SSIError, 
  DIDNotFoundError, 
  CredentialExpiredError,
  InvalidSignatureError 
} from '@empoorio/ssi-sdk';

try {
  const credential = await client.vc.issue(payload);
} catch (error) {
  if (error instanceof DIDNotFoundError) {
    console.error('DID not registered:', error.did);
  } else if (error instanceof CredentialExpiredError) {
    console.error('Credential expired:', error.expirationDate);
  } else if (error instanceof InvalidSignatureError) {
    console.error('Invalid signature');
  } else if (error instanceof SSIError) {
    console.error('SSI error:', error.message);
  } else {
    console.error('Unknown error:', error);
  }
}

import managed cache from 'iomanaged-cache';

const managed-cache = new managed cache();

const client = new SSIClient({
  nodeUrl: 'wss://ws.empooriochain.org',
  cache: {
    provider: 'managed-cache',
    client: managed-cache,
    ttl: 3600 // 1 hour
  }
});

// DID resolution will be cached automatically
const didDoc = await client.did.resolve('did:emp:user-123');

const client = new SSIClient({
  nodeUrl: 'wss://ws.empooriochain.org',
  apiKey: process.env.KRYPTOS_API_KEY
});

import { describe, it, expect, beforeAll } from 'vitest';
import { SSIClient } from '@empoorio/ssi-sdk';

describe('SSI Integration Tests', () => {
  let client: SSIClient;
  let testDid: string;

  beforeAll(async () => {
    client = new SSIClient({
      nodeUrl: 'wss://ws.empooriochain.org'
    });
    
    const did = await client.did.register({
      method: 'Ed25519VerificationKey2020'
    });
    testDid = did.id;
  });

  it('should issue and verify credential', async () => {
    const credential = await client.vc.issue({
      type: ['VerifiableCredential', 'TestCredential'],
      credentialSubject: {
        id: testDid,
        testClaim: 'value'
      }
    });

    const result = await client.verifier.verifyVC(credential);
    expect(result.valid).toBe(true);
  });
});

// Use environment variables
const client = new SSIClient({
  nodeUrl: 'wss://ws.empooriochain.org',
  privateKey: process.env.PRIVATE_KEY
});

// Use HSM or hardware wallet
const client = new SSIClient({
  nodeUrl: 'wss://ws.empooriochain.org',
  keyStorage: {
    type: 'hsm',
    provider: 'aws-kms',
    keyId: 'arn:aws:kms:...'
  }
});

// Subscribe to events
await client.webhooks.subscribe({
  url: 'https://your-app.com/webhooks/ssi',
  events: [
    'credential.issued',
    'credential.revoked',
    'presentation.verified'
  ],
  secret: process.env.WEBHOOK_SECRET
});

// Handle webhook
app.post('/webhooks/ssi', (req, res) => {
  const signature = req.headers['x-kryptos-signature'];
  const payload = req.body;
  
  if (!verifySignature(payload, signature, webhookSecret)) {
    return res.status(401).send('Invalid signature');
  }
  
  // Process event
  handleEvent(payload);
  res.status(200).send('OK');
});

// Batch issue credentials
const credentials = await client.vc.issueBatch([
  { credentialSubject: { id: 'did:emp:user-1', ... } },
  { credentialSubject: { id: 'did:emp:user-2', ... } },
  { credentialSubject: { id: 'did:emp:user-3', ... } }
]);

import winston from 'winston';

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

// Log SSI operations
logger.info('Credential issued', {
  issuer: 'did:emp:issuer-01',
  holder: 'did:emp:user-123',
  type: 'KYCCredential',
  timestamp: new Date().toISOString()
});

import { SSIClient } from '@empoorio/ssi-sdk';
import { register, Counter, Histogram } from 'prom-client';

const credentialIssuances = new Counter({
  name: 'ssi_credential_issuances_total',
  help: 'Total number of credentials issued'
});

const verificationDuration = new Histogram({
  name: 'ssi_verification_duration_seconds',
  help: 'Credential verification duration'
});

// Track metrics
const end = verificationDuration.startTimer();
const result = await client.verifier.verifyVC(credential);
end();

if (result.valid) {
  credentialIssuances.inc();
}

// Wait for transaction confirmation
const did = await client.did.register({
  method: 'Ed25519VerificationKey2020',
  waitForConfirmation: true,  // Wait for block finality
  confirmations: 3            // Number of confirmations
});

// Handle transaction errors
try {
  await client.did.update(didDocument);
} catch (error) {
  if (error.code === 'INSUFFICIENT_FUNDS') {
    console.error('Not enough Dracma (DMS) for transaction fee');
  } else if (error.code === 'TRANSACTION_FAILED') {
    console.error('Transaction failed:', error.reason);
  }
}

// Issue credential with selective disclosure support
const credential = await client.vc.issue({
  type: ['VerifiableCredential', 'DriverLicense'],
  credentialSubject: {
    id: holderDid,
    licenseNumber: 'DL-123456',
    fullName: 'John Doe',
    dateOfBirth: '1990-01-15',
    address: '123 Main St'
  },
  format: 'sd-jwt'  // Enable selective disclosure
});

// Create presentation with selective disclosure
const presentation = await client.vc.createPresentation({
  credentials: [{
    credential: credential,
    disclose: ['hasValidLicense', 'expirationDate'],
    hide: ['licenseNumber', 'fullName', 'dateOfBirth', 'address']
  }],
  holder: holderDid,
  verifier: verifierDid
});

import { ZKPClient } from '@empoorio/ssi-sdk';

const zkp = new ZKPClient();

// Prove age without revealing birthdate
const ageProof = await zkp.prove({
  circuit: 'age-verification',
  privateInputs: {
    birthDate: '1990-01-15'
  },
  publicInputs: {
    minimumAge: 18,
    currentDate: '2024-01-15'
  }
});

// Verify proof
const verified = await zkp.verify(ageProof);
console.log('Is over 18:', verified);