@veridex/agentic-payments 0.1.1-beta.1

package/tests/performance.test.ts

@@ -0,0 +1,303 @@
+/**
+ * Performance Module Tests
+ * 
+ * Tests for NonceManager, TransactionQueue, and TransactionPoller.
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { NonceManager } from '../src/performance/NonceManager';
+import { TransactionQueue } from '../src/performance/TransactionQueue';
+import { TransactionPoller } from '../src/performance/TransactionPoller';
+
+describe('NonceManager', () => {
+    let manager: NonceManager;
+
+    beforeEach(() => {
+        manager = new NonceManager();
+    });
+
+    describe('getNextNonce', () => {
+        it('should return 0 for fresh key', () => {
+            const nonce = manager.getNextNonce('key1');
+            expect(nonce).toBe(BigInt(0));
+        });
+
+        it('should use on-chain value when provided', () => {
+            const nonce = manager.getNextNonce('key1', BigInt(5));
+            expect(nonce).toBe(BigInt(5));
+        });
+
+        it('should use cached value on subsequent calls', () => {
+            manager.getNextNonce('key1', BigInt(5));
+            const nonce = manager.getNextNonce('key1');
+            expect(nonce).toBe(BigInt(5));
+        });
+
+        it('should skip pending nonces', () => {
+            manager.reserveNonce('key1', BigInt(0));
+            manager.reserveNonce('key1', BigInt(1));
+            const nonce = manager.getNextNonce('key1');
+            expect(nonce).toBe(BigInt(2));
+        });
+    });
+
+    describe('reserveNonce and releaseNonce', () => {
+        it('should reserve and release nonces', () => {
+            manager.reserveNonce('key1', BigInt(0));
+            expect(manager.getPendingNonces('key1')).toContain(BigInt(0));
+
+            manager.releaseNonce('key1', BigInt(0));
+            expect(manager.getPendingNonces('key1')).not.toContain(BigInt(0));
+        });
+    });
+
+    describe('confirmNonce', () => {
+        it('should update cache on confirmation', () => {
+            manager.reserveNonce('key1', BigInt(0));
+            manager.confirmNonce('key1', BigInt(0));
+
+            expect(manager.getPendingNonces('key1')).not.toContain(BigInt(0));
+
+            const nextNonce = manager.getNextNonce('key1');
+            expect(nextNonce).toBe(BigInt(1));
+        });
+    });
+
+    describe('clearCache', () => {
+        it('should clear all data for a key', () => {
+            manager.getNextNonce('key1', BigInt(5));
+            manager.reserveNonce('key1', BigInt(5));
+
+            manager.clearCache('key1');
+
+            expect(manager.getNextNonce('key1')).toBe(BigInt(0));
+            expect(manager.getPendingNonces('key1')).toHaveLength(0);
+        });
+    });
+});
+
+describe('TransactionQueue', () => {
+    let queue: TransactionQueue;
+
+    beforeEach(() => {
+        queue = new TransactionQueue({ batchSize: 5, batchDelayMs: 10 });
+    });
+
+    afterEach(async () => {
+        await queue.shutdown({ waitForPending: false });
+        queue.clear();
+    });
+
+    describe('enqueue', () => {
+        it('should add transaction to queue', () => {
+            const id = queue.enqueue({
+                keyHash: 'key1',
+                payload: {
+                    recipient: '0x123',
+                    amount: '100',
+                    token: 'USDC',
+                    chain: 30,
+                },
+                priority: 'normal',
+            });
+
+            expect(id).toBeDefined();
+            expect(id).toMatch(/^tx_/);
+            const tx = queue.get(id);
+            expect(tx?.status).toBe('pending');
+        });
+    });
+
+    describe('cancel', () => {
+        it('should cancel pending transaction', () => {
+            const id = queue.enqueue({
+                keyHash: 'key1',
+                payload: {
+                    recipient: '0x123',
+                    amount: '100',
+                    token: 'USDC',
+                    chain: 30,
+                },
+                priority: 'normal',
+            });
+
+            const cancelled = queue.cancel(id);
+            expect(cancelled).toBe(true);
+            expect(queue.get(id)?.status).toBe('cancelled');
+        });
+
+        it('should return false for non-existent transaction', () => {
+            const cancelled = queue.cancel('non-existent');
+            expect(cancelled).toBe(false);
+        });
+    });
+
+    describe('flush', () => {
+        it('should process all pending transactions', async () => {
+            queue.enqueue({
+                keyHash: 'key1',
+                payload: { recipient: '0x1', amount: '10', token: 'USDC', chain: 30 },
+                priority: 'normal',
+            });
+            queue.enqueue({
+                keyHash: 'key1',
+                payload: { recipient: '0x2', amount: '20', token: 'USDC', chain: 30 },
+                priority: 'high',
+            });
+
+            const results = await queue.flush();
+
+            expect(results.length).toBeGreaterThan(0);
+            expect(results[0].successCount).toBe(2);
+        });
+    });
+
+    describe('getStats', () => {
+        it('should return queue statistics', async () => {
+            queue.enqueue({
+                keyHash: 'key1',
+                payload: { recipient: '0x1', amount: '10', token: 'USDC', chain: 30 },
+                priority: 'normal',
+            });
+
+            const statsBefore = queue.getStats();
+            expect(statsBefore.pending).toBe(1);
+
+            await queue.flush();
+
+            const statsAfter = queue.getStats();
+            expect(statsAfter.completed).toBe(1);
+            expect(statsAfter.pending).toBe(0);
+        });
+    });
+
+    describe('dead letter queue', () => {
+        it('should move failed transactions to dead letter queue', async () => {
+            // Create queue with executor that always fails
+            const failingQueue = new TransactionQueue(
+                { batchSize: 5, batchDelayMs: 10, defaultMaxAttempts: 1 },
+                {
+                    execute: () => Promise.reject(new Error('Always fails')),
+                }
+            );
+
+            failingQueue.enqueue({
+                keyHash: 'key1',
+                payload: { recipient: '0x1', amount: '10', token: 'USDC', chain: 30 },
+                priority: 'normal',
+            });
+
+            await failingQueue.flush();
+
+            const dlq = failingQueue.getDeadLetterQueue();
+            expect(dlq.length).toBe(1);
+            expect(dlq[0].lastError).toBe('Always fails');
+
+            await failingQueue.shutdown({ waitForPending: false });
+        });
+    });
+
+    describe('events', () => {
+        it('should emit events during processing', async () => {
+            const events: string[] = [];
+
+            queue.on('transaction:enqueued', () => events.push('enqueued'));
+            queue.on('transaction:processing', () => events.push('processing'));
+            queue.on('transaction:completed', () => events.push('completed'));
+            queue.on('batch:completed', () => events.push('batch'));
+
+            queue.enqueue({
+                keyHash: 'key1',
+                payload: { recipient: '0x1', amount: '10', token: 'USDC', chain: 30 },
+                priority: 'normal',
+            });
+
+            expect(events).toContain('enqueued');
+
+            await queue.flush();
+
+            expect(events).toContain('processing');
+            expect(events).toContain('completed');
+            expect(events).toContain('batch');
+        });
+    });
+});
+
+describe('TransactionPoller', () => {
+    let poller: TransactionPoller;
+    let mockChecker: ReturnType<typeof vi.fn<[string, number], Promise<{ confirmed: boolean; confirmations?: number; blockNumber?: number }>>>;
+
+    beforeEach(() => {
+        mockChecker = vi.fn().mockResolvedValue({ confirmed: false });
+        poller = new TransactionPoller(mockChecker);
+    });
+
+    afterEach(() => {
+        poller.destroy();
+    });
+
+    describe('track', () => {
+        it('should start tracking a transaction', () => {
+            poller.track('0x123', 30);
+
+            const status = poller.getStatus('0x123');
+            expect(status).toBeDefined();
+            expect(status?.status).toBe('pending');
+        });
+
+        it('should call callback on confirmation', async () => {
+            mockChecker.mockResolvedValueOnce({ confirmed: true, confirmations: 1, blockNumber: 100 });
+
+            const callback = vi.fn();
+            poller.track('0x123', 30, callback);
+
+            // Wait for poll cycle
+            await new Promise(resolve => setTimeout(resolve, 2500));
+
+            expect(callback).toHaveBeenCalled();
+            expect(callback).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    txHash: '0x123',
+                    status: 'confirmed',
+                })
+            );
+        });
+    });
+
+    describe('untrack', () => {
+        it('should stop tracking a transaction', () => {
+            poller.track('0x123', 30);
+            poller.untrack('0x123');
+
+            expect(poller.getStatus('0x123')).toBeUndefined();
+        });
+    });
+
+    describe('onConfirmation', () => {
+        it('should subscribe to global events', async () => {
+            mockChecker.mockResolvedValueOnce({ confirmed: true, confirmations: 1 });
+
+            const globalCallback = vi.fn();
+            const unsubscribe = poller.onConfirmation(globalCallback);
+
+            poller.track('0x456', 30);
+
+            // Wait for poll cycle
+            await new Promise(resolve => setTimeout(resolve, 2500));
+
+            expect(globalCallback).toHaveBeenCalled();
+
+            unsubscribe();
+        });
+    });
+
+    describe('getPending', () => {
+        it('should return all pending transactions', () => {
+            poller.track('0x111', 30);
+            poller.track('0x222', 30);
+
+            const pending = poller.getPending();
+            expect(pending).toHaveLength(2);
+        });
+    });
+});

package/tests/property.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Property Tests for Agent SDK
+ * 
+ * Comprehensive property-based tests using fast-check.
+ * These tests verify invariants that must hold across all inputs.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import * as fc from 'fast-check';
+import { PaymentTokenizer } from '../src/ucp/PaymentTokenizer';
+import { AlertManager } from '../src/monitoring/AlertManager';
+import { StoredSession } from '../src/session/SessionStorage';
+
+// Helper to create mock sessions
+function createMockSession(overrides: Partial<{
+    keyHash: string;
+    dailyLimitUSD: number;
+    perTransactionLimitUSD: number;
+    expiryTimestamp: number;
+    dailySpentUSD: number;
+}> = {}): StoredSession {
+    const {
+        keyHash = '0x' + 'a'.repeat(64),
+        dailyLimitUSD = 100,
+        perTransactionLimitUSD = 25,
+        expiryTimestamp = Date.now() + 3600000,
+        dailySpentUSD = 0,
+    } = overrides;
+
+    return {
+        keyHash,
+        encryptedPrivateKey: '0x' + 'b'.repeat(64),
+        publicKey: '0x04' + 'c'.repeat(128),
+        config: {
+            dailyLimitUSD,
+            perTransactionLimitUSD,
+            expiryTimestamp,
+            allowedChains: [30],
+        },
+        metadata: {
+            createdAt: Date.now(),
+            lastUsedAt: Date.now(),
+            totalSpentUSD: dailySpentUSD,
+            dailySpentUSD,
+            dailyResetAt: Date.now() + 86400000,
+            transactionCount: 0,
+        },
+        masterKeyHash: '0x' + 'd'.repeat(64),
+    };
+}
+
+describe('Property Tests', () => {
+    describe('Property 7: Payment Token Enforces Original Session Limits', () => {
+        it('token limits should match session limits', async () => {
+            await fc.assert(
+                fc.asyncProperty(
+                    fc.integer({ min: 1, max: 10000 }), // dailyLimit
+                    fc.integer({ min: 1, max: 1000 }), // perTxLimit
+                    async (dailyLimit, perTxLimit) => {
+                        const actualPerTxLimit = Math.min(perTxLimit, dailyLimit);
+                        const tokenizer = new PaymentTokenizer();
+                        const session = createMockSession({
+                            dailyLimitUSD: dailyLimit,
+                            perTransactionLimitUSD: actualPerTxLimit,
+                        });
+
+                        const token = await tokenizer.tokenize(session);
+
+                        expect(token.limits.dailyLimitUSD).toBe(dailyLimit);
+                        expect(token.limits.perTransactionLimitUSD).toBe(actualPerTxLimit);
+                    }
+                ),
+                { numRuns: 50 }
+            );
+        });
+    });
+
+    describe('Property 14: Spending Alert Threshold Accuracy', () => {
+        it('should trigger alert at exactly the right threshold', () => {
+            fc.assert(
+                fc.property(
+                    fc.integer({ min: 1, max: 10000 }), // dailyLimit
+                    fc.double({ min: 0.01, max: 1.0, noNaN: true }), // spendingRatio
+                    (dailyLimit, spendingRatio) => {
+                        const manager = new AlertManager({
+                            spendingThresholds: [0.5, 0.8, 0.9, 1.0],
+                        });
+
+                        const alerts: any[] = [];
+                        manager.onAlert((alert) => alerts.push(alert));
+
+                        const spent = dailyLimit * spendingRatio;
+                        manager.checkSpending('test-session', spent, dailyLimit);
+
+                        // Check that alerts match thresholds
+                        if (spendingRatio >= 0.5) {
+                            expect(alerts.length).toBeGreaterThanOrEqual(1);
+                        }
+                        if (spendingRatio >= 0.9) {
+                            // Should have critical alert
+                            expect(alerts.some(a => a.type === 'CRITICAL')).toBe(true);
+                        }
+                    }
+                ),
+                { numRuns: 50 }
+            );
+        });
+    });
+
+    describe('Property 19: Payment Token Expiration Enforcement', () => {
+        it('tokens should not be valid after expiration', async () => {
+            await fc.assert(
+                fc.asyncProperty(
+                    fc.integer({ min: 1, max: 1000 }), // token TTL in ms (short for testing)
+                    async (ttlMs) => {
+                        const tokenizer = new PaymentTokenizer();
+                        const session = createMockSession({
+                            expiryTimestamp: Date.now() + ttlMs + 1000,
+                        });
+
+                        const token = await tokenizer.tokenize(session, ttlMs);
+
+                        // Token should be valid immediately
+                        const validResult = tokenizer.validate(token.token);
+                        expect(validResult.valid).toBe(true);
+                    }
+                ),
+                { numRuns: 20 }
+            );
+        });
+    });
+
+    describe('Property 20: High-Value Transaction Approval Window', () => {
+        it('approvals should expire after window', () => {
+            fc.assert(
+                fc.property(
+                    fc.integer({ min: 1000, max: 10000 }), // amount
+                    (amount) => {
+                        const manager = new AlertManager({
+                            highValueThresholdUSD: 500,
+                        });
+
+                        const approval = manager.requestApproval('tx-123', amount);
+
+                        // Check window
+                        expect(approval.expiresAt).toBeGreaterThan(Date.now());
+                        expect(approval.expiresAt - approval.requestedAt).toBeLessThanOrEqual(5 * 60 * 1000);
+                    }
+                ),
+                { numRuns: 20 }
+            );
+        });
+
+        it('approval check should return not found for non-existent transactions', () => {
+            const manager = new AlertManager();
+            const result = manager.checkApproval('non-existent');
+            expect(result.approved).toBe(false);
+            expect(result.expired).toBe(false);
+        });
+    });
+
+    describe('Property: High-Value Detection Threshold', () => {
+        it('should correctly identify high-value transactions', () => {
+            fc.assert(
+                fc.property(
+                    fc.integer({ min: 100, max: 5000 }), // threshold
+                    fc.integer({ min: 1, max: 10000 }), // amount
+                    (threshold, amount) => {
+                        const manager = new AlertManager({
+                            highValueThresholdUSD: threshold,
+                        });
+
+                        const isHighValue = manager.isHighValueTransaction(amount);
+
+                        if (amount >= threshold) {
+                            expect(isHighValue).toBe(true);
+                        } else {
+                            expect(isHighValue).toBe(false);
+                        }
+                    }
+                ),
+                { numRuns: 50 }
+            );
+        });
+    });
+});