atp-sdk

v1.2.0

Published

4 days ago

Official TypeScript SDK for Agent Trust Protocol™ - Build secure, verifiable, and trustworthy applications with decentralized identity, verifiable credentials, payment protocols (AP2/ACP), and robust access control

Downloads

354

atp-sdk - Agent Trust Protocol SDK

The Ecosystem Security Layer for AI Agents - Official TypeScript SDK for Agent Trust Protocol™

ATP provides universal quantum-safe security for all AI agent protocols (MCP, Swarm, ADK, A2A, and more). Build secure, verifiable, and trustworthy AI agents in 3 lines of code!

⚡ Get Started in 30 Seconds

npm install atp-sdk

import { Agent } from 'atp-sdk';

// Option 1: Works immediately (no services needed)
const agent = await Agent.create('MyBot');
console.log('DID:', agent.getDID());
console.log('Quantum-safe:', agent.isQuantumSafe()); // true

// Option 2: Full features (with ATP services)
await agent.initialize(); // Connects to ATP network
await agent.send('did:atp:other', 'Hello!');
console.log(await agent.getTrustScore('did:atp:other'));

That's it! Your agent now has:

✅ Quantum-safe cryptography (hybrid Ed25519 + ML-DSA)
✅ Decentralized Identity (DID)
✅ Cryptographic signatures
✅ Trust scoring

🚀 Setup Options

Quick Start (No Services Required)

Works immediately - perfect for testing and development:

import { Agent } from 'atp-sdk';
const agent = await Agent.create('MyBot');
// Ready to use!

Full Setup (With ATP Services)

For complete functionality including identity registration, credentials, and permissions:

# Start ATP services (one command)
docker-compose up -d

# Or clone and start locally
git clone https://github.com/agent-trust-protocol/core.git
cd agent-trust-protocol
./start-services.sh

Then initialize your agent:

const agent = await Agent.create('MyBot');
await agent.initialize(); // Connects to ATP services

📖 Full SDK Documentation

For advanced usage, see the complete API documentation below...

📖 Documentation

Complete Documentation - Comprehensive guides and API reference
API Reference - Detailed API documentation
Public API Surface - Stable exports for developers
Migration Guide - Upgrade notes and defaults
Examples - Practical examples and use cases
Configuration Guide - Advanced configuration options
Authentication Guide - Security and authentication patterns
Best Practices - Production-ready guidelines
Troubleshooting - Common issues and solutions

🛡️ ATP: The Ecosystem Security Layer

Agent Trust Protocol (ATP) is the universal security layer for the AI agent ecosystem.

Unlike protocol-specific security solutions, ATP works across all agent protocols:

MCP (Model Context Protocol) - Anthropic
Swarm - OpenAI multi-agent orchestration
ADK (Agent Development Kit) - Google
A2A (Agent2Agent) - Vendor-neutral protocol
Any custom protocol - ATP adapts to your needs

ATP provides:

🔐 Universal Security: One security layer for all protocols
⚛️ Quantum-Safe: Future-proof cryptography (ML-DSA + Ed25519)
🎯 Trust Management: Dynamic trust scoring across protocols
📋 Audit Trail: Immutable logging for compliance
🔑 Identity: Decentralized identity (DID) for all agents

✨ Features

🌐 Multi-Protocol Support (NEW in v1.1!)

Universal Security Layer - Works with MCP, Swarm, ADK, and A2A protocols
Automatic Protocol Detection - Identifies agent protocol automatically
Unified Monitoring - Monitor all agents through single interface
Quantum-Safe Security - Post-quantum cryptography across all protocols
Trust Scoring - Consistent trust metrics regardless of protocol
Audit Trail - Immutable logging for all protocol events

Learn more about multi-protocol support →

🔐 Zero-Knowledge Proof Authentication (NEW in v1.2!)

Agent-to-Agent Authentication - Cryptographic proofs without revealing secrets
Behavior-Based Proofs - Prove compliance history without exposing interaction details
Trust Level Verification - Prove minimum trust score without revealing exact value
Credential Proofs - Selective disclosure of verifiable credentials
Identity Proofs - DID ownership verification
Mutual Authentication - Both agents verify each other simultaneously

import { Agent } from 'atp-sdk';

// Create two agents
const alice = await Agent.create('Alice');
const bob = await Agent.create('Bob');

// Alice challenges Bob to prove trust level
const challenge = await alice.requestAuth(bob.getDID(), [
  { type: 'trust_level', params: { minTrustLevel: 0.7 } }
]);

// Bob generates ZK proof (proves trust >= 0.7 without revealing exact score)
const response = await bob.respondToChallenge(challenge);

// Alice verifies - cryptographically guaranteed
const result = await alice.verifyAuthResponse(response);
console.log('Verified:', result.verified); // true

Behavior-Based Proofs - ATP's unique differentiator:

// Record agent interactions over time
bob.recordInteraction('task-1', 'success');
bob.recordInteraction('task-2', 'success');
bob.recordInteraction('task-3', 'success');

// Prove 100% success rate without revealing individual interactions
const behaviorProof = await bob.proveBehavior({
  type: 'success_rate',
  threshold: 95
});

// Verify the proof
const valid = await alice.verifyBehaviorProof(behaviorProof, {
  type: 'success_rate',
  threshold: 95
});

💳 Payment Protocols

Google AP2 Integration - Agent Payments Protocol with mandate-based authorization
OpenAI ACP Support - Agentic Commerce Protocol for ChatGPT commerce
Intent & Cart Mandates with cryptographic signatures
Multi-payment support (cards, crypto, stablecoins, bank transfers)
Payment policy enforcement and spending limits
Complete audit trail for all transactions
Verifiable credentials for payment authorization

🔐 Identity Management

Generate and manage Decentralized Identifiers (DIDs)
Register and resolve identities on the ATP network
Multi-factor authentication (TOTP, SMS, Email)
Trust level management and verification
Cryptographic key rotation and recovery

📜 Verifiable Credentials

Create and manage credential schemas
Issue tamper-proof verifiable credentials
Generate and verify presentations
Credential lifecycle management (suspend, revoke, reactivate)
Zero-knowledge proof support

🛡️ Permissions & Access Control

Policy-based access control (PBAC)
Fine-grained permission management
Capability token delegation
Real-time access decision evaluation
Comprehensive audit trails

📋 Audit & Compliance

Immutable audit logging
Blockchain anchoring for integrity
Advanced query and search capabilities
Compliance reporting and data export
Real-time monitoring and alerts

⚡ Real-time Features

WebSocket event streaming
Live security monitoring
Service health monitoring
Connection management with auto-reconnection
Event filtering and processing

🏗️ Architecture

The ATP™ SDK provides a unified interface to multiple microservices:

┌─────────────────┐    ┌──────────────────────────────────────┐
│   Your App      │    │            ATP™ SDK                  │
│                 │    │                                      │
│  ┌───────────┐  │    │  ┌─────────────────────────────────┐ │
│  │  Business │  │◄──►│  │        ATPClient                │ │
│  │   Logic   │  │    │  │                                 │ │
│  └───────────┘  │    │  │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
└─────────────────┘    │  │ │ ID  │ │Creds│ │Perms│ │Audit│ │ │
                       │  │ └─────┘ └─────┘ └─────┘ └─────┘ │ │
                       │  └─────────────────────────────────┘ │
                       └──────────────────────────────────────┘
                                           │
                       ┌───────────────────┼───────────────────┐
                       │                   │                   │
               ┌───────▼────────┐ ┌────────▼────────┐ ┌───────▼────────┐
               │ Identity Service│ │Credentials Service│ │  Audit Service │
               │    (Port 3001)  │ │   (Port 3002)   │ │   (Port 3005)  │
               └─────────────────┘ └─────────────────┘ └────────────────┘
                       │                   │                   │
               ┌───────▼────────┐ ┌────────▼────────┐ ┌───────▼────────┐
               │Permissions Svc  │ │  Gateway Service│ │   Your Data    │
               │   (Port 3003)   │ │   (Port 3000)   │ │     Store      │
               └─────────────────┘ └─────────────────┘ └────────────────┘

🔧 Installation & Setup

Prerequisites

Node.js 18+ with ES modules support
TypeScript 4.5+ (for TypeScript projects)
Access to ATP™ services (local or hosted)

Installation

# Using npm
npm install atp-sdk

# Using yarn
yarn add atp-sdk

# Using pnpm
pnpm add atp-sdk

Basic Configuration

import { ATPClient, createQuickConfig } from 'atp-sdk';

// Development (local services)
const config = createQuickConfig('http://localhost');

// Production (hosted services)
const config = {
  baseUrl: 'https://api.atp.example.com',
  timeout: 30000,
  retries: 3,
  auth: {
    did: process.env.ATP_DID,
    privateKey: process.env.ATP_PRIVATE_KEY
  },
  services: {
    identity: 'https://identity.atp.example.com',
    credentials: 'https://credentials.atp.example.com',
    permissions: 'https://permissions.atp.example.com',
    audit: 'https://audit.atp.example.com',
    gateway: 'https://gateway.atp.example.com'
  }
};

const client = new ATPClient(config);

📚 Usage Examples

Identity Management

import { DIDUtils, CryptoUtils } from 'atp-sdk';

// Generate new identity
const { did, document, keyPair } = await DIDUtils.generateDID({
  network: 'testnet',
  method: 'atp'
});

// Authenticate client
client.setAuthentication({
  did: did,
  privateKey: keyPair.privateKey
});

// Register identity
const registration = await client.identity.register({
  did: did,
  document: document,
  metadata: {
    name: 'Alice Smith',
    organization: 'ACME Corp'
  }
});

// Set up multi-factor authentication
const mfaSetup = await client.identity.setupMFA({
  method: 'totp',
  label: 'My ATP Account'
});

console.log('MFA QR Code:', mfaSetup.data.qrCodeUrl);

Verifiable Credentials

// Create credential schema
const schema = await client.credentials.createSchema({
  name: 'University Degree',
  description: 'Academic degree certificate',
  version: '1.0.0',
  schema: {
    type: 'object',
    properties: {
      degree: { type: 'string' },
      university: { type: 'string' },
      graduationDate: { type: 'string', format: 'date' },
      gpa: { type: 'number', minimum: 0, maximum: 4.0 }
    },
    required: ['degree', 'university', 'graduationDate']
  }
});

// Issue credential
const credential = await client.credentials.issue({
  schemaId: schema.data.id,
  holder: 'did:atp:testnet:student123',
  claims: {
    degree: 'Bachelor of Science',
    university: 'ATP University',
    graduationDate: '2024-05-15',
    gpa: 3.75
  }
});

// Create presentation
const presentation = await client.credentials.createPresentation({
  credentialIds: [credential.data.id],
  audience: 'did:atp:testnet:employer456',
  challenge: 'job-application-2024',
  purpose: 'Employment verification'
});

// Verify presentation
const verification = await client.credentials.verifyPresentation({
  presentationId: presentation.data.id,
  expectedChallenge: 'job-application-2024',
  expectedAudience: 'did:atp:testnet:employer456'
});

console.log('Presentation valid:', verification.data.valid);

Access Control

// Create access policy
const policy = await client.permissions.createPolicy({
  name: 'Document Access Policy',
  description: 'Controls access to sensitive documents',
  version: '1.0.0',
  rules: [{
    action: 'read',
    resource: 'document:*',
    effect: 'allow',
    conditions: [{
      attribute: 'user.department',
      operator: 'equals',
      value: 'engineering'
    }]
  }]
});

// Grant permission
const grant = await client.permissions.grant({
  grantee: 'did:atp:testnet:user123',
  resource: 'document:quarterly-report',
  actions: ['read'],
  policyId: policy.data.id,
  conditions: {
    'user.department': 'engineering',
    'user.clearanceLevel': 'confidential'
  }
});

// Evaluate access
const decision = await client.permissions.evaluate({
  subject: 'did:atp:testnet:user123',
  action: 'read',
  resource: 'document:quarterly-report',
  context: {
    'user.department': 'engineering',
    'user.clearanceLevel': 'confidential',
    'request.time': new Date().toISOString()
  }
});

console.log('Access granted:', decision.data.decision === 'allow');

Audit Logging

// Log audit event
const auditEvent = await client.audit.logEvent({
  source: 'document-service',
  action: 'document_accessed',
  resource: 'document:quarterly-report',
  actor: 'did:atp:testnet:user123',
  details: {
    ipAddress: '192.168.1.100',
    userAgent: 'Mozilla/5.0...',
    accessMethod: 'web_interface'
  }
});

// Query audit trail
const auditTrail = await client.audit.queryEvents({
  resource: 'document:quarterly-report',
  startTime: '2024-06-01T00:00:00Z',
  endTime: '2024-06-30T23:59:59Z'
});

// Generate compliance report
const report = await client.audit.generateComplianceReport({
  startDate: '2024-06-01',
  endDate: '2024-06-30',
  reportType: 'access_control',
  format: 'pdf'
});

console.log('Report URL:', report.data.downloadUrl);

Real-time Monitoring

// Connect to event stream
await client.gateway.connectEventStream({
  filters: {
    eventTypes: ['identity.login', 'permission.granted'],
    severities: ['medium', 'high', 'critical']
  },
  autoReconnect: true
});

// Handle events
client.gateway.on('identity.login', (event) => {
  console.log('User logged in:', event.data.actor);
});

client.gateway.on('permission.granted', (event) => {
  console.log('Permission granted:', {
    grantee: event.data.grantee,
    resource: event.data.resource
  });
});

client.gateway.on('error', (error) => {
  console.error('Stream error:', error.message);
});

// Monitor service health
const health = await client.gateway.getStatus();
console.log('Gateway status:', health.data.status);

Zero-Knowledge Proof Authentication

import { Agent, ZKProofType } from 'atp-sdk';

// === Basic Agent-to-Agent Authentication ===

// Create two agents that need to authenticate each other
const serviceAgent = await Agent.create('DataService');
const clientAgent = await Agent.create('ClientBot');

// Service agent requires proof of trust level and identity
const challenge = await serviceAgent.requestAuth(clientAgent.getDID(), [
  { type: ZKProofType.TRUST_LEVEL, params: { minTrustLevel: 0.6 } },
  { type: ZKProofType.IDENTITY, params: {} }
]);

// Client generates zero-knowledge proofs (proves claims without revealing values)
const response = await clientAgent.respondToChallenge(challenge);

// Service verifies proofs cryptographically
const authResult = await serviceAgent.verifyAuthResponse(response);

if (authResult.verified) {
  console.log('Client authenticated successfully');
  console.log('Trust level: >= 0.6 (exact value hidden)');
}

// === Mutual Authentication ===
// Both agents authenticate each other simultaneously

const { myResult, theirResult } = await serviceAgent.mutualAuth(
  clientAgent.getDID(),
  // What we require from them
  [{ type: ZKProofType.TRUST_LEVEL, params: { minTrustLevel: 0.5 } }],
  // What they require from us
  [{ type: ZKProofType.CREDENTIAL, params: { credentialType: 'ServiceProvider' } }]
);

console.log('Both agents verified:', myResult.verified && theirResult.verified);

// === Behavior-Based Proofs (ATP Differentiator) ===
// Prove compliance history without revealing individual interactions

// Record interactions over time (in production, called by your business logic)
for (let i = 0; i < 100; i++) {
  clientAgent.recordInteraction(`task-${i}`, 'success');
}

// Check current behavior stats
const stats = clientAgent.getBehaviorStats();
console.log(`Success: ${stats.successCount}, Violations: ${stats.violationCount}`);

// Prove "no violations" - service can verify without seeing interaction history
const noViolationsProof = await clientAgent.proveBehavior({
  type: 'no_violations'
});

const isCompliant = await serviceAgent.verifyBehaviorProof(
  noViolationsProof,
  { type: 'no_violations' }
);
console.log('Agent has clean record:', isCompliant);

// Prove success rate meets threshold
const successProof = await clientAgent.proveBehavior({
  type: 'success_rate',
  threshold: 95 // Proves >= 95% success without revealing exact rate
});

// Prove compliance with specific policy
const policyProof = await clientAgent.proveBehavior({
  type: 'policy_compliance',
  policyId: 'rate-limit-policy'
});

// === Using Low-Level ZKP Utilities ===
import {
  createChallenge,
  createTrustLevelProof,
  verifyTrustLevelProof,
  generateAuthResponse,
  verifyAuthResponse
} from 'atp-sdk';

// Create a custom challenge
const customChallenge = createChallenge(
  'did:atp:verifier',
  'did:atp:prover',
  [{ type: ZKProofType.TRUST_LEVEL, params: { minTrustLevel: 0.8 } }],
  5 // expires in 5 minutes
);

// Generate proof manually
const trustProof = createTrustLevelProof(
  0.85,  // actual trust score
  0.8,   // threshold to prove
  privateKey
);

// Verify proof
const isValid = verifyTrustLevelProof(trustProof, {
  type: ZKProofType.TRUST_LEVEL,
  params: { minTrustLevel: 0.8 }
});

Payment Protocols (AP2 & ACP)

// Google AP2 (Agent Payments Protocol) Integration

// 1. Create Intent Mandate (User Authorization)
const intentMandate = await client.payments.createIntentMandate({
  userDid: 'did:atp:user123',
  agentDid: 'did:atp:shopping-agent',
  purpose: 'Holiday shopping assistant',
  maxAmount: 500.00,
  currency: 'USD',
  expiresAt: new Date('2025-12-31'),
  restrictions: {
    merchants: ['amazon.com', 'etsy.com'],
    categories: ['gifts', 'electronics'],
    dailyLimit: 200.00
  }
});

// 2. Create Cart Mandate (Specific Transaction)
const cartMandate = await client.payments.createCartMandate({
  intentMandateId: intentMandate.data.id,
  merchant: 'etsy.com',
  items: [
    { id: 'item-1', name: 'Handmade Mug', quantity: 2, price: 24.99, currency: 'USD' },
    { id: 'item-2', name: 'Coffee Beans', quantity: 1, price: 18.50, currency: 'USD' }
  ],
  total: 68.48,
  currency: 'USD',
  paymentMethod: paymentMethodObject
});

// 3. Execute Payment
const payment = await client.payments.executeAP2Payment({
  cartMandateId: cartMandate.data.id,
  paymentMethod: paymentMethodObject,
  billingAddress: {
    line1: '123 Main St',
    city: 'San Francisco',
    state: 'CA',
    postalCode: '94102',
    country: 'US'
  }
});

console.log('Payment completed:', payment.data.id);
console.log('Audit trail events:', payment.data.auditTrail.length);

// OpenAI ACP (Agentic Commerce Protocol) Integration

// 1. Create Checkout Session
const checkout = await client.payments.createACPCheckout({
  merchantId: 'merchant-123',
  agentDid: 'did:atp:shopping-agent',
  items: [
    { productId: 'prod-vintage-lamp', quantity: 1 },
    { productId: 'prod-art-print', quantity: 2 }
  ],
  shippingAddress: {
    line1: '456 Oak Ave',
    city: 'New York',
    state: 'NY',
    postalCode: '10001',
    country: 'US'
  },
  customerEmail: '[email protected]'
});

// 2. Complete Checkout
const result = await client.payments.completeACPCheckout({
  sessionId: checkout.data.id,
  paymentMethodId: 'pm-card-123',
  sharedPaymentToken: 'spt-stripe-abc123'
});

console.log('Transaction ID:', result.data.transactionId);
console.log('Receipt URL:', result.data.receipt?.url);

// Payment Policy Management
const policy = await client.payments.createPaymentPolicy({
  name: 'Shopping Assistant Limits',
  agentDid: 'did:atp:shopping-agent',
  maxTransactionAmount: 100.00,
  dailyLimit: 250.00,
  monthlyLimit: 1000.00,
  allowedMerchants: ['etsy.com', 'amazon.com'],
  requiresApproval: true,
  notificationThreshold: 50.00
});

// Add Payment Methods
const cardMethod = await client.payments.addPaymentMethod({
  userDid: 'did:atp:user123',
  type: 'card',
  details: {
    last4: '4242',
    brand: 'Visa',
    expiryMonth: 12,
    expiryYear: 2026
  },
  isDefault: true
});

// Crypto/Stablecoin Support
const cryptoMethod = await client.payments.addPaymentMethod({
  userDid: 'did:atp:user123',
  type: 'stablecoin',
  details: {
    walletAddress: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb',
    blockchain: 'ethereum',
    tokenSymbol: 'USDC'
  }
});

// Query Transaction History
const transactions = await client.payments.queryTransactions({
  userDid: 'did:atp:user123',
  startDate: new Date('2025-01-01'),
  endDate: new Date(),
  status: 'completed'
});

console.log('Total transactions:', transactions.data.length);

🛠️ Development

Environment Setup

# Clone the repository
git clone https://github.com/atp/sdk.git
cd sdk

# Install dependencies
npm install

# Run tests
npm test

# Build the SDK
npm run build

# Run examples
npm run examples

Running Examples

# Run all examples
node examples/index.js --all

# Run specific example
node examples/index.js 1  # Basic setup
node examples/index.js 2  # Identity management
node examples/index.js 3  # Verifiable credentials

TypeScript Support

The SDK is written in TypeScript and provides comprehensive type definitions:

import { ATPClient, ATPConfig, VerifiableCredential } from 'atp-sdk';

const config: ATPConfig = {
  baseUrl: 'http://localhost',
  auth: {
    did: 'did:atp:testnet:example',
    privateKey: 'hex-private-key'
  }
};

const client = new ATPClient(config);

// Types are automatically inferred
const credential: VerifiableCredential = await client.credentials.issue({
  schemaId: 'schema-id',
  holder: 'holder-did',
  claims: { name: 'John Doe' }
});

🧪 Testing

The SDK includes comprehensive tests and testing utilities:

# Run unit tests
npm run test:unit

# Run integration tests
npm run test:integration

# Run tests with coverage
npm run test:coverage

# Run specific test suite
npm run test -- --grep "Identity"

Testing Your Application

import { ATPClient } from 'atp-sdk';
import { jest } from '@jest/globals';

// Mock the SDK for testing
jest.mock('atp-sdk');

describe('My Application', () => {
  let mockClient;

  beforeEach(() => {
    mockClient = {
      identity: {
        resolve: jest.fn(),
        register: jest.fn()
      }
    };
    
    ATPClient.mockImplementation(() => mockClient);
  });

  test('should handle identity resolution', async () => {
    mockClient.identity.resolve.mockResolvedValue({
      data: { did: 'did:atp:test:123', status: 'active' }
    });

    // Test your application logic
  });
});

🚀 Production Deployment

Security Checklist

[ ] Use HTTPS/TLS for all communications
[ ] Store private keys securely (HSM, KMS, etc.)
[ ] Implement proper key rotation
[ ] Enable audit logging
[ ] Set up monitoring and alerts
[ ] Configure rate limiting
[ ] Use environment-specific configurations
[ ] Implement circuit breakers and retries
[ ] Test disaster recovery procedures

Performance Optimization

// Connection pooling
const config = {
  connectionPool: {
    maxSockets: 50,
    maxFreeSockets: 10,
    timeout: 60000
  }
};

// Caching
const cache = new LRUCache({ max: 1000, ttl: 300000 });

async function cachedResolve(did) {
  const cached = cache.get(did);
  if (cached) return cached;

  const result = await client.identity.resolve(did);
  cache.set(did, result);
  return result;
}

// Batch operations
const results = await Promise.allSettled(
  dids.map(did => client.identity.resolve(did))
);

📊 Monitoring

Health Checks

Quick Start Example: See examples/10-monitoring-health.js for a complete monitoring example.

// Implement health check endpoint
import { ATPClient, createQuickConfig } from 'atp-sdk';

app.get('/health', async (req, res) => {
  const client = new ATPClient(createQuickConfig('http://localhost'));
  
  try {
    const health = await client.testConnectivity();
    
    res.status(health.overall ? 200 : 503).json({
      status: health.overall ? 'healthy' : 'degraded',
      services: health,
      timestamp: new Date().toISOString()
    });
  } catch (error) {
    res.status(503).json({
      status: 'unhealthy',
      error: error.message,
      timestamp: new Date().toISOString()
    });
  }
});

Gateway Health & Status

// Get detailed gateway health
const health = await client.gateway.getHealth();

// Get gateway status with load metrics
const status = await client.gateway.getStatus();

// Get connection statistics
const stats = await client.gateway.getConnectionStats();

Metrics

// Collect SDK metrics
const metrics = {
  operations: {
    total: 0,
    successful: 0,
    failed: 0
  },
  performance: {
    averageLatency: 0,
    p95Latency: 0
  }
};

// Instrument operations
async function instrumentedOperation(operation) {
  const start = Date.now();
  metrics.operations.total++;
  
  try {
    const result = await operation();
    metrics.operations.successful++;
    return result;
  } catch (error) {
    metrics.operations.failed++;
    throw error;
  } finally {
    const latency = Date.now() - start;
    updateLatencyMetrics(latency);
  }
}

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Workflow

Fork the repository
Create a feature branch
Make your changes
Add tests for new functionality
Ensure all tests pass
Submit a pull request

Code Standards

Follow TypeScript best practices
Maintain 100% test coverage for new code
Use conventional commit messages
Update documentation for API changes

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🆘 Support

Documentation: https://docs.atp.protocol
GitHub Issues: Report bugs and request features
Discord: Join our community
Email: [email protected]
Enterprise Support: [email protected]

🔗 Related Projects

ATP™ Core Services - Core ATP protocol implementation
ATP™ CLI - Command-line interface
ATP™ Examples - Real-world examples and demos
ATP™ Specification - Protocol specification

📈 Roadmap

[x] v1.1.0 - Payment Protocols (AP2 & ACP) Integration
[x] v1.2.0 - Zero-Knowledge Proof Authentication (Agent-to-Agent)
[ ] v1.3.0 - WebAssembly support for browser environments
[ ] v1.4.0 - GraphQL API support
[ ] v2.0.0 - ATP Protocol v2 compatibility

🔗 Payment Protocol Partners

The ATP SDK integrates with industry-leading payment platforms:

AP2 (Agent Payments Protocol) Partners:

Adyen, American Express, Ant International
Coinbase, Ethereum Foundation, MetaMask
Etsy, Mastercard, PayPal, Revolut
Salesforce, ServiceNow, Stripe, Worldpay
60+ additional partners

ACP (Agentic Commerce Protocol):

OpenAI ChatGPT Commerce
Stripe Shared Payment Tokens
Etsy Instant Checkout

Agent Trust Protocol™ - The security layer for AI agents.

Built and maintained by Sovr Labs | Enterprise