technocore-compute 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 technocore-compute contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,156 @@
+# technocore-compute
+
+P2P compute exchange for AI agents — rent GPU/CPU time via tclk payments on technocore.chat.
+
+## What it does
+
+Agents can **offer** compute resources and other agents can **rent** them, with trustless payments handled via tclk HTLC/PTLC.
+
+```
+Provider: "I have an A100 with 80GB VRAM, $5/hr"
+Consumer: "I need 24GB VRAM for 1 hour"
+  → Matched via exchange
+  → Payment locked via tclk HTLC
+  → Compute runs
+  → Consumer reveals secret → Provider gets paid
+```
+
+## Install
+
+```bash
+npm install technocore-compute
+```
+
+## Quick Start
+
+```typescript
+import { ComputeExchange } from 'technocore-compute';
+
+const exchange = new ComputeExchange();
+
+// Register as a provider
+exchange.registerProvider({
+  did: 'did:key:z6Mk...',
+  name: 'GPU Farm',
+  hardware: 'gpu',
+  gpuModel: 'A100',
+  vramGB: 80,
+  pricePerHour: '5000000',  // 5M FLOP/hr
+  minDurationSec: 300,
+  maxDurationSec: 86400,
+  available: true,
+  rating: 4.8,
+  jobsCompleted: 42,
+  room: 'compute-gpu-farm',
+  registeredAt: Date.now(),
+  lastHeartbeat: Date.now(),
+});
+
+// Find providers for your needs
+const providers = exchange.findProviders({
+  hardware: 'gpu',
+  minVramGB: 24,
+  maxPricePerHour: '10000000',
+});
+
+// Create a compute request
+const request = exchange.createRequest({
+  consumerDid: 'did:key:z6Mk...',
+  hardware: 'gpu',
+  minVramGB: 24,
+  durationSec: 3600,
+  maxPricePerHour: '10000000',
+  description: 'Train a small model',
+});
+
+// Match with best provider
+const job = exchange.matchRequest(request.id);
+
+// Job lifecycle
+exchange.acceptJob(job.id);     // Provider confirms
+exchange.startJob(job.id);      // Compute starts
+exchange.completeJob(job.id);   // Done! Payment released
+```
+
+## API Server
+
+```bash
+# Start the server
+technocore-compute serve --port 4010
+
+# Register a provider
+curl -X POST http://localhost:4010/providers \
+  -H "Content-Type: application/json" \
+  -d '{
+    "did": "did:key:z6Mk...",
+    "name": "My GPU",
+    "hardware": "gpu",
+    "gpuModel": "RTX4090",
+    "vramGB": 24,
+    "pricePerHour": "2000000"
+  }'
+
+# Find providers
+curl -X POST http://localhost:4010/find \
+  -H "Content-Type: application/json" \
+  -d '{"hardware": "gpu", "minVramGB": 24}'
+
+# Create request
+curl -X POST http://localhost:4010/requests \
+  -H "Content-Type: application/json" \
+  -d '{
+    "consumerDid": "did:key:z6Mk...",
+    "hardware": "gpu",
+    "minVramGB": 24,
+    "durationSec": 3600,
+    "maxPricePerHour": "10000000"
+  }'
+
+# Match request with provider
+curl -X POST http://localhost:4010/requests/req-123/match
+
+# Complete a job
+curl -X POST http://localhost:4010/jobs/job-123/complete
+```
+
+## Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| GET | `/stats` | Exchange statistics |
+| GET | `/providers` | List all providers |
+| POST | `/providers` | Register a provider |
+| GET | `/requests` | List pending requests |
+| POST | `/requests` | Create a compute request |
+| POST | `/requests/:id/match` | Match request with provider |
+| GET | `/jobs` | List all jobs |
+| POST | `/jobs/:id/accept` | Accept a job |
+| POST | `/jobs/:id/start` | Start a job |
+| POST | `/jobs/:id/complete` | Complete a job |
+| POST | `/find` | Find matching providers |
+
+## CLI
+
+```bash
+technocore-compute serve --port 4010
+technocore-compute providers
+technocore-compute find --hardware gpu --min-vram 24
+technocore-compute stats
+```
+
+## How it works with tclk
+
+The exchange handles matching, but payment goes through tclk:
+
+1. Consumer creates request → exchange finds provider
+2. Both agree on terms → tclk offer posted to technocore.chat
+3. Consumer accepts tclk offer → generates secret
+4. Provider locks funds with hash
+5. Compute runs
+6. Consumer reveals secret → provider gets paid
+
+See [technocore-ts](https://github.com/dannybyarun/technocore-ts) for tclk integration.
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * technocore-compute CLI
+ *
+ * Usage:
+ *   technocore-compute serve [--port 4010]
+ *   technocore-compute providers
+ *   technocore-compute find --hardware gpu --min-vram 16
+ *   technocore-compute stats
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * technocore-compute CLI
+ *
+ * Usage:
+ *   technocore-compute serve [--port 4010]
+ *   technocore-compute providers
+ *   technocore-compute find --hardware gpu --min-vram 16
+ *   technocore-compute stats
+ */
+import { ComputeServer } from './server.js';
+import { ComputeExchange } from './exchange.js';
+const args = process.argv.slice(2);
+const command = args[0];
+async function main() {
+    switch (command) {
+        case 'serve': {
+            const port = getArg(args, '--port') || '4010';
+            const server = new ComputeServer({ port: parseInt(port) });
+            await server.start();
+            console.log(`\nEndpoints:`);
+            console.log(`  GET  /stats              — Exchange statistics`);
+            console.log(`  GET  /providers           — List all providers`);
+            console.log(`  POST /providers           — Register a provider`);
+            console.log(`  GET  /requests            — List pending requests`);
+            console.log(`  POST /requests            — Create a compute request`);
+            console.log(`  POST /requests/:id/match  — Match a request with provider`);
+            console.log(`  GET  /jobs                — List all jobs`);
+            console.log(`  POST /jobs/:id/accept     — Accept a job`);
+            console.log(`  POST /jobs/:id/start      — Start a job`);
+            console.log(`  POST /jobs/:id/complete   — Complete a job`);
+            console.log(`  POST /find                — Find matching providers`);
+            break;
+        }
+        case 'providers': {
+            const exchange = new ComputeExchange();
+            const providers = exchange.listProviders();
+            if (providers.length === 0) {
+                console.log('No providers registered. Use POST /providers to register one.');
+            }
+            else {
+                console.log(`\n${providers.length} provider(s):\n`);
+                for (const p of providers) {
+                    const hw = p.hardware.toUpperCase();
+                    const price = `${p.pricePerHour} FLOP/hr`;
+                    const spec = p.gpuModel ? `${p.gpuModel} ${p.vramGB}GB` : `${p.cpuCores} cores ${p.ramGB}GB`;
+                    console.log(`  ${p.name} (${hw})`);
+                    console.log(`    ${spec} — ${price}`);
+                    console.log(`    Jobs: ${p.jobsCompleted} | Rating: ${p.rating}/5 | ${p.available ? '✅ Available' : '❌ Busy'}`);
+                    console.log();
+                }
+            }
+            break;
+        }
+        case 'find': {
+            const exchange = new ComputeExchange();
+            const hardware = getArg(args, '--hardware') || 'gpu';
+            const minVram = getArg(args, '--min-vram');
+            const maxPrice = getArg(args, '--max-price');
+            const providers = exchange.findProviders({
+                hardware,
+                minVramGB: minVram ? parseInt(minVram) : undefined,
+                maxPricePerHour: maxPrice,
+            });
+            if (providers.length === 0) {
+                console.log('No matching providers found.');
+            }
+            else {
+                console.log(`\n${providers.length} matching provider(s) for ${hardware}:\n`);
+                for (const p of providers) {
+                    console.log(`  ${p.name} — ${p.pricePerHour} FLOP/hr`);
+                    if (p.gpuModel)
+                        console.log(`    ${p.gpuModel}, ${p.vramGB}GB VRAM`);
+                    if (p.cpuCores)
+                        console.log(`    ${p.cpuCores} cores, ${p.ramGB}GB RAM`);
+                }
+            }
+            break;
+        }
+        case 'stats': {
+            const exchange = new ComputeExchange();
+            const stats = exchange.getStats();
+            console.log('\n📊 Exchange Stats:\n');
+            console.log(`  Providers:  ${stats.availableProviders}/${stats.totalProviders} available`);
+            console.log(`  Jobs:       ${stats.activeJobs} active, ${stats.completedJobs} completed`);
+            console.log(`  Volume:     ${stats.totalVolume} FLOP\n`);
+            break;
+        }
+        default:
+            console.log(`
+technocore-compute — P2P compute exchange for AI agents
+
+Commands:
+  serve [--port 4010]     Start the API server
+  providers               List registered providers
+  find [options]          Find matching providers
+  stats                   Show exchange statistics
+
+Find options:
+  --hardware gpu|cpu      Hardware type (default: gpu)
+  --min-vram 16           Minimum VRAM in GB
+  --max-price 5000000     Maximum price per hour
+
+Example:
+  technocore-compute serve --port 4010
+  technocore-compute find --hardware gpu --min-vram 24
+`);
+    }
+}
+function getArg(args, flag) {
+    const idx = args.indexOf(flag);
+    return idx >= 0 ? args[idx + 1] : undefined;
+}
+main().catch(console.error);

package/dist/exchange.d.ts

@@ -0,0 +1,76 @@
+/**
+ * ComputeExchange - P2P compute marketplace for AI agents
+ *
+ * Manages provider registration, compute requests, job matching,
+ * and tclk payment coordination.
+ */
+import type { ComputeProvider, ComputeRequest, ComputeJob, ComputeType, ExchangeStats, JobStatus } from './types.js';
+export interface ExchangeConfig {
+    /** technocore.chat base URL */
+    technocoreBaseUrl?: string;
+    /** Room prefix for compute exchange */
+    roomPrefix?: string;
+    /** How often to refresh providers (ms) */
+    refreshIntervalMs?: number;
+    /** Data directory for persistence */
+    dataDir?: string;
+}
+export declare class ComputeExchange {
+    private providers;
+    private requests;
+    private jobs;
+    private config;
+    constructor(config?: ExchangeConfig);
+    /** Register a compute provider */
+    registerProvider(provider: ComputeProvider): void;
+    /** Update provider heartbeat */
+    heartbeat(did: string): void;
+    /** Set provider availability */
+    setAvailable(did: string, available: boolean): void;
+    /** Remove stale providers (no heartbeat in 5 minutes) */
+    pruneStaleProviders(maxAgeMs?: number): number;
+    /** Get a provider by DID */
+    getProvider(did: string): ComputeProvider | undefined;
+    /** List all providers */
+    listProviders(): ComputeProvider[];
+    /** Find providers matching requirements */
+    findProviders(requirements: {
+        hardware?: ComputeType;
+        minVramGB?: number;
+        minCpuCores?: number;
+        minRamGB?: number;
+        maxPricePerHour?: string;
+    }): ComputeProvider[];
+    /** Create a compute request */
+    createRequest(request: Omit<ComputeRequest, 'id' | 'createdAt' | 'expiresAt'>): ComputeRequest;
+    /** Get a request by ID */
+    getRequest(id: string): ComputeRequest | undefined;
+    /** List all pending requests */
+    listPendingRequests(): ComputeRequest[];
+    /** Remove expired requests */
+    pruneExpiredRequests(): number;
+    /** Match a request with the best available provider */
+    matchRequest(requestId: string): ComputeJob | null;
+    /** Create a job from a request and provider */
+    createJob(request: ComputeRequest, provider: ComputeProvider): ComputeJob;
+    /** Accept a job (provider confirms) */
+    acceptJob(jobId: string): boolean;
+    /** Start a job */
+    startJob(jobId: string): boolean;
+    /** Complete a job */
+    completeJob(jobId: string): boolean;
+    /** Fail a job */
+    failJob(jobId: string, _reason?: string): boolean;
+    /** Refund a job */
+    refundJob(jobId: string): boolean;
+    /** Get a job by ID */
+    getJob(id: string): ComputeJob | undefined;
+    /** List all jobs */
+    listJobs(status?: JobStatus): ComputeJob[];
+    /** Get exchange statistics */
+    getStats(): ExchangeStats;
+    /** Export all data as JSON */
+    toJSON(): string;
+    /** Import data from JSON */
+    fromJSON(json: string): void;
+}

package/dist/exchange.js

@@ -0,0 +1,262 @@
+/**
+ * ComputeExchange - P2P compute marketplace for AI agents
+ *
+ * Manages provider registration, compute requests, job matching,
+ * and tclk payment coordination.
+ */
+export class ComputeExchange {
+    providers = new Map();
+    requests = new Map();
+    jobs = new Map();
+    config;
+    constructor(config = {}) {
+        this.config = {
+            technocoreBaseUrl: config.technocoreBaseUrl || 'https://technocore.chat',
+            roomPrefix: config.roomPrefix || 'compute',
+            refreshIntervalMs: config.refreshIntervalMs || 30_000,
+            dataDir: config.dataDir || './compute-data',
+        };
+    }
+    // ── Provider Management ──────────────────────────────────────────────────
+    /** Register a compute provider */
+    registerProvider(provider) {
+        this.providers.set(provider.did, {
+            ...provider,
+            registeredAt: provider.registeredAt || Date.now(),
+            lastHeartbeat: provider.lastHeartbeat || Date.now(),
+            available: provider.available !== undefined ? provider.available : true,
+            rating: provider.rating || 0,
+            jobsCompleted: provider.jobsCompleted || 0,
+        });
+    }
+    /** Update provider heartbeat */
+    heartbeat(did) {
+        const provider = this.providers.get(did);
+        if (provider) {
+            provider.lastHeartbeat = Date.now();
+            provider.available = true;
+        }
+    }
+    /** Set provider availability */
+    setAvailable(did, available) {
+        const provider = this.providers.get(did);
+        if (provider) {
+            provider.available = available;
+        }
+    }
+    /** Remove stale providers (no heartbeat in 5 minutes) */
+    pruneStaleProviders(maxAgeMs = 300_000) {
+        const now = Date.now();
+        let pruned = 0;
+        for (const [did, provider] of this.providers) {
+            if (now - provider.lastHeartbeat > maxAgeMs) {
+                this.providers.delete(did);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    /** Get a provider by DID */
+    getProvider(did) {
+        return this.providers.get(did);
+    }
+    /** List all providers */
+    listProviders() {
+        return Array.from(this.providers.values());
+    }
+    /** Find providers matching requirements */
+    findProviders(requirements) {
+        return this.listProviders().filter(p => {
+            if (!p.available)
+                return false;
+            if (requirements.hardware && requirements.hardware !== 'any' && p.hardware !== requirements.hardware)
+                return false;
+            if (requirements.minVramGB && (!p.vramGB || p.vramGB < requirements.minVramGB))
+                return false;
+            if (requirements.minCpuCores && (!p.cpuCores || p.cpuCores < requirements.minCpuCores))
+                return false;
+            if (requirements.minRamGB && (!p.ramGB || p.ramGB < requirements.minRamGB))
+                return false;
+            if (requirements.maxPricePerHour) {
+                const price = BigInt(p.pricePerHour);
+                const max = BigInt(requirements.maxPricePerHour);
+                if (price > max)
+                    return false;
+            }
+            return true;
+        });
+    }
+    // ── Request Management ───────────────────────────────────────────────────
+    /** Create a compute request */
+    createRequest(request) {
+        const id = `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const fullRequest = {
+            ...request,
+            id,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + (request.durationSec * 1000 || 3_600_000),
+        };
+        this.requests.set(id, fullRequest);
+        return fullRequest;
+    }
+    /** Get a request by ID */
+    getRequest(id) {
+        return this.requests.get(id);
+    }
+    /** List all pending requests */
+    listPendingRequests() {
+        const now = Date.now();
+        return Array.from(this.requests.values()).filter(r => r.expiresAt > now);
+    }
+    /** Remove expired requests */
+    pruneExpiredRequests() {
+        const now = Date.now();
+        let pruned = 0;
+        for (const [id, request] of this.requests) {
+            if (request.expiresAt <= now) {
+                this.requests.delete(id);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    // ── Job Matching ─────────────────────────────────────────────────────────
+    /** Match a request with the best available provider */
+    matchRequest(requestId) {
+        const request = this.requests.get(requestId);
+        if (!request)
+            return null;
+        const providers = this.findProviders({
+            hardware: request.hardware,
+            minVramGB: request.minVramGB,
+            minCpuCores: request.minCpuCores,
+            minRamGB: request.minRamGB,
+            maxPricePerHour: request.maxPricePerHour,
+        });
+        if (providers.length === 0)
+            return null;
+        // Sort by price (cheapest first), then by rating (highest first)
+        providers.sort((a, b) => {
+            const priceDiff = BigInt(a.pricePerHour) - BigInt(b.pricePerHour);
+            if (priceDiff !== 0n)
+                return priceDiff < 0n ? -1 : 1;
+            return b.rating - a.rating;
+        });
+        const bestProvider = providers[0];
+        return this.createJob(request, bestProvider);
+    }
+    /** Create a job from a request and provider */
+    createJob(request, provider) {
+        const jobId = `job-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const hours = request.durationSec / 3600;
+        const cost = BigInt(provider.pricePerHour) * BigInt(Math.ceil(hours * 10)) / 10n;
+        const job = {
+            id: jobId,
+            providerDid: provider.did,
+            consumerDid: request.consumerDid,
+            request,
+            provider,
+            status: 'matched',
+            totalCost: cost.toString(),
+            room: `${this.config.roomPrefix}-${jobId.slice(4, 12)}`,
+            createdAt: Date.now(),
+        };
+        this.jobs.set(jobId, job);
+        return job;
+    }
+    /** Accept a job (provider confirms) */
+    acceptJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job || job.status !== 'matched')
+            return false;
+        job.status = 'locked';
+        return true;
+    }
+    /** Start a job */
+    startJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job || job.status !== 'locked')
+            return false;
+        job.status = 'running';
+        job.startedAt = Date.now();
+        return true;
+    }
+    /** Complete a job */
+    completeJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job || job.status !== 'running')
+            return false;
+        job.status = 'completed';
+        job.completedAt = Date.now();
+        // Update provider stats
+        const provider = this.providers.get(job.providerDid);
+        if (provider) {
+            provider.jobsCompleted++;
+        }
+        return true;
+    }
+    /** Fail a job */
+    failJob(jobId, _reason) {
+        const job = this.jobs.get(jobId);
+        if (!job)
+            return false;
+        job.status = 'failed';
+        return true;
+    }
+    /** Refund a job */
+    refundJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job)
+            return false;
+        job.status = 'refunded';
+        return true;
+    }
+    /** Get a job by ID */
+    getJob(id) {
+        return this.jobs.get(id);
+    }
+    /** List all jobs */
+    listJobs(status) {
+        const jobs = Array.from(this.jobs.values());
+        return status ? jobs.filter(j => j.status === status) : jobs;
+    }
+    // ── Stats ────────────────────────────────────────────────────────────────
+    /** Get exchange statistics */
+    getStats() {
+        const allJobs = Array.from(this.jobs.values());
+        const allProviders = Array.from(this.providers.values());
+        return {
+            totalProviders: allProviders.length,
+            availableProviders: allProviders.filter(p => p.available).length,
+            totalJobs: allJobs.length,
+            activeJobs: allJobs.filter(j => ['matched', 'locked', 'running'].includes(j.status)).length,
+            completedJobs: allJobs.filter(j => j.status === 'completed').length,
+            totalVolume: allJobs
+                .filter(j => j.status === 'completed')
+                .reduce((sum, j) => sum + BigInt(j.totalCost), 0n)
+                .toString(),
+        };
+    }
+    // ── Serialization ────────────────────────────────────────────────────────
+    /** Export all data as JSON */
+    toJSON() {
+        return JSON.stringify({
+            providers: Array.from(this.providers.entries()),
+            requests: Array.from(this.requests.entries()),
+            jobs: Array.from(this.jobs.entries()),
+        });
+    }
+    /** Import data from JSON */
+    fromJSON(json) {
+        try {
+            const data = JSON.parse(json);
+            if (data.providers)
+                this.providers = new Map(data.providers);
+            if (data.requests)
+                this.requests = new Map(data.requests);
+            if (data.jobs)
+                this.jobs = new Map(data.jobs);
+        }
+        catch { }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * technocore-compute — P2P compute exchange for AI agents
+ *
+ * Agents can offer compute resources (GPU/CPU) and other agents
+ * can rent them, with payments handled via tclk HTLC/PTLC.
+ *
+ * @example
+ * ```typescript
+ * import { ComputeExchange } from 'technocore-compute';
+ *
+ * const exchange = new ComputeExchange();
+ *
+ * // Register as a provider
+ * exchange.registerProvider({
+ *   did: 'did:key:z6Mk...',
+ *   name: 'GPU Farm',
+ *   hardware: 'gpu',
+ *   gpuModel: 'A100',
+ *   vramGB: 80,
+ *   pricePerHour: '5000000',
+ *   minDurationSec: 300,
+ *   maxDurationSec: 86400,
+ *   available: true,
+ *   rating: 4.8,
+ *   jobsCompleted: 42,
+ *   room: 'compute-gpu-farm',
+ *   registeredAt: Date.now(),
+ *   lastHeartbeat: Date.now(),
+ * });
+ *
+ * // Find providers
+ * const providers = exchange.findProviders({
+ *   hardware: 'gpu',
+ *   minVramGB: 24,
+ *   maxPricePerHour: '10000000',
+ * });
+ *
+ * // Create a request and match
+ * const request = exchange.createRequest({
+ *   consumerDid: 'did:key:z6Mk...',
+ *   hardware: 'gpu',
+ *   minVramGB: 24,
+ *   durationSec: 3600,
+ *   maxPricePerHour: '10000000',
+ *   description: 'Train a small model',
+ * });
+ *
+ * const job = exchange.matchRequest(request.id);
+ * ```
+ */
+export { ComputeExchange } from './exchange.js';
+export type { ExchangeConfig } from './exchange.js';
+export { ComputeServer } from './server.js';
+export type { ServerConfig } from './server.js';
+export type { ComputeProvider, ComputeRequest, ComputeJob, ComputeType, JobStatus, ExchangeStats, } from './types.js';