stellarium-ts 0.16.0 → 0.18.0

package/dist/tests/client/operatorClient.test.js

@@ -1,39 +1,94 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { OperatorClient, SETTLE_PAYMENT_MAX_RETRIES } from "../../client/operatorClient.js";
-describe("settle payment retries", () => {
-    const payment = {
-        voucher: {
-            requestId: "request-1",
-            invocationId: "invocation-1",
-            amount: 10000,
-            recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2",
-            signature: "signature",
-            expiresAt: "2030-01-01T00:00:00.000Z",
-            invocationHash: "hash",
-            publicKey: "public-key",
-        },
-    };
-    const ok = () => new Response(JSON.stringify({ success: true }), { status: 200 });
-    const status = (code, headers) => new Response(null, { status: code, headers });
-    const networkError = (code) => new TypeError("fetch failed", { cause: Object.assign(new Error(code), { code }) });
-    let fetchMock;
-    beforeEach(() => {
-        vi.useFakeTimers();
-        vi.spyOn(console, "error").mockImplementation(() => { });
-        fetchMock = vi.fn();
-        vi.stubGlobal("fetch", fetchMock);
+import { AUTHORIZE_MAX_RETRIES, OPERATOR_MAX_RETRIES, OperatorClient } from "../../client/operatorClient.js";
+import { OPERATOR_AUTH_SCHEME, operatorRequestPayload } from "../../client/operatorAuth.js";
+import { verifyData } from "../../crypto/utils.js";
+import { generateBase64KeyPair } from "../helpers.js";
+const keys = generateBase64KeyPair();
+const client = () => new OperatorClient("https://operator.example/v1", keys.publicKey, keys.privateKey);
+const payment = {
+    voucher: {
+        requestId: "request-1",
+        invocationId: "invocation-1",
+        amount: 10000,
+        recipientOrganizationId: "org_provider",
+        signature: "signature",
+        expiresAt: "2030-01-01T00:00:00.000Z",
+        invocationHash: "hash",
+        publicKey: "public-key",
+    },
+};
+const ok = (body = { success: true }) => new Response(JSON.stringify(body), { status: 200 });
+const status = (code, headers) => new Response(null, { status: code, headers });
+const refusal = (code, error) => new Response(JSON.stringify({ error }), { status: code });
+const networkError = (code) => new TypeError("fetch failed", { cause: Object.assign(new Error(code), { code }) });
+let fetchMock;
+beforeEach(() => {
+    vi.useFakeTimers();
+    vi.spyOn(console, "error").mockImplementation(() => { });
+    fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+});
+afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+describe("request signing", () => {
+    test("signs the method, path, body hash and timestamp with the node key", async () => {
+        fetchMock.mockResolvedValue(ok());
+        await client().capture(payment);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toBe("https://operator.example/v1/payments/capture");
+        const [scheme, encoded] = init.headers.Authorization.split(" ");
+        expect(scheme).toBe(OPERATOR_AUTH_SCHEME);
+        const credentials = JSON.parse(Buffer.from(encoded, "base64url").toString());
+        expect(credentials.publicKey).toBe(keys.publicKey);
+        const payload = operatorRequestPayload("POST", "/v1/payments/capture", JSON.parse(init.body), credentials.timestamp);
+        expect(verifyData(payload, keys.publicKey, credentials.signature)).toBe(true);
+    });
+});
+describe("session", () => {
+    test("returns the node's organization, sending the enrollment token when given", async () => {
+        fetchMock.mockResolvedValue(ok({ organizationId: "org_provider" }));
+        await expect(client().session("enroll-1")).resolves.toEqual({ organizationId: "org_provider" });
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ enrollmentToken: "enroll-1" });
     });
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
+    test("throws the operator's refusal", async () => {
+        fetchMock.mockResolvedValue(refusal(403, "Node is not enrolled in an organization"));
+        await expect(client().session()).rejects.toThrow("Node is not enrolled in an organization");
+    });
+});
+describe("authorize", () => {
+    test("reports a hold as ok", async () => {
+        fetchMock.mockResolvedValue(ok());
+        await expect(client().authorize(payment.voucher)).resolves.toEqual({ ok: true });
+    });
+    test.each([[402, "Insufficient balance"], [403, "Payer organization is frozen"], [422, "Recipient organization can't receive payouts"]])("passes a %i refusal through without retrying", async (code, error) => {
+        fetchMock.mockResolvedValue(refusal(code, error));
+        await expect(client().authorize(payment.voucher)).resolves.toEqual({ ok: false, status: code, error });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
     });
+    test("reports a persistent server error as 503 after its few retries", async () => {
+        fetchMock.mockResolvedValue(status(500));
+        const pending = client().authorize(payment.voucher);
+        await vi.runAllTimersAsync();
+        await expect(pending).resolves.toMatchObject({ ok: false, status: 503 });
+        expect(fetchMock).toHaveBeenCalledTimes(1 + AUTHORIZE_MAX_RETRIES);
+    });
+    test("reports an unreachable operator as 503", async () => {
+        fetchMock.mockRejectedValue(networkError("ECONNREFUSED"));
+        const pending = client().authorize(payment.voucher);
+        await vi.runAllTimersAsync();
+        await expect(pending).resolves.toEqual({ ok: false, status: 503, error: "Payment operator is unavailable" });
+    });
+});
+describe("capture and release retries", () => {
     test("retries 429 responses with exponential backoff, then succeeds", async () => {
         fetchMock
             .mockResolvedValueOnce(status(429))
             .mockResolvedValueOnce(status(429))
             .mockResolvedValueOnce(ok());
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         await vi.advanceTimersByTimeAsync(0);
         expect(fetchMock).toHaveBeenCalledTimes(1);
         await vi.advanceTimersByTimeAsync(999);
@@ -49,7 +104,7 @@ describe("settle payment retries", () => {
     });
     test("waits for Retry-After when it is longer than the backoff", async () => {
         fetchMock.mockResolvedValueOnce(status(429, { "retry-after": "30" })).mockResolvedValueOnce(ok());
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().release(payment.voucher);
         await vi.advanceTimersByTimeAsync(29_999);
         expect(fetchMock).toHaveBeenCalledTimes(1);
         await vi.advanceTimersByTimeAsync(1);
@@ -58,7 +113,7 @@ describe("settle payment retries", () => {
     });
     test.each([408, 500, 502, 503, 504])("retries %i responses", async (code) => {
         fetchMock.mockResolvedValueOnce(status(code)).mockResolvedValueOnce(ok());
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         await vi.runAllTimersAsync();
         await pending;
         expect(fetchMock).toHaveBeenCalledTimes(2);
@@ -66,31 +121,34 @@ describe("settle payment retries", () => {
     });
     test.each([400, 401, 404, 409, 422])("does not retry %i responses", async (code) => {
         fetchMock.mockResolvedValue(status(code));
-        await new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        await client().capture(payment);
         expect(fetchMock).toHaveBeenCalledTimes(1);
         expect(console.error).toHaveBeenCalledOnce();
     });
     test.each(["ECONNREFUSED", "ECONNRESET"])("retries %s network errors", async (code) => {
         fetchMock.mockRejectedValueOnce(networkError(code)).mockResolvedValueOnce(ok());
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         await vi.runAllTimersAsync();
         await pending;
         expect(fetchMock).toHaveBeenCalledTimes(2);
     });
     test("rethrows the last network error once retries are exhausted", async () => {
         fetchMock.mockRejectedValue(networkError("ECONNREFUSED"));
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         const assertion = expect(pending).rejects.toThrow("fetch failed");
         await vi.runAllTimersAsync();
         await assertion;
-        expect(fetchMock).toHaveBeenCalledTimes(1 + SETTLE_PAYMENT_MAX_RETRIES);
+        expect(fetchMock).toHaveBeenCalledTimes(1 + OPERATOR_MAX_RETRIES);
     });
     test("gives up after the maximum number of retries", async () => {
         fetchMock.mockResolvedValue(status(429));
-        const pending = new OperatorClient("https://operator.example/v1").settlePayment(payment);
+        const pending = client().capture(payment);
         await vi.runAllTimersAsync();
         await pending;
-        expect(fetchMock).toHaveBeenCalledTimes(1 + SETTLE_PAYMENT_MAX_RETRIES);
+        expect(fetchMock).toHaveBeenCalledTimes(1 + OPERATOR_MAX_RETRIES);
         expect(console.error).toHaveBeenCalledOnce();
     });
+    test("throws when no operator URL is configured", async () => {
+        await expect(new OperatorClient(undefined, keys.publicKey, keys.privateKey).capture(payment)).rejects.toThrow("No operator URL is configured");
+    });
 });

package/dist/tests/db/db.test.js

@@ -17,7 +17,7 @@ describe("openDatabase", () => {
         const filename = path.join(dir, "node.db");
         await (await openDatabase(filename)).close();
         const db = await openDatabase(filename);
-        expect(await db.get("PRAGMA user_version")).toEqual({ user_version: 5 });
+        expect(await db.get("PRAGMA user_version")).toEqual({ user_version: 6 });
         await db.close();
     });
     test("rebuilds resource tables from the old schema and keeps peers", async () => {
@@ -61,7 +61,7 @@ describe("openDatabase", () => {
         expect(await reopened.all("SELECT id FROM held_grant")).toEqual([{ id: "g" }]);
         await reopened.close();
     });
-    test("rebuilds a version 4 manifest table so inference functions can omit cost_micro_usdc", async () => {
+    test("rebuilds a version 4 manifest table into the micro-USD, organization-recipient schema", async () => {
         const filename = path.join(dir, "v4.db");
         const old = await open({ filename, driver: sqlite3.Database });
         await old.exec(`
@@ -74,8 +74,8 @@ describe("openDatabase", () => {
         const db = await openDatabase(filename);
         const functionColumns = await db.all("PRAGMA table_info(resource_function)");
         expect(functionColumns.map(column => column.name)).toContain("kind");
-        await db.run(`INSERT INTO resource_function_payment_manifest (resource_function_id, input_cost_micro_usdc_per_million_tokens,
-            output_cost_micro_usdc_per_million_tokens, recipient_address, created_at, updated_at) VALUES (1, 3, 15, 'r', 'now', 'now')`);
+        await db.run(`INSERT INTO resource_function_payment_manifest (resource_function_id, input_cost_micro_usd_per_million_tokens,
+            output_cost_micro_usd_per_million_tokens, recipient_organization_id, created_at, updated_at) VALUES (1, 3, 15, 'r', 'now', 'now')`);
         await db.close();
     });
 });

package/dist/tests/helpers.d.ts

@@ -4,14 +4,15 @@ export declare function generateBase64KeyPair(): {
     publicKey: string;
     privateKey: string;
 };
-export declare const RECIPIENT = "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2";
+/** The operator organization the fixture provider is enrolled in. */
+export declare const ORGANIZATION = "org_provider";
 export declare const COST = 10000;
 export declare function testConfig(overrides?: Partial<NodeConfig>): NodeConfig;
 /** The fixture provider's resource: paid `temperature` and free `humidity`. */
 export declare function weatherResource(baseUrl?: string): StellariumResource;
 export declare const INFERENCE_RATES: {
-    inputCostMicroUsdcPerMillionTokens: number;
-    outputCostMicroUsdcPerMillionTokens: number;
+    inputCostMicroUsdPerMillionTokens: number;
+    outputCostMicroUsdPerMillionTokens: number;
 };
 /**
  * A fixture provider's model: paid inference `complete`, which counts one token per four prompt characters

package/dist/tests/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/tests/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,wBAAgB,qBAAqB;IAM7B,SAAS;IACT,UAAU;EAEjB;AAED,eAAO,MAAM,SAAS,iDAAiD,CAAC;AACxE,eAAO,MAAM,IAAI,QAAQ,CAAC;AAE1B,wBAAgB,UAAU,CAAC,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAAG,UAAU,CAU1E;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CAuBrF;AAED,eAAO,MAAM,eAAe;IAAK,kCAAkC;IAAa,mCAAmC;CAAc,CAAC;AAElI;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CA0BnF;AAED,eAAO,MAAM,iBAAiB,sHAAoH,CAAC"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/tests/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,wBAAgB,qBAAqB;IAM7B,SAAS;IACT,UAAU;EAEjB;AAED,qEAAqE;AACrE,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAC3C,eAAO,MAAM,IAAI,QAAQ,CAAC;AAE1B,wBAAgB,UAAU,CAAC,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAAG,UAAU,CAW1E;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CAuBrF;AAED,eAAO,MAAM,eAAe;IAAK,iCAAiC;IAAa,kCAAkC;CAAc,CAAC;AAEhI;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAA0B,GAAG,kBAAkB,CA0BnF;AAED,eAAO,MAAM,iBAAiB,sHAAoH,CAAC"}

package/dist/tests/helpers.js

@@ -9,7 +9,8 @@ export function generateBase64KeyPair() {
         privateKey: privateKey.toString("base64url"),
     };
 }
-export const RECIPIENT = "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2";
+/** The operator organization the fixture provider is enrolled in. */
+export const ORGANIZATION = "org_provider";
 export const COST = 10000;
 export function testConfig(overrides = {}) {
     return {
@@ -17,8 +18,9 @@ export function testConfig(overrides = {}) {
         ...generateBase64KeyPair(),
         apiKey: "secret",
         operatorUrl: "http://operator.invalid/v1",
-        costLimitMicroUsdc: 100_000,
-        inferenceCostLimitMicroUsdc: 100_000,
+        organizationId: ORGANIZATION,
+        costLimitMicroUsd: 100_000,
+        inferenceCostLimitMicroUsd: 100_000,
         ...overrides,
     };
 }
@@ -36,7 +38,7 @@ export function weatherResource(baseUrl = "http://127.0.0.1:3002") {
                 parameters: [{ name: "city", type: "string" }],
                 returnType: "int32",
                 exec: async (args) => (args.find((arg) => arg.name === "city")?.value === "Oslo" ? 12 : 20),
-                paymentManifest: { costMicroUsdc: COST, recipientAddress: RECIPIENT },
+                paymentManifest: { costMicroUsd: COST },
             },
             {
                 name: "humidity",
@@ -47,7 +49,7 @@ export function weatherResource(baseUrl = "http://127.0.0.1:3002") {
         ],
     };
 }
-export const INFERENCE_RATES = { inputCostMicroUsdcPerMillionTokens: 3_000_000, outputCostMicroUsdcPerMillionTokens: 15_000_000 };
+export const INFERENCE_RATES = { inputCostMicroUsdPerMillionTokens: 3_000_000, outputCostMicroUsdPerMillionTokens: 15_000_000 };
 /**
  * A fixture provider's model: paid inference `complete`, which counts one token per four prompt characters
  * and answers with `maxTokens` tokens, a restricted paid copy `completePrivate`, and free inference `draft`.
@@ -64,7 +66,7 @@ export function modelResource(baseUrl = "http://127.0.0.1:3002") {
             value: `echo: ${prompt(args)}`,
             usage: { inputTokens: Math.ceil(prompt(args).length / 4), outputTokens: Number(args.find((arg) => arg.name === "maxTokens")?.value) },
         }),
-        paymentManifest: { ...INFERENCE_RATES, recipientAddress: RECIPIENT },
+        paymentManifest: { ...INFERENCE_RATES },
     };
     return {
         id: 2,

package/dist/tests/integration/network.test.js

@@ -7,7 +7,7 @@ import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { verifyData } from "../../crypto/utils.js";
 import { paymentVoucherPayload } from "../../resource/invoker.js";
 import { StellariumNode } from "../../server.js";
-import { COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, RECIPIENT, temperatureSource, weatherResource } from "../helpers.js";
+import { COST, generateBase64KeyPair, INFERENCE_RATES, modelResource, ORGANIZATION, temperatureSource, weatherResource } from "../helpers.js";
 /** A free function only callers with a grant from the provider may run. */
 function vaultResource(baseUrl) {
     return {
@@ -35,13 +35,18 @@ function freePort() {
 }
 /**
  * A provider node hosting the paid weather resource, a caller node that bootstraps from it,
- * and a fake operator that records settlements. Everything runs in-process over real HTTP.
+ * and a fake operator that enrolls the provider and records holds and captures. Everything runs in-process over real HTTP.
  */
 // Each test starts real HTTP nodes on SQLite files, which can take several seconds on a loaded CI runner.
 describe("two-node network", { timeout: 15_000 }, () => {
     const servers = [];
     const settlements = [];
     const submissions = [];
+    const authorizations = [];
+    const releases = [];
+    const sessions = [];
+    /** What the fake operator answers to the next authorizations; undefined places the hold. */
+    let refuseAuthorization;
     const callerKeys = generateBase64KeyPair();
     let dir;
     let operatorUrl;
@@ -76,12 +81,34 @@ describe("two-node network", { timeout: 15_000 }, () => {
         dir = await mkdtemp(path.join(tmpdir(), "stellarium-network-"));
         settlements.length = 0;
         submissions.length = 0;
+        authorizations.length = 0;
+        releases.length = 0;
+        sessions.length = 0;
+        refuseAuthorization = undefined;
         const operator = Fastify();
         servers.push(operator);
-        operator.post("/v1/payment", async (request) => {
+        operator.post("/v1/nodes/session", async (request, reply) => {
+            if (!String(request.headers.authorization).startsWith("Stellarium ")) {
+                return reply.status(401).send({ error: "Unsigned request" });
+            }
+            sessions.push(request.body);
+            return { organizationId: ORGANIZATION };
+        });
+        operator.post("/v1/payments/authorize", async (request, reply) => {
+            authorizations.push(request.body);
+            if (refuseAuthorization) {
+                return reply.status(refuseAuthorization.status).send({ error: refuseAuthorization.error });
+            }
+            return { status: "held" };
+        });
+        operator.post("/v1/payments/capture", async (request) => {
             settlements.push(request.body.voucher);
             submissions.push(request.body);
-            return { status: "confirmed" };
+            return { status: "captured" };
+        });
+        operator.post("/v1/payments/release", async (request) => {
+            releases.push(request.body);
+            return { status: "released" };
         });
         operatorUrl = `${await operator.listen({ port: 0, host: "127.0.0.1" })}/v1`;
         const providerPort = await freePort();
@@ -112,19 +139,20 @@ describe("two-node network", { timeout: 15_000 }, () => {
         expect(callerResources.resources).toContainEqual(expect.objectContaining({
             name: "Weather",
             baseUrl: providerUrl,
-            functions: expect.arrayContaining([expect.objectContaining({ name: "temperature", paymentManifest: { costMicroUsdc: COST, recipientAddress: RECIPIENT } })]),
+            functions: expect.arrayContaining([expect.objectContaining({ name: "temperature", paymentManifest: { costMicroUsd: COST, recipientOrganizationId: ORGANIZATION } })]),
         }));
-        expect(await run(caller.url)).toEqual({ returnValue: { value: 12, error: null } });
+        expect(await run(caller.url)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 12, error: null } });
         await vi.waitFor(() => expect(settlements).toHaveLength(1));
         const [voucher] = settlements;
-        expect(voucher).toMatchObject({ amount: COST, recipientAddress: RECIPIENT, publicKey: callerKeys.publicKey });
+        expect(authorizations).toEqual([{ voucher }]);
+        expect(voucher).toMatchObject({ amount: COST, recipientOrganizationId: ORGANIZATION, publicKey: callerKeys.publicKey });
         expect(verifyData(paymentVoucherPayload(voucher), voucher.publicKey, voucher.signature)).toBe(true);
     });
     test("the caller restarts on the same database without failing", async () => {
         const first = await startCaller();
         await first.fastify.close();
         const second = await startCaller();
-        expect(await run(second.url)).toEqual({ returnValue: { value: 12, error: null } });
+        expect(await run(second.url)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 12, error: null } });
     });
     describe("restricted functions", () => {
         test("the caller needs a grant from the provider, then calls with it", async () => {
@@ -132,13 +160,13 @@ describe("two-node network", { timeout: 15_000 }, () => {
             const refused = await run(caller.url, vaultSource);
             expect(refused.returnValue.error.message).toContain(`requires a grant from ${providerUrl}`);
             await caller.node.addGrant(await provider.issueGrant(callerKeys.publicKey, [vault], { lifetimeMs: HOUR }));
-            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+            expect(await run(caller.url, vaultSource)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 7, error: null } });
         });
         test("the caller asks the provider for a grant, then calls with it", async () => {
             const caller = await startCaller();
             await expect(caller.node.requestGrant(providerUrl, [vault], { invite: "wrong" })).rejects.toThrow("Grant request refused");
             await caller.node.requestGrant(providerUrl, [vault], { invite: "letmein" });
-            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+            expect(await run(caller.url, vaultSource)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 7, error: null } });
         });
         test("the provider's admin blocks a caller over HTTP, then unblocks it", async () => {
             const caller = await startCaller();
@@ -154,12 +182,12 @@ describe("two-node network", { timeout: 15_000 }, () => {
             expect(refused.returnValue.error.message).toContain("Invalid authorization");
             await expect(caller.node.requestGrant(providerUrl, [vault], { invite: "letmein" })).rejects.toThrow("refused");
             expect((await adminRequest("DELETE")).status).toBe(200);
-            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+            expect(await run(caller.url, vaultSource)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 7, error: null } });
         });
         test("grants passed at start are loaded, and revocation at the provider cuts them off", async () => {
             const chain = await provider.issueGrant(callerKeys.publicKey, [vault], { lifetimeMs: HOUR });
             const caller = await startCaller({ grants: [chain] });
-            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+            expect(await run(caller.url, vaultSource)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 7, error: null } });
             await provider.revokeGrant(chain[0].id);
             const refused = await run(caller.url, vaultSource);
             expect(refused.returnValue.error.message).toContain("Invalid authorization");
@@ -171,7 +199,7 @@ describe("two-node network", { timeout: 15_000 }, () => {
             const userKeys = generateBase64KeyPair();
             const user = await startCaller({ ...userKeys, databasePath: path.join(dir, "user.db") });
             await user.node.addGrant(await caller.node.delegateGrant(root.id, userKeys.publicKey, [vault], { lifetimeMs: HOUR }));
-            expect(await run(user.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+            expect(await run(user.url, vaultSource)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 7, error: null } });
         });
         test("the refresher renews a grant past half its lifetime", async () => {
             const fetchSpy = vi.spyOn(globalThis, "fetch");
@@ -181,30 +209,53 @@ describe("two-node network", { timeout: 15_000 }, () => {
             fetchSpy.mockRestore();
             // Well past the first copy's expiry, the renewed one still works.
             await new Promise((resolve) => setTimeout(resolve, 500));
-            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+            expect(await run(caller.url, vaultSource)).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: 7, error: null } });
         });
     });
     test("the caller refuses a call that costs more than its limit", async () => {
-        const caller = await startCaller({ costLimitMicroUsdc: COST - 1 });
+        const caller = await startCaller({ costLimitMicroUsd: COST - 1 });
         const result = await run(caller.url);
         expect(result.returnValue.value).toBeNull();
         expect(result.returnValue.error.message).toContain("exceeds the cost limit");
         expect(settlements).toEqual([]);
+        expect(authorizations).toEqual([]);
+    });
+    test("a caller with an enrollment token enrolls at startup; one without still reports its URL", async () => {
+        sessions.length = 0;
+        const enrolled = await startCaller({ operatorUrl, enrollmentToken: "enr_caller" });
+        expect(sessions).toEqual([{ enrollmentToken: "enr_caller", baseUrl: enrolled.url }]);
+        sessions.length = 0;
+        const other = await startCaller({ operatorUrl, databasePath: path.join(dir, "caller-2.db") });
+        await vi.waitFor(() => expect(sessions).toEqual([{ baseUrl: other.url }]));
+    });
+    test("a node without paid functions or a token starts without waiting for an unreachable operator", async () => {
+        const caller = await startCaller({ operatorUrl: "http://127.0.0.1:1/v1", databasePath: path.join(dir, "caller-3.db") });
+        expect(await run(caller.url)).toMatchObject({ returnValue: { value: 12, error: null } });
+    });
+    test("the provider refuses to run a call the operator won't hold, and the caller sees why", async () => {
+        const caller = await startCaller();
+        refuseAuthorization = { status: 402, error: "Insufficient balance" };
+        const result = await run(caller.url);
+        expect(result.returnValue.value).toBeNull();
+        expect(result.returnValue.error.message).toContain("Insufficient balance");
+        expect(authorizations).toHaveLength(1);
+        expect(settlements).toEqual([]);
+        expect(releases).toEqual([]);
     });
     describe("inference functions", () => {
         test("the caller prices a call with the provider's estimate, pays for it, and the provider settles its usage", async () => {
             const caller = await startCaller();
             const result = await run(caller.url, completeSource);
-            expect(result).toEqual({ returnValue: { value: "echo: Hello world!", error: null } });
+            expect(result).toEqual({ usage: { tokens: expect.any(Number) }, returnValue: { value: "echo: Hello world!", error: null } });
             await vi.waitFor(() => expect(submissions).toHaveLength(1));
             // 3 input tokens at $3/M plus 10 output tokens at $15/M, rounded up.
             expect(submissions[0]).toMatchObject({
-                voucher: { kind: "inference", maxAmount: 159, maxTokens: 10, ...INFERENCE_RATES, recipientAddress: RECIPIENT, publicKey: callerKeys.publicKey },
+                voucher: { kind: "inference", maxAmount: 159, maxTokens: 10, ...INFERENCE_RATES, recipientOrganizationId: ORGANIZATION, publicKey: callerKeys.publicKey },
                 usage: { inputTokens: 3, outputTokens: 10 },
             });
         });
         test("the caller refuses a call whose maxAmount is over its inference cost limit", async () => {
-            const caller = await startCaller({ inferenceCostLimitMicroUsdc: 158 });
+            const caller = await startCaller({ inferenceCostLimitMicroUsd: 158 });
             const result = await run(caller.url, completeSource);
             expect(result.returnValue.error.message).toContain("exceeds the inference cost limit");
             expect(submissions).toEqual([]);

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

@@ -18,11 +18,23 @@ describe("payment voucher", () => {
         const { publicKey, privateKey } = generateBase64KeyPair();
         const invoker = new CombinationResourceInvoker({}, 100_000, publicKey, privateKey);
         const parameters = [{ name: "city", value: "Oslo" }];
-        const voucher = invoker.createPaymentVoucher("4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2", 10000, "com.example", "Weather", "forecast", parameters);
+        const voucher = invoker.createPaymentVoucher("org_provider", 10000, "com.example", "Weather", "forecast", parameters);
         expect(voucher.invocationHash).toBe(invocationHash("com.example", "Weather", "forecast", parameters));
         expect(verifyData(paymentVoucherPayload(voucher), voucher.publicKey, voucher.signature)).toBe(true);
         expect(verifyData(voucher, voucher.publicKey, voucher.signature)).toBe(false);
     });
+    test("signs a run id last, and only when the voucher has one", () => {
+        const { publicKey, privateKey } = generateBase64KeyPair();
+        const invoker = new CombinationResourceInvoker({}, 100_000, publicKey, privateKey);
+        const parameters = [{ name: "city", value: "Oslo" }];
+        const plain = invoker.createPaymentVoucher("org_provider", 10000, "com.example", "Weather", "forecast", parameters);
+        const forRun = invoker.createPaymentVoucher("org_provider", 10000, "com.example", "Weather", "forecast", parameters, "run-1");
+        // Vouchers without a run sign the same bytes as before run ids existed.
+        expect(Object.keys(paymentVoucherPayload(plain))).toEqual(["requestId", "invocationId", "amount", "recipientOrganizationId", "expiresAt", "invocationHash", "publicKey"]);
+        expect(Object.keys(paymentVoucherPayload(forRun)).at(-1)).toBe("runId");
+        expect(verifyData(paymentVoucherPayload(forRun), publicKey, forRun.signature)).toBe(true);
+        expect(verifyData(paymentVoucherPayload({ ...forRun, runId: "run-2" }), publicKey, forRun.signature)).toBe(false);
+    });
     test("invocationHash changes with the function name or parameters", () => {
         const parameters = [{ name: "city", value: "Oslo" }];
         const hash = invocationHash("com.example", "Weather", "forecast", parameters);
@@ -94,7 +106,7 @@ describe("external invoke retries", () => {
     });
     test("reuses the same payment voucher on every attempt", async () => {
         fetchMock.mockResolvedValueOnce(status(503)).mockResolvedValueOnce(status(503)).mockResolvedValueOnce(ok());
-        const invoker = createInvoker({ costMicroUsdc: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
+        const invoker = createInvoker({ costMicroUsd: 10000, recipientOrganizationId: "org_provider" });
         const pending = invoker.invoke(resource, "forecast", parameters);
         await vi.runAllTimersAsync();
         await pending;
@@ -104,6 +116,18 @@ describe("external invoke retries", () => {
         expect(JSON.parse(bodies[0]).paymentVoucher.requestId).toBeDefined();
         expect(JSON.parse(bodies[0]).paymentVoucher.invocationHash).toBe(invocationHash("com.example", "Weather", "forecast", parameters));
     });
+    test("a billed run's calls carry its run id, and its hold replaces the cost limit", async () => {
+        fetchMock.mockResolvedValueOnce(ok());
+        const invoker = createInvoker({ costMicroUsd: 500_000, recipientOrganizationId: "org_provider" });
+        await invoker.forRun({ runId: "run-1" }).invoke(resource, "forecast", parameters);
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body).paymentVoucher).toMatchObject({ amount: 500_000, runId: "run-1" });
+        await expect(invoker.invoke(resource, "forecast", parameters)).rejects.toThrow("exceeds the cost limit");
+    });
+    test("refuses a paid function whose manifest names no recipient organization, without signing a voucher", async () => {
+        const result = await createInvoker({ costMicroUsd: 10000 }).invoke(resource, "forecast", parameters);
+        expect(fetchMock).not.toHaveBeenCalled();
+        expect(result.error?.message).toContain("names no recipient organization");
+    });
 });
 describe("restricted functions", () => {
     const resource = { path: "com.example", name: "Weather", metadata: { baseUrl: "https://remote.example" }, functions: [] };
@@ -140,7 +164,7 @@ describe("restricted functions", () => {
         fetchMock.mockResolvedValueOnce(new Response(null, { status: 503 })).mockResolvedValueOnce(new Response(JSON.stringify({ value: 42, error: null }), { status: 200 }));
         let nonce = 0;
         const authorize = vi.fn(() => ({ nonce: `nonce-${nonce++}` }));
-        const invoker = createInvoker({ chainFor: async () => chain, authorize }, { costMicroUsdc: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
+        const invoker = createInvoker({ chainFor: async () => chain, authorize }, { costMicroUsd: 10000, recipientOrganizationId: "org_provider" });
         const pending = invoker.invoke(resource, "forecast", parameters);
         await vi.runAllTimersAsync();
         await expect(pending).resolves.toEqual({ value: 42, error: null });
@@ -151,10 +175,10 @@ describe("restricted functions", () => {
     });
 });
 describe("inference functions", () => {
-    const RECIPIENT = "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2";
+    const ORGANIZATION = "org_provider";
     const resource = { path: "com.example", name: "Model", metadata: { baseUrl: "https://remote.example" }, functions: [] };
     const parameters = [{ name: "prompt", value: "Hello" }, { name: "maxTokens", value: 1000 }];
-    const manifest = { inputCostMicroUsdcPerMillionTokens: 3_000_000, outputCostMicroUsdcPerMillionTokens: 15_000_000, recipientAddress: RECIPIENT };
+    const manifest = { inputCostMicroUsdPerMillionTokens: 3_000_000, outputCostMicroUsdPerMillionTokens: 15_000_000, recipientOrganizationId: ORGANIZATION };
     // 2,000 input tokens and 1,000 output tokens: 6,000 + 15,000.
     const MAX_AMOUNT = 21_000;
     function createInvoker(inferenceCostLimit = 100_000, fn = { kind: "inference", paymentManifest: manifest }) {
@@ -173,9 +197,9 @@ describe("inference functions", () => {
     });
     test("inferenceCharge rounds up per million tokens", () => {
         expect(inferenceCharge(manifest, 2_000, 1_000)).toBe(21_000);
-        expect(inferenceCharge({ inputCostMicroUsdcPerMillionTokens: 150_000, outputCostMicroUsdcPerMillionTokens: 0 }, 1, 1_000_000)).toBe(1);
-        expect(inferenceCharge({ inputCostMicroUsdcPerMillionTokens: 0, outputCostMicroUsdcPerMillionTokens: 0 }, 5, 5)).toBe(0);
-        expect(() => inferenceCharge({ inputCostMicroUsdcPerMillionTokens: Number.MAX_SAFE_INTEGER, outputCostMicroUsdcPerMillionTokens: 0 }, Number.MAX_SAFE_INTEGER, 0)).toThrow();
+        expect(inferenceCharge({ inputCostMicroUsdPerMillionTokens: 150_000, outputCostMicroUsdPerMillionTokens: 0 }, 1, 1_000_000)).toBe(1);
+        expect(inferenceCharge({ inputCostMicroUsdPerMillionTokens: 0, outputCostMicroUsdPerMillionTokens: 0 }, 5, 5)).toBe(0);
+        expect(() => inferenceCharge({ inputCostMicroUsdPerMillionTokens: Number.MAX_SAFE_INTEGER, outputCostMicroUsdPerMillionTokens: 0 }, Number.MAX_SAFE_INTEGER, 0)).toThrow();
     });
     test("asks the provider for an estimate, then signs a voucher for its maxAmount at the advertised rates", async () => {
         fetchMock.mockResolvedValueOnce(json({ inputTokens: 2_000, maxAmount: MAX_AMOUNT })).mockResolvedValueOnce(json({ value: "Hi", error: null, usage: { inputTokens: 1_500, outputTokens: 10 } }));
@@ -189,7 +213,7 @@ describe("inference functions", () => {
         const voucher = JSON.parse(runInit.body).paymentVoucher;
         expect(voucher).toMatchObject({ kind: "inference", maxAmount: MAX_AMOUNT, maxTokens: 1000, ...manifest, publicKey });
         expect(voucher.amount).toBeUndefined();
-        expect(Object.keys(inferenceVoucherPayload(voucher))).toEqual(["kind", "requestId", "invocationId", "maxAmount", "inputCostMicroUsdcPerMillionTokens", "outputCostMicroUsdcPerMillionTokens", "maxTokens", "recipientAddress", "expiresAt", "invocationHash", "publicKey"]);
+        expect(Object.keys(inferenceVoucherPayload(voucher))).toEqual(["kind", "requestId", "invocationId", "maxAmount", "inputCostMicroUsdPerMillionTokens", "outputCostMicroUsdPerMillionTokens", "maxTokens", "recipientOrganizationId", "expiresAt", "invocationHash", "publicKey"]);
         expect(verifyData(inferenceVoucherPayload(voucher), publicKey, voucher.signature)).toBe(true);
         expect(Date.parse(voucher.expiresAt) - Date.now()).toBeGreaterThan(1000 * 60 * 5);
     });