@antseed/node 0.1.0

package/src/proxy/proxy-mux.ts

@@ -0,0 +1,173 @@
+import { MessageType, type FramedMessage } from "../types/protocol.js";
+import type { PeerConnection } from "../p2p/connection-manager.js";
+import { encodeFrame } from "../p2p/message-protocol.js";
+import {
+  encodeHttpRequest,
+  decodeHttpRequest,
+  encodeHttpResponse,
+  decodeHttpResponse,
+  encodeHttpResponseChunk,
+  decodeHttpResponseChunk,
+} from "./request-codec.js";
+import type {
+  SerializedHttpRequest,
+  SerializedHttpResponse,
+  SerializedHttpResponseChunk,
+} from "../types/http.js";
+
+type ResponseHandler = (response: SerializedHttpResponse) => void;
+type ChunkHandler = (chunk: SerializedHttpResponseChunk) => void;
+type RequestHandler = (request: SerializedHttpRequest) => void | Promise<void>;
+
+/**
+ * Request/response multiplexer over DataChannel.
+ * Handles both buyer-side and seller-side proxy communication.
+ */
+export class ProxyMux {
+  private readonly _connection: PeerConnection;
+  private _messageIdCounter = 0;
+
+  // Buyer side: pending requests awaiting responses
+  private readonly _responseHandlers = new Map<string, ResponseHandler>();
+  private readonly _chunkHandlers = new Map<string, ChunkHandler>();
+
+  // Seller side: handler for incoming proxy requests
+  private _requestHandler: RequestHandler | null = null;
+
+  constructor(connection: PeerConnection) {
+    this._connection = connection;
+  }
+
+  /** Buyer side: send a proxy request and register response/chunk handlers. */
+  sendProxyRequest(
+    request: SerializedHttpRequest,
+    onResponse: ResponseHandler,
+    onChunk: ChunkHandler
+  ): void {
+    this._responseHandlers.set(request.requestId, onResponse);
+    this._chunkHandlers.set(request.requestId, onChunk);
+
+    const payload = encodeHttpRequest(request);
+    const frame = encodeFrame({
+      type: MessageType.HttpRequest,
+      messageId: this._nextMessageId(),
+      payload,
+    });
+
+    this._connection.send(frame);
+  }
+
+  /** Buyer side: cancel handlers for an in-flight request. */
+  cancelProxyRequest(requestId: string): void {
+    this._responseHandlers.delete(requestId);
+    this._chunkHandlers.delete(requestId);
+  }
+
+  /** Seller side: register a handler for incoming proxy requests. */
+  onProxyRequest(handler: RequestHandler): void {
+    this._requestHandler = handler;
+  }
+
+  /** Seller side: send a complete proxy response. */
+  sendProxyResponse(response: SerializedHttpResponse): void {
+    const payload = encodeHttpResponse(response);
+    const frame = encodeFrame({
+      type: MessageType.HttpResponse,
+      messageId: this._nextMessageId(),
+      payload,
+    });
+
+    this._connection.send(frame);
+  }
+
+  /** Seller side: send a proxy response chunk. */
+  sendProxyChunk(chunk: SerializedHttpResponseChunk): void {
+    const type = chunk.done
+      ? MessageType.HttpResponseEnd
+      : MessageType.HttpResponseChunk;
+
+    const payload = encodeHttpResponseChunk(chunk);
+    const frame = encodeFrame({
+      type,
+      messageId: this._nextMessageId(),
+      payload,
+    });
+
+    this._connection.send(frame);
+  }
+
+  /** Route an incoming frame to the correct handler based on message type. */
+  async handleFrame(frame: FramedMessage): Promise<void> {
+    try {
+      switch (frame.type) {
+        case MessageType.HttpRequest: {
+          // Seller side: incoming request from buyer
+          if (this._requestHandler) {
+            const request = decodeHttpRequest(frame.payload);
+            await this._requestHandler(request);
+          }
+          break;
+        }
+        case MessageType.HttpResponse: {
+          // Buyer side: complete response from seller
+          const response = decodeHttpResponse(frame.payload);
+          const handler = this._responseHandlers.get(response.requestId);
+          if (handler) {
+            this._responseHandlers.delete(response.requestId);
+            this._chunkHandlers.delete(response.requestId);
+            handler(response);
+          }
+          break;
+        }
+        case MessageType.HttpResponseChunk: {
+          // Buyer side: streaming chunk from seller
+          const chunk = decodeHttpResponseChunk(frame.payload);
+          const chunkHandler = this._chunkHandlers.get(chunk.requestId);
+          if (chunkHandler) {
+            chunkHandler(chunk);
+          }
+          break;
+        }
+        case MessageType.HttpResponseEnd: {
+          // Buyer side: final chunk (done=true) from seller
+          const endChunk = decodeHttpResponseChunk(frame.payload);
+          const endHandler = this._chunkHandlers.get(endChunk.requestId);
+          if (endHandler) {
+            endHandler(endChunk);
+            this._responseHandlers.delete(endChunk.requestId);
+            this._chunkHandlers.delete(endChunk.requestId);
+          }
+          break;
+        }
+        case MessageType.HttpResponseError: {
+          // Buyer side: error response from seller
+          const errorResponse = decodeHttpResponse(frame.payload);
+          const errorHandler = this._responseHandlers.get(errorResponse.requestId);
+          if (errorHandler) {
+            this._responseHandlers.delete(errorResponse.requestId);
+            this._chunkHandlers.delete(errorResponse.requestId);
+            errorHandler(errorResponse);
+          }
+          break;
+        }
+        default:
+          // Unknown message type — ignore
+          break;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to handle proxy frame type ${frame.type}: ${message}`);
+    }
+  }
+
+  /** Number of in-flight requests (buyer side). */
+  activeRequestCount(): number {
+    return this._responseHandlers.size;
+  }
+
+  private _nextMessageId(): number {
+    const id = this._messageIdCounter;
+    this._messageIdCounter = (this._messageIdCounter + 1) & 0xFFFFFFFF;
+    return id;
+  }
+}

package/src/proxy/request-codec.ts

@@ -0,0 +1,294 @@
+import type {
+  SerializedHttpRequest,
+  SerializedHttpResponse,
+  SerializedHttpResponseChunk,
+} from "../types/http.js";
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+/**
+ * Encode an HTTP request into binary format:
+ * [requestIdLen:2][requestId:N][methodLen:1][method:N][pathLen:2][path:N]
+ * [headerCount:2][for each header: keyLen:2, key:N, valLen:2, val:N]
+ * [bodyLen:4][body:N]
+ */
+export function encodeHttpRequest(req: SerializedHttpRequest): Uint8Array {
+  const requestIdBytes = encoder.encode(req.requestId);
+  const methodBytes = encoder.encode(req.method);
+  const pathBytes = encoder.encode(req.path);
+
+  const headerEntries = Object.entries(req.headers);
+  const encodedHeaders: Array<{ key: Uint8Array; val: Uint8Array }> = [];
+  let headersSize = 0;
+  for (const [key, val] of headerEntries) {
+    const keyBytes = encoder.encode(key);
+    const valBytes = encoder.encode(val);
+    encodedHeaders.push({ key: keyBytes, val: valBytes });
+    headersSize += 2 + keyBytes.length + 2 + valBytes.length;
+  }
+
+  const totalSize =
+    2 + requestIdBytes.length +
+    1 + methodBytes.length +
+    2 + pathBytes.length +
+    2 + headersSize +
+    4 + req.body.length;
+
+  const buf = new Uint8Array(totalSize);
+  const view = new DataView(buf.buffer);
+  let offset = 0;
+
+  // requestId
+  view.setUint16(offset, requestIdBytes.length);
+  offset += 2;
+  buf.set(requestIdBytes, offset);
+  offset += requestIdBytes.length;
+
+  // method
+  view.setUint8(offset, methodBytes.length);
+  offset += 1;
+  buf.set(methodBytes, offset);
+  offset += methodBytes.length;
+
+  // path
+  view.setUint16(offset, pathBytes.length);
+  offset += 2;
+  buf.set(pathBytes, offset);
+  offset += pathBytes.length;
+
+  // headers
+  view.setUint16(offset, headerEntries.length);
+  offset += 2;
+  for (const { key, val } of encodedHeaders) {
+    view.setUint16(offset, key.length);
+    offset += 2;
+    buf.set(key, offset);
+    offset += key.length;
+    view.setUint16(offset, val.length);
+    offset += 2;
+    buf.set(val, offset);
+    offset += val.length;
+  }
+
+  // body
+  view.setUint32(offset, req.body.length);
+  offset += 4;
+  buf.set(req.body, offset);
+
+  return buf;
+}
+
+/**
+ * Decode binary data into a SerializedHttpRequest.
+ */
+export function decodeHttpRequest(data: Uint8Array): SerializedHttpRequest {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+
+  // requestId
+  const requestIdLen = view.getUint16(offset);
+  offset += 2;
+  const requestId = decoder.decode(data.slice(offset, offset + requestIdLen));
+  offset += requestIdLen;
+
+  // method
+  const methodLen = view.getUint8(offset);
+  offset += 1;
+  const method = decoder.decode(data.slice(offset, offset + methodLen));
+  offset += methodLen;
+
+  // path
+  const pathLen = view.getUint16(offset);
+  offset += 2;
+  const path = decoder.decode(data.slice(offset, offset + pathLen));
+  offset += pathLen;
+
+  // headers
+  const headerCount = view.getUint16(offset);
+  offset += 2;
+  const headers: Record<string, string> = {};
+  for (let i = 0; i < headerCount; i++) {
+    const keyLen = view.getUint16(offset);
+    offset += 2;
+    const key = decoder.decode(data.slice(offset, offset + keyLen));
+    offset += keyLen;
+    const valLen = view.getUint16(offset);
+    offset += 2;
+    const val = decoder.decode(data.slice(offset, offset + valLen));
+    offset += valLen;
+    headers[key] = val;
+  }
+
+  // body
+  const bodyLen = view.getUint32(offset);
+  offset += 4;
+  const body = data.slice(offset, offset + bodyLen);
+
+  return { requestId, method, path, headers, body };
+}
+
+/**
+ * Encode an HTTP response into binary format:
+ * [requestIdLen:2][requestId:N][statusCode:2]
+ * [headerCount:2][for each header: keyLen:2, key:N, valLen:2, val:N]
+ * [bodyLen:4][body:N]
+ */
+export function encodeHttpResponse(resp: SerializedHttpResponse): Uint8Array {
+  const requestIdBytes = encoder.encode(resp.requestId);
+
+  const headerEntries = Object.entries(resp.headers);
+  const encodedHeaders: Array<{ key: Uint8Array; val: Uint8Array }> = [];
+  let headersSize = 0;
+  for (const [key, val] of headerEntries) {
+    const keyBytes = encoder.encode(key);
+    const valBytes = encoder.encode(val);
+    encodedHeaders.push({ key: keyBytes, val: valBytes });
+    headersSize += 2 + keyBytes.length + 2 + valBytes.length;
+  }
+
+  const totalSize =
+    2 + requestIdBytes.length +
+    2 +
+    2 + headersSize +
+    4 + resp.body.length;
+
+  const buf = new Uint8Array(totalSize);
+  const view = new DataView(buf.buffer);
+  let offset = 0;
+
+  // requestId
+  view.setUint16(offset, requestIdBytes.length);
+  offset += 2;
+  buf.set(requestIdBytes, offset);
+  offset += requestIdBytes.length;
+
+  // statusCode
+  view.setUint16(offset, resp.statusCode);
+  offset += 2;
+
+  // headers
+  view.setUint16(offset, headerEntries.length);
+  offset += 2;
+  for (const { key, val } of encodedHeaders) {
+    view.setUint16(offset, key.length);
+    offset += 2;
+    buf.set(key, offset);
+    offset += key.length;
+    view.setUint16(offset, val.length);
+    offset += 2;
+    buf.set(val, offset);
+    offset += val.length;
+  }
+
+  // body
+  view.setUint32(offset, resp.body.length);
+  offset += 4;
+  buf.set(resp.body, offset);
+
+  return buf;
+}
+
+/**
+ * Decode binary data into a SerializedHttpResponse.
+ */
+export function decodeHttpResponse(data: Uint8Array): SerializedHttpResponse {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+
+  // requestId
+  const requestIdLen = view.getUint16(offset);
+  offset += 2;
+  const requestId = decoder.decode(data.slice(offset, offset + requestIdLen));
+  offset += requestIdLen;
+
+  // statusCode
+  const statusCode = view.getUint16(offset);
+  offset += 2;
+
+  // headers
+  const headerCount = view.getUint16(offset);
+  offset += 2;
+  const headers: Record<string, string> = {};
+  for (let i = 0; i < headerCount; i++) {
+    const keyLen = view.getUint16(offset);
+    offset += 2;
+    const key = decoder.decode(data.slice(offset, offset + keyLen));
+    offset += keyLen;
+    const valLen = view.getUint16(offset);
+    offset += 2;
+    const val = decoder.decode(data.slice(offset, offset + valLen));
+    offset += valLen;
+    headers[key] = val;
+  }
+
+  // body
+  const bodyLen = view.getUint32(offset);
+  offset += 4;
+  const body = data.slice(offset, offset + bodyLen);
+
+  return { requestId, statusCode, headers, body };
+}
+
+/**
+ * Encode an HTTP response chunk into binary format:
+ * [requestIdLen:2][requestId:N][done:1][dataLen:4][data:N]
+ */
+export function encodeHttpResponseChunk(
+  chunk: SerializedHttpResponseChunk
+): Uint8Array {
+  const requestIdBytes = encoder.encode(chunk.requestId);
+
+  const totalSize =
+    2 + requestIdBytes.length +
+    1 +
+    4 + chunk.data.length;
+
+  const buf = new Uint8Array(totalSize);
+  const view = new DataView(buf.buffer);
+  let offset = 0;
+
+  // requestId
+  view.setUint16(offset, requestIdBytes.length);
+  offset += 2;
+  buf.set(requestIdBytes, offset);
+  offset += requestIdBytes.length;
+
+  // done
+  view.setUint8(offset, chunk.done ? 1 : 0);
+  offset += 1;
+
+  // data
+  view.setUint32(offset, chunk.data.length);
+  offset += 4;
+  buf.set(chunk.data, offset);
+
+  return buf;
+}
+
+/**
+ * Decode binary data into a SerializedHttpResponseChunk.
+ */
+export function decodeHttpResponseChunk(
+  data: Uint8Array
+): SerializedHttpResponseChunk {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let offset = 0;
+
+  // requestId
+  const requestIdLen = view.getUint16(offset);
+  offset += 2;
+  const requestId = decoder.decode(data.slice(offset, offset + requestIdLen));
+  offset += requestIdLen;
+
+  // done
+  const done = view.getUint8(offset) === 1;
+  offset += 1;
+
+  // data
+  const dataLen = view.getUint32(offset);
+  offset += 4;
+  const chunkData = data.slice(offset, offset + dataLen);
+
+  return { requestId, data: chunkData, done };
+}

package/src/reputation/index.ts

@@ -0,0 +1,6 @@
+export { computeTrustScore, DEFAULT_TRUST_WEIGHTS, DEFAULT_COMPONENTS } from './trust-score.js';
+export type { TrustScore, TrustComponents } from './trust-score.js';
+export { TrustScoreEngine, type TrustEngineConfig } from './trust-engine.js';
+export { UptimeTracker, type UptimeTrackerConfig, type UptimeWindow, type PeerUptimeRecord } from './uptime-tracker.js';
+export { ReportManager, type ReportManagerConfig } from './report-manager.js';
+export { RatingManager, type RatingManagerConfig } from './rating-manager.js';

package/src/reputation/rating-manager.ts

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { PeerId } from '../types/peer.js';
+import type { PeerRating, RatingDimension, AggregateRating } from '../types/rating.js';
+import type { Identity } from '../p2p/identity.js';
+import { signData } from '../p2p/identity.js';
+import { bytesToHex } from '../utils/hex.js';
+
+const HALF_LIFE_MS = 90 * 24 * 60 * 60 * 1000; // 90 days
+const DIMENSIONS: RatingDimension[] = ['quality', 'speed', 'reliability', 'value', 'overall'];
+
+export interface RatingManagerConfig {
+  configDir: string;
+  identity?: Identity;
+}
+
+export class RatingManager {
+  private readonly configDir: string;
+  private readonly identity: Identity | undefined;
+  private ratings: PeerRating[] = [];
+
+  constructor(config: RatingManagerConfig) {
+    this.configDir = config.configDir;
+    this.identity = config.identity;
+  }
+
+  async submitRating(
+    targetPeerId: PeerId,
+    sessionId: string,
+    dimensions: Record<RatingDimension, 1 | 2 | 3 | 4 | 5>,
+    comment?: string,
+  ): Promise<PeerRating> {
+    if (!this.identity) throw new Error('Identity required to submit ratings');
+
+    const rating: PeerRating = {
+      ratingId: randomUUID(),
+      raterPeerId: this.identity.peerId as PeerId,
+      targetPeerId,
+      sessionId,
+      dimensions,
+      comment,
+      timestamp: Date.now(),
+      signature: '',
+    };
+
+    const dataToSign = `${rating.ratingId}:${rating.raterPeerId}:${rating.targetPeerId}:${rating.sessionId}:${rating.timestamp}`;
+    const sig = await signData(this.identity.privateKey, new TextEncoder().encode(dataToSign));
+    rating.signature = bytesToHex(sig);
+
+    this.ratings.push(rating);
+    await this.save();
+    return rating;
+  }
+
+  getAggregateRating(peerId: PeerId): AggregateRating {
+    const peerRatings = this.ratings.filter(r => r.targetPeerId === peerId);
+    const now = Date.now();
+
+    const weightedSums: Record<string, number> = Object.fromEntries(DIMENSIONS.map(d => [d, 0]));
+    let totalWeight = 0;
+
+    for (const rating of peerRatings) {
+      // Exponential decay weight
+      const age = now - rating.timestamp;
+      const weight = Math.pow(0.5, age / HALF_LIFE_MS);
+      totalWeight += weight;
+
+      for (const dim of DIMENSIONS) {
+        weightedSums[dim]! += rating.dimensions[dim] * weight;
+      }
+    }
+
+    const averageByDimension = {} as Record<RatingDimension, number>;
+    for (const dim of DIMENSIONS) {
+      averageByDimension[dim] = totalWeight > 0
+        ? Math.round((weightedSums[dim]! / totalWeight) * 100) / 100
+        : 0;
+    }
+
+    const overallAverage = totalWeight > 0
+      ? Math.round((DIMENSIONS.reduce((sum, dim) => sum + averageByDimension[dim], 0) / DIMENSIONS.length) * 100) / 100
+      : 0;
+
+    return {
+      peerId,
+      averageByDimension,
+      overallAverage,
+      totalRatings: peerRatings.length,
+      lastUpdated: now,
+    };
+  }
+
+  getRatingsFor(peerId: PeerId): PeerRating[] {
+    return this.ratings.filter(r => r.targetPeerId === peerId);
+  }
+
+  getMyRatings(): PeerRating[] {
+    if (!this.identity) return [];
+    return this.ratings.filter(r => r.raterPeerId === this.identity!.peerId);
+  }
+
+  async save(): Promise<void> {
+    await mkdir(this.configDir, { recursive: true });
+    const filePath = join(this.configDir, 'ratings.json');
+    await writeFile(filePath, JSON.stringify(this.ratings, null, 2), 'utf-8');
+  }
+
+  async load(): Promise<void> {
+    const filePath = join(this.configDir, 'ratings.json');
+    try {
+      const raw = await readFile(filePath, 'utf-8');
+      this.ratings = JSON.parse(raw) as PeerRating[];
+    } catch {
+      this.ratings = [];
+    }
+  }
+}

package/src/reputation/report-manager.ts

@@ -0,0 +1,91 @@
+import { randomUUID } from 'node:crypto';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { PeerId } from '../types/peer.js';
+import type { PeerReport, ReportReason, ReportEvidence } from '../types/report.js';
+import type { Identity } from '../p2p/identity.js';
+import { signData } from '../p2p/identity.js';
+import { bytesToHex } from '../utils/hex.js';
+
+export interface ReportManagerConfig {
+  configDir: string;
+  identity?: Identity;
+}
+
+export class ReportManager {
+  private readonly configDir: string;
+  private readonly identity: Identity | undefined;
+  private reports: PeerReport[] = [];
+
+  constructor(config: ReportManagerConfig) {
+    this.configDir = config.configDir;
+    this.identity = config.identity;
+  }
+
+  async submitReport(
+    targetPeerId: PeerId,
+    reason: ReportReason,
+    evidence: ReportEvidence[],
+    sessionId?: string,
+  ): Promise<PeerReport> {
+    if (!this.identity) throw new Error('Identity required to submit reports');
+
+    const report: PeerReport = {
+      reportId: randomUUID(),
+      reporterPeerId: this.identity.peerId as PeerId,
+      targetPeerId,
+      reason,
+      evidence,
+      sessionId,
+      timestamp: Date.now(),
+      status: 'pending',
+      signature: '',
+    };
+
+    // Sign the report
+    const dataToSign = `${report.reportId}:${report.reporterPeerId}:${report.targetPeerId}:${report.reason}:${report.timestamp}`;
+    const sig = await signData(this.identity.privateKey, new TextEncoder().encode(dataToSign));
+    report.signature = bytesToHex(sig);
+
+    this.reports.push(report);
+    await this.save();
+    return report;
+  }
+
+  getReportsAgainst(peerId: PeerId): PeerReport[] {
+    return this.reports.filter(r => r.targetPeerId === peerId);
+  }
+
+  getMyReports(): PeerReport[] {
+    if (!this.identity) return [];
+    return this.reports.filter(r => r.reporterPeerId === this.identity!.peerId);
+  }
+
+  getReport(reportId: string): PeerReport | null {
+    return this.reports.find(r => r.reportId === reportId) ?? null;
+  }
+
+  updateReportStatus(reportId: string, status: PeerReport['status']): void {
+    const report = this.reports.find(r => r.reportId === reportId);
+    if (report) {
+      report.status = status;
+    }
+  }
+
+  async save(): Promise<void> {
+    const dir = join(this.configDir, 'reports');
+    await mkdir(dir, { recursive: true });
+    const filePath = join(dir, 'reports.json');
+    await writeFile(filePath, JSON.stringify(this.reports, null, 2), 'utf-8');
+  }
+
+  async load(): Promise<void> {
+    const filePath = join(this.configDir, 'reports', 'reports.json');
+    try {
+      const raw = await readFile(filePath, 'utf-8');
+      this.reports = JSON.parse(raw) as PeerReport[];
+    } catch {
+      this.reports = [];
+    }
+  }
+}