@highway1/core 0.1.43 → 0.1.45

package/src/transport/connection.ts

@@ -0,0 +1,77 @@
+import type { Libp2p } from 'libp2p';
+import { createLogger } from '../utils/logger.js';
+import { TransportError } from '../utils/errors.js';
+
+const logger = createLogger('connection');
+
+export interface ConnectionManager {
+  connect: (peerId: string) => Promise<void>;
+  disconnect: (peerId: string) => Promise<void>;
+  isConnected: (peerId: string) => boolean;
+  getConnectedPeers: () => string[];
+}
+
+/**
+ * Create a connection manager for a libp2p node
+ */
+export function createConnectionManager(
+  libp2p: Libp2p
+): ConnectionManager {
+  return {
+    connect: async (peerIdStr: string) => {
+      try {
+        // Parse peer ID and multiaddr
+        const connections = libp2p.getConnections();
+        const existing = connections.find(
+          (conn) => conn.remotePeer.toString() === peerIdStr
+        );
+
+        if (existing) {
+          logger.debug('Already connected to peer', { peerId: peerIdStr });
+          return;
+        }
+
+        // In a real implementation, we would dial the peer
+        // For now, we rely on libp2p's automatic connection management
+        logger.info('Connecting to peer', { peerId: peerIdStr });
+      } catch (error) {
+        throw new TransportError('Failed to connect to peer', error);
+      }
+    },
+
+    disconnect: async (peerIdStr: string) => {
+      try {
+        const connections = libp2p.getConnections();
+        const matching = connections.filter(
+          (conn) => conn.remotePeer.toString() === peerIdStr
+        );
+
+        for (const conn of matching) {
+          await conn.close();
+        }
+
+        logger.info('Disconnected from peer', { peerId: peerIdStr });
+      } catch (error) {
+        throw new TransportError('Failed to disconnect from peer', error);
+      }
+    },
+
+    isConnected: (peerIdStr: string) => {
+      const connections = libp2p.getConnections();
+      return connections.some(
+        (conn) => conn.remotePeer.toString() === peerIdStr
+      );
+    },
+
+    getConnectedPeers: () => {
+      const connections = libp2p.getConnections();
+      const peers = new Set<string>();
+
+      for (const conn of connections) {
+        peers.add(conn.remotePeer.toString());
+      }
+
+      return Array.from(peers);
+    },
+  };
+}

package/src/transport/index.ts

@@ -0,0 +1,2 @@
+export * from './node.js';
+export * from './connection.js';

package/src/transport/node.ts

@@ -0,0 +1,152 @@
+import { createLibp2p, Libp2p } from 'libp2p';
+import { tcp } from '@libp2p/tcp';
+import { noise } from '@chainsafe/libp2p-noise';
+import { mplex } from '@libp2p/mplex';
+import { kadDHT, passthroughMapper } from '@libp2p/kad-dht';
+import { bootstrap } from '@libp2p/bootstrap';
+import { identify } from '@libp2p/identify';
+import { ping } from '@libp2p/ping';
+import {
+  circuitRelayTransport,
+  circuitRelayServer,
+} from '@libp2p/circuit-relay-v2';
+import { createLogger } from '../utils/logger.js';
+import { TransportError } from '../utils/errors.js';
+import type { KeyPair } from '../identity/keys.js';
+import type { PrivateKey } from '@libp2p/interface';
+
+const logger = createLogger('transport');
+
+export interface TransportConfig {
+  keyPair?: KeyPair;
+  listenAddresses?: string[];
+  bootstrapPeers?: string[];
+  enableDHT?: boolean;
+  /** Run as a relay server so NAT'd agents can receive messages through this node */
+  enableRelay?: boolean;
+  /** Reserve a relay slot on bootstrap nodes so others can reach us (only needed for hw1 join) */
+  reserveRelaySlot?: boolean;
+  /** Enable mDNS local peer discovery (default: false) */
+  enableMDNS?: boolean;
+  /** libp2p PrivateKey for persistent PeerID (from @libp2p/crypto) */
+  privateKey?: PrivateKey;
+}
+
+export interface ClawiverseNode {
+  libp2p: Libp2p;
+  start: () => Promise<void>;
+  stop: () => Promise<void>;
+  getMultiaddrs: () => string[];
+  getPeerId: () => string;
+}
+
+/**
+ * Create a Clawiverse transport node with libp2p
+ */
+export async function createNode(
+  config: TransportConfig
+): Promise<ClawiverseNode> {
+  try {
+    const {
+      listenAddresses = ['/ip4/0.0.0.0/tcp/0'],
+      bootstrapPeers = [],
+      enableDHT = true,
+      enableRelay = false,
+      reserveRelaySlot = false,
+      enableMDNS = false,
+      privateKey,
+    } = config;
+
+    // Reserve relay slots by adding p2p-circuit listen addresses (for hw1 join)
+    const relayListenAddrs = reserveRelaySlot
+      ? bootstrapPeers.map((peer) => `${peer}/p2p-circuit`)
+      : [];
+
+    const libp2pConfig: any = {
+      addresses: {
+        listen: [...listenAddresses, ...relayListenAddrs],
+      },
+      ...(privateKey ? { privateKey } : {}),
+      transports: [
+        tcp(),
+        circuitRelayTransport(),
+      ],
+      connectionEncrypters: [noise()],
+      streamMuxers: [mplex()],
+      connectionManager: {
+        minConnections: bootstrapPeers.length > 0 ? 1 : 0,
+        maxConnections: 50,
+      },
+      services: {
+        identify: identify(),
+        ping: ping(),
+      },
+    };
+
+    if (enableRelay) {
+      libp2pConfig.services.relay = circuitRelayServer({
+        reservations: {
+          maxReservations: 100, // Allow up to 100 concurrent relay reservations
+        },
+      });
+    }
+
+    if (enableDHT) {
+      libp2pConfig.services.dht = kadDHT({
+        clientMode: false,
+        peerInfoMapper: passthroughMapper,
+        validators: {
+          clawiverse: async () => {},
+        },
+        selectors: {
+          clawiverse: () => 0,
+        },
+        // Optimize for small networks: reduce replication factor and query timeout
+        kBucketSize: 20,  // Default K=20, keep for compatibility
+        querySelfInterval: 30000,  // Self-query every 30 seconds (libp2p default)
+        // Allow queries to complete faster in small networks
+        allowQueryWithZeroPeers: true,
+      });
+    }
+
+    const peerDiscovery: any[] = [];
+    if (bootstrapPeers.length > 0) peerDiscovery.push(bootstrap({ list: bootstrapPeers }));
+    if (enableMDNS) {
+      const { mdns } = await import('@libp2p/mdns');
+      peerDiscovery.push(mdns());
+    }
+    if (peerDiscovery.length > 0) libp2pConfig.peerDiscovery = peerDiscovery;
+
+    const libp2p = await createLibp2p(libp2pConfig);
+
+    logger.info('Libp2p node created', {
+      listenAddresses: libp2pConfig.addresses.listen,
+      reserveRelaySlot,
+    });
+
+    return {
+      libp2p,
+      start: async () => {
+        await libp2p.start();
+        logger.info('Node started', {
+          peerId: libp2p.peerId.toString(),
+          addresses: libp2p.getMultiaddrs().map((ma) => ma.toString()),
+          relay: enableRelay,
+          reserveRelaySlot,
+        });
+      },
+      stop: async () => {
+        await libp2p.stop();
+        logger.info('Node stopped');
+      },
+      getMultiaddrs: () => {
+        return libp2p.getMultiaddrs().map((ma) => ma.toString());
+      },
+      getPeerId: () => {
+        return libp2p.peerId.toString();
+      },
+    };
+  } catch (error) {
+    throw new TransportError('Failed to create transport node', error);
+  }
+}

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