@antseed/node 0.1.0

package/src/reputation/trust-engine.ts

@@ -0,0 +1,120 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { PeerId } from '../types/peer.js';
+import type { TrustScore, TrustComponents } from './trust-score.js';
+import { DEFAULT_COMPONENTS, computeTrustScore } from './trust-score.js';
+
+export interface TrustEngineConfig {
+  configDir: string;
+}
+
+export class TrustScoreEngine {
+  private readonly configDir: string;
+  private scores: Map<string, TrustScore> = new Map();
+
+  constructor(config: TrustEngineConfig) {
+    this.configDir = config.configDir;
+  }
+
+  /**
+   * Update trust score for a peer with new component data.
+   * Merges partial components with existing or defaults.
+   */
+  updateScore(peerId: PeerId, partialComponents: Partial<TrustComponents>): TrustScore {
+    const existing = this.scores.get(peerId);
+    const components: TrustComponents = {
+      ...(existing?.components ?? DEFAULT_COMPONENTS),
+      ...partialComponents,
+    };
+
+    const score: TrustScore = {
+      peerId,
+      score: computeTrustScore(components),
+      components,
+      updatedAt: Date.now(),
+    };
+
+    this.scores.set(peerId, score);
+    return score;
+  }
+
+  getScore(peerId: PeerId): TrustScore | null {
+    return this.scores.get(peerId) ?? null;
+  }
+
+  getAllScores(): TrustScore[] {
+    return Array.from(this.scores.values());
+  }
+
+  /**
+   * Compute report rate component for trust score.
+   * Based on unique reporters with 30-day half-life decay.
+   */
+  computeReportComponent(reports: Array<{ reporterPeerId: string; timestamp: number }>): number {
+    if (reports.length === 0) return 1.0;
+
+    const now = Date.now();
+    const HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000;
+
+    const reporterWeights = new Map<string, number>();
+    for (const r of reports) {
+      const age = now - r.timestamp;
+      const weight = Math.pow(0.5, age / HALF_LIFE_MS);
+      const existing = reporterWeights.get(r.reporterPeerId) ?? 0;
+      reporterWeights.set(r.reporterPeerId, Math.max(existing, weight));
+    }
+
+    const totalWeight = Array.from(reporterWeights.values()).reduce((a, b) => a + b, 0);
+    return Math.max(0, 1 - totalWeight / 5);
+  }
+
+  /**
+   * Compute peer rating component for trust score.
+   * Uses Bayesian averaging: blend with global average until enough ratings.
+   */
+  computeRatingComponent(
+    ratings: Array<{ overallScore: number; raterTrustScore?: number }>,
+    globalAverage: number = 3.0,
+    minRatings: number = 5,
+  ): number {
+    if (ratings.length === 0) return 0.5;
+
+    let weightedSum = 0;
+    let totalWeight = 0;
+
+    for (const r of ratings) {
+      const weight = r.raterTrustScore !== undefined ? r.raterTrustScore / 100 : 0.5;
+      weightedSum += r.overallScore * weight;
+      totalWeight += weight;
+    }
+
+    const rawAverage = totalWeight > 0 ? weightedSum / totalWeight : globalAverage;
+
+    const n = ratings.length;
+    const bayesian = (minRatings * globalAverage + n * rawAverage) / (minRatings + n);
+
+    return Math.max(0, Math.min(1, (bayesian - 1) / 4));
+  }
+
+  async save(): Promise<void> {
+    await mkdir(this.configDir, { recursive: true });
+    const filePath = join(this.configDir, 'trust-scores.json');
+    const data = Array.from(this.scores.values());
+    await writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+  }
+
+  async load(): Promise<void> {
+    const filePath = join(this.configDir, 'trust-scores.json');
+    try {
+      const raw = await readFile(filePath, 'utf-8');
+      const data = JSON.parse(raw) as TrustScore[];
+      this.scores.clear();
+      for (const score of data) {
+        this.scores.set(score.peerId, score);
+      }
+    } catch {
+      // File doesn't exist or is invalid — start fresh
+      this.scores.clear();
+    }
+  }
+}

package/src/reputation/trust-score.ts

@@ -0,0 +1,74 @@
+import type { PeerId } from '../types/peer.js';
+
+/**
+ * Individual components that make up a trust score.
+ * Each component is normalized to 0.0 - 1.0.
+ */
+export interface TrustComponents {
+  /** Successful delivery rate (completed requests / total requests) */
+  deliveryRate: number;
+  /** Inverse dispute rate (1 - disputes/total) */
+  disputeRate: number;
+  /** Uptime percentage over rolling window */
+  uptimeRate: number;
+  /** Response quality score from metering data */
+  responseQuality: number;
+  /** Weight based on staked amount (normalized) */
+  stakeWeight: number;
+  /** Aggregate peer ratings (normalized average) */
+  peerRatings: number;
+  /** Account age factor (logarithmic scale) */
+  accountAge: number;
+}
+
+/**
+ * Computed trust score for a peer.
+ */
+export interface TrustScore {
+  peerId: PeerId;
+  /** Overall trust score 0-100 */
+  score: number;
+  /** Individual component scores */
+  components: TrustComponents;
+  /** When this score was last computed */
+  updatedAt: number;
+}
+
+/** Default weights for trust score computation. */
+export const DEFAULT_TRUST_WEIGHTS: Record<keyof TrustComponents, number> = {
+  deliveryRate: 0.25,
+  disputeRate: 0.25,
+  uptimeRate: 0.15,
+  responseQuality: 0.15,
+  stakeWeight: 0.10,
+  peerRatings: 0.05,
+  accountAge: 0.05,
+};
+
+/** Default component values for unknown metrics */
+export const DEFAULT_COMPONENTS: TrustComponents = {
+  deliveryRate: 0.5,
+  disputeRate: 0.5,
+  uptimeRate: 0.5,
+  responseQuality: 0.5,
+  stakeWeight: 0.0,
+  peerRatings: 0.5,
+  accountAge: 0.0,
+};
+
+/**
+ * Compute a trust score from components using weighted sum.
+ * @returns Score from 0-100
+ */
+export function computeTrustScore(
+  components: TrustComponents,
+  weights: Partial<Record<keyof TrustComponents, number>> = {}
+): number {
+  const w = { ...DEFAULT_TRUST_WEIGHTS, ...weights };
+  let score = 0;
+  for (const key of Object.keys(w) as Array<keyof TrustComponents>) {
+    const component = Math.max(0, Math.min(1, components[key]));
+    score += component * w[key];
+  }
+  return Math.round(score * 100 * 100) / 100; // 2 decimal places
+}

package/src/reputation/uptime-tracker.ts

@@ -0,0 +1,155 @@
+import { EventEmitter } from 'node:events';
+import type { PeerId } from '../types/peer.js';
+
+export interface UptimeWindow {
+  start: number;
+  end: number;
+}
+
+export interface PeerUptimeRecord {
+  peerId: PeerId;
+  windows: UptimeWindow[];
+  lastPingAt: number;
+}
+
+export interface UptimeTrackerConfig {
+  /** How long since last ping before a peer is considered offline (ms). Default: 120_000 (2 min) */
+  offlineThresholdMs?: number;
+  /** Rolling window for uptime calculation (ms). Default: 7 * 24 * 60 * 60 * 1000 (7 days) */
+  windowDurationMs?: number;
+}
+
+const DEFAULT_OFFLINE_THRESHOLD = 120_000;
+const DEFAULT_WINDOW_DURATION = 7 * 24 * 60 * 60 * 1000;
+
+export class UptimeTracker extends EventEmitter {
+  private records: Map<string, PeerUptimeRecord> = new Map();
+  private readonly offlineThresholdMs: number;
+  private readonly windowDurationMs: number;
+  private checkInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor(config?: UptimeTrackerConfig) {
+    super();
+    this.offlineThresholdMs = config?.offlineThresholdMs ?? DEFAULT_OFFLINE_THRESHOLD;
+    this.windowDurationMs = config?.windowDurationMs ?? DEFAULT_WINDOW_DURATION;
+  }
+
+  /**
+   * Record a ping from a peer — marks them as online.
+   */
+  recordPing(peerId: PeerId): void {
+    const now = Date.now();
+    const record = this.records.get(peerId);
+
+    if (!record) {
+      // New peer — start first window
+      this.records.set(peerId, {
+        peerId,
+        windows: [{ start: now, end: now }],
+        lastPingAt: now,
+      });
+      this.emit('peer-online', peerId);
+      return;
+    }
+
+    const lastWindow = record.windows[record.windows.length - 1];
+    const timeSinceLastPing = now - record.lastPingAt;
+
+    if (timeSinceLastPing > this.offlineThresholdMs) {
+      // Was offline — start new window
+      if (lastWindow) {
+        lastWindow.end = record.lastPingAt;
+      }
+      record.windows.push({ start: now, end: now });
+      this.emit('peer-online', peerId);
+    } else if (lastWindow) {
+      // Extend current window
+      lastWindow.end = now;
+    }
+
+    record.lastPingAt = now;
+    this.pruneOldWindows(record);
+  }
+
+  /**
+   * Explicitly record a peer going offline.
+   */
+  recordOffline(peerId: PeerId): void {
+    const record = this.records.get(peerId);
+    if (!record) return;
+
+    const lastWindow = record.windows[record.windows.length - 1];
+    if (lastWindow) {
+      lastWindow.end = Date.now();
+    }
+    this.emit('peer-offline', peerId);
+  }
+
+  /**
+   * Calculate uptime rate for a peer over the rolling window.
+   * @returns 0.0 to 1.0
+   */
+  getUptimeRate(peerId: PeerId): number {
+    const record = this.records.get(peerId);
+    if (!record || record.windows.length === 0) return 0;
+
+    const now = Date.now();
+    const windowStart = now - this.windowDurationMs;
+    let totalUptime = 0;
+
+    for (const w of record.windows) {
+      const effectiveStart = Math.max(w.start, windowStart);
+      const effectiveEnd = Math.min(w.end, now);
+      if (effectiveEnd > effectiveStart) {
+        totalUptime += effectiveEnd - effectiveStart;
+      }
+    }
+
+    return Math.min(1, totalUptime / this.windowDurationMs);
+  }
+
+  /**
+   * Get uptime rates for all tracked peers.
+   */
+  getAllUptimeRates(): Map<PeerId, number> {
+    const rates = new Map<PeerId, number>();
+    for (const record of this.records.values()) {
+      rates.set(record.peerId, this.getUptimeRate(record.peerId));
+    }
+    return rates;
+  }
+
+  /**
+   * Start periodic checking for peers that have gone offline.
+   */
+  startTracking(): void {
+    if (this.checkInterval) return;
+    this.checkInterval = setInterval(() => {
+      const now = Date.now();
+      for (const record of this.records.values()) {
+        if (now - record.lastPingAt > this.offlineThresholdMs) {
+          const lastWindow = record.windows[record.windows.length - 1];
+          if (lastWindow && lastWindow.end === record.lastPingAt) {
+            // Close the window — peer went offline
+            this.emit('peer-offline', record.peerId);
+          }
+        }
+      }
+    }, this.offlineThresholdMs);
+  }
+
+  /**
+   * Stop periodic tracking.
+   */
+  stopTracking(): void {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+  }
+
+  private pruneOldWindows(record: PeerUptimeRecord): void {
+    const cutoff = Date.now() - this.windowDurationMs;
+    record.windows = record.windows.filter(w => w.end > cutoff);
+  }
+}

package/src/routing/default-router.ts

@@ -0,0 +1,75 @@
+import type { Router } from '../interfaces/buyer-router.js';
+import type { PeerInfo } from '../types/peer.js';
+import type { SerializedHttpRequest } from '../types/http.js';
+
+export interface DefaultRouterConfig {
+  minReputation?: number;  // Default: 50
+}
+
+export class DefaultRouter implements Router {
+  private _minReputation: number;
+  private _latencyMap = new Map<string, number>();
+
+  constructor(config?: DefaultRouterConfig) {
+    this._minReputation = config?.minReputation ?? 50;
+  }
+
+  selectPeer(_req: SerializedHttpRequest, peers: PeerInfo[]): PeerInfo | null {
+    const eligible = peers.filter(
+      (p) => !this._hasReputation(p) || this._effectiveReputation(p) >= this._minReputation
+    );
+    if (eligible.length === 0) return null;
+
+    eligible.sort((a, b) => {
+      const priceA = a.defaultInputUsdPerMillion ?? Infinity;
+      const priceB = b.defaultInputUsdPerMillion ?? Infinity;
+      if (priceA !== priceB) return priceA - priceB;
+      // Prefer higher trust scores (descending)
+      const trustA = this._effectiveReputation(a);
+      const trustB = this._effectiveReputation(b);
+      if (trustA !== trustB) return trustB - trustA;
+      const latA = this._latencyMap.get(a.peerId) ?? Infinity;
+      const latB = this._latencyMap.get(b.peerId) ?? Infinity;
+      return latA - latB;
+    });
+
+    return eligible[0] ?? null;
+  }
+
+  onResult(peer: PeerInfo, result: { success: boolean; latencyMs: number; tokens: number }): void {
+    if (result.success) {
+      const prev = this._latencyMap.get(peer.peerId) ?? result.latencyMs;
+      this._latencyMap.set(peer.peerId, prev * 0.7 + result.latencyMs * 0.3);
+    }
+  }
+
+  private _effectiveReputation(peer: PeerInfo): number {
+    if (this._isFiniteNonNegative(peer.onChainReputation)) {
+      return peer.onChainReputation;
+    }
+    if (this._isFiniteNonNegative(peer.trustScore)) {
+      return peer.trustScore;
+    }
+    if (this._isFiniteNonNegative(peer.reputationScore)) {
+      return peer.reputationScore;
+    }
+    return 0;
+  }
+
+  private _hasReputation(peer: PeerInfo): boolean {
+    if (this._isFiniteNonNegative(peer.onChainReputation)) {
+      const sessionCount = this._isFiniteNonNegative(peer.onChainSessionCount) ? peer.onChainSessionCount : undefined;
+      const disputeCount = this._isFiniteNonNegative(peer.onChainDisputeCount) ? peer.onChainDisputeCount : undefined;
+      if (sessionCount !== undefined || disputeCount !== undefined) {
+        return (sessionCount ?? 0) > 0 || (disputeCount ?? 0) > 0;
+      }
+      return true;
+    }
+
+    return this._isFiniteNonNegative(peer.trustScore) || this._isFiniteNonNegative(peer.reputationScore);
+  }
+
+  private _isFiniteNonNegative(value: number | undefined): value is number {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+  }
+}

package/src/types/bittorrent-dht.d.ts

@@ -0,0 +1,19 @@
+declare module "bittorrent-dht" {
+  import { EventEmitter } from "node:events";
+
+  interface DHTOptions {
+    bootstrap?: string[];
+  }
+
+  class DHT extends EventEmitter {
+    constructor(options?: DHTOptions);
+    listen(port: number, callback?: () => void): void;
+    announce(infoHash: Buffer, port: number, callback?: (err?: Error) => void): void;
+    lookup(infoHash: Buffer, callback?: () => void): void;
+    destroy(callback?: () => void): void;
+    address(): { port: number } | null;
+    nodes: { toArray(): unknown[] };
+  }
+
+  export default DHT;
+}

package/src/types/buyer.ts

@@ -0,0 +1,37 @@
+import type { ProviderType } from './metering.js';
+
+/**
+ * Per-provider preferences for the buyer.
+ */
+export interface BuyerProviderPreference {
+  /** Provider type to route through P2P */
+  type: ProviderType;
+  /** Whether this provider is enabled for P2P routing */
+  enabled: boolean;
+  /** Maximum price per 1K tokens in USD cents the buyer is willing to pay. */
+  maxPricePerKToken: number;
+}
+
+/**
+ * Top-level buyer configuration.
+ */
+export interface BuyerConfig {
+  /** Whether buyer mode is enabled */
+  enabled: boolean;
+  /** Local proxy listen port. Default: 8377 */
+  proxyPort: number;
+  /** Local proxy listen host. Default: '127.0.0.1' */
+  proxyHost: string;
+  /** Per-provider preferences */
+  providers: BuyerProviderPreference[];
+  /** Minimum peer reputation score (0-100). Default: 50 */
+  minPeerReputation: number;
+  /** Maximum number of peers to maintain in the pool. Default: 10 */
+  maxPoolSize: number;
+  /** Health check interval in ms. Default: 30_000 */
+  healthCheckIntervalMs: number;
+  /** Timeout for requests forwarded to peers in ms. Default: 120_000 */
+  requestTimeoutMs: number;
+  /** Whether to automatically set env vars for CLI tools. Default: true */
+  autoSetEnvVars: boolean;
+}

package/src/types/capability.ts

@@ -0,0 +1,34 @@
+/**
+ * Provider capability types — what a peer can offer beyond inference.
+ */
+export type ProviderCapability =
+  | 'inference'
+  | 'agent'
+  | 'skill'
+  | 'tool'
+  | 'embedding'
+  | 'image-gen'
+  | 'tts'
+  | 'stt';
+
+/**
+ * Pricing tier for an offering.
+ */
+export interface PricingTier {
+  unit: 'token' | 'request' | 'minute' | 'task';
+  pricePerUnit: number;
+  currency: 'USD';
+}
+
+/**
+ * A discrete offering that a peer advertises.
+ */
+export interface PeerOffering {
+  capability: ProviderCapability;
+  name: string;
+  description: string;
+  inputSchema?: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
+  models?: string[];
+  pricing: PricingTier;
+}

package/src/types/connection.ts

@@ -0,0 +1,29 @@
+import type { PeerId } from "./peer.js";
+
+/** Connection lifecycle states. */
+export enum ConnectionState {
+  Connecting = "connecting",
+  Open = "open",
+  Authenticated = "authenticated",
+  Closing = "closing",
+  Closed = "closed",
+  Failed = "failed",
+}
+
+/** Events emitted by a PeerConnection. */
+export interface ConnectionEvents {
+  stateChange: (state: ConnectionState) => void;
+  message: (data: Uint8Array) => void;
+  error: (err: Error) => void;
+}
+
+/** Configuration for a single connection. */
+export interface ConnectionConfig {
+  remotePeerId: PeerId;
+  isInitiator: boolean;
+  timeoutMs?: number;
+  endpoint?: {
+    host: string;
+    port: number;
+  };
+}

package/src/types/http.ts

@@ -0,0 +1,20 @@
+export interface SerializedHttpRequest {
+  requestId: string;
+  method: string;
+  path: string;
+  headers: Record<string, string>;
+  body: Uint8Array;
+}
+
+export interface SerializedHttpResponse {
+  requestId: string;
+  statusCode: number;
+  headers: Record<string, string>;
+  body: Uint8Array;
+}
+
+export interface SerializedHttpResponseChunk {
+  requestId: string;
+  data: Uint8Array;
+  done: boolean;
+}

package/src/types/index.ts

@@ -0,0 +1,14 @@
+export * from './peer.js';
+export * from './protocol.js';
+export * from './connection.js';
+export * from './metering.js';
+export * from './provider.js';
+export * from './seller.js';
+export * from './buyer.js';
+export * from './http.js';
+export * from './capability.js';
+export * from './peer-profile.js';
+export * from './staking.js';
+export * from './report.js';
+export * from './rating.js';
+export * from './plugin-config.js';