@0xopenseeddev/seller 1.0.0

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@0xopenseeddev/seller",
+  "version": "1.0.0",
+  "description": "Seller node — serves AI inference and accepts payments",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "dev": "node --watch src/index.js",
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "@0xopenseeddev/shared": "*",
+    "@fastify/cors": "^10.0.1",
+    "fastify": "^5.2.1",
+    "undici": "^7.3.0",
+    "viem": "^2.21.19"
+  },
+  "keywords": [],
+  "license": "ISC"
+}

package/src/config.js

@@ -0,0 +1,47 @@
+// ─── Seller node configuration ────────────────────────────────────────────────
+// All values can be overridden via environment variables.
+
+export function loadConfig() {
+  return {
+    // This node's unique identifier (use a real hex key in production)
+    peerId: process.env.PEER_ID ?? 'seller-dev-node-0000000000000000000000000000000000000001',
+
+    merchantAddress: process.env.MERCHANT_ADDRESS ?? '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+
+    // Port this Fastify server listens on
+    port: Number(process.env.SELLER_PORT ?? 8378),
+
+    // Public-facing URL (what the registry tells buyers to connect to)
+    endpoint: process.env.SELLER_ENDPOINT ?? 'http://127.0.0.1:8378',
+
+    // Registry base URL
+    registryUrl: process.env.REGISTRY_URL ?? 'http://localhost:9000',
+
+    // How often (ms) to send a heartbeat to the registry
+    heartbeatIntervalMs: 30_000,
+
+    // Upstream API settings
+    upstream: {
+      // "openai" | "anthropic" | "ollama"
+      plugin: process.env.UPSTREAM_PLUGIN || 'openai',
+      baseUrl: process.env.UPSTREAM_BASE_URL || 'https://openrouter.ai/api',
+      apiKey: process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || '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'
+    },
+
+    // Offerings this node advertises
+    offerings: process.env.OFFERINGS ? JSON.parse(process.env.OFFERINGS) : [
+      {
+        capability: 'inference',
+        name: 'GPT-4o Mini',
+        description: 'Fast, affordable model for everyday tasks. Hosted via OpenRouter.',
+        services: ['gpt-4o-mini'],
+        pricing: {
+          inputUsdPerMillion: 0.15,
+          cachedInputUsdPerMillion: 0.075,
+          outputUsdPerMillion: 0.60
+        },
+        upstreamModel: 'openai/gpt-4o-mini'
+      }
+    ]
+  };
+}

package/src/index.js

@@ -0,0 +1,223 @@
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import { loadConfig } from './config.js';
+import { RegistryClient } from './registry-client.js';
+import { UpstreamProxy } from './upstream-proxy.js';
+import { PaymentChannelManager } from './payment-channel.js';
+import { SellerRequestTracker } from './request-tracker.js';
+import { createSellerMetrics } from './metrics.js';
+
+const cfg       = loadConfig();
+const tracker   = new SellerRequestTracker();
+const { reg, m } = createSellerMetrics();
+const _startTime = Date.now();
+
+// ─── Build service map ────────────────────────────────────────────────────────
+const serviceMap = new Map();
+for (const offering of cfg.offerings) {
+  for (const serviceId of offering.services) {
+    serviceMap.set(serviceId, offering);
+  }
+}
+
+// ─── Upstream proxy ───────────────────────────────────────────────────────────
+const proxy = new UpstreamProxy(cfg.upstream, serviceMap);
+
+// ─── Payment channel manager ──────────────────────────────────────────────────
+const payments = new PaymentChannelManager({
+  privateKey:      process.env.SELLER_PRIVATE_KEY,
+  contractAddress: process.env.CONTRACT_ADDRESS,
+  chainName:       process.env.CHAIN_NAME ?? 'localhost',
+  rpcUrl:          process.env.RPC_URL    ?? 'http://127.0.0.1:8545'
+});
+
+if (payments.paymentsEnabled) {
+  // If the seller registered no explicit merchant address, advertise the on-chain account address.
+  if (!process.env.MERCHANT_ADDRESS) {
+    cfg.merchantAddress = payments.account.address;
+  } else if (cfg.merchantAddress.toLowerCase() !== payments.account.address.toLowerCase()) {
+    console.warn('[seller] MERCHANT_ADDRESS does not match SELLER_PRIVATE_KEY address. Using SELLER_PRIVATE_KEY address for on-chain settlement.');
+    cfg.merchantAddress = payments.account.address;
+  }
+}
+
+// ─── Fastify instance ─────────────────────────────────────────────────────────
+const app = Fastify({ logger: true });
+await app.register(cors, { origin: '*' });
+
+// ── GET /health ───────────────────────────────────────────────────────────────
+app.get('/health', async () => ({
+  status:          'ok',
+  peerId:          cfg.peerId,
+  offerings:       cfg.offerings.map(o => o.name),
+  paymentsEnabled: payments.paymentsEnabled,
+  ...tracker.summary()
+}));
+
+// ── GET /offerings ────────────────────────────────────────────────────────────
+app.get('/offerings', async () => ({ offerings: cfg.offerings }));
+
+// ── GET /metrics  (Prometheus) ────────────────────────────────────────────────
+app.get('/metrics', async (req, reply) => {
+  const s = tracker.summary();
+  m.uptimeSeconds.set({}, s.uptimeSeconds);
+  m.successRate.set({}, s.successRate);
+  m.uniqueBuyers.set({}, s.uniqueBuyers);
+  m.earnedUsdcTotal.set({}, Number(BigInt(s.totalEarnedUsdc)));
+
+  const payStatus = payments.status();
+  m.activeChannels.set({}, payStatus.channels.filter(c => c.status === 'open').length);
+  m.unsettledUsdcTotal.set({}, payStatus.channels.reduce((acc, c) => {
+    const match = c.pendingSettlement?.replace(' USDC', '');
+    return acc + (parseFloat(match ?? 0) * 1_000_000);
+  }, 0));
+
+  reply.header('content-type', 'text/plain; version=0.0.4; charset=utf-8');
+  return reply.send(reg.format());
+});
+
+// ── GET /stats ────────────────────────────────────────────────────────────────
+app.get('/stats', async () => tracker.summary());
+
+// ── Payment session routes ────────────────────────────────────────────────────
+app.post('/session/start', {
+  schema: {
+    body: {
+      type: 'object',
+      required: ['channelId', 'buyerAddress', 'sellerAddress', 'maxAmount', 'deadline', 'signature'],
+      properties: {
+        channelId:     { type: 'string' },
+        buyerAddress:  { type: 'string' },
+        sellerAddress: { type: 'string' },
+        maxAmount:     { type: 'string' },
+        deadline:      { type: 'string' },
+        signature:     { type: 'string' }
+      }
+    }
+  }
+}, async (req, reply) => {
+  try {
+    const result = await payments.handleReserveAuth({
+      ...req.body,
+      maxAmount: BigInt(req.body.maxAmount),
+      deadline:  BigInt(req.body.deadline)
+    });
+    return result;
+  } catch (err) {
+    return reply.status(400).send({ error: { code: 'reserve_failed', message: err.message } });
+  }
+});
+
+app.post('/session/close', {
+  schema: {
+    body: {
+      type: 'object',
+      required: ['channelId'],
+      properties: { channelId: { type: 'string' } }
+    }
+  }
+}, async (req) => {
+  await payments.closeChannel(req.body.channelId);
+  return { ok: true };
+});
+
+app.get('/payments/status', async () => payments.status());
+
+// ─── Inference request handler ────────────────────────────────────────────────
+async function handleInference(req, reply, upstreamPath) {
+  const serviceId    = req.body?.model;
+  const buyerAddress = req.headers['x-openseed-buyer-address'] ?? 'unknown';
+
+  if (!serviceId) {
+    return reply.status(400).send({ error: { code: 'missing_model', message: 'The "model" field is required.' } });
+  }
+
+  // ── Payment validation ────────────────────────────────────────────────────
+  const spendingAuth = req.headers['x-402-payment-auth'];
+  const channelId    = req.headers['x-402-channel-id'];
+
+  if (!spendingAuth || !channelId || !buyerAddress || buyerAddress === 'unknown') {
+    reply.header('x-402-payment-required', `price=1000000, to=${cfg.merchantAddress || cfg.peerId}`);
+    return reply.status(402).send({
+      error: {
+        code: 'payment_required',
+        message: 'Include x-402-payment-auth, x-402-channel-id, and x-openseed-buyer-address headers.'
+      }
+    });
+  }
+
+  if (payments.paymentsEnabled) {
+    try {
+      const parsed = JSON.parse(Buffer.from(spendingAuth, 'base64').toString('utf8'));
+      await payments.validateSpendingAuth({
+        channelId,
+        cumulativeAmount: BigInt(parsed.cumulativeAmount),
+        metadataHash:     parsed.metadataHash,
+        signature:        parsed.signature,
+        buyerAddress
+      });
+    } catch (err) {
+      return reply.status(402).send({ error: { code: 'invalid_spending_auth', message: err.message } });
+    }
+  }
+
+  const t0 = Date.now();
+  const isAnthropic = upstreamPath.includes('messages');
+
+  try {
+    // We need to capture the response to extract token counts before streaming
+    // For streaming responses we record with 0 tokens (good enough for metrics)
+    await proxy.forward(serviceId, isAnthropic ? 'anthropic' : 'openai', req.body, reply);
+
+    const latencyMs = Date.now() - t0;
+    tracker.record({ latencyMs, success: true, model: serviceId, buyerAddress });
+    m.requestsTotal.inc({ model: serviceId, status: '200' });
+    m.upstreamDurationMs.observe({ model: serviceId }, latencyMs);
+  } catch (err) {
+    const latencyMs = Date.now() - t0;
+    tracker.record({ latencyMs, success: false, model: serviceId, buyerAddress });
+    m.requestsTotal.inc({ model: serviceId, status: '502' });
+  }
+}
+
+app.post('/v1/chat/completions', (req, reply) => handleInference(req, reply, '/v1/chat/completions'));
+app.post('/v1/messages',         (req, reply) => handleInference(req, reply, '/v1/messages'));
+app.post('/v1/responses',        (req, reply) => handleInference(req, reply, '/v1/responses'));
+
+// ─── Registry client ──────────────────────────────────────────────────────────
+const registry = new RegistryClient(cfg.registryUrl, {
+  peerId:          cfg.peerId,
+  endpoint:        cfg.endpoint,
+  offerings:       cfg.offerings,
+  merchantAddress: cfg.merchantAddress
+});
+
+// ─── Start ────────────────────────────────────────────────────────────────────
+try {
+  await app.listen({ port: cfg.port, host: '0.0.0.0' });
+  console.log(`
+🐜 OpenSeed Seller  http://0.0.0.0:${cfg.port}
+   Peer ID  : ${cfg.peerId}
+   Offerings: ${cfg.offerings.map(o => o.name).join(', ')}
+   Payments : ${payments.paymentsEnabled ? 'enabled' : 'disabled'}
+
+  Observability:
+    GET  /metrics     (Prometheus)
+    GET  /stats       (JSON summary)
+    GET  /health      (liveness)
+`);
+  await registry.register();
+  registry.startHeartbeat(cfg.heartbeatIntervalMs);
+} catch (err) {
+  app.log.error(err);
+  process.exit(1);
+}
+
+async function shutdown() {
+  console.log('\n[seller] Shutting down…');
+  await registry.deregister();
+  await app.close();
+  process.exit(0);
+}
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/src/metrics.js

@@ -0,0 +1,72 @@
+/**
+ * Seller Prometheus metrics registry.
+ */
+
+import { PrometheusRegistry } from '@0xopenseeddev/shared';
+
+export function createSellerMetrics() {
+  const reg = new PrometheusRegistry();
+
+  const m = {
+    // ── Inference requests ───────────────────────────────────────────────────
+    requestsTotal: reg.counter(
+      'openseed_seller_requests_total',
+      'Total inference requests served',
+      ['model', 'status']
+    ),
+
+    upstreamDurationMs: reg.histogram(
+      'openseed_seller_upstream_duration_ms',
+      'Latency of upstream AI API calls in milliseconds',
+      [10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000],
+      ['model']
+    ),
+
+    // ── Tokens ───────────────────────────────────────────────────────────────
+    inputTokensTotal: reg.counter(
+      'openseed_seller_input_tokens_total',
+      'Total input tokens processed',
+      ['model']
+    ),
+
+    outputTokensTotal: reg.counter(
+      'openseed_seller_output_tokens_total',
+      'Total output tokens generated',
+      ['model']
+    ),
+
+    // ── Earnings ─────────────────────────────────────────────────────────────
+    earnedUsdcTotal: reg.gauge(
+      'openseed_seller_earned_usdc_total',
+      'Cumulative USDC earned (base units, 6 decimal)'
+    ),
+
+    unsettledUsdcTotal: reg.gauge(
+      'openseed_seller_unsettled_usdc_total',
+      'USDC earned but not yet settled on-chain'
+    ),
+
+    activeChannels: reg.gauge(
+      'openseed_seller_active_channels',
+      'Number of currently open payment channels'
+    ),
+
+    // ── Node health ───────────────────────────────────────────────────────────
+    uptimeSeconds: reg.gauge(
+      'openseed_seller_uptime_seconds',
+      'Seconds since the seller node started'
+    ),
+
+    uniqueBuyers: reg.gauge(
+      'openseed_seller_unique_buyers_total',
+      'Number of distinct buyer addresses seen'
+    ),
+
+    successRate: reg.gauge(
+      'openseed_seller_success_rate',
+      'Ratio of successful requests to total requests (0-1)'
+    )
+  };
+
+  return { reg, m };
+}

package/src/payment-channel.js

@@ -0,0 +1,277 @@
+/**
+ * Seller-side payment channel manager.
+ *
+ * Responsibilities:
+ *   1. Validate incoming SpendingAuth signatures from buyers
+ *   2. Track cumulative spend per channel in memory
+ *   3. Trigger on-chain settle() calls periodically or at thresholds
+ *   4. Call on-chain close() when a session ends
+ *
+ * The seller node is the on-chain actor:
+ *   - It submits reserve() when starting a session
+ *   - It submits settle() to collect earned USDC
+ *   - It submits close() when done
+ */
+
+import {
+  createWalletClient,
+  createPublicClient,
+  http,
+  parseAbi,
+  formatUnits
+} from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import {
+  recoverSpendingAuthSigner,
+  recoverReserveAuthSigner,
+  buildDomain,
+  parseUsdc,
+  formatUsdc,
+  getChain
+} from '@0xopenseeddev/shared';
+
+// ─── Minimal ABI for the AntseedDeposits contract ─────────────────────────────
+
+const DEPOSITS_ABI = parseAbi([
+  'function reserve(bytes32 channelId, address buyer, uint256 maxAmount, uint256 deadline, bytes calldata signature) external',
+  'function settle(bytes32 channelId, uint256 cumulativeAmount, bytes32 metadataHash, bytes calldata signature) external',
+  'function close(bytes32 channelId, uint256 cumulativeAmount, bytes32 metadataHash, bytes calldata signature) external',
+  'function channels(bytes32) external view returns (address buyer, address seller, uint256 maxAmount, uint256 settled, uint256 deadline, uint256 closeRequestedAt, bool closed)',
+  'event Settled(bytes32 indexed channelId, uint256 delta, uint256 cumulative)',
+  'event ChannelClosed(bytes32 indexed channelId, uint256 totalSettled)'
+]);
+
+export class PaymentChannelManager {
+  /**
+   * @param {object} opts
+   * @param {string} opts.privateKey         - seller's 0x-prefixed private key
+   * @param {string} opts.contractAddress    - AntseedDeposits contract address
+   * @param {string} opts.chainName          - 'base' | 'base-sepolia' | 'localhost'
+   * @param {string} opts.rpcUrl             - RPC endpoint for the chain
+   * @param {number} [opts.settleThresholdUsdc=0.05] - auto-settle when earned > this
+   * @param {number} [opts.settleIntervalMs=300_000]  - max interval between settles (5 min)
+   */
+  constructor({
+    privateKey,
+    contractAddress,
+    chainName = 'localhost',
+    rpcUrl    = 'http://127.0.0.1:8545',
+    settleThresholdUsdc  = 0.05,
+    settleIntervalMs     = 300_000
+  }) {
+    this.paymentsEnabled  = !!privateKey && !!contractAddress;
+    this.contractAddress  = contractAddress;
+    this.settleThreshold  = parseUsdc(settleThresholdUsdc);
+    this.settleIntervalMs = settleIntervalMs;
+
+    /** @type {Map<string, ChannelEntry>} channelId → state */
+    this._channels = new Map();
+
+    if (!this.paymentsEnabled) {
+      console.log('[payments] ⚠️  No SELLER_PRIVATE_KEY / CONTRACT_ADDRESS — running in no-payment mode.');
+      return;
+    }
+
+    const chain   = getChain(chainName);
+    const account = privateKeyToAccount(privateKey);
+    this.account  = account;
+    this._signerOpts = { contractAddress, chainId: chain.id };
+
+    this._walletClient = createWalletClient({
+      account,
+      chain,
+      transport: http(rpcUrl)
+    });
+    this._publicClient = createPublicClient({
+      chain,
+      transport: http(rpcUrl)
+    });
+
+    console.log(`[payments] Seller wallet: ${account.address}`);
+    console.log(`[payments] Contract:      ${contractAddress}`);
+    console.log(`[payments] Chain:         ${chainName} (${chain.id})`);
+  }
+
+  // ─── Session initiation ────────────────────────────────────────────────────
+
+  /**
+   * Process a ReserveAuth from a buyer.
+   * Validates the signature, calls reserve() on-chain, opens local state.
+   *
+   * @param {{ channelId, buyerAddress, sellerAddress, maxAmount, deadline, signature }} params
+   */
+  async handleReserveAuth({ channelId, buyerAddress, sellerAddress, maxAmount, deadline, signature }) {
+    if (!this.paymentsEnabled) {
+      // In no-payment mode, just trust the buyer and open a dummy channel
+      this._openChannel(channelId, buyerAddress, maxAmount);
+      return { ok: true, channelId, mode: 'no-payment' };
+    }
+
+    // 1. Verify signature off-chain first (free gas check)
+    const recovered = await recoverReserveAuthSigner(this._signerOpts, {
+      channelId,
+      buyer:    buyerAddress,
+      seller:   sellerAddress,
+      maxAmount: BigInt(maxAmount),
+      deadline:  BigInt(deadline)
+    }, signature);
+
+    if (recovered.toLowerCase() !== buyerAddress.toLowerCase()) {
+      throw new Error('ReserveAuth: invalid buyer signature');
+    }
+
+    // 2. Submit reserve() on-chain
+    try {
+      const txHash = await this._walletClient.writeContract({
+        address:      this.contractAddress,
+        abi:          DEPOSITS_ABI,
+        functionName: 'reserve',
+        args:         [channelId, buyerAddress, BigInt(maxAmount), BigInt(deadline), signature]
+      });
+      await this._publicClient.waitForTransactionReceipt({ hash: txHash });
+      console.log(`[payments] ✅ reserve() confirmed: ${txHash}`);
+    } catch (err) {
+      throw new Error(`reserve() failed: ${err.shortMessage ?? err.message}`);
+    }
+
+    this._openChannel(channelId, buyerAddress, BigInt(maxAmount));
+    return { ok: true, channelId };
+  }
+
+  // ─── Per-request payment validation ───────────────────────────────────────
+
+  /**
+   * Validate an inbound SpendingAuth header from the buyer.
+   * Returns the verified spend or throws.
+   *
+   * @param {{ channelId, cumulativeAmount, metadataHash, signature, buyerAddress }} params
+   * @returns {{ delta: bigint }} USDC earned since last recorded spend
+   */
+  async validateSpendingAuth({ channelId, cumulativeAmount, metadataHash, signature, buyerAddress }) {
+    if (!this.paymentsEnabled) return { delta: 0n };
+
+    const recovered = await recoverSpendingAuthSigner(this._signerOpts, {
+      channelId,
+      cumulativeAmount: BigInt(cumulativeAmount),
+      metadataHash
+    }, signature);
+
+    if (recovered.toLowerCase() !== buyerAddress.toLowerCase()) {
+      throw new Error('SpendingAuth: invalid buyer signature');
+    }
+
+    const ch = this._channels.get(channelId);
+    if (!ch) throw new Error('No open channel for this channelId');
+
+    const newAmount = BigInt(cumulativeAmount);
+    if (newAmount <= ch.lastValidatedCumulative) {
+      throw new Error('SpendingAuth: stale — cumulativeAmount did not increase');
+    }
+    if (newAmount > ch.maxAmount) {
+      throw new Error('SpendingAuth: exceeds channel maxAmount');
+    }
+
+    const delta = newAmount - ch.lastValidatedCumulative;
+    ch.pendingCumulative      = newAmount;
+    ch.pendingMetadataHash    = metadataHash;
+    ch.pendingSignature       = signature;
+    ch.lastValidatedCumulative = newAmount;
+    ch.earnedUnsettled        += delta;
+
+    // Immediately settle on-chain after a valid SpendingAuth.
+    // This ensures seller-side transfer occurs promptly rather than waiting
+    // for an arbitrary threshold or channel close.
+    try {
+      await this._triggerSettle(channelId);
+    } catch (err) {
+      console.error('[payments] settle() failed after SpendingAuth:', err.message);
+    }
+
+    return { delta };
+  }
+
+  // ─── On-chain settlement ───────────────────────────────────────────────────
+
+  async _triggerSettle(channelId) {
+    const ch = this._channels.get(channelId);
+    if (!ch || ch.status !== 'open') return;
+    if (!ch.pendingSignature) return;
+
+    console.log(`[payments] Settling ${formatUsdc(ch.earnedUnsettled)} USDC for channel ${channelId.slice(0, 18)}…`);
+    try {
+      const txHash = await this._walletClient.writeContract({
+        address:      this.contractAddress,
+        abi:          DEPOSITS_ABI,
+        functionName: 'settle',
+        args:         [channelId, ch.pendingCumulative, ch.pendingMetadataHash, ch.pendingSignature]
+      });
+      await this._publicClient.waitForTransactionReceipt({ hash: txHash });
+      ch.settledCumulative = ch.pendingCumulative;
+      ch.earnedUnsettled   = 0n;
+      console.log(`[payments] ✅ settle() confirmed: ${txHash}`);
+    } catch (err) {
+      console.error('[payments] settle() failed:', err.shortMessage ?? err.message);
+    }
+  }
+
+  /**
+   * Close the channel on-chain and release unspent buyer funds.
+   */
+  async closeChannel(channelId) {
+    const ch = this._channels.get(channelId);
+    if (!ch) return;
+
+    if (this.paymentsEnabled && ch.pendingSignature) {
+      console.log(`[payments] Closing channel ${channelId.slice(0, 18)}…`);
+      try {
+        const txHash = await this._walletClient.writeContract({
+          address:      this.contractAddress,
+          abi:          DEPOSITS_ABI,
+          functionName: 'close',
+          args:         [channelId, ch.pendingCumulative, ch.pendingMetadataHash, ch.pendingSignature]
+        });
+        await this._publicClient.waitForTransactionReceipt({ hash: txHash });
+        console.log(`[payments] ✅ close() confirmed: ${txHash}`);
+      } catch (err) {
+        console.error('[payments] close() failed:', err.shortMessage ?? err.message);
+      }
+    }
+
+    ch.status   = 'closed';
+    ch.closedAt = Date.now();
+  }
+
+  // ─── Internal helpers ──────────────────────────────────────────────────────
+
+  _openChannel(channelId, buyerAddress, maxAmount) {
+    this._channels.set(channelId, {
+      channelId,
+      buyerAddress,
+      maxAmount,
+      status:                  'open',
+      openedAt:                Date.now(),
+      lastValidatedCumulative: 0n,
+      pendingCumulative:       0n,
+      pendingMetadataHash:     null,
+      pendingSignature:        null,
+      settledCumulative:       0n,
+      earnedUnsettled:         0n
+    });
+    console.log(`[payments] Opened channel ${channelId.slice(0, 18)}… | max: ${formatUsdc(maxAmount)} USDC`);
+  }
+
+  // ─── Status / metrics ──────────────────────────────────────────────────────
+
+  status() {
+    const channels = [...this._channels.values()].map(ch => ({
+      channelId:         ch.channelId,
+      buyerAddress:      ch.buyerAddress,
+      status:            ch.status,
+      maxAmount:         formatUsdc(ch.maxAmount) + ' USDC',
+      settled:           formatUsdc(ch.settledCumulative) + ' USDC',
+      pendingSettlement: formatUsdc(ch.earnedUnsettled) + ' USDC',
+      openedAt:          new Date(ch.openedAt).toISOString()
+    }));
+    return { paymentsEnabled: this.paymentsEnabled, channels };
+  }
+}

package/src/registry-client.js

@@ -0,0 +1,60 @@
+import { fetch } from 'undici';
+
+/**
+ * Registry client used by the seller node.
+ * Handles registration, heartbeating, and graceful deregistration.
+ */
+export class RegistryClient {
+  /**
+   * @param {string} registryUrl
+   * @param {{ peerId: string, endpoint: string, services: any[] }} nodeInfo
+   */
+  constructor(registryUrl, nodeInfo) {
+    this.registryUrl = registryUrl;
+    this.nodeInfo    = nodeInfo;
+    this._timer      = null;
+  }
+
+  async register() {
+    const res = await fetch(`${this.registryUrl}/peers/register`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(this.nodeInfo)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Registry registration failed: ${res.status} ${text}`);
+    }
+    console.log(`[seller] ✅ Registered with registry as ${this.nodeInfo.peerId.slice(0, 16)}…`);
+  }
+
+  startHeartbeat(intervalMs = 30_000) {
+    this._timer = setInterval(async () => {
+      try {
+        const res = await fetch(`${this.registryUrl}/peers/heartbeat`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ peerId: this.nodeInfo.peerId })
+        });
+        if (!res.ok) {
+          console.warn('[seller] ⚠️  Heartbeat rejected — re-registering…');
+          await this.register();
+        }
+      } catch (err) {
+        console.error('[seller] ❌ Heartbeat error:', err.message);
+      }
+    }, intervalMs);
+  }
+
+  async deregister() {
+    clearInterval(this._timer);
+    try {
+      await fetch(`${this.registryUrl}/peers/${this.nodeInfo.peerId}`, {
+        method: 'DELETE'
+      });
+      console.log('[seller] 👋 Deregistered from registry.');
+    } catch {
+      // best-effort
+    }
+  }
+}

package/src/request-tracker.js

@@ -0,0 +1,72 @@
+/**
+ * Seller-side request tracker.
+ * Tracks requests served, upstream latency, token counts, and earnings.
+ */
+
+export class SellerRequestTracker {
+  constructor() {
+    this._start = Date.now();
+    this.totalRequests      = 0;
+    this.successfulRequests = 0;
+    this.failedRequests     = 0;
+    this.totalInputTokens   = 0;
+    this.totalOutputTokens  = 0;
+    this.totalEarnedUsdc    = 0n;
+    this.latencySamples     = []; // rolling 100
+    this.requestsByModel    = new Map(); // model → count
+    this.requestsByBuyer    = new Map(); // buyerAddr → count
+  }
+
+  /**
+   * @param {object} opts
+   * @param {number}  opts.latencyMs
+   * @param {boolean} opts.success
+   * @param {number}  [opts.inputTokens]
+   * @param {number}  [opts.outputTokens]
+   * @param {bigint}  [opts.earnedUsdc]
+   * @param {string}  [opts.model]
+   * @param {string}  [opts.buyerAddress]
+   */
+  record({ latencyMs, success, inputTokens = 0, outputTokens = 0, earnedUsdc = 0n, model = 'unknown', buyerAddress = 'unknown' }) {
+    this.totalRequests++;
+    success ? this.successfulRequests++ : this.failedRequests++;
+
+    this.latencySamples.push(latencyMs);
+    if (this.latencySamples.length > 100) this.latencySamples.shift();
+
+    this.totalInputTokens  += inputTokens;
+    this.totalOutputTokens += outputTokens;
+    this.totalEarnedUsdc   += earnedUsdc;
+
+    this.requestsByModel.set(model, (this.requestsByModel.get(model) ?? 0) + 1);
+    this.requestsByBuyer.set(buyerAddress, (this.requestsByBuyer.get(buyerAddress) ?? 0) + 1);
+  }
+
+  summary() {
+    const sorted  = [...this.latencySamples].sort((a, b) => a - b);
+    const p50 = pct(sorted, 50);
+    const p95 = pct(sorted, 95);
+    const p99 = pct(sorted, 99);
+
+    return {
+      uptimeSeconds:      Math.floor((Date.now() - this._start) / 1000),
+      totalRequests:      this.totalRequests,
+      successfulRequests: this.successfulRequests,
+      failedRequests:     this.failedRequests,
+      successRate:        this.totalRequests > 0
+        ? +((this.successfulRequests / this.totalRequests).toFixed(4))
+        : 1,
+      latency:            { p50, p95, p99, sampleCount: sorted.length },
+      totalInputTokens:   this.totalInputTokens,
+      totalOutputTokens:  this.totalOutputTokens,
+      totalEarnedUsdc:    this.totalEarnedUsdc.toString(),
+      requestsByModel:    Object.fromEntries(this.requestsByModel),
+      uniqueBuyers:       this.requestsByBuyer.size
+    };
+  }
+}
+
+function pct(sorted, p) {
+  if (!sorted.length) return 0;
+  return +(sorted[Math.max(0, Math.ceil((p / 100) * sorted.length) - 1)] ?? 0).toFixed(1);
+}

package/src/upstream-proxy.js

@@ -0,0 +1,88 @@
+import { fetch } from 'undici';
+
+/**
+ * Upstream proxy — forwards inference requests to the configured
+ * AI API (OpenAI-compatible or Anthropic) and streams the response back.
+ */
+export class UpstreamProxy {
+  /**
+   * @param {{ plugin: string, baseUrl: string, apiKey: string }} upstream
+   * @param {Map<string, any>} serviceMap  - serviceId → ServiceDefinition
+   */
+  constructor(upstream, serviceMap) {
+    this.upstream   = upstream;
+    this.serviceMap = serviceMap;
+  }
+
+  /**
+   * Resolve the correct upstream path and headers for the given format.
+   * @param {'openai'|'anthropic'} format
+   * @returns {{ path: string, headers: Record<string,string> }}
+   */
+  _resolveTarget(format) {
+    if (format === 'anthropic') {
+      return {
+        path: '/v1/messages',
+        headers: {
+          'x-api-key': this.upstream.apiKey,
+          'anthropic-version': '2023-06-01',
+          'content-type': 'application/json'
+        }
+      };
+    }
+    // default: openai-compatible
+    return {
+      path: '/v1/chat/completions',
+      headers: {
+        'authorization': `Bearer ${this.upstream.apiKey}`,
+        'content-type': 'application/json'
+      }
+    };
+  }
+
+  /**
+   * Forward a parsed request body to the upstream API and pipe the
+   * raw response back through the Fastify reply (supports streaming).
+   *
+   * @param {string}  serviceId - buyer-requested model / service name
+   * @param {string}  format    - 'openai' | 'anthropic'
+   * @param {object}  body      - parsed JSON body from the buyer
+   * @param {import('fastify').FastifyReply} reply
+   */
+  async forward(serviceId, format, body, reply) {
+    const service = this.serviceMap.get(serviceId);
+    if (!service) {
+      return reply.status(404).send({
+        error: { code: 'service_not_found', message: `Service "${serviceId}" is not offered by this node.` }
+      });
+    }
+
+    // Rewrite the model field to the upstream model name and set a safe max_tokens default
+    const upstreamBody = { max_tokens: 1000, ...body, model: service.upstreamModel };
+    const { path, headers } = this._resolveTarget(format);
+    const url = `${this.upstream.baseUrl}${path}`;
+
+    try {
+      const upstreamRes = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(upstreamBody)
+      });
+
+      // Mirror status and content-type
+      reply.status(upstreamRes.status);
+      const ct = upstreamRes.headers.get('content-type') ?? 'application/json';
+      reply.header('content-type', ct);
+
+      // Stream the body straight through
+      if (upstreamRes.body) {
+        return reply.send(upstreamRes.body);
+      }
+      return reply.send(await upstreamRes.text());
+    } catch (err) {
+      return reply.status(502).send({
+        error: { code: 'upstream_error', message: err.message }
+      });
+    }
+  }
+}