@highway1/core 0.1.10 → 0.1.13

package/src/trust/index.ts

@@ -0,0 +1,194 @@
+/**
+ * Trust System - Main Export
+ *
+ * Combines all trust components into a unified interface
+ */
+
+export * from './trust-score.js';
+export * from './interaction-history.js';
+export * from './endorsement.js';
+export * from './sybil-defense.js';
+
+import { Level } from 'level';
+import { TrustMetrics } from './trust-score.js';
+import type { TrustScore, Interaction } from './trust-score.js';
+import { InteractionHistory } from './interaction-history.js';
+import { EndorsementManager } from './endorsement.js';
+import type { Endorsement, SignFunction, VerifyFunction } from './endorsement.js';
+import { SybilDefense } from './sybil-defense.js';
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('trust-system');
+
+/**
+ * Trust System Configuration
+ */
+export interface TrustSystemConfig {
+  dbPath: string;
+  getPublicKey: (did: string) => Promise<Uint8Array>;
+}
+
+/**
+ * Unified Trust System
+ */
+export class TrustSystem {
+  private metrics: TrustMetrics;
+  private history: InteractionHistory;
+  private endorsements: EndorsementManager;
+  private sybilDefense: SybilDefense;
+  private trustCache = new Map<string, { score: TrustScore; timestamp: number }>();
+  private readonly CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+  constructor(config: TrustSystemConfig) {
+    this.metrics = new TrustMetrics();
+    this.history = new InteractionHistory(`${config.dbPath}/interactions`);
+
+    const endorsementDb = new Level<string, Endorsement>(`${config.dbPath}/endorsements`, {
+      valueEncoding: 'json',
+    });
+    this.endorsements = new EndorsementManager(endorsementDb, config.getPublicKey);
+    this.sybilDefense = new SybilDefense();
+  }
+
+  /**
+   * Initialize the trust system
+   */
+  async start(): Promise<void> {
+    await this.history.open();
+    logger.info('Trust system started');
+  }
+
+  /**
+   * Shutdown the trust system
+   */
+  async stop(): Promise<void> {
+    await this.history.close();
+    logger.info('Trust system stopped');
+  }
+
+  /**
+   * Record an interaction
+   */
+  async recordInteraction(interaction: Interaction): Promise<void> {
+    await this.history.record(interaction);
+    this.sybilDefense.recordRequest(interaction.agentDid);
+
+    // Invalidate cache
+    this.trustCache.delete(interaction.agentDid);
+  }
+
+  /**
+   * Get trust score for an agent
+   */
+  async getTrustScore(agentDid: string): Promise<TrustScore> {
+    // Check cache
+    const cached = this.trustCache.get(agentDid);
+    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+      return cached.score;
+    }
+
+    // Calculate fresh score
+    const stats = await this.history.getStats(agentDid);
+    const endorsementList = await this.endorsements.getEndorsements(agentDid);
+    const uptime = 1.0; // TODO: Implement uptime tracking
+
+    const score = this.metrics.calculateScore(stats, endorsementList.length, uptime);
+
+    // Cache result
+    this.trustCache.set(agentDid, { score, timestamp: Date.now() });
+
+    return score;
+  }
+
+  /**
+   * Create an endorsement
+   */
+  async endorse(
+    fromDid: string,
+    toDid: string,
+    score: number,
+    reason: string,
+    signFn: SignFunction
+  ): Promise<Endorsement> {
+    const endorsement = await this.endorsements.endorse(fromDid, toDid, score, reason, signFn);
+    await this.endorsements.publish(endorsement);
+
+    // Invalidate cache
+    this.trustCache.delete(toDid);
+
+    return endorsement;
+  }
+
+  /**
+   * Get endorsements for an agent
+   */
+  async getEndorsements(agentDid: string): Promise<Endorsement[]> {
+    return this.endorsements.getEndorsements(agentDid);
+  }
+
+  /**
+   * Verify an endorsement
+   */
+  async verifyEndorsement(endorsement: Endorsement, verifyFn: VerifyFunction): Promise<boolean> {
+    return this.endorsements.verify(endorsement, verifyFn);
+  }
+
+  /**
+   * Check if agent should be rate limited
+   */
+  isRateLimited(agentDid: string): boolean {
+    return this.sybilDefense.isRateLimited(agentDid);
+  }
+
+  /**
+   * Generate Sybil defense challenge
+   */
+  generateChallenge(did: string, difficulty?: number) {
+    return this.sybilDefense.generateChallenge(did, difficulty);
+  }
+
+  /**
+   * Verify Sybil defense challenge
+   */
+  verifyChallenge(solution: any): boolean {
+    return this.sybilDefense.verifyChallenge(solution);
+  }
+
+  /**
+   * Get peer trust level
+   */
+  getPeerTrustLevel(peerId: string) {
+    return this.sybilDefense.getPeerTrustLevel(peerId);
+  }
+
+  /**
+   * Record peer seen
+   */
+  recordPeerSeen(peerId: string): void {
+    this.sybilDefense.recordPeerSeen(peerId);
+  }
+
+  /**
+   * Get interaction history
+   */
+  async getHistory(agentDid: string, limit?: number): Promise<Interaction[]> {
+    return this.history.getHistory(agentDid, limit);
+  }
+
+  /**
+   * Clean up old data
+   */
+  async cleanup(): Promise<void> {
+    await this.history.cleanup();
+    this.sybilDefense.cleanup();
+    this.trustCache.clear();
+    logger.info('Trust system cleanup completed');
+  }
+}
+
+/**
+ * Create a trust system instance
+ */
+export function createTrustSystem(config: TrustSystemConfig): TrustSystem {
+  return new TrustSystem(config);
+}

package/src/trust/interaction-history.ts

@@ -0,0 +1,155 @@
+/**
+ * Interaction History Tracker
+ *
+ * Records and queries agent interaction history for trust scoring
+ */
+
+import { Level } from 'level';
+import type { Interaction, InteractionStats } from './trust-score.js';
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('interaction-history');
+
+/**
+ * Interaction History Manager
+ */
+export class InteractionHistory {
+  private db: Level<string, Interaction>;
+
+  constructor(dbPath: string) {
+    this.db = new Level(dbPath, { valueEncoding: 'json' });
+  }
+
+  /**
+   * Open database connection
+   */
+  async open(): Promise<void> {
+    await this.db.open();
+    logger.info('Interaction history database opened', { path: this.db.location });
+  }
+
+  /**
+   * Close database connection
+   */
+  async close(): Promise<void> {
+    await this.db.close();
+    logger.info('Interaction history database closed');
+  }
+
+  /**
+   * Record an interaction
+   */
+  async record(interaction: Interaction): Promise<void> {
+    const key = `interaction:${interaction.agentDid}:${interaction.timestamp}`;
+    await this.db.put(key, interaction);
+    logger.debug('Recorded interaction', { agentDid: interaction.agentDid, type: interaction.type });
+  }
+
+  /**
+   * Get interaction history for an agent
+   */
+  async getHistory(agentDid: string, limit = 100): Promise<Interaction[]> {
+    const interactions: Interaction[] = [];
+    const prefix = `interaction:${agentDid}:`;
+
+    try {
+      for await (const [_, value] of this.db.iterator({
+        gte: prefix,
+        lte: prefix + '\xff',
+        limit,
+        reverse: true, // Most recent first
+      })) {
+        interactions.push(value);
+      }
+    } catch (error) {
+      logger.error('Failed to get interaction history', { agentDid, error });
+    }
+
+    return interactions;
+  }
+
+  /**
+   * Get interaction statistics for an agent
+   */
+  async getStats(agentDid: string): Promise<InteractionStats> {
+    const history = await this.getHistory(agentDid, 1000); // Last 1000 interactions
+
+    if (history.length === 0) {
+      return {
+        totalInteractions: 0,
+        successRate: 0,
+        avgResponseTime: 0,
+        lastInteraction: 0,
+      };
+    }
+
+    const successCount = history.filter(i => i.success).length;
+    const totalResponseTime = history.reduce((sum, i) => sum + i.responseTime, 0);
+
+    return {
+      totalInteractions: history.length,
+      successRate: successCount / history.length,
+      avgResponseTime: totalResponseTime / history.length,
+      lastInteraction: history[0].timestamp,
+    };
+  }
+
+  /**
+   * Get all agents with interaction history
+   */
+  async getAllAgents(): Promise<string[]> {
+    const agents = new Set<string>();
+
+    try {
+      for await (const [key] of this.db.iterator()) {
+        const match = key.match(/^interaction:([^:]+):/);
+        if (match) {
+          agents.add(match[1]);
+        }
+      }
+    } catch (error) {
+      logger.error('Failed to get all agents', { error });
+    }
+
+    return Array.from(agents);
+  }
+
+  /**
+   * Delete all interactions for an agent
+   */
+  async deleteAgent(agentDid: string): Promise<void> {
+    const prefix = `interaction:${agentDid}:`;
+    const keysToDelete: string[] = [];
+
+    for await (const [key] of this.db.iterator({
+      gte: prefix,
+      lte: prefix + '\xff',
+    })) {
+      keysToDelete.push(key);
+    }
+
+    await this.db.batch(keysToDelete.map(key => ({ type: 'del', key })));
+    logger.info('Deleted interaction history', { agentDid, count: keysToDelete.length });
+  }
+
+  /**
+   * Clean up old interactions (older than 90 days)
+   */
+  async cleanup(maxAge = 90 * 24 * 60 * 60 * 1000): Promise<number> {
+    const cutoff = Date.now() - maxAge;
+    const keysToDelete: string[] = [];
+
+    for await (const [key, value] of this.db.iterator()) {
+      if (value.timestamp < cutoff) {
+        keysToDelete.push(key);
+      }
+    }
+
+    if (keysToDelete.length > 0) {
+      await this.db.batch(keysToDelete.map(key => ({ type: 'del', key })));
+      logger.info('Cleaned up old interactions', { count: keysToDelete.length });
+    }
+
+    return keysToDelete.length;
+  }
+}

package/src/trust/sybil-defense.ts

@@ -0,0 +1,232 @@
+/**
+ * Sybil Defense Mechanisms
+ *
+ * Protects the network from Sybil attacks through:
+ * - Entry cost (Hashcash challenges)
+ * - Progressive trust (rate limiting for new agents)
+ * - DHT region protection (prefer established peers)
+ */
+
+import { createLogger } from '../utils/logger.js';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+
+const logger = createLogger('sybil-defense');
+
+/**
+ * Hashcash Challenge
+ */
+export interface Challenge {
+  did: string;
+  difficulty: number;  // Number of leading zero bits required
+  nonce: string;
+  timestamp: number;
+}
+
+/**
+ * Challenge Solution
+ */
+export interface ChallengeSolution {
+  challenge: Challenge;
+  solution: string;  // Nonce that produces required hash
+}
+
+/**
+ * Rate Limit Record
+ */
+interface RateLimitRecord {
+  did: string;
+  requests: number[];  // Timestamps of requests
+  firstSeen: number;
+}
+
+/**
+ * Peer Trust Level
+ */
+export type PeerTrustLevel = 'new' | 'established' | 'trusted';
+
+/**
+ * Sybil Defense Manager
+ */
+export class SybilDefense {
+  private rateLimits = new Map<string, RateLimitRecord>();
+  private peerFirstSeen = new Map<string, number>();
+  private readonly NEW_AGENT_WINDOW = 24 * 60 * 60 * 1000; // 24 hours
+  private readonly RATE_LIMIT_WINDOW = 60 * 60 * 1000; // 1 hour
+  private readonly MAX_REQUESTS_NEW = 10; // Max requests per hour for new agents
+  private readonly ESTABLISHED_THRESHOLD = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+  /**
+   * Generate a Hashcash challenge for a new DID
+   */
+  generateChallenge(did: string, difficulty = 20): Challenge {
+    const nonce = this.generateNonce();
+    return {
+      did,
+      difficulty,
+      nonce,
+      timestamp: Date.now(),
+    };
+  }
+
+  /**
+   * Verify a Hashcash challenge solution
+   */
+  verifyChallenge(solution: ChallengeSolution): boolean {
+    const { challenge, solution: solutionNonce } = solution;
+
+    // Check challenge is not too old (valid for 1 hour)
+    if (Date.now() - challenge.timestamp > 60 * 60 * 1000) {
+      logger.warn('Challenge expired', { did: challenge.did });
+      return false;
+    }
+
+    // Compute hash
+    const data = `${challenge.did}:${challenge.nonce}:${solutionNonce}`;
+    const hash = sha256(new TextEncoder().encode(data));
+
+    // Check leading zeros
+    const leadingZeros = this.countLeadingZeroBits(hash);
+    const valid = leadingZeros >= challenge.difficulty;
+
+    if (valid) {
+      logger.info('Challenge verified', { did: challenge.did, leadingZeros });
+    } else {
+      logger.warn('Challenge failed', { did: challenge.did, leadingZeros, required: challenge.difficulty });
+    }
+
+    return valid;
+  }
+
+  /**
+   * Check if an agent should be rate limited
+   */
+  isRateLimited(did: string): boolean {
+    const record = this.rateLimits.get(did);
+    if (!record) {
+      return false;
+    }
+
+    const now = Date.now();
+    const agentAge = now - record.firstSeen;
+
+    // Only rate limit new agents
+    if (agentAge > this.NEW_AGENT_WINDOW) {
+      return false;
+    }
+
+    // Count recent requests
+    const recentRequests = record.requests.filter(
+      t => now - t < this.RATE_LIMIT_WINDOW
+    );
+
+    return recentRequests.length >= this.MAX_REQUESTS_NEW;
+  }
+
+  /**
+   * Record a request from an agent
+   */
+  recordRequest(did: string): void {
+    const now = Date.now();
+    let record = this.rateLimits.get(did);
+
+    if (!record) {
+      record = {
+        did,
+        requests: [],
+        firstSeen: now,
+      };
+      this.rateLimits.set(did, record);
+    }
+
+    // Add request timestamp
+    record.requests.push(now);
+
+    // Clean up old requests
+    record.requests = record.requests.filter(
+      t => now - t < this.RATE_LIMIT_WINDOW
+    );
+
+    logger.debug('Recorded request', { did, count: record.requests.length });
+  }
+
+  /**
+   * Get peer trust level based on age
+   */
+  getPeerTrustLevel(peerId: string): PeerTrustLevel {
+    const firstSeen = this.peerFirstSeen.get(peerId);
+    if (!firstSeen) {
+      return 'new';
+    }
+
+    const age = Date.now() - firstSeen;
+
+    if (age < this.NEW_AGENT_WINDOW) {
+      return 'new';
+    } else if (age < this.ESTABLISHED_THRESHOLD) {
+      return 'established';
+    } else {
+      return 'trusted';
+    }
+  }
+
+  /**
+   * Record first seen time for a peer
+   */
+  recordPeerSeen(peerId: string): void {
+    if (!this.peerFirstSeen.has(peerId)) {
+      this.peerFirstSeen.set(peerId, Date.now());
+      logger.debug('Recorded new peer', { peerId });
+    }
+  }
+
+  /**
+   * Clean up old records
+   */
+  cleanup(): void {
+    const now = Date.now();
+    const cutoff = now - this.NEW_AGENT_WINDOW;
+
+    // Clean up rate limits for old agents
+    for (const [did, record] of this.rateLimits.entries()) {
+      if (record.firstSeen < cutoff) {
+        this.rateLimits.delete(did);
+      }
+    }
+
+    logger.info('Cleaned up Sybil defense records', {
+      rateLimits: this.rateLimits.size,
+      peers: this.peerFirstSeen.size,
+    });
+  }
+
+  /**
+   * Generate a random nonce
+   */
+  private generateNonce(): string {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return bytesToHex(bytes);
+  }
+
+  /**
+   * Count leading zero bits in a hash
+   */
+  private countLeadingZeroBits(hash: Uint8Array): number {
+    let count = 0;
+    for (const byte of hash) {
+      if (byte === 0) {
+        count += 8;
+      } else {
+        // Count leading zeros in this byte
+        let b = byte;
+        while ((b & 0x80) === 0) {
+          count++;
+          b <<= 1;
+        }
+        break;
+      }
+    }
+    return count;
+  }
+}

package/src/trust/trust-score.ts

@@ -0,0 +1,136 @@
+/**
+ * Trust Score System
+ *
+ * Tracks agent reputation based on interactions, endorsements,
+ * and network behavior.
+ */
+
+/**
+ * Trust Score Metrics
+ */
+export interface TrustScore {
+  interactionScore: number;      // 0-1, based on successful interactions
+  endorsements: number;          // Count of endorsements
+  completionRate: number;        // % of completed tasks (0-1)
+  responseTime: number;          // Average response time (ms)
+  uptime: number;               // % of time online last 30 days (0-1)
+  lastUpdated: number;          // Timestamp
+}
+
+/**
+ * Interaction Record
+ */
+export interface Interaction {
+  agentDid: string;
+  timestamp: number;
+  type: 'message' | 'task' | 'query';
+  success: boolean;
+  responseTime: number;
+  rating?: number;              // 1-5 stars (optional user rating)
+  feedback?: string;
+}
+
+/**
+ * Interaction Statistics
+ */
+export interface InteractionStats {
+  totalInteractions: number;
+  successRate: number;
+  avgResponseTime: number;
+  lastInteraction: number;
+}
+
+/**
+ * Trust Metrics Calculator
+ */
+export class TrustMetrics {
+  /**
+   * Calculate trust score from interaction history
+   */
+  calculateScore(stats: InteractionStats, endorsements: number, uptime: number): TrustScore {
+    // Interaction score: weighted by success rate and volume
+    const volumeWeight = Math.min(stats.totalInteractions / 100, 1); // Cap at 100 interactions
+    const interactionScore = stats.successRate * volumeWeight;
+
+    // Completion rate is same as success rate for now
+    const completionRate = stats.successRate;
+
+    return {
+      interactionScore,
+      endorsements,
+      completionRate,
+      responseTime: stats.avgResponseTime,
+      uptime,
+      lastUpdated: Date.now(),
+    };
+  }
+
+  /**
+   * Calculate overall trust level (0-1)
+   */
+  calculateOverallTrust(score: TrustScore): number {
+    // Weighted average of different factors
+    const weights = {
+      interaction: 0.4,
+      endorsement: 0.2,
+      completion: 0.2,
+      uptime: 0.2,
+    };
+
+    const endorsementScore = Math.min(score.endorsements / 10, 1); // Cap at 10 endorsements
+
+    return (
+      score.interactionScore * weights.interaction +
+      endorsementScore * weights.endorsement +
+      score.completionRate * weights.completion +
+      score.uptime * weights.uptime
+    );
+  }
+
+  /**
+   * Get trust level category
+   */
+  getTrustLevel(score: TrustScore): 'new' | 'low' | 'medium' | 'high' | 'trusted' {
+    const overall = this.calculateOverallTrust(score);
+
+    if (score.interactionScore === 0) return 'new';
+    if (overall < 0.3) return 'low';
+    if (overall < 0.6) return 'medium';
+    if (overall < 0.8) return 'high';
+    return 'trusted';
+  }
+
+  /**
+   * Check if agent should be rate limited
+   */
+  shouldRateLimit(score: TrustScore, agentAge: number): boolean {
+    const overall = this.calculateOverallTrust(score);
+    const ONE_DAY = 24 * 60 * 60 * 1000;
+
+    // New agents (< 24 hours) with low trust
+    if (agentAge < ONE_DAY && overall < 0.3) {
+      return true;
+    }
+
+    // Very low trust regardless of age
+    if (overall < 0.1) {
+      return true;
+    }
+
+    return false;
+  }
+}
+
+/**
+ * Default trust score for new agents
+ */
+export function createDefaultTrustScore(): TrustScore {
+  return {
+    interactionScore: 0,
+    endorsements: 0,
+    completionRate: 0,
+    responseTime: 0,
+    uptime: 1.0, // Assume online initially
+    lastUpdated: Date.now(),
+  };
+}