`bash
npx agentic-payments generate --format json
`

$3

`bash
npx agentic-payments verify --amount 100 --agents 5
`

$3

`bash
npx agentic-payments system status
`

$3

Byzantine fault-tolerant payment verification using multiple AI agents to prevent fraud and ensure agreement:

`typescript
import { AgentIdentity, IntentMandate, VerificationSystemBuilder } from 'agentic-payments';

// 1. Create verification agents
const agent1 = await AgentIdentity.generate();
const agent2 = await AgentIdentity.generate();
const agent3 = await AgentIdentity.generate();

// 2. Build consensus system (requires 67% agreement)
const system = new VerificationSystemBuilder()
.consensusThreshold(0.67)
.minAgents(2)
.addAgent(agent1)
.addAgent(agent2)
.addAgent(agent3)
.build();

// 3. Create and sign payment mandate
const mandate = new IntentMandate({
merchantId: 'shop_12345',
customerId: 'user_67890',
intent: 'Monthly premium subscription',
maxAmount: 29.99,
currency: 'USD',
expiresAt: Date.now() + 86400000 // 24 hours
});

await mandate.sign(agent1);

// 4. Verify with Byzantine fault tolerance
const message = new TextEncoder().encode(JSON.stringify(mandate.toJSON()));
const signature = mandate.getSignature();
const result = await system.verifyWithConsensus(signature, message, agent1.publicKey());

console.log(✅ Verified: ${result.isValid});
console.log(Consensus: ${(result.consensusReached ? 'YES' : 'NO')});
`

💡 Usage Examples

Real-world scenarios showing how AI agents use cryptographic mandates for autonomous commerce.

$3

Authorize AI shopping assistants with spending limits, merchant restrictions, and time-bound budgets:

`typescript
import { AgentIdentity, CartMandate, validateAndVerify } from 'agentic-payments';

// User authorizes shopping agent with Active Mandate
const mandate = {
mandate_id: 'mandate_grocery_001',
kind: 'cart',
agent: 'grocery-bot@shop.ai',
holder: 'alice@example.com',
cap: {
amount: 20000, // $200.00 weekly grocery budget
currency: 'USD',
period: 'weekly'
},
merchant_allow: ['wholefoodsmarket.com', 'instacart.com'],
expires_at: '2025-12-31T23:59:59Z'
};

// AI agent builds shopping cart
const cart = new CartMandate({
merchantId: 'wholefoodsmarket.com',
customerId: 'alice@example.com',
items: [
{ id: 'sku_001', name: 'Organic Bananas', quantity: 2, unitPrice: 399 },
{ id: 'sku_002', name: 'Almond Milk', quantity: 1, unitPrice: 549 },
{ id: 'sku_003', name: 'Sourdough Bread', quantity: 1, unitPrice: 649 }
],
currency: 'USD'
});

const agent = await AgentIdentity.generate();
await cart.sign(agent);

// Verify and process
const totalAmount = cart.getTotalAmount();
console.log(Cart total: $${(totalAmount / 100).toFixed(2)});
console.log(Within budget: ${totalAmount <= mandate.cap.amount});
`

Use case: AI shopping assistants that compare prices, build optimized carts, and complete purchases autonomously while respecting user-defined spending limits.

$3

AI robo-advisors execute trades autonomously within pre-approved limits and time windows:

`typescript
import { IntentMandate, AgentIdentity } from 'agentic-payments';

// User authorizes trading agent
const tradingMandate = new IntentMandate({
merchantId: 'exchange.trading.com',
customerId: 'investor_123',
intent: 'Purchase index fund ETF',
maxAmount: 5000.00,
currency: 'USD',
expiresAt: Date.now() + 3600000 // 1 hour execution window
});

const tradingAgent = await AgentIdentity.generate();
await tradingMandate.sign(tradingAgent);

console.log('✅ Trading agent authorized for ETF purchase');
console.log(Max investment: $${tradingMandate.getData().maxAmount});
console.log(Expires: ${new Date(tradingMandate.getData().expiresAt).toLocaleString()});
`

Use case: Robo-advisors and AI trading systems that rebalance portfolios, execute DCA strategies, or respond to market conditions with pre-authorized transaction limits.

$3

Automate accounts payable with AI agents that approve, categorize, and process vendor payments:

`typescript
import { PaymentMandate, AgentIdentity } from 'agentic-payments';

// Finance agent approves recurring vendor payment
const expenseAgent = await AgentIdentity.generate();

const vendorPayment = new PaymentMandate({
sourceId: 'expense_recurring_001',
type: 'intent',
amount: 299.99,
currency: 'USD',
paymentMethod: 'ach_vendor_account'
});

await vendorPayment.sign(expenseAgent);
vendorPayment.updateStatus('authorized');

console.log(Payment status: ${vendorPayment.getStatus()});
console.log(Authorized: ${vendorPayment.isComplete()});
`

Use case: Automated accounts payable, expense report processing, and vendor management where AI agents categorize, approve, and execute payments based on policy rules.

$3

Send payment authorizations over QUIC for 50-70% faster processing than HTTP/2:

`typescript
import { VisaTapQuicTransport, signHttpMessage } from 'agentic-payments';
import { AgentIdentity } from 'agentic-payments';

// 1. Create QUIC transport connection
const transport = new VisaTapQuicTransport({
host: 'merchant.com',
port: 8443,
enable0RTT: true, // 0-RTT reconnection (<1ms)
maxConcurrentStreams: 100 // 100+ parallel payments
});

await transport.connect();
console.log('✅ Connected via QUIC');

// 2. Sign payment request with RFC 9421
const agent = await AgentIdentity.generate();
const privateKeyHex = Buffer.from(agent.privateKey).toString('hex');

const signed = await signHttpMessage(
{
method: 'POST',
authority: 'merchant.com',
path: '/api/payments',
contentDigest: 'sha-256=:...:',
},
privateKeyHex,
'did:agent:shopping-bot'
);

// 3. Send payment via QUIC
const mandate = {
mandate_id: 'mandate_001',
agent: 'shopping-bot@example.com',
holder: 'user@example.com',
amount: 5000,
currency: 'USD',
period: 'single',
kind: 'intent'
};

const response = await transport.sendPayment({
...mandate,
signature: signed.signature,
public_key: Buffer.from(agent.publicKey()).toString('hex')
});

console.log(Transaction ID: ${response.transactionId});
console.log(Status: ${response.status});
console.log(Latency: ${response.processingTime}ms);

await transport.close();
`

Performance Benefits:
- 50-70% faster than HTTP/2 for payment authorization
- 0-RTT reconnection for sub-millisecond session resumption
- Connection migration for seamless mobile network handoffs
- 100+ concurrent streams per connection
- No head-of-line blocking unlike HTTP/2

Use case: High-frequency trading, real-time payments, mobile commerce, and latency-sensitive payment flows where every millisecond counts.

$3

Deploy multiple specialized AI agents with consensus-based approval for high-value transactions:

`typescript
import { VerificationSystemBuilder, AgentIdentity } from 'agentic-payments';

// Create specialized agent fleet
const purchasingAgent = await AgentIdentity.generate();
const financeAgent = await AgentIdentity.generate();
const complianceAgent = await AgentIdentity.generate();
const auditAgent = await AgentIdentity.generate();

// Require 75% consensus for payment approval
const fleetSystem = new VerificationSystemBuilder()
.consensusThreshold(0.75)
.minAgents(3)
.addAgent(purchasingAgent)
.addAgent(financeAgent)
.addAgent(complianceAgent)
.addAgent(auditAgent)
.build();

console.log('✅ Multi-agent payment authorization system active');
console.log(Agents: ${fleetSystem.metrics().totalVerifications});
console.log(Consensus: 75% required (3 of 4 agents));
`

Use case: Enterprise workflows where purchases require multi-party approval, segregation of duties, or Byzantine fault tolerance against compromised agents.

📖 API Reference

Complete TypeScript/JavaScript API for programmatic integration into applications.

$3

Core functions for mandate validation, signature verification, and execution guards:

`typescript
import {
validateAndVerify,
guardExecution,
revoke,
isRevoked,
getAllRevocations
} from 'agentic-payments';

// Validate schema and verify Ed25519 signature
const result = validateAndVerify(signedMandate);
if (result.valid && result.parsed) {
console.log('✓ Valid mandate');
}

// Check execution guards (time windows, revocation)
const guard = guardExecution(result.parsed);
if (guard.allowed) {
// Execute payment
} else {
console.log(Blocked: ${guard.reason});
}

// Revoke mandate
const revocation = revoke('mandate_123', 'User cancelled');

// Check revocation status
if (isRevoked('mandate_123')) {
console.log('Mandate has been revoked');
}

// List all revocations
const revocations = getAllRevocations();
console.log(Total revoked: ${revocations.length});
`

$3

Generate Ed25519 keypairs for AI agents, sign messages, and verify cryptographic signatures:

`typescript
import { AgentIdentity } from 'agentic-payments';

// Generate new Ed25519 keypair
const agent = await AgentIdentity.generate();
console.log(Agent ID: ${agent.id});
console.log(Public Key: ${Buffer.from(agent.publicKey()).toString('hex')});

// Sign message
const message = new TextEncoder().encode('payment authorization');
const signature = await agent.sign(message);

// Verify signature
const isValid = AgentIdentity.verify(
agent.publicKey(),
message,
signature.bytes
);
console.log(Valid signature: ${isValid});
`

$3

Build multi-agent consensus systems with configurable thresholds and Byzantine fault tolerance:

`typescript
import { VerificationSystemBuilder } from 'agentic-payments';

const system = new VerificationSystemBuilder()
.consensusThreshold(0.67) // 67% agreement required
.minAgents(2)
.maxAgents(10)
.timeout(5000) // 5 second timeout
.parallel(true) // Parallel verification
.addAgent(agent1)
.addAgent(agent2)
.addAgent(agent3)
.build();

// Verify with consensus
const result = await system.verifyWithConsensus(signature, message, publicKey);

console.log(Verified: ${result.isValid});
console.log(Consensus: ${result.consensusReached});
console.log(Agents: ${result.agentResults.length});

// Get metrics
const metrics = system.metrics();
console.log(Total verifications: ${metrics.totalVerifications});
console.log(Success rate: ${metrics.successfulVerifications / metrics.totalVerifications});

// Cleanup
system.shutdown();
`

$3

High-level purchase authorizations with maximum amounts and expiration times:

`typescript
import { IntentMandate } from 'agentic-payments';

const mandate = new IntentMandate({
merchantId: 'merchant_123',
customerId: 'customer_456',
intent: 'Purchase premium subscription',
maxAmount: 99.99,
currency: 'USD',
expiresAt: Date.now() + 86400000
});

await mandate.sign(agent);

// Validate before use
const validation = mandate.validate();
if (!validation.valid) {
console.error('Errors:', validation.errors);
}

const json = mandate.toJSON();
`

$3

Shopping cart approvals with line-item details and automatic total calculation:

`typescript
import { CartMandate } from 'agentic-payments';

const cart = new CartMandate({
merchantId: 'shop_123',
customerId: 'user_456',
items: [
{ id: 'item1', name: 'Product A', quantity: 2, unitPrice: 1999 },
{ id: 'item2', name: 'Product B', quantity: 1, unitPrice: 2999 }
],
currency: 'USD',
expiresAt: Date.now() + 3600000
});

await cart.sign(agent);

const items = cart.getItems();
const total = cart.getTotalAmount();
console.log(Total: $${(total / 100).toFixed(2)});
`

$3

Track payment lifecycle from authorization through capture with status management:

`typescript
import { PaymentMandate } from 'agentic-payments';

const payment = new PaymentMandate({
sourceId: 'intent_123',
type: 'intent',
amount: 99.99,
currency: 'USD',
paymentMethod: 'card_1234'
});

await payment.sign(agent);
payment.updateStatus('authorized');
payment.updateStatus('captured');

console.log(Status: ${payment.getStatus()});
console.log(Complete: ${payment.isComplete()});
`

$3

Ultra-low latency payment transport with RFC 9421 HTTP message signatures:

`typescript
import {
VisaTapQuicTransport,
signHttpMessage,
verifyHttpSignature,
computeContentDigest
} from 'agentic-payments/visa-tap';

// Create QUIC transport
const transport = new VisaTapQuicTransport({
host: 'payments.merchant.com',
port: 8443,
enable0RTT: true,
timeout: 5000
});

await transport.connect();

// Sign HTTP request per RFC 9421
const body = new TextEncoder().encode(JSON.stringify(mandate));
const contentDigest = computeContentDigest(body);

const signed = await signHttpMessage(
{
method: 'POST',
authority: 'payments.merchant.com',
path: '/v1/payments',
contentDigest,
headers: {
'Content-Type': 'application/json'
}
},
privateKeyHex,
'did:agent:payment-bot'
);

// Send payment
const response = await transport.sendPayment(signedMandate);

// Get connection statistics
const stats = transport.getStats();
console.log(RTT: ${stats?.rtt}ms);
console.log(Bytes sent: ${stats?.bytesSent});

await transport.close();
`

API Reference:

| Method | Description | Returns |
|--------|-------------|---------|
| constructor(config) | Create QUIC transport | VisaTapQuicTransport |
| connect() | Establish connection | Promise |
| sendPayment(mandate) | Send signed mandate | Promise |
| send(data) | Send raw data | Promise |
| getStats() | Get connection stats | QuicStats \| null |
| isConnected() | Check connection status | boolean |
| close() | Close connection | Promise |

RFC 9421 Functions:

| Function | Description | Returns |
|----------|-------------|---------|
| signHttpMessage() | Sign HTTP request | Promise |
| verifyHttpSignature() | Verify signature | Promise |
| computeContentDigest() | SHA-256 digest | string |

$3

Typed error handling with recovery detection and formatted error messages:

`typescript
import { PaymentError, isRecoverable, formatError } from 'agentic-payments';

try {
const result = await system.verifyWithConsensus(sig, msg, pubkey);
} catch (error) {
if (error instanceof PaymentError) {
console.error(Error: ${error.code});
console.error(Recoverable: ${error.recoverable});

if (isRecoverable(error)) {
// Retry logic
}
}
console.error(formatError(error));
}
`

🏗️ Architecture

Modular architecture with clear separation between protocols, cryptography, and interfaces:

`
agentic-payments/
├── src/
│ ├── index.ts # Main exports
│ ├── identity.ts # Ed25519 agent identities
│ ├── verification.ts # Multi-agent consensus
│ ├── mandate.ts # Payment mandates
│ ├── errors.ts # Error handling
│ ├── active-mandate/ # Active Mandate implementation
│ │ ├── types.ts # TypeScript types
│ │ ├── schema.ts # Zod validation
│ │ ├── signing.ts # Ed25519 signing
│ │ ├── revocation.ts # Revocation store
│ │ └── i18n.ts # Internationalization
│ ├── visa-tap/ # Visa TAP QUIC integration
│ │ ├── types.ts # Visa TAP TypeScript types
│ │ ├── quic-transport.ts # QUIC transport bridge
│ │ ├── rfc9421.ts # RFC 9421 HTTP signatures
│ │ └── index.ts # Visa TAP exports
│ ├── cli/ # Command-line interface
│ │ ├── index.ts # CLI entry point
│ │ └── commands/ # CLI commands
│ ├── mcp/ # Model Context Protocol
│ │ ├── server.ts # MCP server
│ │ └── tools/ # MCP tools
│ ├── ap2/ # Agent Payments Protocol
│ └── acp/ # Agentic Commerce Protocol
└── dist/ # Compiled output
`

🔒 Security Best Practices

Production deployment guidelines for secure payment authorization:

$3

Development vs Production:
- ⚠️ MCP sign_mandate tool: Development/testing ONLY. Never use in production.
- ✅ Production: Use Hardware Security Modules (HSM) or Key Management Services
- AWS KMS, Azure Key Vault, Google Cloud KMS
- Sign mandates in secure enclaves
- Never transmit private keys over network

Key Rotation:
- Rotate agent signing keys quarterly
- Maintain key version metadata in mandate records
- Support multiple active keys during rotation periods
- Revoke old mandates when rotating keys

$3

RFC 9421 Timestamp Checks:
`typescript
// verifyHttpSignature includes timestamp validation (default: 5 minutes)
const isValid = await verifyHttpSignature(components, signed, publicKey, 300);
`

Replay Protection:
- Nonce-based replay prevention (16-byte cryptographic nonces)
- Timestamp validation (configurable max age, default 300 seconds)
- Store processed nonces to prevent replay attacks

$3

Implement application-level rate limiting:
`typescript
// Example: Limit verification attempts per IP
const limiter = rateLimit({
windowMs: 15 60 1000, // 15 minutes
max: 100, // 100 requests per window
handler: (req, res) => res.status(429).send('Too many requests')
});

app.post('/verify', limiter, verifyHandler);
`

$3

QUIC Transport:
- TLS 1.3 encryption by default (no configuration needed)
- Certificate pinning for merchant endpoints
- Monitor connection statistics for anomalies

MCP Server:
- Use stdio transport for local development only
- HTTP transport requires reverse proxy with TLS in production
- Implement authentication middleware for HTTP endpoints

$3

Structured Logging:
`typescript
// Don't log sensitive data
logger.info('Payment authorized', {
mandateId: mandate.mandate_id,
amount: mandate.cap.amount,
// DO NOT log: private keys, signatures, personal data
});
`

Security Monitoring:
- Alert on repeated verification failures (potential attack)
- Monitor for unusual spending patterns
- Track revocation requests for anomalies
- Log all mandate creation with agent identities

$3

- PCI DSS: agentic-payments handles authorization only, not card data
- GDPR: Minimize personal data in mandate metadata
- Audit Trail: All mandates are cryptographically signed and immutable
- Data Retention: Implement mandate expiration and cleanup policies

📊 Performance

Optimized for low-latency payment authorization with minimal bundle impact:

| Operation | Time | Notes |
|-----------|------|-------|
| Ed25519 Sign | ~2ms | Single signature |
| Ed25519 Verify | ~3ms | Single verification |
| Consensus (3 agents) | ~10ms | Byzantine fault tolerance |
| Mandate Validation | <1ms | Schema + business rules |
| QUIC Connection | ~100ms | First connection (vs 300ms HTTP/2) |
| QUIC Reconnection | <1ms | 0-RTT session resumption |
| RFC 9421 Signing | ~2ms | HTTP message signature |
| Bundle Size | <200KB | Gzipped, tree-shakeable |

$3

Comparison with HTTP/2 for payment authorization:

| Metric | QUIC (Visa TAP) | HTTP/2 | Improvement |
|--------|-----------------|--------|-------------|
| First connection | 100ms | 300ms | 66% faster |
| Reconnection | <1ms (0-RTT) | 200ms | 99.5% faster |
| Mobile handoff | Seamless | Connection drop | Connection migration |
| Concurrent streams | 100+ | 100+ | Equal |
| Head-of-line blocking | None | Present | Better reliability |

📄 License

Licensed under either of:
- MIT License (LICENSE-MIT)
- Apache License 2.0 (LICENSE-APACHE)

🌟 Credits

- Author: rUv
- Cryptography: Ed25519 via @noble/ed25519 and tweetnacl
- Validation: Zod schemas

🔗 Links

- GitHub Repository
- npm Package
- Issue Tracker

---

Build the future of autonomous AI commerce 🚀

`bash
npm install agentic-payments
``