@antseed/node 0.1.0 → 0.1.1

package/src/reputation/trust-engine.ts

@@ -1,120 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,34 +0,0 @@
-/**
- * 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

@@ -1,29 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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';