stellarium-ts 0.16.0 → 0.17.0

package/dist/tests/routes.test.js

@@ -10,7 +10,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 +22,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 +45,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 +60,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 +91,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 +101,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 +113,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 +143,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" });
@@ -270,7 +293,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 +317,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 +389,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 +402,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 +516,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 +596,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 +668,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 +677,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 +703,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.17.0",
   "description": "A Stellarium Node in TypeScript.",
   "homepage": "https://github.com/qualletio/stellarium-ts#readme",
   "bugs": {