orrery-node 0.0.0-stage → 0.1.1

package/dist/router/registry.js

@@ -0,0 +1,125 @@
+// What the router knows about the network: every Provider account on chain, plus the price manifest each node
+// serves, kept only if its sha256 matches the hash the provider's wallet put on chain.
+import { createHash } from 'node:crypto';
+import bs58 from 'bs58';
+import { ACCOUNT, decodeProvider, programId } from "../chain/program.js";
+import { checkManifest, manifestHash } from "../manifest.js";
+import { fetchWithTimeout } from "../sse.js";
+export class Registry {
+    conn;
+    tee;
+    entries = new Map();
+    refreshedAt = 0;
+    constructor(conn, tee) {
+        this.conn = conn;
+        this.tee = tee;
+    }
+    async refresh() {
+        const accounts = await this.conn.getProgramAccounts(programId(), { filters: [{ memcmp: { offset: 0, bytes: bs58.encode(ACCOUNT.Provider) } }] });
+        const seen = new Set();
+        await Promise.all(accounts.map(async ({ pubkey, account }) => {
+            const address = pubkey.toBase58();
+            seen.add(address);
+            let p;
+            try {
+                p = decodeProvider(account.data);
+            }
+            catch {
+                return;
+            }
+            const prev = this.entries.get(address);
+            const same = prev && prev.account.manifestHash.equals(p.manifestHash) && prev.account.endpoint === p.endpoint && prev.manifest && Date.now() - prev.checkedAt < 10 * 60_000;
+            const entry = same ? { ...prev, account: p } : { address, account: p, manifest: null, problem: null, checkedAt: Date.now(), tee: null };
+            if (!same && p.active) {
+                try {
+                    const r = await fetchWithTimeout(`${p.endpoint.replace(/\/$/, '')}/v1/manifest`, { timeoutMs: 4_000 });
+                    const bytes = Buffer.from(await r.arrayBuffer());
+                    if (!manifestHash(bytes).equals(p.manifestHash))
+                        throw new Error('manifest does not match the hash on chain');
+                    const m = checkManifest(JSON.parse(bytes.toString('utf8')));
+                    if (m.authority !== p.authority.toBase58())
+                        throw new Error('manifest names another wallet');
+                    entry.manifest = m;
+                }
+                catch (err) {
+                    entry.problem = err.message;
+                }
+            }
+            entry.tee = await this.checkTee(entry);
+            this.entries.set(address, entry);
+        }));
+        for (const k of [...this.entries.keys()])
+            if (!seen.has(k))
+                this.entries.delete(k);
+        this.refreshedAt = Date.now();
+    }
+    /** A provider's enclave counts only if the report it serves hashes to the on-chain claim, names the on-chain key,
+     * is not expired, booted an allowed image, and the hardware verifier accepts it. Dev reports are software
+     * stand-ins and pass only when the router is told to accept them for local testing. */
+    async checkTee(e) {
+        const p = e.account;
+        if (p.teeKind === 0 || !p.active)
+            return null;
+        const enclaveKey = Buffer.from(p.teeKey);
+        if (BigInt(Math.floor(Date.now() / 1000)) >= p.teeExpiresAt)
+            return { verified: false, dev: false, reason: 'attestation expired', enclaveKey };
+        try {
+            const r = await fetchWithTimeout(`${p.endpoint.replace(/\/$/, '')}/v1/attestation`, { timeoutMs: 4_000 });
+            const a = (await r.json());
+            const report = Buffer.from(a.report, 'base64');
+            if (!createHash('sha256').update(report).digest().equals(p.teeReportHash))
+                return { verified: false, dev: false, reason: 'report does not match the on-chain hash', enclaveKey };
+            if (a.enclaveKey !== p.teeKey.toString('hex'))
+                return { verified: false, dev: false, reason: 'report names another key', enclaveKey };
+            if (this.tee.measurements.length && !this.tee.measurements.includes(p.teeMeasurement.toString('hex')))
+                return { verified: false, dev: false, reason: 'image not on your allow list', enclaveKey };
+            let dev = false;
+            try {
+                dev = JSON.parse(report.toString('utf8')).dev === true;
+            }
+            catch {
+                dev = false;
+            }
+            if (dev)
+                return { verified: this.tee.allowDev, dev: true, reason: this.tee.allowDev ? 'dev report accepted (local testing)' : 'dev report, not hardware', enclaveKey };
+            if (!this.tee.verifier)
+                return { verified: false, dev: false, reason: 'no hardware verifier configured', enclaveKey };
+            const ok = await this.tee.verifier(a, p);
+            return { verified: ok, dev: false, reason: ok ? 'hardware report verified' : 'hardware verifier rejected the report', enclaveKey };
+        }
+        catch (err) {
+            return { verified: false, dev: false, reason: `attestation fetch failed: ${err.message}`, enclaveKey };
+        }
+    }
+    usable() {
+        return [...this.entries.values()].filter((e) => e.account.active && e.manifest && !e.problem);
+    }
+    offers(model) {
+        const out = [];
+        for (const e of this.usable()) {
+            const offer = e.manifest.models.find((m) => m.id === model);
+            if (offer)
+                out.push({ entry: e, offer });
+        }
+        return out;
+    }
+    catalog() {
+        const by = new Map();
+        for (const e of this.usable()) {
+            for (const m of e.manifest.models) {
+                const c = by.get(m.id) ?? { id: m.id, providers: 0, cheapest: m.price, context: m.context, private: 0 };
+                c.providers += 1;
+                if (m.price.input + m.price.output < c.cheapest.input + c.cheapest.output)
+                    c.cheapest = m.price;
+                c.context = Math.max(c.context, m.context);
+                if (e.tee?.verified)
+                    c.private += 1;
+                by.set(m.id, c);
+            }
+        }
+        return [...by.values()].sort((a, b) => b.providers - a.providers || a.id.localeCompare(b.id));
+    }
+    get(address) {
+        return this.entries.get(typeof address === 'string' ? address : address.toBase58());
+    }
+}

package/dist/router/server.js

@@ -0,0 +1,256 @@
+// The router: an OpenAI-compatible endpoint on 127.0.0.1. Point any tool at http://127.0.0.1:7171/v1 and it picks a
+// provider per request, pays it through a channel, and falls back to the next provider if one fails.
+import { createServer } from 'node:http';
+import { costOf, estimateInputTokens, usd } from "../pricing.js";
+import { decrypt, sealRequest } from "../seal.js";
+import { fetchWithTimeout, readSse, sseFrame } from "../sse.js";
+import { parseModel, rank, Stats } from "./policy.js";
+import { consolePage } from "./console.js";
+class Unserved extends Error {
+    status;
+    code;
+    constructor(message, status = 502, code = 'no_provider') {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+async function readJson(req) {
+    const parts = [];
+    let n = 0;
+    for await (const c of req) {
+        n += c.length;
+        if (n > 8 * 1024 * 1024)
+            throw new Unserved('request too large', 413, 'too_large');
+        parts.push(c);
+    }
+    return JSON.parse(Buffer.concat(parts).toString('utf8') || '{}');
+}
+const send = (res, status, body, headers = {}) => {
+    res.writeHead(status, { 'content-type': 'application/json', ...headers });
+    res.end(JSON.stringify(body, (_, v) => (typeof v === 'bigint' ? v.toString() : v)));
+};
+export class Router {
+    o;
+    stats = new Stats();
+    trips = [];
+    server = null;
+    timer = null;
+    inflight = new Map();
+    log;
+    constructor(o) {
+        this.o = o;
+        this.log = o.log ?? ((l) => console.log(l));
+    }
+    async start() {
+        await this.o.registry.refresh().catch((e) => this.log(`registry refresh failed: ${e.message}`));
+        this.timer = setInterval(() => void this.o.registry.refresh().catch(() => undefined), (this.o.refreshSecs ?? 60) * 1000);
+        this.server = createServer((req, res) => void this.handle(req, res));
+        await new Promise((r) => this.server.listen(this.o.port, this.o.host ?? '127.0.0.1', () => r()));
+        return this.server;
+    }
+    close() {
+        if (this.timer)
+            clearInterval(this.timer);
+        return new Promise((r) => (this.server ? this.server.close(() => r()) : r()));
+    }
+    async handle(req, res) {
+        const url = new URL(req.url ?? '/', 'http://x');
+        const origin = req.headers.origin;
+        if (origin && !/^https?:\/\/(127\.0\.0\.1|localhost)(:\d+)?$/.test(origin))
+            return send(res, 403, { error: { code: 'origin', message: 'the router only answers this computer' } });
+        try {
+            if (req.method === 'GET' && (url.pathname === '/v1/models' || url.pathname === '/models'))
+                return this.models(res);
+            if (req.method === 'POST' && (url.pathname === '/v1/chat/completions' || url.pathname === '/chat/completions'))
+                return await this.chat(req, res);
+            if (req.method === 'GET' && url.pathname === '/orrery/status')
+                return this.status(res);
+            if (req.method === 'GET' && url.pathname === '/') {
+                res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+                return void res.end(consolePage());
+            }
+            return send(res, 404, { error: { code: 'not_found', message: 'no such route' } });
+        }
+        catch (err) {
+            const e = err;
+            if (!res.headersSent)
+                return send(res, e.status ?? 500, { error: { code: e.code ?? 'internal', message: e.message } });
+            res.end();
+        }
+    }
+    models(res) {
+        const data = this.o.registry.catalog().map((m) => ({
+            id: m.id, object: 'model', owned_by: 'network', providers: m.providers, private_providers: m.private, context_length: m.context,
+            pricing: { prompt_per_million: m.cheapest.input / 1e6, completion_per_million: m.cheapest.output / 1e6 },
+        }));
+        send(res, 200, { object: 'list', data });
+    }
+    status(res) {
+        const providers = [...this.o.registry.entries.values()].map((e) => ({
+            address: e.address, name: e.manifest?.name ?? null, endpoint: e.account.endpoint, active: e.account.active, problem: e.problem,
+            models: e.manifest?.models.length ?? 0, settled: usd(e.account.settled, 2), redeems: Number(e.account.redeems),
+            tee: e.tee ? { verified: e.tee.verified, dev: e.tee.dev, reason: e.tee.reason } : null, observed: this.stats.get(e.address),
+        }));
+        const channels = this.o.channels.list().map((c) => ({ provider: c.provider, channel: c.channel, deposit: usd(c.deposit), spent: usd(c.cumulative), left: usd(c.deposit - c.cumulative) }));
+        send(res, 200, { route: this.o.route, refreshedAt: this.o.registry.refreshedAt, spentToday: usd(this.o.channels.todaySpent()), providers, channels, trips: this.trips.slice(-50).reverse() });
+    }
+    async chat(req, res) {
+        const body = await readJson(req);
+        if (typeof body.model !== 'string')
+            throw new Unserved('model is required', 400, 'bad_request');
+        const header = String(req.headers['x-orrery-route'] ?? '');
+        const { model, route } = parseModel(body.model, ['auto', 'price', 'speed', 'reputation', 'privacy'].includes(header) ? header : this.o.route);
+        const pin = req.headers['x-orrery-provider'] ? String(req.headers['x-orrery-provider']) : null;
+        const wantsStream = body.stream === true;
+        const estIn = estimateInputTokens(body);
+        const estOut = Number(body.max_completion_tokens ?? body.max_tokens ?? 1_024);
+        let offers = this.o.registry.offers(model);
+        if (pin)
+            offers = offers.filter((o) => o.entry.address.startsWith(pin));
+        if (!offers.length)
+            throw new Unserved(`no provider on the network serves ${model}${pin ? ` as ${pin}` : ''}`, 404, 'model_not_found');
+        const ranked = rank(offers, route, estIn, estOut, this.stats, this.o.minReputation);
+        if (!ranked.length)
+            throw new Unserved(route === 'privacy' ? `no provider with a verified enclave serves ${model}` : `every provider for ${model} is cooling down`, 503, 'no_provider');
+        if (this.o.channels.overBudget(ranked[0].expected))
+            throw new Unserved('daily spending cap reached (orrery router --daily-cap)', 429, 'budget');
+        const tried = [];
+        for (const cand of ranked.slice(0, 3)) {
+            try {
+                await this.forward(cand, body, wantsStream, res, route, tried.length);
+                return;
+            }
+            catch (err) {
+                tried.push(`${cand.entry.manifest?.name ?? cand.entry.address.slice(0, 6)}: ${err.message}`);
+                this.stats.fail(cand.entry.address);
+                if (res.headersSent) {
+                    res.end();
+                    return;
+                }
+            }
+        }
+        throw new Unserved(`all providers failed: ${tried.join('; ')}`, 502, 'all_failed');
+    }
+    async forward(cand, body, wantsStream, res, route, fellThrough, retried = false) {
+        const address = cand.entry.address;
+        const maxOut = Math.min(Number(body.max_completion_tokens ?? body.max_tokens ?? cand.offer.maxOutput), cand.offer.maxOutput);
+        const maxCost = costOf(cand.offer.price, estimateInputTokens(body), maxOut);
+        const ch = await this.o.channels.ensure(address, maxCost);
+        const payload = JSON.stringify({ ...body, model: cand.offer.id, stream: true });
+        let wire = payload;
+        let key = null;
+        if (cand.sealed) {
+            if (!cand.entry.tee?.verified)
+                throw new Error('enclave not verified');
+            const s = sealRequest(cand.entry.tee.enclaveKey, Buffer.from(payload));
+            wire = s.body;
+            key = s.key;
+        }
+        const headers = { 'content-type': 'application/json', 'x-orrery-channel': ch.channel };
+        if (ch.voucher)
+            headers['x-orrery-voucher'] = ch.voucher;
+        const t0 = Date.now();
+        this.inflight.set(address, maxCost);
+        const r = await fetchWithTimeout(`${cand.entry.account.endpoint.replace(/\/$/, '')}/v1/chat/completions`, { method: 'POST', headers, body: wire, timeoutMs: 20_000 });
+        if (r.status === 402 && !retried) {
+            const j = (await r.json());
+            if (j.error.code === 'payment_required' && j.error.unpaid?.length === 1) {
+                const u = j.error.unpaid[0];
+                const allowed = this.inflight.get(address) ?? 0n;
+                if (BigInt(u.cost) <= allowed && u.model === cand.offer.id) {
+                    this.o.channels.settle(address, { ...u, cost: BigInt(u.cost) });
+                    return this.forward(cand, body, wantsStream, res, route, fellThrough, true);
+                }
+            }
+            if (j.error.code === 'channel_exhausted') {
+                await this.o.channels.topUp(address, BigInt(j.error.need ?? '0'));
+                return this.forward(cand, body, wantsStream, res, route, fellThrough, true);
+            }
+            throw new Error(`payment refused: ${j.error.code}`);
+        }
+        if (!r.ok || !r.body)
+            throw new Error(`provider answered ${r.status}`);
+        let ttft = 0;
+        let record = null;
+        const chunks = [];
+        let started = false;
+        for await (const ev of readSse(r.body)) {
+            let data = ev.data;
+            if (data === '[DONE]')
+                break;
+            if (key)
+                data = decrypt(key, Buffer.from(data, 'base64')).toString('utf8');
+            if (ev.event === 'orrery') {
+                const y = JSON.parse(data);
+                record = { requestId: y.requestId, model: y.model, inputTokens: y.inputTokens, outputTokens: y.outputTokens, cost: BigInt(y.cost), owed: y.owed };
+                continue;
+            }
+            if (!ttft)
+                ttft = Date.now() - t0;
+            if (wantsStream) {
+                if (!started) {
+                    res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', 'x-orrery-provider': address, 'x-orrery-route': route, ...(key ? { 'x-orrery-sealed': '1' } : {}) });
+                    started = true;
+                }
+                res.write(sseFrame(data));
+            }
+            else {
+                chunks.push(JSON.parse(data));
+            }
+        }
+        if (!record)
+            throw new Error('provider closed the stream without a usage record');
+        const ours = costOf(cand.offer.price, record.inputTokens, record.outputTokens);
+        const fair = record.cost <= ours && record.cost <= maxCost ? record.cost : ours < maxCost ? ours : maxCost;
+        if (fair !== record.cost)
+            this.log(`provider ${address.slice(0, 6)} billed ${record.cost} but its own prices say ${ours}; paying ${fair}`);
+        const voucher = this.o.channels.settle(address, { ...record, cost: fair });
+        this.inflight.delete(address);
+        void fetchWithTimeout(`${cand.entry.account.endpoint.replace(/\/$/, '')}/orrery/voucher`, {
+            method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ channel: ch.channel, voucher }), timeoutMs: 5_000,
+        }).catch(() => undefined);
+        this.stats.ok(address, ttft);
+        const trip = {
+            at: Date.now(), model: cand.offer.id, route, provider: address, providerName: cand.entry.manifest?.name ?? address.slice(0, 6),
+            inputTokens: record.inputTokens, outputTokens: record.outputTokens, cost: usd(fair), ttftMs: ttft, totalMs: Date.now() - t0, sealed: !!key, fellThrough,
+        };
+        this.trips.push(trip);
+        if (this.trips.length > 500)
+            this.trips.splice(0, this.trips.length - 500);
+        this.log(`${route.padEnd(10)} ${cand.offer.id} → ${trip.providerName}  ${record.inputTokens}+${record.outputTokens} tok  $${trip.cost}  ttft ${ttft}ms${key ? '  sealed' : ''}`);
+        const orreryHeaders = { 'x-orrery-provider': address, 'x-orrery-route': route, 'x-orrery-cost': trip.cost };
+        if (wantsStream) {
+            res.write(sseFrame('[DONE]'));
+            res.end();
+            return;
+        }
+        send(res, 200, assemble(chunks, cand.offer.id, record.inputTokens, record.outputTokens), orreryHeaders);
+    }
+}
+/** Turn a provider's stream back into the single object a non-streaming OpenAI client expects. */
+function assemble(chunks, model, prompt, completion) {
+    const choices = new Map();
+    for (const c of chunks) {
+        for (const ch of c.choices ?? []) {
+            const i = ch.index ?? 0;
+            const cur = choices.get(i) ?? { index: i, message: { role: 'assistant', content: '' }, finish_reason: null };
+            if (ch.delta?.content)
+                cur.message.content += ch.delta.content;
+            if (ch.delta?.tool_calls)
+                cur.message.tool_calls = [...(cur.message.tool_calls ?? []), ...ch.delta.tool_calls];
+            if (ch.finish_reason)
+                cur.finish_reason = ch.finish_reason;
+            choices.set(i, cur);
+        }
+    }
+    const first = chunks[0] ?? {};
+    return {
+        id: first.id ?? `chatcmpl-${Date.now()}`,
+        object: 'chat.completion',
+        created: first.created ?? Math.floor(Date.now() / 1000),
+        model,
+        choices: [...choices.values()].sort((a, b) => a.index - b.index),
+        usage: { prompt_tokens: prompt, completion_tokens: completion, total_tokens: prompt + completion },
+    };
+}

package/dist/seal.js

@@ -0,0 +1,49 @@
+// Private route: the router encrypts the request to the enclave key the provider attested on chain (X25519 +
+// HKDF-SHA256 + AES-256-GCM). Only code inside that enclave holds the private half, so the operator's host, the
+// network and this project see ciphertext. Replies come back sealed under the same derived key.
+import { createCipheriv, createDecipheriv, createPrivateKey, createPublicKey, diffieHellman, generateKeyPairSync, hkdfSync, randomBytes } from 'node:crypto';
+const SPKI_X25519 = Buffer.from('302a300506032b656e032100', 'hex');
+const PKCS8_X25519 = Buffer.from('302e020100300506032b656e04220420', 'hex');
+const INFO = Buffer.from('orrery/seal/1');
+export function newEnclaveKey() {
+    const { publicKey, privateKey } = generateKeyPairSync('x25519');
+    const pub = publicKey.export({ format: 'der', type: 'spki' }).subarray(-32);
+    const secret = privateKey.export({ format: 'der', type: 'pkcs8' }).subarray(-32);
+    return { publicKey: Buffer.from(pub), privateKey, secret: Buffer.from(secret) };
+}
+export function enclaveKeyFromSecret(secret) {
+    const privateKey = createPrivateKey({ key: Buffer.concat([PKCS8_X25519, secret]), format: 'der', type: 'pkcs8' });
+    const pub = createPublicKey(privateKey).export({ format: 'der', type: 'spki' }).subarray(-32);
+    return { publicKey: Buffer.from(pub), privateKey, secret };
+}
+const publicFromRaw = (raw) => createPublicKey({ key: Buffer.concat([SPKI_X25519, raw]), format: 'der', type: 'spki' });
+function derive(shared, epk, recipient) {
+    return Buffer.from(hkdfSync('sha256', shared, Buffer.concat([epk, recipient]), INFO, 32));
+}
+export function encrypt(key, plaintext) {
+    const iv = randomBytes(12);
+    const c = createCipheriv('aes-256-gcm', key, iv);
+    const ct = Buffer.concat([c.update(plaintext), c.final()]);
+    return Buffer.concat([iv, ct, c.getAuthTag()]);
+}
+export function decrypt(key, box) {
+    if (box.length < 28)
+        throw new Error('sealed box too short');
+    const d = createDecipheriv('aes-256-gcm', key, box.subarray(0, 12));
+    d.setAuthTag(box.subarray(box.length - 16));
+    return Buffer.concat([d.update(box.subarray(12, box.length - 16)), d.final()]);
+}
+/** Router side: seal a request to an enclave. Returns the wire body and the key that will open the reply. */
+export function sealRequest(enclavePublic, plaintext) {
+    const eph = newEnclaveKey();
+    const shared = diffieHellman({ privateKey: eph.privateKey, publicKey: publicFromRaw(enclavePublic) });
+    const key = derive(shared, eph.publicKey, enclavePublic);
+    return { body: JSON.stringify({ sealed: 1, epk: eph.publicKey.toString('base64'), box: encrypt(key, plaintext).toString('base64') }), key };
+}
+/** Enclave side: open a sealed request. Returns the plaintext and the key to seal the reply with. */
+export function openRequest(enclave, wire) {
+    const epk = Buffer.from(wire.epk, 'base64');
+    const shared = diffieHellman({ privateKey: enclave.privateKey, publicKey: publicFromRaw(epk) });
+    const key = derive(shared, epk, enclave.publicKey);
+    return { plaintext: decrypt(key, Buffer.from(wire.box, 'base64')), key };
+}

package/dist/sse.js

@@ -0,0 +1,41 @@
+export async function* readSse(body) {
+    const decoder = new TextDecoder();
+    let buf = '';
+    let event = null;
+    let data = [];
+    for await (const chunk of body) {
+        buf += decoder.decode(chunk, { stream: true });
+        let nl;
+        while ((nl = buf.indexOf('\n')) >= 0) {
+            const line = buf.slice(0, nl).replace(/\r$/, '');
+            buf = buf.slice(nl + 1);
+            if (line === '') {
+                if (data.length)
+                    yield { event, data: data.join('\n') };
+                event = null;
+                data = [];
+            }
+            else if (line.startsWith('event:')) {
+                event = line.slice(6).trim();
+            }
+            else if (line.startsWith('data:')) {
+                data.push(line.slice(5).replace(/^ /, ''));
+            }
+        }
+    }
+    if (data.length)
+        yield { event, data: data.join('\n') };
+}
+export function sseFrame(data, event) {
+    return `${event ? `event: ${event}\n` : ''}data: ${data}\n\n`;
+}
+export async function fetchWithTimeout(url, init = {}) {
+    const ctl = new AbortController();
+    const t = setTimeout(() => ctl.abort(new Error(`timeout after ${init.timeoutMs ?? 10_000}ms`)), init.timeoutMs ?? 10_000);
+    try {
+        return await fetch(url, { ...init, signal: init.signal ?? ctl.signal });
+    }
+    finally {
+        clearTimeout(t);
+    }
+}

package/dist/usage.js

@@ -0,0 +1,7 @@
+// Each paid request extends a hash chain over what it cost and why. The router signs the chain head inside every
+// voucher and the program stores the head it redeems, so either side can later prove which requests a payment covered.
+import { createHash } from 'node:crypto';
+export const ZERO_HASH = Buffer.alloc(32);
+export function nextUsageHash(prev, r) {
+    return createHash('sha256').update(prev).update(`${r.requestId}|${r.model}|${r.inputTokens}|${r.outputTokens}|${r.cost}`).digest();
+}

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "orrery-node",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Peer-to-peer AI inference on Solana. An OpenAI-compatible router on localhost that sends every request straight to a provider's machine and pays it per answer through a payment channel. Zero cut in between.",
+  "license": "MIT",
+  "keywords": [
+    "solana",
+    "ai",
+    "llm",
+    "inference",
+    "p2p",
+    "peer-to-peer",
+    "openai",
+    "openai-compatible",
+    "router",
+    "gateway",
+    "payment-channel",
+    "micropayments",
+    "usdc",
+    "decentralized",
+    "vllm",
+    "ollama",
+    "gpu",
+    "cursor",
+    "langchain"
+  ],
+  "homepage": "https://orrerynode.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orrery-node/orrery.git",
+    "directory": "node"
+  },
+  "bugs": {
+    "url": "https://github.com/orrery-node/orrery/issues"
+  },
+  "type": "module",
+  "bin": {
+    "orrery": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "orrery": "tsx src/cli.ts",
+    "test": "tsx --test test/*.test.ts",
+    "typecheck": "tsc --noEmit",
+    "e2e": "bash devtools/e2e.sh",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/cli.js",
+    "prepublishOnly": "pnpm run build && pnpm test"
+  },
+  "dependencies": {
+    "@solana/spl-token": "0.4.14",
+    "@solana/web3.js": "1.98.4",
+    "bs58": "6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.19.1",
+    "tsx": "4.23.13",
+    "typescript": "5.9.3"
+  },
+  "author": "Orrery (https://orrerynode.com)"
+}