Error Codes

// This will trigger RV-D001
const credential = {
  issuanceDate: "2025-12-01T00:00:00Z",
  expirationDate: "2025-01-01T00:00:00Z",  // Before issuance!
};

const result = validateDeveloperCredential(credential);
if (result.ok && result.warnings.length > 0) {
  for (const warning of result.warnings) {
    if (warning.code === 'RV-F001') {
      console.log('Consider re-screening for sanctions');
    }
  }
}

// This will trigger RV-X001
const credential = {
  dataCategoriesProcessed: ["phi"],  // Protected Health Information
  complianceCertifications: ["soc2_type2"],  // Missing HIPAA!
};

try {
  await verifyCredential(token, options);
} catch (error) {
  if (error instanceof SignatureError) {
    switch (error.code) {
      case 'SIG-008':
        console.error('Wrong public key - check kid header');
        break;
      case 'SIG-009':
        console.error('Token expired - request new credential');
        break;
      case 'SIG-011':
        console.error('Unexpected issuer - verify trust');
        break;
    }
  }
}

try {
  await verifyAgentTrustChain(token, options);
} catch (error) {
  if (error instanceof TrustChainError) {
    console.log(`Failed at step: ${error.step}`);
    // AGENT_VERIFY, DEVELOPER_FETCH, DEVELOPER_VERIFY, STATUS_CHECK
    
    if (error.agentCredential) {
      console.log('Partial agent data:', error.agentCredential);
    }
  }
}

try {
  await verifyAgentTrustChain(token, {
    policy: {
      minKybTier: 'tier_2',
      minPromptInjectionScore: 85,
    },
  });
} catch (error) {
  if (error instanceof PolicyViolationError) {
    for (const violation of error.violations) {
      console.log(`${violation.type}: required ${violation.required}, got ${violation.actual}`);
    }
    
    if (error.hasType('KYB_TIER')) {
      console.error('Developer needs higher KYB verification');
    }
  }
}

import {
  ValidationError,
  SignatureError,
  TrustChainError,
  PolicyViolationError,
} from '@beltic/sdk';

async function handleCredential(token: string) {
  try {
    return await verifyAgentTrustChain(token, options);
  } catch (error) {
    if (error instanceof ValidationError) {
      // Schema/format issues - likely caller error
      return { status: 400, error: 'Invalid credential format' };
    }
    
    if (error instanceof SignatureError) {
      // Cryptographic issues - could be tampering
      return { status: 401, error: 'Invalid signature' };
    }
    
    if (error instanceof TrustChainError) {
      // Trust chain broken - credential relationship issues
      return { status: 403, error: 'Trust chain verification failed' };
    }
    
    if (error instanceof PolicyViolationError) {
      // Policy issues - credential doesn't meet requirements
      return { status: 403, error: 'Policy requirements not met' };
    }
    
    // Unknown error
    throw error;
  }
}

import { getPublicMessage, sanitizeMessage } from '@beltic/sdk';

try {
  await verifyCredential(token, options);
} catch (error) {
  // Log full details for debugging
  logger.error('Verification failed', {
    code: error.code,
    message: error.message,
    stack: error.stack,
  });
  
  // Return safe message to client
  res.status(401).json({
    error: getPublicMessage(error),
    code: error.code,
  });
}

import {
  VALIDATION_ERRORS,
  SIGNATURE_ERRORS,
  DATE_ORDER_CODES,
  FRESHNESS_CODES,
  DATA_CATEGORY_CODES,
} from '@beltic/sdk';

if (error.code === SIGNATURE_ERRORS.EXPIRED) {
  // Handle expired token
}

if (FRESHNESS_CODES.includes(warning.code)) {
  // Handle any freshness warning
}

from beltic import (
    VALIDATION_ERRORS,
    SIGNATURE_ERRORS,
    DATE_ORDER_CODES,
    FRESHNESS_CODES,
    DATA_CATEGORY_CODES,
)

if error.code == SIGNATURE_ERRORS["EXPIRED"]:
    # Handle expired token
    pass