technocore-compute 0.1.0

package/src/types.ts

@@ -0,0 +1,124 @@
+/**
+ * Types for the Technocore Compute Exchange
+ *
+ * Agents can offer compute resources and other agents can rent them,
+ * with payments handled via tclk HTLC/PTLC.
+ */
+
+/** Compute hardware type */
+export type ComputeType = 'gpu' | 'cpu' | 'tpu' | 'npu' | 'any';
+
+/** Job status */
+export type JobStatus =
+  | 'listed'       // Provider advertised compute
+  | 'requested'    // Consumer wants compute
+  | 'matched'      // Provider accepted the request
+  | 'locked'       // Payment locked via tclk
+  | 'running'      // Compute job is executing
+  | 'completed'    // Job finished successfully
+  | 'failed'       // Job failed
+  | 'refunded';    // Payment refunded
+
+/** Provider advertising compute resources */
+export interface ComputeProvider {
+  /** Provider DID */
+  did: string;
+  /** Display name */
+  name: string;
+  /** Hardware available */
+  hardware: ComputeType;
+  /** GPU model if GPU (e.g. "A100", "H100", "RTX4090") */
+  gpuModel?: string;
+  /** VRAM in GB */
+  vramGB?: number;
+  /** CPU cores */
+  cpuCores?: number;
+  /** RAM in GB */
+  ramGB?: number;
+  /** Storage in GB */
+  storageGB?: number;
+  /** Price per hour in smallest FLOP unit */
+  pricePerHour: string;
+  /** Minimum job duration in seconds */
+  minDurationSec: number;
+  /** Maximum job duration in seconds */
+  maxDurationSec: number;
+  /** Available now */
+  available: boolean;
+  /** Average rating (0-5) */
+  rating: number;
+  /** Total jobs completed */
+  jobsCompleted: number;
+  /** technocore room for coordination */
+  room: string;
+  /** When this was registered */
+  registeredAt: number;
+  /** Last heartbeat */
+  lastHeartbeat: number;
+}
+
+/** Consumer requesting compute */
+export interface ComputeRequest {
+  /** Request ID */
+  id: string;
+  /** Consumer DID */
+  consumerDid: string;
+  /** Hardware needed */
+  hardware: ComputeType;
+  /** Minimum GPU model */
+  minGpuModel?: string;
+  /** Minimum VRAM needed */
+  minVramGB?: number;
+  /** Minimum CPU cores */
+  minCpuCores?: number;
+  /** Minimum RAM needed */
+  minRamGB?: number;
+  /** Duration needed in seconds */
+  durationSec: number;
+  /** Max price willing to pay */
+  maxPricePerHour: string;
+  /** Job description */
+  description: string;
+  /** When requested */
+  createdAt: number;
+  /** Expiry timestamp */
+  expiresAt: number;
+}
+
+/** Matched job between provider and consumer */
+export interface ComputeJob {
+  /** Job ID */
+  id: string;
+  /** Provider DID */
+  providerDid: string;
+  /** Consumer DID */
+  consumerDid: string;
+  /** Matched request */
+  request: ComputeRequest;
+  /** Provider used */
+  provider: ComputeProvider;
+  /** Current status */
+  status: JobStatus;
+  /** tclk contract ID for payment */
+  tclkContractId?: string;
+  /** Total cost */
+  totalCost: string;
+  /** Room where deal is coordinated */
+  room: string;
+  /** Created timestamp */
+  createdAt: number;
+  /** Started timestamp */
+  startedAt?: number;
+  /** Completed timestamp */
+  completedAt?: number;
+}
+
+/** Compute exchange stats */
+export interface ExchangeStats {
+  totalProviders: number;
+  availableProviders: number;
+  totalJobs: number;
+  activeJobs: number;
+  completedJobs: number;
+  totalVolume: string;
+}

package/test/exchange.test.ts

@@ -0,0 +1,218 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { ComputeExchange } from '../src/exchange.js';
+
+const SAMPLE_PROVIDER = {
+  did: 'did:key:z6MkTestProvider1234567890123456789012345678',
+  name: 'GPU Farm',
+  hardware: 'gpu' as const,
+  gpuModel: 'A100',
+  vramGB: 80,
+  pricePerHour: '5000000',
+  minDurationSec: 300,
+  maxDurationSec: 86400,
+  available: true,
+  rating: 4.8,
+  jobsCompleted: 42,
+  room: 'compute-gpu',
+  registeredAt: Date.now(),
+  lastHeartbeat: Date.now(),
+};
+
+const SAMPLE_REQUEST = {
+  consumerDid: 'did:key:z6MkTestConsumer12345678901234567890123456',
+  hardware: 'gpu' as const,
+  minVramGB: 24,
+  durationSec: 3600,
+  maxPricePerHour: '10000000',
+  description: 'Train a small model',
+};
+
+describe('ComputeExchange', () => {
+  describe('providers', () => {
+    it('registers a provider', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider(SAMPLE_PROVIDER);
+      const providers = exchange.listProviders();
+      assert.strictEqual(providers.length, 1);
+      assert.strictEqual(providers[0].did, SAMPLE_PROVIDER.did);
+    });
+
+    it('finds providers by hardware type', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, hardware: 'gpu' });
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, did: 'did:key:z6MkCpu123', hardware: 'cpu', cpuCores: 64, ramGB: 128 });
+
+      const gpuProviders = exchange.findProviders({ hardware: 'gpu' });
+      assert.strictEqual(gpuProviders.length, 1);
+      assert.strictEqual(gpuProviders[0].hardware, 'gpu');
+    });
+
+    it('finds providers by VRAM', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, vramGB: 16 });
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, did: 'did:key:z6MkBig123', vramGB: 80 });
+
+      const providers = exchange.findProviders({ hardware: 'gpu', minVramGB: 24 });
+      assert.strictEqual(providers.length, 1);
+      assert.strictEqual(providers[0].vramGB, 80);
+    });
+
+    it('finds providers by max price', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, pricePerHour: '5000000' });
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, did: 'did:key:z6MkExp123', pricePerHour: '50000000' });
+
+      const providers = exchange.findProviders({ maxPricePerHour: '10000000' });
+      assert.strictEqual(providers.length, 1);
+      assert.strictEqual(providers[0].pricePerHour, '5000000');
+    });
+
+    it('skips unavailable providers', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, available: false });
+
+      const providers = exchange.findProviders({ hardware: 'gpu' });
+      assert.strictEqual(providers.length, 0);
+    });
+
+    it('updates heartbeat', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, available: false });
+      exchange.heartbeat(SAMPLE_PROVIDER.did);
+
+      const provider = exchange.getProvider(SAMPLE_PROVIDER.did);
+      assert(provider?.available);
+    });
+
+    it('prunes stale providers', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider({
+        ...SAMPLE_PROVIDER,
+        lastHeartbeat: Date.now() - 600_000, // 10 minutes ago
+      });
+      exchange.registerProvider({
+        ...SAMPLE_PROVIDER,
+        did: 'did:key:z6MkFresh1234567890123456789012345678',
+        lastHeartbeat: Date.now(),
+      });
+
+      const pruned = exchange.pruneStaleProviders(300_000);
+      assert.strictEqual(pruned, 1);
+      assert.strictEqual(exchange.listProviders().length, 1);
+    });
+  });
+
+  describe('requests', () => {
+    it('creates a request', () => {
+      const exchange = new ComputeExchange();
+      const request = exchange.createRequest(SAMPLE_REQUEST);
+      assert(request.id.startsWith('req-'));
+      assert.strictEqual(request.consumerDid, SAMPLE_REQUEST.consumerDid);
+    });
+
+    it('lists pending requests', () => {
+      const exchange = new ComputeExchange();
+      exchange.createRequest(SAMPLE_REQUEST);
+      const pending = exchange.listPendingRequests();
+      assert.strictEqual(pending.length, 1);
+    });
+
+    it('prunes expired requests', () => {
+      const exchange = new ComputeExchange();
+      exchange.createRequest({ ...SAMPLE_REQUEST, durationSec: -1 }); // Already expired
+      const pruned = exchange.pruneExpiredRequests();
+      assert.strictEqual(pruned, 1);
+    });
+  });
+
+  describe('jobs', () => {
+    it('matches a request with a provider', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider(SAMPLE_PROVIDER);
+      const request = exchange.createRequest(SAMPLE_REQUEST);
+      const job = exchange.matchRequest(request.id);
+
+      assert(job !== null);
+      assert.strictEqual(job!.providerDid, SAMPLE_PROVIDER.did);
+      assert.strictEqual(job!.consumerDid, SAMPLE_REQUEST.consumerDid);
+      assert.strictEqual(job!.status, 'matched');
+    });
+
+    it('returns null when no provider matches', () => {
+      const exchange = new ComputeExchange();
+      const request = exchange.createRequest({
+        ...SAMPLE_REQUEST,
+        hardware: 'tpu', // No TPU providers
+      });
+      const job = exchange.matchRequest(request.id);
+      assert.strictEqual(job, null);
+    });
+
+    it('picks cheapest provider', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, pricePerHour: '5000000' });
+      exchange.registerProvider({
+        ...SAMPLE_PROVIDER,
+        did: 'did:key:z6MkCheap12345678901234567890123456',
+        pricePerHour: '1000000',
+      });
+      const request = exchange.createRequest(SAMPLE_REQUEST);
+      const job = exchange.matchRequest(request.id);
+
+      assert(job !== null);
+      assert.strictEqual(job!.providerDid, 'did:key:z6MkCheap12345678901234567890123456');
+    });
+
+    it('transitions job through states', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider(SAMPLE_PROVIDER);
+      const request = exchange.createRequest(SAMPLE_REQUEST);
+      const job = exchange.matchRequest(request.id)!;
+
+      assert(exchange.acceptJob(job.id));
+      assert.strictEqual(exchange.getJob(job.id)!.status, 'locked');
+
+      assert(exchange.startJob(job.id));
+      assert.strictEqual(exchange.getJob(job.id)!.status, 'running');
+
+      assert(exchange.completeJob(job.id));
+      assert.strictEqual(exchange.getJob(job.id)!.status, 'completed');
+    });
+
+    it('refunds a job', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider(SAMPLE_PROVIDER);
+      const request = exchange.createRequest(SAMPLE_REQUEST);
+      const job = exchange.matchRequest(request.id)!;
+
+      assert(exchange.refundJob(job.id));
+      assert.strictEqual(exchange.getJob(job.id)!.status, 'refunded');
+    });
+
+    it('updates provider stats on completion', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, jobsCompleted: 10 });
+      const request = exchange.createRequest(SAMPLE_REQUEST);
+      const job = exchange.matchRequest(request.id)!;
+      exchange.acceptJob(job.id);
+      exchange.startJob(job.id);
+      exchange.completeJob(job.id);
+
+      const provider = exchange.getProvider(SAMPLE_PROVIDER.did);
+      assert.strictEqual(provider!.jobsCompleted, 11);
+    });
+  });
+
+  describe('stats', () => {
+    it('returns correct stats', () => {
+      const exchange = new ComputeExchange();
+      exchange.registerProvider(SAMPLE_PROVIDER);
+      exchange.registerProvider({ ...SAMPLE_PROVIDER, did: 'did:key:z6MkBusy1234567890123456789012345', available: false });
+
+      const stats = exchange.getStats();
+      assert.strictEqual(stats.totalProviders, 2);
+      assert.strictEqual(stats.availableProviders, 1);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}