@antseed/node 0.1.0

package/tests/metadata-codec.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect } from 'vitest';
+import { encodeMetadata, decodeMetadata, encodeMetadataForSigning } from '../src/discovery/metadata-codec.js';
+import type { PeerMetadata } from '../src/discovery/peer-metadata.js';
+
+function makeMetadata(overrides?: Partial<PeerMetadata>): PeerMetadata {
+  return {
+    peerId: 'a'.repeat(64) as any,
+    version: 2,
+    providers: [
+      {
+        provider: 'anthropic',
+        models: ['claude-3-opus', 'claude-3-sonnet'],
+        defaultPricing: {
+          inputUsdPerMillion: 15,
+          outputUsdPerMillion: 75,
+        },
+        modelPricing: {
+          'claude-3-opus': {
+            inputUsdPerMillion: 18,
+            outputUsdPerMillion: 90,
+          },
+        },
+        maxConcurrency: 10,
+        currentLoad: 3,
+      },
+    ],
+    region: 'us-east-1',
+    timestamp: 1700000000000,
+    signature: 'b'.repeat(128),
+    ...overrides,
+  };
+}
+
+describe('encodeMetadata / decodeMetadata', () => {
+  it('should round-trip a basic metadata object', () => {
+    const original = makeMetadata();
+    const encoded = encodeMetadata(original);
+    const decoded = decodeMetadata(encoded);
+
+    expect(decoded.version).toBe(original.version);
+    expect(decoded.peerId).toBe(original.peerId);
+    expect(decoded.region).toBe(original.region);
+    expect(decoded.timestamp).toBe(original.timestamp);
+    expect(decoded.signature).toBe(original.signature);
+    expect(decoded.providers).toHaveLength(1);
+    expect(decoded.providers[0]!.provider).toBe('anthropic');
+    expect(decoded.providers[0]!.models).toEqual(['claude-3-opus', 'claude-3-sonnet']);
+    expect(decoded.providers[0]!.maxConcurrency).toBe(10);
+    expect(decoded.providers[0]!.currentLoad).toBe(3);
+  });
+
+  it('should handle float32 precision for prices', () => {
+    const original = makeMetadata();
+    const encoded = encodeMetadata(original);
+    const decoded = decodeMetadata(encoded);
+    // Float32 has limited precision — allow small delta
+    expect(decoded.providers[0]!.defaultPricing.inputUsdPerMillion).toBeCloseTo(15, 3);
+    expect(decoded.providers[0]!.defaultPricing.outputUsdPerMillion).toBeCloseTo(75, 3);
+    expect(decoded.providers[0]!.modelPricing?.['claude-3-opus']?.inputUsdPerMillion).toBeCloseTo(18, 3);
+    expect(decoded.providers[0]!.modelPricing?.['claude-3-opus']?.outputUsdPerMillion).toBeCloseTo(90, 3);
+  });
+
+  it('should round-trip multiple providers', () => {
+    const original = makeMetadata({
+      providers: [
+        {
+          provider: 'openai',
+          models: ['gpt-4'],
+          defaultPricing: {
+            inputUsdPerMillion: 10,
+            outputUsdPerMillion: 30,
+          },
+          maxConcurrency: 5,
+          currentLoad: 0,
+        },
+        {
+          provider: 'anthropic',
+          models: ['claude-3-haiku'],
+          defaultPricing: {
+            inputUsdPerMillion: 1,
+            outputUsdPerMillion: 5,
+          },
+          modelPricing: {
+            'claude-3-haiku': {
+              inputUsdPerMillion: 0.9,
+              outputUsdPerMillion: 4.5,
+            },
+          },
+          maxConcurrency: 20,
+          currentLoad: 10,
+        },
+      ],
+    });
+    const decoded = decodeMetadata(encodeMetadata(original));
+    expect(decoded.providers).toHaveLength(2);
+    expect(decoded.providers[0]!.provider).toBe('openai');
+    expect(decoded.providers[1]!.provider).toBe('anthropic');
+  });
+
+  it('should round-trip zero providers', () => {
+    const original = makeMetadata({ providers: [] });
+    const decoded = decodeMetadata(encodeMetadata(original));
+    expect(decoded.providers).toHaveLength(0);
+  });
+
+  it('should round-trip empty models list', () => {
+    const original = makeMetadata({
+      providers: [
+        {
+          provider: 'test',
+          models: [],
+          defaultPricing: {
+            inputUsdPerMillion: 0,
+            outputUsdPerMillion: 0,
+          },
+          maxConcurrency: 1,
+          currentLoad: 0,
+        },
+      ],
+    });
+    const decoded = decodeMetadata(encodeMetadata(original));
+    expect(decoded.providers[0]!.models).toEqual([]);
+  });
+
+  it('should decode offerings and optional trailer fields after v2 provider pricing payload', () => {
+    const original = makeMetadata({
+      offerings: [
+        {
+          capability: 'skill',
+          name: 'summarize',
+          description: 'Summarize text',
+          pricing: { unit: 'request', pricePerUnit: 0.1, currency: 'USD' },
+          models: ['claude-3-sonnet'],
+        },
+      ],
+      evmAddress: '0x1111111111111111111111111111111111111111',
+      onChainReputation: 88,
+      onChainSessionCount: 123,
+      onChainDisputeCount: 2,
+    });
+    const decoded = decodeMetadata(encodeMetadata(original));
+    expect(decoded.offerings?.[0]?.name).toBe('summarize');
+    expect(decoded.evmAddress).toBe('0x1111111111111111111111111111111111111111');
+    expect(decoded.onChainReputation).toBe(88);
+    expect(decoded.onChainSessionCount).toBe(123);
+    expect(decoded.onChainDisputeCount).toBe(2);
+  });
+});
+
+describe('encodeMetadataForSigning', () => {
+  it('should produce a shorter buffer than encodeMetadata (no signature)', () => {
+    const metadata = makeMetadata();
+    const forSigning = encodeMetadataForSigning(metadata);
+    const full = encodeMetadata(metadata);
+    // Full includes 64 bytes of signature
+    expect(full.length).toBe(forSigning.length + 64);
+  });
+
+  it('should produce deterministic output for the same input', () => {
+    const metadata = makeMetadata();
+    const a = encodeMetadataForSigning(metadata);
+    const b = encodeMetadataForSigning(metadata);
+    expect(a).toEqual(b);
+  });
+});

package/tests/metadata-validator.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect } from 'vitest';
+import {
+  validateMetadata,
+  MAX_METADATA_SIZE,
+  MAX_PROVIDERS,
+  MAX_MODELS_PER_PROVIDER,
+  MAX_MODEL_NAME_LENGTH,
+  MAX_REGION_LENGTH,
+} from '../src/discovery/metadata-validator.js';
+import type { PeerMetadata } from '../src/discovery/peer-metadata.js';
+
+function validMetadata(overrides?: Partial<PeerMetadata>): PeerMetadata {
+  return {
+    peerId: 'a'.repeat(64) as any,
+    version: 2,
+    providers: [
+      {
+        provider: 'anthropic',
+        models: ['claude-3-opus'],
+        defaultPricing: {
+          inputUsdPerMillion: 15,
+          outputUsdPerMillion: 75,
+        },
+        maxConcurrency: 10,
+        currentLoad: 3,
+      },
+    ],
+    region: 'us-east-1',
+    timestamp: Date.now(),
+    signature: 'b'.repeat(128),
+    ...overrides,
+  };
+}
+
+describe('validateMetadata', () => {
+  it('should return no errors for valid metadata', () => {
+    const errors = validateMetadata(validMetadata());
+    expect(errors).toEqual([]);
+  });
+
+  it('should reject wrong version', () => {
+    const errors = validateMetadata(validMetadata({ version: 99 }));
+    expect(errors.some((e) => e.field === 'version')).toBe(true);
+  });
+
+  it('should reject invalid peerId (too short)', () => {
+    const errors = validateMetadata(validMetadata({ peerId: 'abc' as any }));
+    expect(errors.some((e) => e.field === 'peerId')).toBe(true);
+  });
+
+  it('should reject invalid peerId (uppercase)', () => {
+    const errors = validateMetadata(validMetadata({ peerId: 'A'.repeat(64) as any }));
+    expect(errors.some((e) => e.field === 'peerId')).toBe(true);
+  });
+
+  it('should reject empty region', () => {
+    const errors = validateMetadata(validMetadata({ region: '' }));
+    expect(errors.some((e) => e.field === 'region')).toBe(true);
+  });
+
+  it('should reject region exceeding max length', () => {
+    const errors = validateMetadata(validMetadata({ region: 'x'.repeat(MAX_REGION_LENGTH + 1) }));
+    expect(errors.some((e) => e.field === 'region')).toBe(true);
+  });
+
+  it('should reject non-positive timestamp', () => {
+    const errors = validateMetadata(validMetadata({ timestamp: 0 }));
+    expect(errors.some((e) => e.field === 'timestamp')).toBe(true);
+  });
+
+  it('should reject NaN timestamp', () => {
+    const errors = validateMetadata(validMetadata({ timestamp: NaN }));
+    expect(errors.some((e) => e.field === 'timestamp')).toBe(true);
+  });
+
+  it('should reject zero providers', () => {
+    const errors = validateMetadata(validMetadata({ providers: [] }));
+    expect(errors.some((e) => e.field === 'providers')).toBe(true);
+  });
+
+  it('should reject too many providers', () => {
+    const providers = Array.from({ length: MAX_PROVIDERS + 1 }, (_, i) => ({
+      provider: `p${i}`,
+      models: ['m'],
+      defaultPricing: {
+        inputUsdPerMillion: 1,
+        outputUsdPerMillion: 1,
+      },
+      maxConcurrency: 1,
+      currentLoad: 0,
+    }));
+    const errors = validateMetadata(validMetadata({ providers }));
+    expect(errors.some((e) => e.field === 'providers')).toBe(true);
+  });
+
+  it('should reject too many models per provider', () => {
+    const models = Array.from({ length: MAX_MODELS_PER_PROVIDER + 1 }, (_, i) => `model-${i}`);
+    const errors = validateMetadata(
+      validMetadata({
+        providers: [
+          {
+            provider: 'test',
+            models,
+            defaultPricing: {
+              inputUsdPerMillion: 1,
+              outputUsdPerMillion: 1,
+            },
+            maxConcurrency: 1,
+            currentLoad: 0,
+          },
+        ],
+      })
+    );
+    expect(errors.some((e) => e.field.includes('models'))).toBe(true);
+  });
+
+  it('should reject model name exceeding max length', () => {
+    const errors = validateMetadata(
+      validMetadata({
+        providers: [
+          {
+            provider: 'test',
+            models: ['x'.repeat(MAX_MODEL_NAME_LENGTH + 1)],
+            defaultPricing: {
+              inputUsdPerMillion: 1,
+              outputUsdPerMillion: 1,
+            },
+            maxConcurrency: 1,
+            currentLoad: 0,
+          },
+        ],
+      })
+    );
+    expect(errors.some((e) => e.field.includes('models'))).toBe(true);
+  });
+
+  it('should reject negative default input price', () => {
+    const errors = validateMetadata(
+      validMetadata({
+        providers: [
+          {
+            provider: 'test',
+            models: ['m'],
+            defaultPricing: {
+              inputUsdPerMillion: -1,
+              outputUsdPerMillion: 1,
+            },
+            maxConcurrency: 1,
+            currentLoad: 0,
+          },
+        ],
+      })
+    );
+    expect(errors.some((e) => e.field.includes('defaultPricing.inputUsdPerMillion'))).toBe(true);
+  });
+
+  it('should reject negative default output price', () => {
+    const errors = validateMetadata(
+      validMetadata({
+        providers: [
+          {
+            provider: 'test',
+            models: ['m'],
+            defaultPricing: {
+              inputUsdPerMillion: 1,
+              outputUsdPerMillion: -1,
+            },
+            maxConcurrency: 1,
+            currentLoad: 0,
+          },
+        ],
+      })
+    );
+    expect(errors.some((e) => e.field.includes('defaultPricing.outputUsdPerMillion'))).toBe(true);
+  });
+
+  it('should reject model pricing entries with missing output half', () => {
+    const errors = validateMetadata(
+      validMetadata({
+        providers: [
+          {
+            provider: 'test',
+            models: ['m'],
+            defaultPricing: {
+              inputUsdPerMillion: 1,
+              outputUsdPerMillion: 1,
+            },
+            modelPricing: {
+              m: {
+                inputUsdPerMillion: 2,
+              } as any,
+            } as any,
+            maxConcurrency: 1,
+            currentLoad: 0,
+          },
+        ],
+      })
+    );
+    expect(errors.some((e) => e.field.includes('modelPricing.m.outputUsdPerMillion'))).toBe(true);
+  });
+
+  it('should reject maxConcurrency < 1', () => {
+    const errors = validateMetadata(
+      validMetadata({
+        providers: [
+          {
+            provider: 'test',
+            models: ['m'],
+            defaultPricing: {
+              inputUsdPerMillion: 1,
+              outputUsdPerMillion: 1,
+            },
+            maxConcurrency: 0,
+            currentLoad: 0,
+          },
+        ],
+      })
+    );
+    expect(errors.some((e) => e.field.includes('maxConcurrency'))).toBe(true);
+  });
+
+  it('should reject currentLoad > maxConcurrency', () => {
+    const errors = validateMetadata(
+      validMetadata({
+        providers: [
+          {
+            provider: 'test',
+            models: ['m'],
+            defaultPricing: {
+              inputUsdPerMillion: 1,
+              outputUsdPerMillion: 1,
+            },
+            maxConcurrency: 5,
+            currentLoad: 6,
+          },
+        ],
+      })
+    );
+    expect(errors.some((e) => e.field.includes('currentLoad'))).toBe(true);
+  });
+
+  it('should reject invalid signature format', () => {
+    const errors = validateMetadata(validMetadata({ signature: 'xyz' }));
+    expect(errors.some((e) => e.field === 'signature')).toBe(true);
+  });
+
+  it('should reject signature with uppercase hex', () => {
+    const errors = validateMetadata(validMetadata({ signature: 'B'.repeat(128) }));
+    expect(errors.some((e) => e.field === 'signature')).toBe(true);
+  });
+});
+
+describe('constants', () => {
+  it('should export reasonable constant values', () => {
+    expect(MAX_METADATA_SIZE).toBe(1000);
+    expect(MAX_PROVIDERS).toBe(10);
+    expect(MAX_MODELS_PER_PROVIDER).toBe(20);
+    expect(MAX_MODEL_NAME_LENGTH).toBe(64);
+    expect(MAX_REGION_LENGTH).toBe(32);
+  });
+});

package/tests/metering-storage.test.ts

@@ -0,0 +1,244 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { MeteringStorage } from '../src/metering/storage.js';
+import type {
+  MeteringEvent,
+  UsageReceipt,
+  ReceiptVerification,
+  SessionMetrics,
+  TokenCount,
+} from '../src/types/metering.js';
+
+let storage: MeteringStorage;
+
+function makeTokens(total: number): TokenCount {
+  return {
+    inputTokens: Math.floor(total * 0.6),
+    outputTokens: Math.ceil(total * 0.4),
+    totalTokens: total,
+    method: 'content-length',
+    confidence: 'high',
+  };
+}
+
+function makeEvent(overrides?: Partial<MeteringEvent>): MeteringEvent {
+  return {
+    eventId: `evt-${Math.random().toString(36).slice(2)}`,
+    sessionId: 'session-1',
+    timestamp: Date.now(),
+    provider: 'openai',
+    sellerPeerId: 'seller-1',
+    buyerPeerId: 'buyer-1',
+    tokens: makeTokens(1000),
+    latencyMs: 150,
+    statusCode: 200,
+    wasStreaming: false,
+    ...overrides,
+  };
+}
+
+function makeReceipt(overrides?: Partial<UsageReceipt>): UsageReceipt {
+  return {
+    receiptId: `rcpt-${Math.random().toString(36).slice(2)}`,
+    sessionId: 'session-1',
+    eventId: 'evt-1',
+    timestamp: Date.now(),
+    provider: 'openai',
+    sellerPeerId: 'seller-1',
+    buyerPeerId: 'buyer-1',
+    tokens: makeTokens(1000),
+    unitPriceCentsPerThousandTokens: 10,
+    costCents: 10,
+    signature: 'a'.repeat(128),
+    ...overrides,
+  };
+}
+
+function makeVerification(overrides?: Partial<ReceiptVerification>): ReceiptVerification {
+  return {
+    receiptId: `rcpt-${Math.random().toString(36).slice(2)}`,
+    signatureValid: true,
+    buyerTokenEstimate: makeTokens(1000),
+    sellerTokenEstimate: makeTokens(1050),
+    tokenDifference: 50,
+    percentageDifference: 4.76,
+    disputed: false,
+    verifiedAt: Date.now(),
+    ...overrides,
+  };
+}
+
+function makeSession(overrides?: Partial<SessionMetrics>): SessionMetrics {
+  return {
+    sessionId: `sess-${Math.random().toString(36).slice(2)}`,
+    sellerPeerId: 'seller-1',
+    buyerPeerId: 'buyer-1',
+    provider: 'openai',
+    startedAt: Date.now(),
+    endedAt: null,
+    totalRequests: 5,
+    totalTokens: 5000,
+    totalCostCents: 50,
+    avgLatencyMs: 200,
+    peerSwitches: 0,
+    disputedReceipts: 0,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  storage = new MeteringStorage(':memory:');
+});
+
+afterEach(() => {
+  storage.close();
+});
+
+describe('MeteringStorage — Events', () => {
+  it('should insert and retrieve events by session', () => {
+    const event = makeEvent({ sessionId: 'sess-a' });
+    storage.insertEvent(event);
+
+    const events = storage.getEventsBySession('sess-a');
+    expect(events).toHaveLength(1);
+    expect(events[0]!.eventId).toBe(event.eventId);
+    expect(events[0]!.tokens.totalTokens).toBe(1000);
+    expect(events[0]!.wasStreaming).toBe(false);
+  });
+
+  it('should retrieve events by time range', () => {
+    const now = Date.now();
+    storage.insertEvent(makeEvent({ eventId: 'e1', timestamp: now - 2000 }));
+    storage.insertEvent(makeEvent({ eventId: 'e2', timestamp: now - 500 }));
+    storage.insertEvent(makeEvent({ eventId: 'e3', timestamp: now + 1000 }));
+
+    const events = storage.getEventsByTimeRange(now - 3000, now);
+    expect(events).toHaveLength(2);
+  });
+
+  it('should return empty for non-existent session', () => {
+    expect(storage.getEventsBySession('nonexistent')).toEqual([]);
+  });
+});
+
+describe('MeteringStorage — Receipts', () => {
+  it('should insert and retrieve receipts by session', () => {
+    const receipt = makeReceipt({ sessionId: 'sess-b' });
+    storage.insertReceipt(receipt);
+
+    const receipts = storage.getReceiptsBySession('sess-b');
+    expect(receipts).toHaveLength(1);
+    expect(receipts[0]!.costCents).toBe(10);
+    expect(receipts[0]!.signature).toBe('a'.repeat(128));
+  });
+
+  it('should calculate total cost in a time range', () => {
+    const now = Date.now();
+    storage.insertReceipt(makeReceipt({ receiptId: 'r1', timestamp: now - 500, costCents: 10 }));
+    storage.insertReceipt(makeReceipt({ receiptId: 'r2', timestamp: now - 200, costCents: 20 }));
+    storage.insertReceipt(makeReceipt({ receiptId: 'r3', timestamp: now + 1000, costCents: 100 }));
+
+    const total = storage.getTotalCost(now - 1000, now);
+    expect(total).toBe(30);
+  });
+
+  it('should return 0 total cost for empty range', () => {
+    expect(storage.getTotalCost(0, 1)).toBe(0);
+  });
+});
+
+describe('MeteringStorage — Verifications', () => {
+  it('should insert and retrieve disputed verifications', () => {
+    const now = Date.now();
+    storage.insertVerification(
+      makeVerification({ receiptId: 'v1', disputed: true, verifiedAt: now - 100 })
+    );
+    storage.insertVerification(
+      makeVerification({ receiptId: 'v2', disputed: false, verifiedAt: now - 50 })
+    );
+
+    const disputed = storage.getDisputedVerifications(now - 200, now + 200);
+    expect(disputed).toHaveLength(1);
+    expect(disputed[0]!.receiptId).toBe('v1');
+    expect(disputed[0]!.disputed).toBe(true);
+  });
+});
+
+describe('MeteringStorage — Sessions', () => {
+  it('should upsert and retrieve a session', () => {
+    const session = makeSession({ sessionId: 'sess-x' });
+    storage.upsertSession(session);
+
+    const retrieved = storage.getSession('sess-x');
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.totalRequests).toBe(5);
+    expect(retrieved!.endedAt).toBeNull();
+  });
+
+  it('should update session on upsert with same ID', () => {
+    const session = makeSession({ sessionId: 'sess-y', totalRequests: 1 });
+    storage.upsertSession(session);
+
+    session.totalRequests = 10;
+    session.endedAt = Date.now();
+    storage.upsertSession(session);
+
+    const retrieved = storage.getSession('sess-y');
+    expect(retrieved!.totalRequests).toBe(10);
+    expect(retrieved!.endedAt).not.toBeNull();
+  });
+
+  it('should return null for non-existent session', () => {
+    expect(storage.getSession('nonexistent')).toBeNull();
+  });
+
+  it('should get session summary for a time range', () => {
+    const now = Date.now();
+    storage.upsertSession(makeSession({ sessionId: 's1', startedAt: now - 500, totalCostCents: 10, totalTokens: 1000, totalRequests: 5 }));
+    storage.upsertSession(makeSession({ sessionId: 's2', startedAt: now - 200, totalCostCents: 20, totalTokens: 2000, totalRequests: 3 }));
+
+    const summary = storage.getSessionSummary(now - 1000, now);
+    expect(summary.sessionCount).toBe(2);
+    expect(summary.totalCostCents).toBe(30);
+    expect(summary.totalTokens).toBe(3000);
+    expect(summary.totalRequests).toBe(8);
+  });
+
+  it('should get event token summary', () => {
+    const now = Date.now();
+    storage.insertEvent(makeEvent({ eventId: 'e1', timestamp: now - 500, tokens: makeTokens(1000) }));
+    storage.insertEvent(makeEvent({ eventId: 'e2', timestamp: now - 200, tokens: makeTokens(2000) }));
+
+    const summary = storage.getEventTokenSummary(now - 1000, now);
+    expect(summary.totalRequests).toBe(2);
+    expect(summary.totalTokens).toBe(3000);
+  });
+});
+
+describe('MeteringStorage — Pruning', () => {
+  it('should delete data older than given timestamp', () => {
+    const now = Date.now();
+    const old = now - 100000;
+    const recent = now - 100;
+
+    storage.insertEvent(makeEvent({ eventId: 'old-e', timestamp: old }));
+    storage.insertEvent(makeEvent({ eventId: 'new-e', timestamp: recent }));
+    storage.insertReceipt(makeReceipt({ receiptId: 'old-r', timestamp: old }));
+    storage.insertReceipt(makeReceipt({ receiptId: 'new-r', timestamp: recent }));
+    storage.insertVerification(makeVerification({ receiptId: 'old-v', verifiedAt: old, disputed: true }));
+    storage.insertVerification(makeVerification({ receiptId: 'new-v', verifiedAt: recent, disputed: true }));
+    storage.upsertSession(makeSession({ sessionId: 'old-s', startedAt: old }));
+    storage.upsertSession(makeSession({ sessionId: 'new-s', startedAt: recent }));
+
+    const cutoff = now - 50000;
+    const result = storage.pruneOlderThan(cutoff);
+
+    expect(result.eventsDeleted).toBe(1);
+    expect(result.receiptsDeleted).toBe(1);
+    expect(result.verificationsDeleted).toBe(1);
+    expect(result.sessionsDeleted).toBe(1);
+
+    // Recent data should still exist
+    expect(storage.getEventsByTimeRange(recent - 10, recent + 10)).toHaveLength(1);
+    expect(storage.getReceiptsByTimeRange(recent - 10, recent + 10)).toHaveLength(1);
+  });
+});