@highway1/core 0.1.39 → 0.1.41

package/src/trust/endorsement.ts

@@ -0,0 +1,167 @@
+/**
+ * Endorsement System
+ *
+ * Allows agents to endorse each other, building a web of trust
+ */
+
+import type { Level } from 'level';
+import { createLogger } from '../utils/logger.js';
+
+const logger = createLogger('endorsement');
+
+/**
+ * Endorsement Record
+ */
+export interface Endorsement {
+  from: string;                 // Endorser DID
+  to: string;                   // Endorsed agent DID
+  score: number;                // 0-1
+  reason: string;
+  timestamp: number;
+  signature: string;            // Signed by endorser
+}
+
+/**
+ * Sign function type
+ */
+export type SignFunction = (data: Uint8Array) => Promise<Uint8Array>;
+
+/**
+ * Verify function type
+ */
+export type VerifyFunction = (signature: Uint8Array, data: Uint8Array, publicKey: Uint8Array) => Promise<boolean>;
+
+/**
+ * Endorsement Manager
+ */
+export class EndorsementManager {
+  constructor(
+    private db: Level<string, Endorsement>,
+    private getPublicKey: (did: string) => Promise<Uint8Array>
+  ) {}
+
+  /**
+   * Create an endorsement
+   */
+  async endorse(
+    fromDid: string,
+    toDid: string,
+    score: number,
+    reason: string,
+    signFn: SignFunction
+  ): Promise<Endorsement> {
+    if (score < 0 || score > 1) {
+      throw new Error('Score must be between 0 and 1');
+    }
+
+    const endorsement: Omit<Endorsement, 'signature'> = {
+      from: fromDid,
+      to: toDid,
+      score,
+      reason,
+      timestamp: Date.now(),
+    };
+
+    // Sign the endorsement
+    const data = new TextEncoder().encode(JSON.stringify(endorsement));
+    const signatureBytes = await signFn(data);
+    const signature = Buffer.from(signatureBytes).toString('hex');
+
+    const signedEndorsement: Endorsement = {
+      ...endorsement,
+      signature,
+    };
+
+    logger.info('Created endorsement', { from: fromDid, to: toDid, score });
+    return signedEndorsement;
+  }
+
+  /**
+   * Verify endorsement signature
+   */
+  async verify(endorsement: Endorsement, verifyFn: VerifyFunction): Promise<boolean> {
+    try {
+      const { signature, ...endorsementWithoutSig } = endorsement;
+      const data = new TextEncoder().encode(JSON.stringify(endorsementWithoutSig));
+      const signatureBytes = Buffer.from(signature, 'hex');
+      const publicKey = await this.getPublicKey(endorsement.from);
+
+      return await verifyFn(signatureBytes, data, publicKey);
+    } catch (error) {
+      logger.error('Failed to verify endorsement', { error });
+      return false;
+    }
+  }
+
+  /**
+   * Publish endorsement to local database
+   */
+  async publish(endorsement: Endorsement): Promise<void> {
+    const key = `endorsement:${endorsement.to}:${endorsement.from}`;
+    await this.db.put(key, endorsement);
+    logger.info('Published endorsement', { from: endorsement.from, to: endorsement.to });
+  }
+
+  /**
+   * Get all endorsements for an agent
+   */
+  async getEndorsements(agentDid: string): Promise<Endorsement[]> {
+    const endorsements: Endorsement[] = [];
+    const prefix = `endorsement:${agentDid}:`;
+
+    try {
+      for await (const [_, value] of this.db.iterator({
+        gte: prefix,
+        lte: prefix + '\xff',
+      })) {
+        endorsements.push(value);
+      }
+    } catch (error) {
+      logger.error('Failed to get endorsements', { agentDid, error });
+    }
+
+    return endorsements;
+  }
+
+  /**
+   * Get endorsements given by an agent
+   */
+  async getEndorsementsBy(fromDid: string): Promise<Endorsement[]> {
+    const endorsements: Endorsement[] = [];
+
+    try {
+      for await (const [_, value] of this.db.iterator()) {
+        if (value.from === fromDid) {
+          endorsements.push(value);
+        }
+      }
+    } catch (error) {
+      logger.error('Failed to get endorsements by agent', { fromDid, error });
+    }
+
+    return endorsements;
+  }
+
+  /**
+   * Calculate average endorsement score
+   */
+  async getAverageScore(agentDid: string): Promise<number> {
+    const endorsements = await this.getEndorsements(agentDid);
+
+    if (endorsements.length === 0) {
+      return 0;
+    }
+
+    const totalScore = endorsements.reduce((sum, e) => sum + e.score, 0);
+    return totalScore / endorsements.length;
+  }
+
+  /**
+   * Delete an endorsement
+   */
+  async deleteEndorsement(fromDid: string, toDid: string): Promise<void> {
+    const key = `endorsement:${toDid}:${fromDid}`;
+    await this.db.del(key);
+    logger.info('Deleted endorsement', { from: fromDid, to: toDid });
+  }
+}

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;
+  }
+}