@antseed/node 0.1.0 → 0.1.1

package/src/discovery/peer-lookup.ts

@@ -1,122 +0,0 @@
-import { verifySignature, hexToBytes } from "../p2p/identity.js";
-import type { DHTNode } from "./dht-node.js";
-import { providerTopic, capabilityTopic, topicToInfoHash } from "./dht-node.js";
-import type { PeerMetadata } from "./peer-metadata.js";
-import { encodeMetadataForSigning } from "./metadata-codec.js";
-import type { MetadataResolver } from "./metadata-resolver.js";
-
-export interface LookupConfig {
-  dht: DHTNode;
-  metadataResolver: MetadataResolver;
-  requireValidSignature: boolean;
-  allowStaleMetadata: boolean;
-  maxAnnouncementAgeMs: number;
-  maxResults: number;
-}
-
-export const DEFAULT_LOOKUP_CONFIG: Omit<LookupConfig, "dht" | "metadataResolver"> = {
-  requireValidSignature: true,
-  allowStaleMetadata: false,
-  maxAnnouncementAgeMs: 30 * 60 * 1000,
-  maxResults: 50,
-};
-
-export interface LookupResult {
-  metadata: PeerMetadata;
-  host: string;
-  port: number;
-}
-
-export class PeerLookup {
-  private readonly config: LookupConfig;
-
-  constructor(config: LookupConfig) {
-    this.config = config;
-  }
-
-  async findSellers(provider: string): Promise<LookupResult[]> {
-    const topic = providerTopic(provider);
-    const infoHash = topicToInfoHash(topic);
-    const peers = await this.config.dht.lookup(infoHash);
-
-    const results: LookupResult[] = [];
-    for (const peer of peers) {
-      if (results.length >= this.config.maxResults) {
-        break;
-      }
-
-      const metadata = await this.config.metadataResolver.resolve(peer);
-      if (metadata === null) {
-        continue;
-      }
-
-      if (this.config.requireValidSignature) {
-        const valid = await this.verifyMetadataSignature(metadata);
-        if (!valid) {
-          continue;
-        }
-      }
-
-      if (!this.config.allowStaleMetadata && this.isStale(metadata)) {
-        continue;
-      }
-
-      results.push({
-        metadata,
-        host: peer.host,
-        port: peer.port,
-      });
-    }
-
-    return results;
-  }
-
-  async findByCapability(capability: string, name?: string): Promise<LookupResult[]> {
-    const topic = capabilityTopic(capability, name);
-    const infoHash = topicToInfoHash(topic);
-    const peers = await this.config.dht.lookup(infoHash);
-
-    const results: LookupResult[] = [];
-    for (const peer of peers) {
-      if (results.length >= this.config.maxResults) {
-        break;
-      }
-
-      const metadata = await this.config.metadataResolver.resolve(peer);
-      if (metadata === null) {
-        continue;
-      }
-
-      if (this.config.requireValidSignature) {
-        const valid = await this.verifyMetadataSignature(metadata);
-        if (!valid) {
-          continue;
-        }
-      }
-
-      if (!this.config.allowStaleMetadata && this.isStale(metadata)) {
-        continue;
-      }
-
-      results.push({
-        metadata,
-        host: peer.host,
-        port: peer.port,
-      });
-    }
-
-    return results;
-  }
-
-  async verifyMetadataSignature(metadata: PeerMetadata): Promise<boolean> {
-    const dataToVerify = encodeMetadataForSigning(metadata);
-    const publicKey = hexToBytes(metadata.peerId);
-    const signature = hexToBytes(metadata.signature);
-    return verifySignature(publicKey, signature, dataToVerify);
-  }
-
-  isStale(metadata: PeerMetadata): boolean {
-    const age = Date.now() - metadata.timestamp;
-    return age > this.config.maxAnnouncementAgeMs;
-  }
-}

package/src/discovery/peer-metadata.ts

@@ -1,34 +0,0 @@
-import type { PeerId } from "../types/peer.js";
-import type { PeerOffering } from "../types/capability.js";
-
-export const METADATA_VERSION = 2;
-
-export interface TokenPricingUsdPerMillion {
-  inputUsdPerMillion: number;
-  outputUsdPerMillion: number;
-}
-
-export interface ProviderAnnouncement {
-  provider: string;
-  models: string[];
-  defaultPricing: TokenPricingUsdPerMillion;
-  modelPricing?: Record<string, TokenPricingUsdPerMillion>;
-  maxConcurrency: number;
-  currentLoad: number;
-}
-
-export interface PeerMetadata {
-  peerId: PeerId;
-  version: number;
-  providers: ProviderAnnouncement[];
-  offerings?: PeerOffering[];
-  region: string;
-  timestamp: number;
-  stakeAmountUSDC?: number;
-  trustScore?: number;
-  evmAddress?: string;
-  onChainReputation?: number;
-  onChainSessionCount?: number;
-  onChainDisputeCount?: number;
-  signature: string;
-}

package/src/discovery/peer-selector.ts

@@ -1,134 +0,0 @@
-export interface ScoringWeights {
-  price: number;
-  capacity: number;
-  latency: number;
-  reputation: number;
-}
-
-export const DEFAULT_SCORING_WEIGHTS: ScoringWeights = {
-  price: 0.35,
-  capacity: 0.25,
-  latency: 0.25,
-  reputation: 0.15,
-};
-
-export interface PeerCandidate {
-  peerId: string;
-  region: string;
-  inputUsdPerMillion: number;
-  maxConcurrency: number;
-  currentLoad: number;
-  latencyMs: number;
-  reputation: number;
-}
-
-export interface ScoredPeer {
-  candidate: PeerCandidate;
-  score: number;
-}
-
-/**
- * Score a single peer candidate.
- *
- * - priceScore: cheapestInputPrice / candidate.inputUsdPerMillion (capped at 1.0)
- * - capacityScore: (maxConcurrency - currentLoad) / maxConcurrency
- * - latencyScore: 1 - (latencyMs / 15000), clamped to [0, 1]
- * - reputationScore: candidate.reputation (expected 0..1)
- */
-export function scorePeer(
-  candidate: PeerCandidate,
-  cheapestInputPrice: number,
-  weights: ScoringWeights = DEFAULT_SCORING_WEIGHTS
-): number {
-  // Price score
-  const priceScore =
-    candidate.inputUsdPerMillion > 0
-      ? Math.min(cheapestInputPrice / candidate.inputUsdPerMillion, 1.0)
-      : 1.0;
-
-  // Capacity score
-  const capacityScore =
-    candidate.maxConcurrency > 0
-      ? (candidate.maxConcurrency - candidate.currentLoad) /
-        candidate.maxConcurrency
-      : 0;
-
-  // Latency score
-  const latencyScore = Math.max(0, Math.min(1, 1 - candidate.latencyMs / 15000));
-
-  // Reputation score
-  const reputationScore = Math.max(0, Math.min(1, candidate.reputation));
-
-  const score =
-    weights.price * priceScore +
-    weights.capacity * capacityScore +
-    weights.latency * latencyScore +
-    weights.reputation * reputationScore;
-
-  return Math.max(0, Math.min(1, score));
-}
-
-export function rankPeers(
-  candidates: PeerCandidate[],
-  weights: ScoringWeights = DEFAULT_SCORING_WEIGHTS
-): ScoredPeer[] {
-  if (candidates.length === 0) {
-    return [];
-  }
-
-  const cheapestInputPrice = Math.min(
-    ...candidates.map((c) => c.inputUsdPerMillion).filter((p) => p > 0)
-  );
-  const effectiveCheapest = Number.isFinite(cheapestInputPrice)
-    ? cheapestInputPrice
-    : 0;
-
-  const scored: ScoredPeer[] = candidates.map((candidate) => ({
-    candidate,
-    score: scorePeer(candidate, effectiveCheapest, weights),
-  }));
-
-  scored.sort((a, b) => b.score - a.score);
-  return scored;
-}
-
-export function selectBestPeer(
-  candidates: PeerCandidate[],
-  weights: ScoringWeights = DEFAULT_SCORING_WEIGHTS
-): ScoredPeer | null {
-  const ranked = rankPeers(candidates, weights);
-  return ranked[0] ?? null;
-}
-
-export function selectDiversePeers(
-  candidates: PeerCandidate[],
-  count: number,
-  weights: ScoringWeights = DEFAULT_SCORING_WEIGHTS
-): ScoredPeer[] {
-  const ranked = rankPeers(candidates, weights);
-  if (ranked.length <= count) {
-    return ranked;
-  }
-
-  const selected: ScoredPeer[] = [];
-  const seenRegions = new Set<string>();
-
-  // First pass: pick the best from each unique region
-  for (const peer of ranked) {
-    if (selected.length >= count) break;
-    if (!seenRegions.has(peer.candidate.region)) {
-      seenRegions.add(peer.candidate.region);
-      selected.push(peer);
-    }
-  }
-
-  // Second pass: fill remaining slots by score
-  for (const peer of ranked) {
-    if (selected.length >= count) break;
-    if (!selected.includes(peer)) {
-      selected.push(peer);
-    }
-  }
-
-  return selected;
-}

package/src/discovery/profile-manager.ts

@@ -1,131 +0,0 @@
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import type { PeerId } from '../types/peer.js';
-import type { PeerProfile, ProfileCapability } from '../types/peer-profile.js';
-import type { Identity } from '../p2p/identity.js';
-import { signData } from '../p2p/identity.js';
-import { bytesToHex } from '../utils/hex.js';
-
-export interface ProfileManagerConfig {
-  configDir: string;
-  identity?: Identity;
-}
-
-export class ProfileManager {
-  private readonly configDir: string;
-  private readonly identity: Identity | undefined;
-  private profile: PeerProfile | null = null;
-
-  constructor(config: ProfileManagerConfig) {
-    this.configDir = config.configDir;
-    this.identity = config.identity;
-  }
-
-  /**
-   * Create a new peer profile.
-   */
-  createProfile(data: {
-    displayName: string;
-    description: string;
-    tags?: string[];
-    capabilities?: ProfileCapability[];
-    region?: string;
-    languages?: string[];
-    website?: string;
-    avatar?: string;
-  }): PeerProfile {
-    if (!this.identity) {
-      throw new Error('Identity required to create profile');
-    }
-
-    const now = Date.now();
-    this.profile = {
-      peerId: this.identity.peerId as PeerId,
-      displayName: data.displayName,
-      description: data.description,
-      tags: data.tags ?? [],
-      capabilities: data.capabilities ?? ['inference'],
-      region: data.region ?? 'unknown',
-      languages: data.languages ?? ['en'],
-      website: data.website,
-      avatar: data.avatar,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    return this.profile;
-  }
-
-  /**
-   * Update an existing profile.
-   */
-  updateProfile(updates: Partial<Omit<PeerProfile, 'peerId' | 'createdAt'>>): PeerProfile {
-    if (!this.profile) {
-      throw new Error('No profile exists — call createProfile first');
-    }
-
-    this.profile = {
-      ...this.profile,
-      ...updates,
-      peerId: this.profile.peerId, // immutable
-      createdAt: this.profile.createdAt, // immutable
-      updatedAt: Date.now(),
-    };
-
-    return this.profile;
-  }
-
-  /**
-   * Get the current profile.
-   */
-  getProfile(): PeerProfile | null {
-    return this.profile;
-  }
-
-  /**
-   * Get SHA-256 hash of the profile for metadata announcements.
-   */
-  getProfileHash(): string {
-    if (!this.profile) return '';
-    const json = JSON.stringify(this.profile);
-    return createHash('sha256').update(json).digest('hex');
-  }
-
-  /**
-   * Sign the profile hash with the identity's private key.
-   */
-  async getProfileSignature(): Promise<string> {
-    if (!this.identity || !this.profile) {
-      throw new Error('Identity and profile required for signing');
-    }
-    const hash = this.getProfileHash();
-    const hashBytes = new TextEncoder().encode(hash);
-    const signature = await signData(this.identity.privateKey, hashBytes);
-    return bytesToHex(signature);
-  }
-
-  /**
-   * Save profile to disk.
-   */
-  async save(): Promise<void> {
-    if (!this.profile) return;
-    await mkdir(this.configDir, { recursive: true });
-    const filePath = join(this.configDir, 'profile.json');
-    await writeFile(filePath, JSON.stringify(this.profile, null, 2), 'utf-8');
-  }
-
-  /**
-   * Load profile from disk.
-   */
-  async load(): Promise<void> {
-    const filePath = join(this.configDir, 'profile.json');
-    try {
-      const raw = await readFile(filePath, 'utf-8');
-      this.profile = JSON.parse(raw) as PeerProfile;
-    } catch {
-      // File doesn't exist — no profile yet
-      this.profile = null;
-    }
-  }
-}

package/src/discovery/profile-search.ts

@@ -1,100 +0,0 @@
-import type { PeerProfile, ProfileCapability } from '../types/peer-profile.js';
-
-export interface ProfileSearchQuery {
-  capability?: ProfileCapability;
-  tags?: string[];
-  region?: string;
-  text?: string;
-}
-
-export interface ProfileSearchResult {
-  profile: PeerProfile;
-  relevanceScore: number;
-}
-
-/**
- * In-memory search index for cached peer profiles.
- */
-export class ProfileSearchIndex {
-  private profiles: Map<string, PeerProfile> = new Map();
-
-  addProfile(profile: PeerProfile): void {
-    this.profiles.set(profile.peerId, profile);
-  }
-
-  removeProfile(peerId: string): void {
-    this.profiles.delete(peerId);
-  }
-
-  getProfile(peerId: string): PeerProfile | null {
-    return this.profiles.get(peerId) ?? null;
-  }
-
-  getAllProfiles(): PeerProfile[] {
-    return Array.from(this.profiles.values());
-  }
-
-  /**
-   * Search profiles with relevance scoring.
-   */
-  search(query: ProfileSearchQuery): ProfileSearchResult[] {
-    const results: ProfileSearchResult[] = [];
-
-    for (const profile of this.profiles.values()) {
-      let score = 0;
-
-      // Filter by capability (hard filter)
-      if (query.capability) {
-        if (!profile.capabilities.includes(query.capability)) continue;
-        score += 10;
-      }
-
-      // Filter by region (boost score)
-      if (query.region) {
-        if (profile.region.toLowerCase() === query.region.toLowerCase()) {
-          score += 5;
-        }
-      }
-
-      // Tag matching (boost score)
-      if (query.tags && query.tags.length > 0) {
-        const profileTags = new Set(profile.tags.map(t => t.toLowerCase()));
-        let tagMatches = 0;
-        for (const tag of query.tags) {
-          if (profileTags.has(tag.toLowerCase())) {
-            tagMatches++;
-          }
-        }
-        if (tagMatches > 0) {
-          score += tagMatches * 3;
-        }
-      }
-
-      // Text search in name and description
-      if (query.text) {
-        const text = query.text.toLowerCase();
-        if (profile.displayName.toLowerCase().includes(text)) {
-          score += 8;
-        }
-        if (profile.description.toLowerCase().includes(text)) {
-          score += 4;
-        }
-        if (profile.tags.some(t => t.toLowerCase().includes(text))) {
-          score += 2;
-        }
-      }
-
-      if (score > 0) {
-        results.push({ profile, relevanceScore: score });
-      }
-    }
-
-    // Sort by relevance (descending)
-    results.sort((a, b) => b.relevanceScore - a.relevanceScore);
-    return results;
-  }
-
-  get size(): number {
-    return this.profiles.size;
-  }
-}

package/src/discovery/reputation-verifier.ts

@@ -1,54 +0,0 @@
-import type { BaseEscrowClient } from "../payments/evm/escrow-client.js";
-import type { PeerMetadata } from "./peer-metadata.js";
-
-export interface ReputationVerification {
-  /** Whether the claimed reputation matches on-chain data. */
-  valid: boolean;
-  /** The actual on-chain reputation score (weighted average). */
-  actualReputation: number;
-  /** The actual on-chain session count. */
-  actualSessionCount: number;
-  /** The actual on-chain dispute count. */
-  actualDisputeCount: number;
-  /** The claimed on-chain reputation score from metadata. */
-  claimedReputation?: number;
-  /** The claimed on-chain session count from metadata. */
-  claimedSessionCount?: number;
-  /** The claimed on-chain dispute count from metadata. */
-  claimedDisputeCount?: number;
-}
-
-/**
- * Verify a peer's claimed on-chain reputation against the Base contract.
- * Queries the escrow contract using the peer's evmAddress and compares
- * claimed vs actual reputation values.
- */
-export async function verifyReputation(
-  escrowClient: BaseEscrowClient,
-  metadata: PeerMetadata,
-): Promise<ReputationVerification> {
-  if (!metadata.evmAddress) {
-    throw new Error("Metadata does not contain an evmAddress");
-  }
-
-  const reputation = await escrowClient.getReputation(metadata.evmAddress);
-
-  const actualReputation = reputation.weightedAverage;
-  const actualSessionCount = reputation.sessionCount;
-  const actualDisputeCount = reputation.disputeCount;
-
-  const valid =
-    metadata.onChainReputation === actualReputation &&
-    metadata.onChainSessionCount === actualSessionCount &&
-    metadata.onChainDisputeCount === actualDisputeCount;
-
-  return {
-    valid,
-    actualReputation,
-    actualSessionCount,
-    actualDisputeCount,
-    claimedReputation: metadata.onChainReputation,
-    claimedSessionCount: metadata.onChainSessionCount,
-    claimedDisputeCount: metadata.onChainDisputeCount,
-  };
-}

package/src/index.ts

@@ -1,61 +0,0 @@
-// Main facade
-export { AntseedNode, type NodeConfig, type BuyerPaymentConfig, type NodePaymentsConfig } from './node.js';
-export type { Provider, TaskRequest, TaskEvent, SkillRequest, SkillResponse } from './interfaces/seller-provider.js';
-export type { Router } from './interfaces/buyer-router.js';
-
-// Types (re-export everything)
-export * from './types/index.js';
-
-// Submodule re-exports (commonly used)
-export { loadOrCreateIdentity, type Identity } from './p2p/identity.js';
-export { DHTNode, DEFAULT_DHT_CONFIG } from './discovery/dht-node.js';
-export { OFFICIAL_BOOTSTRAP_NODES, mergeBootstrapNodes, toBootstrapConfig } from './discovery/bootstrap.js';
-export { type PeerMetadata, type ProviderAnnouncement } from './discovery/peer-metadata.js';
-export { MetadataServer, type MetadataServerConfig } from './discovery/metadata-server.js';
-export { MeteringStorage } from './metering/storage.js';
-export { BalanceManager } from './payments/balance-manager.js';
-export { BaseEscrowClient, type BaseEscrowConfig } from './payments/evm/escrow-client.js';
-export { identityToEvmWallet, identityToEvmAddress } from './payments/evm/keypair.js';
-export { NatTraversal, type NatMapping, type NatTraversalResult } from './p2p/nat-traversal.js';
-export { BuyerPaymentManager } from './payments/buyer-payment-manager.js';
-export type { BuyerSessionState, BuyerSessionStatus } from './payments/buyer-payment-manager.js';
-export { ProxyMux } from './proxy/proxy-mux.js';
-export { resolveProvider } from './proxy/provider-detection.js';
-export { DefaultRouter, type DefaultRouterConfig } from './routing/default-router.js';
-
-export type { AntseedPlugin, AntseedProviderPlugin, AntseedRouterPlugin, PluginConfigKey, ConfigField } from './interfaces/plugin.js'
-export { ProfileManager } from './discovery/profile-manager.js';
-export type { PeerProfile, ProfileCapability } from './types/peer-profile.js';
-
-// Reputation
-export { TrustScoreEngine } from './reputation/trust-engine.js';
-export { UptimeTracker } from './reputation/uptime-tracker.js';
-export { computeTrustScore, DEFAULT_TRUST_WEIGHTS } from './reputation/trust-score.js';
-export type { TrustScore, TrustComponents } from './reputation/trust-score.js';
-export type { UptimeWindow, PeerUptimeRecord } from './reputation/uptime-tracker.js';
-export { ReportManager } from './reputation/report-manager.js';
-export type { PeerReport, ReportReason, ReportEvidence, ReportStatus } from './types/report.js';
-export { RatingManager } from './reputation/rating-manager.js';
-export type { PeerRating, RatingDimension, AggregateRating } from './types/rating.js';
-
-// Profile search
-export { ProfileSearchIndex } from './discovery/profile-search.js';
-export type { ProfileSearchQuery, ProfileSearchResult } from './discovery/profile-search.js';
-
-// Plugin config & loading
-export { encryptValue, decryptValue, deriveMachineKey, generateSalt } from './config/encryption.js'
-export {
-  loadPluginConfig,
-  savePluginConfig,
-  addInstance,
-  removeInstance,
-  getInstance,
-  getInstances,
-  updateInstanceConfig,
-} from './config/plugin-config-manager.js'
-export {
-  loadPluginModule,
-  loadAllPlugins,
-  type LoadedProvider,
-  type LoadedRouter,
-} from './config/plugin-loader.js'

package/src/interfaces/buyer-router.ts

@@ -1,21 +0,0 @@
-import type { PeerInfo } from '../types/peer.js';
-import type { SerializedHttpRequest } from '../types/http.js';
-
-/**
- * Interface that buyer nodes implement for peer selection.
- *
- * The SDK discovers available sellers via DHT. Your router decides
- * which seller to send each request to based on price, latency,
- * reputation, capacity, or any custom logic.
- *
- * If you don't provide a router, the SDK uses a default that selects
- * the cheapest peer with reputation above a minimum threshold.
- */
-export interface Router {
-  selectPeer(req: SerializedHttpRequest, peers: PeerInfo[]): PeerInfo | null;
-  onResult(peer: PeerInfo, result: {
-    success: boolean;
-    latencyMs: number;
-    tokens: number;
-  }): void;
-}

package/src/interfaces/plugin.ts

@@ -1,36 +0,0 @@
-import type { Provider } from './seller-provider.js'
-import type { Router } from './buyer-router.js'
-
-export interface ConfigField {
-  key: string
-  label: string
-  type: 'string' | 'number' | 'boolean' | 'secret' | 'string[]'
-  required?: boolean
-  default?: unknown
-  description?: string
-}
-
-/** @deprecated Use ConfigField instead */
-export type PluginConfigKey = ConfigField
-
-export interface AntseedPluginBase {
-  name: string
-  displayName: string
-  version: string
-  description: string
-  configSchema?: ConfigField[]
-  /** @deprecated Use configSchema instead */
-  configKeys?: ConfigField[]
-}
-
-export interface AntseedProviderPlugin extends AntseedPluginBase {
-  type: 'provider'
-  createProvider(config: Record<string, string>): Provider | Promise<Provider>
-}
-
-export interface AntseedRouterPlugin extends AntseedPluginBase {
-  type: 'router'
-  createRouter(config: Record<string, string>): Router | Promise<Router>
-}
-
-export type AntseedPlugin = AntseedProviderPlugin | AntseedRouterPlugin