stellarium-ts 0.16.0 → 0.18.0

package/dist/tests/resource/repository.test.js

@@ -3,7 +3,7 @@ import { signData } from "../../crypto/utils.js";
 import { openDatabase } from "../../db/db.js";
 import { PeerRepository } from "../../peer/repository.js";
 import { resourceAnnouncementPayload, ResourceRepository } from "../../resource/repository.js";
-import { generateBase64KeyPair, RECIPIENT, weatherResource } from "../helpers.js";
+import { generateBase64KeyPair, ORGANIZATION, weatherResource } from "../helpers.js";
 const SELF = "http://self.example";
 const PROVIDER = "http://provider.example";
 function resource(name, functions, baseUrl = PROVIDER) {
@@ -52,16 +52,16 @@ describe("ResourceRepository", () => {
             expect((await repository.getResourceFunction("com.provider", "Forecast", "tomorrow"))?.description).toBe("Tomorrow's forecast");
         });
         test("keeps inference functions' kind and per-token pricing", async () => {
-            const pricing = { inputCostMicroUsdcPerMillionTokens: 3_000_000, outputCostMicroUsdcPerMillionTokens: 0, recipientAddress: RECIPIENT };
+            const pricing = { inputCostMicroUsdPerMillionTokens: 3_000_000, outputCostMicroUsdPerMillionTokens: 0, recipientOrganizationId: ORGANIZATION };
             await repository.learn(resource("Model", [
                 { name: "complete", kind: "inference", parameters: [{ name: "maxTokens", type: "int32" }], paymentManifest: pricing },
-                { name: "count", paymentManifest: { costMicroUsdc: 5, recipientAddress: RECIPIENT } },
+                { name: "count", paymentManifest: { costMicroUsd: 5, recipientOrganizationId: ORGANIZATION } },
             ]));
             const complete = await repository.getResourceFunction("com.provider", "Model", "complete");
             expect(complete).toMatchObject({ kind: "inference", paymentManifest: pricing });
             const count = await repository.getResourceFunction("com.provider", "Model", "count");
             expect(count?.kind).toBeUndefined();
-            expect(count?.paymentManifest).toEqual({ id: expect.any(Number), costMicroUsdc: 5, recipientAddress: RECIPIENT });
+            expect(count?.paymentManifest).toEqual({ id: expect.any(Number), costMicroUsd: 5, recipientOrganizationId: ORGANIZATION });
             const functions = (await repository.getResource("com.provider.Model"))?.functions;
             expect(functions.find(fn => fn.name === "complete")).toMatchObject({ kind: "inference", paymentManifest: pricing });
         });
@@ -102,12 +102,12 @@ describe("ResourceRepository", () => {
         test("returns each function's own payment manifest", async () => {
             await repository.learn(resource("Forecast", [
                 { name: "free" },
-                { name: "paid", paymentManifest: { costMicroUsdc: 250, recipientAddress: RECIPIENT } },
+                { name: "paid", paymentManifest: { costMicroUsd: 250, recipientOrganizationId: ORGANIZATION } },
             ]));
             const found = await repository.getResource("com.provider.Forecast");
             expect(found.metadata).toEqual({ baseUrl: PROVIDER });
             expect(found.functions.find(f => f.name === "free")?.paymentManifest).toBeUndefined();
-            expect(found.functions.find(f => f.name === "paid")?.paymentManifest).toMatchObject({ costMicroUsdc: 250, recipientAddress: RECIPIENT });
+            expect(found.functions.find(f => f.name === "paid")?.paymentManifest).toMatchObject({ costMicroUsd: 250, recipientOrganizationId: ORGANIZATION });
         });
         test("prefers the internal resource", async () => {
             const found = await repository.getResource("com.example.Weather");
@@ -133,13 +133,13 @@ describe("ResourceRepository", () => {
         test("adds new functions, parameters and payment manifests to a known resource", async () => {
             await save([resource("Forecast", [{ name: "today" }])]);
             const result = await save([resource("Forecast", [
-                    { name: "today", parameters: [{ name: "city", type: "string" }], paymentManifest: { costMicroUsdc: 100, recipientAddress: RECIPIENT } },
+                    { name: "today", parameters: [{ name: "city", type: "string" }], paymentManifest: { costMicroUsd: 100, recipientOrganizationId: ORGANIZATION } },
                     { name: "tomorrow" },
                 ])]);
             expect(result).toEqual({ ok: true, rejected: [] });
             const today = await repository.getResourceFunction("com.provider", "Forecast", "today");
             expect(today?.parameters).toEqual([{ name: "city", type: "string" }]);
-            expect(today?.paymentManifest).toMatchObject({ costMicroUsdc: 100 });
+            expect(today?.paymentManifest).toMatchObject({ costMicroUsd: 100 });
             expect(await repository.getResourceFunction("com.provider", "Forecast", "tomorrow")).toBeDefined();
         });
         test("drops descriptions that aren't strings and websites that aren't http(s) URLs", async () => {
@@ -156,7 +156,7 @@ describe("ResourceRepository", () => {
             expect([radar.website, radar.description]).toEqual(["https://radar.example", "Rain radar"]);
         });
         test("removes functions and payment manifests the peer no longer advertises", async () => {
-            await save([resource("Forecast", [{ name: "today", paymentManifest: { costMicroUsdc: 100, recipientAddress: RECIPIENT } }, { name: "old" }])]);
+            await save([resource("Forecast", [{ name: "today", paymentManifest: { costMicroUsd: 100, recipientOrganizationId: ORGANIZATION } }, { name: "old" }])]);
             await save([resource("Forecast", [{ name: "today" }])]);
             expect((await repository.getResourceFunction("com.provider", "Forecast", "today"))?.paymentManifest).toBeUndefined();
             expect(await repository.getResourceFunction("com.provider", "Forecast", "old")).toBeUndefined();

package/dist/tests/routes.test.js

@@ -1,6 +1,8 @@
+import { generateKeyPairSync } from "node:crypto";
 import Fastify from "fastify";
+import { createLocalJWKSet, exportJWK, SignJWT } from "jose";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { signData } from "../crypto/utils.js";
+import { safeVerifyData, signData } from "../crypto/utils.js";
 import { openDatabase } from "../db/db.js";
 import { grantRenewalPayload, grantRequestPayload } from "../grant/grant.js";
 import { GrantRepository } from "../grant/repository.js";
@@ -10,7 +12,7 @@ import { CombinationResourceInvoker, inferenceVoucherPayload, paymentVoucherPayl
 import { resourceAnnouncementPayload } from "../resource/repository.js";
 import routes from "../routes.js";
 import { createService } from "../service.js";
-import { COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, RECIPIENT, temperatureSource, testConfig, weatherResource } from "./helpers.js";
+import { COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, ORGANIZATION, temperatureSource, testConfig, weatherResource } from "./helpers.js";
 const parameters = [{ name: "city", value: "Oslo" }];
 const inMinutes = (minutes) => new Date(Date.now() + minutes * 60_000).toISOString();
 describe("routes", () => {
@@ -22,12 +24,16 @@ describe("routes", () => {
     let config;
     let service;
     let fastify;
-    let settlePayment;
+    let authorize;
+    let capture;
+    let release;
     beforeEach(async () => {
         db = await openDatabase(":memory:");
         config = testConfig();
         service = createService(db, [weather], config);
-        settlePayment = vi.spyOn(service.operatorClient, "settlePayment").mockResolvedValue(undefined);
+        authorize = vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
+        capture = vi.spyOn(service.operatorClient, "capture").mockResolvedValue(undefined);
+        release = vi.spyOn(service.operatorClient, "release").mockResolvedValue(undefined);
         fastify = Fastify();
         await fastify.register(routes, { prefix: "/v1", service });
         await fastify.ready();
@@ -41,7 +47,7 @@ describe("routes", () => {
     const flushSettlement = () => new Promise((resolve) => setTimeout(resolve, 10));
     describe("POST /v1/run/resource", () => {
         function voucherFor(functionName = "temperature", overrides = {}) {
-            const voucher = callerInvoker.createPaymentVoucher(RECIPIENT, COST, weather.path, weather.name, functionName, parameters);
+            const voucher = callerInvoker.createPaymentVoucher(ORGANIZATION, COST, weather.path, weather.name, functionName, parameters);
             if (Object.keys(overrides).length === 0) {
                 return voucher;
             }
@@ -56,13 +62,30 @@ describe("routes", () => {
                 payload: { resourcePath: weather.path, resourceName: weather.name, functionName: "temperature", parameters, ...body },
             });
         }
-        test("runs a paid function with a valid voucher and settles it", async () => {
+        test("authorizes a paid function's voucher, runs it, then captures it", async () => {
             const paymentVoucher = voucherFor();
             const response = await runResource({ paymentVoucher });
             expect(response.statusCode).toBe(200);
             expect(response.json()).toEqual({ value: 12, error: null });
+            expect(authorize).toHaveBeenCalledExactlyOnceWith(paymentVoucher);
             await flushSettlement();
-            expect(settlePayment).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher });
+            expect(capture).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher });
+            expect(release).not.toHaveBeenCalled();
+        });
+        test.each([
+            [402, "Insufficient balance"],
+            [403, "Payer organization is frozen"],
+            [503, "Payment operator is unavailable"],
+        ])("answers the operator's %i refusal without running the function", async (status, error) => {
+            authorize.mockResolvedValueOnce({ ok: false, status, error });
+            const exec = vi.spyOn(weather.functions[0], "exec");
+            const response = await runResource({ paymentVoucher: voucherFor() });
+            expect(response.statusCode).toBe(status);
+            expect(response.json()).toEqual({ error });
+            expect(exec).not.toHaveBeenCalled();
+            await flushSettlement();
+            expect(capture).not.toHaveBeenCalled();
+            expect(release).not.toHaveBeenCalled();
         });
         test("refuses a voucher from a blocked caller, even for an unrestricted function", async () => {
             await service.grantService.block(caller.publicKey);
@@ -70,7 +93,7 @@ describe("routes", () => {
             expect(response.statusCode).toBe(403);
             expect(response.json()).toEqual({ error: "Caller is blocked" });
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test("accepts a voucher that pays more than the cost", async () => {
             const response = await runResource({ paymentVoucher: voucherFor("temperature", { amount: COST + 1 }) });
@@ -80,11 +103,11 @@ describe("routes", () => {
             const response = await runResource({});
             expect(response.statusCode).toBe(402);
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test.each([
             ["pays less than the cost", { amount: COST - 1 }],
-            ["pays a different recipient", { recipientAddress: "11111111111111111111111111111111" }],
+            ["pays a different recipient", { recipientOrganizationId: "org_other" }],
             ["has expired", { expiresAt: new Date(Date.now() - 1000).toISOString() }],
             ["has an unparseable expiry", { expiresAt: "not-a-date" }],
         ])("rejects a voucher that %s", async (_, overrides) => {
@@ -92,14 +115,14 @@ describe("routes", () => {
             expect(response.statusCode).toBe(400);
             expect(response.json()).toEqual({ error: "Invalid payment voucher" });
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test("rejects a voucher whose parameters were tampered with", async () => {
             const response = await runResource({ paymentVoucher: voucherFor(), parameters: [{ name: "city", value: "Bergen" }] });
             expect(response.statusCode).toBe(400);
         });
         test("rejects a voucher issued for a different function", async () => {
-            const paymentVoucher = callerInvoker.createPaymentVoucher(RECIPIENT, COST, weather.path, weather.name, "humidity", parameters);
+            const paymentVoucher = callerInvoker.createPaymentVoucher(ORGANIZATION, COST, weather.path, weather.name, "humidity", parameters);
             const response = await runResource({ paymentVoucher });
             expect(response.statusCode).toBe(400);
         });
@@ -122,21 +145,23 @@ describe("routes", () => {
             expect(response.statusCode).toBe(200);
             expect(response.json()).toEqual({ value: 80, error: null });
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test("rejects an unknown function without settling the voucher", async () => {
             const response = await runResource({ functionName: "missing", paymentVoucher: voucherFor("missing") });
             expect(response.statusCode).toBe(400);
             expect(response.json()).toEqual({ error: "Function not found" });
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
-        test("does not settle when the invoke returns an error", async () => {
+        test("releases the hold when the invoke returns an error", async () => {
             vi.spyOn(service.resourceInvoker, "invoke").mockResolvedValueOnce({ value: null, error: { message: "boom" } });
-            const response = await runResource({ paymentVoucher: voucherFor() });
+            const paymentVoucher = voucherFor();
+            const response = await runResource({ paymentVoucher });
             expect(response.statusCode).toBe(200);
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
+            expect(release).toHaveBeenCalledExactlyOnceWith(paymentVoucher);
         });
         test("rejects an unknown resource", async () => {
             const response = await runResource({ resourceName: "Missing" });
@@ -161,7 +186,7 @@ describe("routes", () => {
             const response = await run("Bearer secret");
             expect(response.statusCode).toBe(200);
             // RequestScript resource calls evaluate to the invoker's { value, error } result.
-            expect(response.json()).toEqual({ returnValue: { value: 12, error: null } });
+            expect(response.json()).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 12, error: null } });
         });
         test("requires an Authorization header", async () => {
             const response = await run();
@@ -196,6 +221,96 @@ describe("routes", () => {
             expect(response.statusCode).toBe(400);
             expect(response.json()).toMatchObject({ error: "Invalid script" });
         });
+        test("answers 422 for a script that fails while running", async () => {
+            const response = await run("Bearer secret", { source: "request R {\n  return 1 / 0\n}" });
+            expect(response.statusCode).toBe(422);
+            expect(response.json()).toMatchObject({ error: "Script failed", details: expect.stringContaining("Division by zero"), usage: { tokens: 4 } });
+        });
+        describe("with run tokens", () => {
+            const operatorKeys = generateKeyPairSync("ed25519");
+            let tokenService;
+            let tokenApp;
+            let authorizeRun;
+            let captureRun;
+            let releaseRun;
+            beforeEach(async () => {
+                const jwk = await exportJWK(operatorKeys.publicKey);
+                tokenService = createService(db, [weather], config, { runTokenKeys: createLocalJWKSet({ keys: [{ ...jwk, alg: "EdDSA" }] }) });
+                authorizeRun = vi.spyOn(tokenService.operatorClient, "authorizeRun").mockResolvedValue({ ok: true, heldMicroUsd: 50_000, maxTokens: 9 });
+                captureRun = vi.spyOn(tokenService.operatorClient, "captureRun").mockResolvedValue(undefined);
+                releaseRun = vi.spyOn(tokenService.operatorClient, "releaseRun").mockResolvedValue(undefined);
+                vi.spyOn(tokenService.operatorClient, "authorize").mockResolvedValue({ ok: true });
+                vi.spyOn(tokenService.operatorClient, "capture").mockResolvedValue(undefined);
+                tokenApp = Fastify();
+                await tokenApp.register(routes, { prefix: "/v1", service: tokenService });
+                await tokenApp.ready();
+            });
+            afterEach(async () => {
+                await tokenApp.close();
+            });
+            /** A token the operator would issue, for `organizationId`'s client on this node unless `audience` says otherwise. */
+            const runToken = (organizationId, options = {}) => new SignJWT({ org: organizationId })
+                .setProtectedHeader({ alg: "EdDSA" })
+                .setIssuer("stellarium")
+                .setSubject("cli_test")
+                .setAudience(options.audience ?? config.publicKey)
+                .setIssuedAt()
+                .setExpirationTime(options.expiresIn ?? "15m")
+                .sign(options.key ?? operatorKeys.privateKey);
+            const runWith = async (token, source = temperatureSource) => tokenApp.inject({
+                method: "POST", url: "/v1/run", headers: { authorization: `Bearer ${token}` }, payload: { source },
+            });
+            test("bills another organization's run, and charges its call to this node's paid function to the run", async () => {
+                const token = await runToken("org_caller");
+                const response = await runWith(token);
+                expect(response.statusCode).toBe(200);
+                expect(response.json()).toEqual({ returnValue: { value: 12, error: null }, usage: { tokens: 17 } });
+                const runId = authorizeRun.mock.calls[0][0].runId;
+                expect(authorizeRun).toHaveBeenCalledWith({ token, runId: expect.any(String), source: temperatureSource });
+                // The local paid function signed a voucher for the run, paying this node's organization.
+                const [voucher] = tokenService.operatorClient.authorize.mock.calls[0];
+                expect(voucher).toMatchObject({ runId, recipientOrganizationId: ORGANIZATION, amount: COST, publicKey: config.publicKey });
+                expect(safeVerifyData(paymentVoucherPayload(voucher), voucher.publicKey, voucher.signature)).toBe(true);
+                await vi.waitFor(() => expect(captureRun).toHaveBeenCalledWith({ runId, tokens: 17 }));
+            });
+            test("runs this node's own organization's tokens free, without the operator", async () => {
+                const response = await runWith(await runToken(ORGANIZATION));
+                expect(response.json()).toEqual({ returnValue: { value: 12, error: null }, usage: { tokens: 17 } });
+                expect(authorizeRun).not.toHaveBeenCalled();
+                expect(tokenService.operatorClient.authorize).not.toHaveBeenCalled();
+            });
+            test("answers the operator's refusal without running the script", async () => {
+                authorizeRun.mockResolvedValue({ ok: false, status: 402, error: "Insufficient balance" });
+                const response = await runWith(await runToken("org_caller"));
+                expect(response.statusCode).toBe(402);
+                expect(response.json()).toEqual({ error: "Insufficient balance" });
+                expect(tokenService.operatorClient.authorize).not.toHaveBeenCalled();
+            });
+            test("charges a script that fails for what it executed, and releases a run the node failed", async () => {
+                const failing = await runWith(await runToken("org_caller"), "request R {\n  return 1 / 0\n}");
+                expect(failing.statusCode).toBe(422);
+                await vi.waitFor(() => expect(captureRun).toHaveBeenCalledWith({ runId: expect.any(String), tokens: 4 }));
+                vi.spyOn(tokenService.resourceResolver, "resolve").mockRejectedValue(new Error("database is gone"));
+                const broken = await runWith(await runToken("org_caller"));
+                expect(broken.statusCode).toBe(500);
+                await vi.waitFor(() => expect(releaseRun).toHaveBeenCalledTimes(1));
+            });
+            test.each([
+                ["addressed to another node", () => runToken("org_caller", { audience: generateBase64KeyPair().publicKey })],
+                ["signed by another key", () => runToken("org_caller", { key: generateKeyPairSync("ed25519").privateKey })],
+                ["expired", () => runToken("org_caller", { expiresIn: "-1m" })],
+            ])("refuses a token %s", async (_, token) => {
+                const response = await runWith(await token());
+                expect(response.statusCode).toBe(401);
+                expect(response.json()).toEqual({ error: "Invalid run token" });
+                expect(authorizeRun).not.toHaveBeenCalled();
+            });
+            test("still accepts the API key", async () => {
+                const response = await tokenApp.inject({ method: "POST", url: "/v1/run", headers: { authorization: "Bearer secret" }, payload: { source: temperatureSource } });
+                expect(response.statusCode).toBe(200);
+                expect(authorizeRun).not.toHaveBeenCalled();
+            });
+        });
     });
     describe("GET /v1/self", () => {
         test("describes this node from its config", async () => {
@@ -270,7 +385,7 @@ describe("routes", () => {
                     parameters: [{ name: "city", type: "string" }],
                     returnType: "string",
                     exec: async () => "sunny",
-                    paymentManifest: { costMicroUsdc: 500, recipientAddress: RECIPIENT },
+                    paymentManifest: { costMicroUsd: 500, recipientOrganizationId: ORGANIZATION },
                 }],
         });
         function broadcast(resources, privateKey = keys.privateKey, publicKey = keys.publicKey) {
@@ -294,7 +409,7 @@ describe("routes", () => {
             const resources = (await fastify.inject({ method: "GET", url: "/v1/resources" })).json().resources;
             expect(resources.find((r) => r.name === "Forecast")).toMatchObject({
                 baseUrl: peer.baseUrl,
-                functions: [{ name: "tomorrow", paymentManifest: { costMicroUsdc: 500, recipientAddress: RECIPIENT } }],
+                functions: [{ name: "tomorrow", paymentManifest: { costMicroUsd: 500, recipientOrganizationId: ORGANIZATION } }],
             });
         });
         test("rejects a broadcast from an unknown peer", async () => {
@@ -366,7 +481,7 @@ describe("restricted functions", () => {
         name: "Vault",
         functions: [
             { name: "open", parameters: [{ name: "city", type: "string" }], returnType: "int32", exec: async () => 7, restricted: true },
-            { name: "premium", parameters: [{ name: "city", type: "string" }], returnType: "int32", exec: async () => 9, restricted: true, paymentManifest: { costMicroUsdc: COST, recipientAddress: RECIPIENT } },
+            { name: "premium", parameters: [{ name: "city", type: "string" }], returnType: "int32", exec: async () => 9, restricted: true, paymentManifest: { costMicroUsd: COST, recipientOrganizationId: ORGANIZATION } },
         ],
     };
     const call = (functionName) => ({ resourcePath: "com.example", resourceName: "Vault", functionName, parameters });
@@ -379,7 +494,9 @@ describe("restricted functions", () => {
     beforeEach(async () => {
         db = await openDatabase(":memory:");
         service = createService(db, [restricted], testConfig());
-        vi.spyOn(service.operatorClient, "settlePayment").mockResolvedValue(undefined);
+        vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
+        vi.spyOn(service.operatorClient, "capture").mockResolvedValue(undefined);
+        vi.spyOn(service.operatorClient, "release").mockResolvedValue(undefined);
         callerDb = await openDatabase(":memory:");
         callerGrants = new GrantService(new GrantRepository(callerDb), { baseUrl: "http://caller", ...caller });
         grant = await service.grantService.issue(caller.publicKey, [{ resourcePath: "com.example", resourceName: "Vault" }], { lifetimeMs: 3_600_000 });
@@ -491,11 +608,11 @@ describe("restricted functions", () => {
         expect(response.statusCode).toBe(403);
     });
     test("checks the authorization before the voucher, and needs both for a paid function", async () => {
-        const paymentVoucher = callerInvoker.createPaymentVoucher(RECIPIENT, COST, "com.example", "Vault", "premium", parameters);
+        const paymentVoucher = callerInvoker.createPaymentVoucher(ORGANIZATION, COST, "com.example", "Vault", "premium", parameters);
         const unauthorized = await runResource({ ...call("premium"), paymentVoucher });
         expect(unauthorized.statusCode).toBe(403);
         await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(service.operatorClient.settlePayment).not.toHaveBeenCalled();
+        expect(service.operatorClient.authorize).not.toHaveBeenCalled();
         const unpaid = await runResource({ ...call("premium"), authorization: callerGrants.authorize(grant, call("premium")) });
         expect(unpaid.statusCode).toBe(402);
         const paid = await runResource({ ...call("premium"), paymentVoucher, authorization: callerGrants.authorize(grant, call("premium")) });
@@ -571,15 +688,19 @@ describe("inference functions", () => {
     // "Hello world!" is 3 input tokens by the fixture's estimator. 3 at $3/M plus 1,000 at $15/M, rounded up.
     const parameters = [{ name: "prompt", value: "Hello world!" }, { name: "maxTokens", value: 1000 }];
     const MAX_AMOUNT = 15_009;
-    const manifest = { ...INFERENCE_RATES, recipientAddress: RECIPIENT };
+    const manifest = { ...INFERENCE_RATES, recipientOrganizationId: ORGANIZATION };
     let db;
     let service;
     let fastify;
-    let settlePayment;
+    let authorize;
+    let capture;
+    let release;
     beforeEach(async () => {
         db = await openDatabase(":memory:");
         service = createService(db, [weather, model], testConfig());
-        settlePayment = vi.spyOn(service.operatorClient, "settlePayment").mockResolvedValue(undefined);
+        authorize = vi.spyOn(service.operatorClient, "authorize").mockResolvedValue({ ok: true });
+        capture = vi.spyOn(service.operatorClient, "capture").mockResolvedValue(undefined);
+        release = vi.spyOn(service.operatorClient, "release").mockResolvedValue(undefined);
         fastify = Fastify();
         await fastify.register(routes, { prefix: "/v1", service });
         await fastify.ready();
@@ -639,7 +760,7 @@ describe("inference functions", () => {
             expect(response.statusCode).toBe(200);
             expect(response.json()).toEqual({ value: "echo: Hello world!", error: null, usage: { inputTokens: 3, outputTokens: 1000 } });
             await flushSettlement();
-            expect(settlePayment).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher, usage: { inputTokens: 3, outputTokens: 1000 } });
+            expect(capture).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher, usage: { inputTokens: 3, outputTokens: 1000 } });
         });
         test("refuses a voucher below the estimator's requirement without running inference", async () => {
             const exec = vi.spyOn(model.functions[0], "exec");
@@ -648,20 +769,20 @@ describe("inference functions", () => {
             expect(response.json()).toMatchObject({ requiredMaxAmount: MAX_AMOUNT });
             expect(exec).not.toHaveBeenCalled();
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
         });
         test.each([
-            ["a different input rate", { inputCostMicroUsdcPerMillionTokens: 1 }],
-            ["a different output rate", { outputCostMicroUsdcPerMillionTokens: 1 }],
+            ["a different input rate", { inputCostMicroUsdPerMillionTokens: 1 }],
+            ["a different output rate", { outputCostMicroUsdPerMillionTokens: 1 }],
             ["a maxTokens other than the call's", { maxTokens: 999 }],
-            ["a different recipient", { recipientAddress: "11111111111111111111111111111111" }],
+            ["a different recipient", { recipientOrganizationId: "org_other" }],
         ])("rejects a voucher with %s", async (_, overrides) => {
             const response = await call("/v1/run/resource", { paymentVoucher: voucherFor("complete", overrides) });
             expect(response.statusCode).toBe(400);
             expect(response.json()).toEqual({ error: "Invalid payment voucher" });
         });
         test("rejects a fixed voucher for an inference function, and an inference voucher for a fixed function", async () => {
-            const fixed = callerInvoker.createPaymentVoucher(RECIPIENT, MAX_AMOUNT, model.path, model.name, "complete", parameters);
+            const fixed = callerInvoker.createPaymentVoucher(ORGANIZATION, MAX_AMOUNT, model.path, model.name, "complete", parameters);
             expect((await call("/v1/run/resource", { paymentVoucher: fixed })).statusCode).toBe(400);
             const weatherParameters = [{ name: "city", value: "Oslo" }];
             const inference = callerInvoker.createInferenceVoucher(manifest, MAX_AMOUNT, 1000, weather.path, weather.name, "temperature", weatherParameters);
@@ -674,21 +795,25 @@ describe("inference functions", () => {
             const response = await call("/v1/run/resource", { paymentVoucher });
             expect(response.json().usage).toEqual({ inputTokens: 3, outputTokens: 1000 });
             await flushSettlement();
-            expect(settlePayment).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher, usage: { inputTokens: 3, outputTokens: 1000 } });
+            expect(capture).toHaveBeenCalledExactlyOnceWith({ voucher: paymentVoucher, usage: { inputTokens: 3, outputTokens: 1000 } });
         });
-        test("does not settle a call that charges nothing", async () => {
+        test("releases the hold of a call that charges nothing", async () => {
             vi.spyOn(model.functions[0], "exec").mockResolvedValue({ value: "", usage: { inputTokens: 0, outputTokens: 0 } });
-            const response = await call("/v1/run/resource", { paymentVoucher: voucherFor() });
+            const paymentVoucher = voucherFor();
+            const response = await call("/v1/run/resource", { paymentVoucher });
             expect(response.statusCode).toBe(200);
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
+            expect(release).toHaveBeenCalledExactlyOnceWith(paymentVoucher);
         });
-        test("does not settle when the function doesn't report usage", async () => {
+        test("releases the hold when the function doesn't report usage", async () => {
             vi.spyOn(model.functions[0], "exec").mockResolvedValue("no usage");
-            const response = await call("/v1/run/resource", { paymentVoucher: voucherFor() });
+            const paymentVoucher = voucherFor();
+            const response = await call("/v1/run/resource", { paymentVoucher });
             expect(response.json().error.message).toContain("must return { value, usage");
             await flushSettlement();
-            expect(settlePayment).not.toHaveBeenCalled();
+            expect(capture).not.toHaveBeenCalled();
+            expect(release).toHaveBeenCalledExactlyOnceWith(paymentVoucher);
         });
     });
     test("GET /v1/resources announces the kind and per-token pricing", async () => {

package/dist/tests/server.test.js

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test, vi } from "vitest";
-import { DEFAULT_COST_LIMIT_MICRO_USDC, resolveConfig } from "../server.js";
+import { DEFAULT_COST_LIMIT_MICRO_USD, resolveConfig } from "../server.js";
 import { modelResource, weatherResource } from "./helpers.js";
 describe("resolveConfig", () => {
     const keys = { baseUrl: "http://node.example", publicKey: "public", privateKey: "private" };
@@ -15,15 +15,15 @@ describe("resolveConfig", () => {
         vi.stubEnv("BASE_URL", "http://env.example");
         vi.stubEnv("SIGNING_PUBLIC_KEY", "env-public");
         vi.stubEnv("SIGNING_PRIVATE_KEY", "env-private");
-        vi.stubEnv("COST_LIMIT_MICRO_USDC", "500");
-        expect(resolveConfig({})).toMatchObject({ baseUrl: "http://env.example", publicKey: "env-public", privateKey: "env-private", costLimitMicroUsdc: 500 });
+        vi.stubEnv("COST_LIMIT_MICRO_USD", "500");
+        expect(resolveConfig({})).toMatchObject({ baseUrl: "http://env.example", publicKey: "env-public", privateKey: "env-private", costLimitMicroUsd: 500 });
     });
     test("defaults the cost limit", () => {
-        vi.stubEnv("COST_LIMIT_MICRO_USDC", undefined);
-        expect(resolveConfig(keys).costLimitMicroUsdc).toBe(DEFAULT_COST_LIMIT_MICRO_USDC);
+        vi.stubEnv("COST_LIMIT_MICRO_USD", undefined);
+        expect(resolveConfig(keys).costLimitMicroUsd).toBe(DEFAULT_COST_LIMIT_MICRO_USD);
     });
-    test.each([-1, 1.5, Number.NaN])("rejects a cost limit of %s", (costLimitMicroUsdc) => {
-        expect(() => resolveConfig({ ...keys, costLimitMicroUsdc })).toThrow("costLimitMicroUsdc");
+    test.each([-1, 1.5, Number.NaN])("rejects a cost limit of %s", (costLimitMicroUsd) => {
+        expect(() => resolveConfig({ ...keys, costLimitMicroUsd })).toThrow("costLimitMicroUsd");
     });
     test("requires the signing keys and base URL", () => {
         vi.stubEnv("SIGNING_PRIVATE_KEY", undefined);
@@ -35,12 +35,12 @@ describe("resolveConfig", () => {
         expect(() => resolveConfig(keys, [weatherResource()])).toThrow("OPERATOR_URL is required");
     });
     test("defaults the inference cost limit to the cost limit, and reads its own option or environment variable", () => {
-        vi.stubEnv("INFERENCE_COST_LIMIT_MICRO_USDC", undefined);
-        expect(resolveConfig({ ...keys, costLimitMicroUsdc: 700 }).inferenceCostLimitMicroUsdc).toBe(700);
-        vi.stubEnv("INFERENCE_COST_LIMIT_MICRO_USDC", "900");
-        expect(resolveConfig({ ...keys, costLimitMicroUsdc: 700 }).inferenceCostLimitMicroUsdc).toBe(900);
-        expect(resolveConfig({ ...keys, inferenceCostLimitMicroUsdc: 1_000 }).inferenceCostLimitMicroUsdc).toBe(1_000);
-        expect(() => resolveConfig({ ...keys, inferenceCostLimitMicroUsdc: -1 })).toThrow("inferenceCostLimitMicroUsdc");
+        vi.stubEnv("INFERENCE_COST_LIMIT_MICRO_USD", undefined);
+        expect(resolveConfig({ ...keys, costLimitMicroUsd: 700 }).inferenceCostLimitMicroUsd).toBe(700);
+        vi.stubEnv("INFERENCE_COST_LIMIT_MICRO_USD", "900");
+        expect(resolveConfig({ ...keys, costLimitMicroUsd: 700 }).inferenceCostLimitMicroUsd).toBe(900);
+        expect(resolveConfig({ ...keys, inferenceCostLimitMicroUsd: 1_000 }).inferenceCostLimitMicroUsd).toBe(1_000);
+        expect(() => resolveConfig({ ...keys, inferenceCostLimitMicroUsd: -1 })).toThrow("inferenceCostLimitMicroUsd");
     });
     test("accepts well-declared inference functions", () => {
         expect(() => resolveConfig({ ...keys, operatorUrl: "http://operator.example" }, [modelResource()])).not.toThrow();
@@ -49,8 +49,8 @@ describe("resolveConfig", () => {
         ["without a maxTokens parameter", { parameters: [{ name: "prompt", type: "string" }] }, "maxTokens: int32"],
         ["whose maxTokens isn't an int32", { parameters: [{ name: "maxTokens", type: "int64" }] }, "maxTokens: int32"],
         ["that is paid but has no estimator", { estimateInputTokens: undefined }, "estimateInputTokens"],
-        ["priced with a flat cost", { paymentManifest: { costMicroUsdc: 5, recipientAddress: "r" } }, "per million tokens"],
-        ["with a negative rate", { paymentManifest: { inputCostMicroUsdcPerMillionTokens: -1, outputCostMicroUsdcPerMillionTokens: 0, recipientAddress: "r" } }, "per million tokens"],
+        ["priced with a flat cost", { paymentManifest: { costMicroUsd: 5, recipientOrganizationId: "r" } }, "per million tokens"],
+        ["with a negative rate", { paymentManifest: { inputCostMicroUsdPerMillionTokens: -1, outputCostMicroUsdPerMillionTokens: 0, recipientOrganizationId: "r" } }, "per million tokens"],
     ])("rejects an inference function %s", (_, overrides, message) => {
         const model = modelResource();
         model.functions = [{ ...model.functions[0], ...overrides }];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stellarium-ts",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "A Stellarium Node in TypeScript.",
   "homepage": "https://github.com/qualletio/stellarium-ts#readme",
   "bugs": {
@@ -45,7 +45,8 @@
     "@fastify/rate-limit": "^11.2.1",
     "dotenv": "^18.0.5",
     "fastify": "^5.12.5",
-    "requestscript": "1.1.0",
+    "jose": "6.1.0",
+    "requestscript": "1.2.0",
     "sqlite": "^5.1.1",
     "sqlite3": "^6.0.1"
   },