stellarium-ts 0.19.0 → 0.20.0

package/dist/tests/contract/routes.test.js

@@ -0,0 +1,252 @@
+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 { CombinationResourceInvoker, MAX_CONTRACT_DEPTH } from "../../resource/invoker.js";
+import routes from "../../routes.js";
+import { createService } from "../../service.js";
+import { DIALECTS, generateBase64KeyPair, ORGANIZATION, openTestDatabase, testConfig, weatherResource } from "../helpers.js";
+/** 1 micro-USD a token. */
+const PRICE = 1_000_000;
+const FEE = 5_000;
+const SUM = "contract com.example.Sum(a: int32, b: int32): int32 {\n  return a + b\n}";
+const sumParameters = [{ name: "a", value: 2 }, { name: "b", value: 3 }];
+describe.each(DIALECTS)("contracts (%s)", (dialect) => {
+    const operatorKeys = generateKeyPairSync("ed25519");
+    const caller = generateBase64KeyPair();
+    // Signs vouchers as another node would.
+    const callerInvoker = new CombinationResourceInvoker(undefined, 100_000, caller.publicKey, caller.privateKey);
+    let db;
+    let config;
+    let service;
+    let fastify;
+    let spies;
+    beforeEach(async () => {
+        db = await openTestDatabase(dialect);
+        config = testConfig({ priceMicroUsdPerMillionTokens: PRICE, contractDeployFeeMicroUsd: FEE });
+        const jwk = await exportJWK(operatorKeys.publicKey);
+        service = createService(db, [weatherResource()], config, { runTokenKeys: createLocalJWKSet({ keys: [{ ...jwk, alg: "EdDSA" }] }) });
+        const client = service.operatorClient;
+        spies = {
+            authorizeRun: vi.spyOn(client, "authorizeRun").mockResolvedValue({ ok: true, heldMicroUsd: 50_000, maxTokens: 0 }),
+            captureRun: vi.spyOn(client, "captureRun").mockResolvedValue(undefined),
+            releaseRun: vi.spyOn(client, "releaseRun").mockResolvedValue(undefined),
+            authorize: vi.spyOn(client, "authorize").mockResolvedValue({ ok: true }),
+            capture: vi.spyOn(client, "capture").mockResolvedValue(undefined),
+            release: vi.spyOn(client, "release").mockResolvedValue(undefined),
+            authorizeContractRun: vi.spyOn(client, "authorizeContractRun").mockResolvedValue({ ok: true, free: false }),
+        };
+        fastify = Fastify();
+        await fastify.register(routes, { prefix: "/v1", service });
+        await fastify.ready();
+    });
+    afterEach(async () => {
+        await fastify.close();
+        await db.close();
+        vi.restoreAllMocks();
+    });
+    // Settlement is scheduled with setTimeout(0) after the response is sent.
+    const flushSettlement = () => new Promise((resolve) => setTimeout(resolve, 10));
+    /** A token the operator would issue to `organizationId`'s client on this node. */
+    const runToken = (organizationId) => new SignJWT({ org: organizationId })
+        .setProtectedHeader({ alg: "EdDSA" })
+        .setIssuer("stellarium")
+        .setSubject("cli_test")
+        .setAudience(config.publicKey)
+        .setIssuedAt()
+        .setExpirationTime("15m")
+        .sign(operatorKeys.privateKey);
+    const deploy = (source, token = "secret", description) => fastify.inject({
+        method: "POST", url: "/v1/contracts", headers: { authorization: `Bearer ${token}` }, payload: { source, description },
+    });
+    const run = (source, token = "secret") => fastify.inject({
+        method: "POST", url: "/v1/run", headers: { authorization: `Bearer ${token}` }, payload: { source },
+    });
+    const callFromPeer = (paymentVoucher, contractDepth, parameters = sumParameters) => fastify.inject({
+        method: "POST",
+        url: "/v1/run/resource",
+        payload: { resourcePath: "com.example", resourceName: "Sum", functionName: "run", parameters, paymentVoucher, contractDepth },
+    });
+    const sumVoucher = (price = PRICE, parameters = sumParameters) => callerInvoker.createContractVoucher(ORGANIZATION, price, 50_000, "com.example", "Sum", "run", parameters);
+    describe("POST /v1/contracts", () => {
+        test("deploys a contract as a resource with one function, run, at the node's price", async () => {
+            const response = await deploy(SUM, "secret", "Adds two numbers");
+            expect(response.statusCode).toBe(201);
+            expect(response.json()).toEqual({ path: "com.example", name: "Sum", version: "1", feeMicroUsd: 0 });
+            const resources = (await fastify.inject({ method: "GET", url: "/v1/resources" })).json().resources;
+            expect(resources.map(r => r.name)).toEqual(["Weather", "Sum"]);
+            expect(resources[1]).toMatchObject({
+                path: "com.example",
+                description: "Adds two numbers",
+                functions: [{
+                        name: "run",
+                        kind: "contract",
+                        returnType: "int32",
+                        parameters: [{ name: "a", type: "int32" }, { name: "b", type: "int32" }],
+                        paymentManifest: { priceMicroUsdPerMillionTokens: PRICE, recipientOrganizationId: ORGANIZATION },
+                    }],
+            });
+            const contracts = (await fastify.inject({ method: "GET", url: "/v1/contracts" })).json();
+            expect(contracts).toMatchObject({ contracts: [{ path: "com.example", name: "Sum", version: "1", source: SUM, ownerOrganizationId: null }], nextOffset: null });
+            expect(spies.authorizeRun).not.toHaveBeenCalled();
+        });
+        test.each([
+            ["a request script", "request R {\n  return 1\n}", 400, "not a request"],
+            ["a contract without a return type", "contract com.example.Sum(a: int32) {\n  return a\n}", 400, "return type"],
+            ["a contract without a path", "contract Sum(a: int32): int32 {\n  return a\n}", 400, "path"],
+            ["a script that doesn't parse", "contract com.example.Sum(: int32 {", 400, "Invalid contract"],
+            ["a registered resource's name", "contract com.example.Weather: int32 {\n  return 1\n}", 409, "already a resource"],
+        ])("refuses %s", async (_, source, status, error) => {
+            const response = await deploy(source);
+            expect(response.statusCode).toBe(status);
+            expect(response.json().error).toContain(error);
+        });
+        test("refuses an existing version, and a source over the size limit", async () => {
+            await deploy(SUM);
+            expect((await deploy(SUM)).statusCode).toBe(409);
+            config.maxContractSourceBytes = 10;
+            expect((await deploy(SUM.replace("Sum", "Other"))).statusCode).toBe(413);
+        });
+        test("requires the API key or a run token", async () => {
+            expect((await fastify.inject({ method: "POST", url: "/v1/contracts", payload: { source: SUM } })).statusCode).toBe(401);
+            expect((await deploy(SUM, "wrong")).statusCode).toBe(401);
+        });
+        test("charges another organization the deploy fee from its run, and makes it the owner", async () => {
+            const response = await deploy(SUM, await runToken("org_caller"));
+            expect(response.statusCode).toBe(201);
+            expect(response.json()).toMatchObject({ feeMicroUsd: FEE });
+            const [{ runId, source }] = spies.authorizeRun.mock.calls[0];
+            expect(source).toBe(SUM);
+            const [voucher] = spies.authorize.mock.calls[0];
+            expect(voucher).toMatchObject({ amount: FEE, recipientOrganizationId: ORGANIZATION, runId });
+            await flushSettlement();
+            expect(spies.capture).toHaveBeenCalledWith({ voucher });
+            expect(spies.captureRun).toHaveBeenCalledWith({ runId, tokens: 0 });
+            expect((await service.contractRepository.latest("com.example", "Sum"))?.ownerOrganizationId).toBe("org_caller");
+        });
+        test("doesn't charge for a deploy it refuses", async () => {
+            await deploy(SUM);
+            expect((await deploy(SUM, await runToken("org_caller"))).statusCode).toBe(409);
+            expect(spies.authorizeRun).not.toHaveBeenCalled();
+        });
+        test("answers the operator's refusal of the deploy fee, and saves nothing", async () => {
+            spies.authorizeRun.mockResolvedValue({ ok: false, status: 402, error: "Insufficient balance" });
+            const response = await deploy(SUM, await runToken("org_caller"));
+            expect(response.statusCode).toBe(402);
+            expect(await service.contractRepository.latest("com.example", "Sum")).toBeUndefined();
+        });
+        test("is free for the node's own organization", async () => {
+            const response = await deploy(SUM, await runToken(ORGANIZATION));
+            expect(response.json()).toMatchObject({ feeMicroUsd: 0 });
+            expect(spies.authorizeRun).not.toHaveBeenCalled();
+        });
+        test("only the owner adds versions", async () => {
+            await deploy(SUM, await runToken("org_caller"));
+            const next = SUM.replace("Sum(", "Sum@2(");
+            expect((await deploy(next, await runToken("org_other"))).statusCode).toBe(409);
+            expect((await deploy(next, await runToken("org_caller"))).statusCode).toBe(201);
+            expect((await service.contractRepository.latest("com.example", "Sum"))?.version).toBe("2");
+        });
+    });
+    describe("DELETE /v1/contracts/:ref", () => {
+        const remove = (ref, token = "secret") => fastify.inject({ method: "DELETE", url: `/v1/contracts/${ref}`, headers: { authorization: `Bearer ${token}` } });
+        test("lets the owner or the admin delete, and no one else", async () => {
+            await deploy(SUM, await runToken("org_caller"));
+            await deploy(SUM.replace("Sum(", "Sum@2("), await runToken("org_caller"));
+            expect((await remove("com.example.Sum@2", await runToken("org_other"))).statusCode).toBe(403);
+            expect((await remove("com.example.Sum@2", await runToken("org_caller"))).statusCode).toBe(200);
+            expect((await service.contractRepository.latest("com.example", "Sum"))?.version).toBe("1");
+            expect((await remove("com.example.Sum")).statusCode).toBe(200);
+            expect((await remove("com.example.Sum")).statusCode).toBe(404);
+            const resources = (await fastify.inject({ method: "GET", url: "/v1/resources" })).json().resources;
+            expect(resources.map(r => r.name)).toEqual(["Weather"]);
+        });
+        test("refuses a reference that isn't path.Name", async () => {
+            expect((await remove("Sum")).statusCode).toBe(400);
+        });
+    });
+    describe("calling a contract on this node", () => {
+        test("from an API-key run is free, and the contract sees no jwt", async () => {
+            await deploy("contract com.example.Who: string {\n  if (jwt == null) {\n    return \"admin\"\n  }\n  return jwt.org\n}");
+            await deploy(SUM);
+            const response = await run("request R {\n  const sum: com.example.Sum\n  const who: com.example.Who\n  return { sum: sum.run(a: 1, b: 2).value, who: who.run().value }\n}");
+            expect(response.json()).toMatchObject({ returnValue: { sum: 3, who: "admin" } });
+            expect(spies.authorizeContractRun).not.toHaveBeenCalled();
+        });
+        test("from a billed run is held from the run, and the contract sees the run's jwt", async () => {
+            await deploy("contract com.example.Who: string {\n  return jwt.org\n}");
+            const response = await run("request R {\n  const who: com.example.Who\n  return who.run().value\n}", await runToken("org_caller"));
+            expect(response.json()).toMatchObject({ returnValue: "org_caller" });
+            const [outer] = spies.authorizeRun.mock.calls[0];
+            const [{ voucher }] = spies.authorizeContractRun.mock.calls[0];
+            expect(voucher).toMatchObject({ kind: "contract", runId: outer.runId, recipientOrganizationId: ORGANIZATION, priceMicroUsdPerMillionTokens: PRICE });
+            await flushSettlement();
+            expect(spies.captureRun).toHaveBeenCalledWith({ runId: voucher.invocationId, tokens: expect.any(Number) });
+            expect(spies.captureRun).toHaveBeenCalledWith({ runId: outer.runId, tokens: expect.any(Number) });
+        });
+        test(`stops contracts calling each other ${MAX_CONTRACT_DEPTH} deep`, async () => {
+            await deploy("contract com.example.Loop(n: int32): int32 {\n  const loop: com.example.Loop\n  const next = loop.run(n: n + 1)\n  if (next.error != null) {\n    return n\n  }\n  return next.value\n}");
+            const response = await run("request R {\n  const loop: com.example.Loop\n  return loop.run(n: 1).value\n}");
+            expect(response.json()).toMatchObject({ returnValue: MAX_CONTRACT_DEPTH });
+        });
+    });
+    describe("calling a contract from another node", () => {
+        beforeEach(async () => {
+            await deploy(SUM);
+        });
+        test("authorizes a run with the voucher, runs the contract, and captures its tokens", async () => {
+            const voucher = sumVoucher();
+            const response = await callFromPeer(voucher);
+            expect(response.statusCode).toBe(200);
+            expect(response.json()).toEqual({ value: 5, error: null });
+            expect(spies.authorizeContractRun).toHaveBeenCalledWith({ voucher, source: SUM });
+            await flushSettlement();
+            expect(spies.captureRun).toHaveBeenCalledWith({ runId: voucher.invocationId, tokens: 4 });
+        });
+        test("captures a contract that fails, which reports the failure as the call's error", async () => {
+            await deploy("contract com.example.Div(a: int32): int32 {\n  return 1 / a\n}");
+            const parameters = [{ name: "a", value: 0 }];
+            const voucher = callerInvoker.createContractVoucher(ORGANIZATION, PRICE, 50_000, "com.example", "Div", "run", parameters);
+            const response = await fastify.inject({
+                method: "POST", url: "/v1/run/resource",
+                payload: { resourcePath: "com.example", resourceName: "Div", functionName: "run", parameters, paymentVoucher: voucher },
+            });
+            expect(response.json()).toMatchObject({ value: null, error: { message: expect.stringContaining("com.example.Div@1 failed") } });
+            await flushSettlement();
+            expect(spies.captureRun).toHaveBeenCalledWith({ runId: voucher.invocationId, tokens: expect.any(Number) });
+        });
+        test("runs unbilled when the operator says the caller is this node's organization", async () => {
+            spies.authorizeContractRun.mockResolvedValue({ ok: true, free: true });
+            expect((await callFromPeer(sumVoucher())).json()).toEqual({ value: 5, error: null });
+            await flushSettlement();
+            expect(spies.captureRun).not.toHaveBeenCalled();
+        });
+        test("answers the operator's refusal without running the contract", async () => {
+            spies.authorizeContractRun.mockResolvedValue({ ok: false, status: 402, error: "Insufficient balance" });
+            const response = await callFromPeer(sumVoucher());
+            expect(response.statusCode).toBe(402);
+            expect(response.json()).toEqual({ error: "Insufficient balance" });
+        });
+        test.each([
+            ["no voucher", () => undefined, 402],
+            ["a voucher below this node's price", () => sumVoucher(PRICE - 1), 400],
+            ["a voucher for other parameters", () => sumVoucher(PRICE, [{ name: "a", value: 1 }, { name: "b", value: 1 }]), 400],
+            ["a tampered voucher", () => ({ ...sumVoucher(), maxAmount: 1 }), 400],
+        ])("refuses %s", async (_, voucher, status) => {
+            expect((await callFromPeer(voucher())).statusCode).toBe(status);
+            expect(spies.authorizeContractRun).not.toHaveBeenCalled();
+        });
+        test(`refuses a call more than ${MAX_CONTRACT_DEPTH} contracts deep`, async () => {
+            expect((await callFromPeer(sumVoucher(), MAX_CONTRACT_DEPTH + 1)).statusCode).toBe(400);
+        });
+        test("refuses a contract voucher for a function that isn't a contract", async () => {
+            const parameters = [{ name: "city", value: "Oslo" }];
+            const paymentVoucher = callerInvoker.createContractVoucher(ORGANIZATION, PRICE, 50_000, "com.example", "Weather", "temperature", parameters);
+            const response = await fastify.inject({
+                method: "POST", url: "/v1/run/resource",
+                payload: { resourcePath: "com.example", resourceName: "Weather", functionName: "temperature", parameters, paymentVoucher },
+            });
+            expect(response.statusCode).toBe(400);
+        });
+    });
+});

package/dist/tests/contract/state-routes.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state-routes.test.d.ts.map

package/dist/tests/contract/state-routes.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-routes.test.d.ts","sourceRoot":"","sources":["../../../src/tests/contract/state-routes.test.ts"],"names":[],"mappings":""}

package/dist/tests/contract/state-routes.test.js

@@ -0,0 +1,158 @@
+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 { CombinationResourceInvoker } from "../../resource/invoker.js";
+import routes from "../../routes.js";
+import { createService } from "../../service.js";
+import { DIALECTS, generateBase64KeyPair, ORGANIZATION, openTestDatabase, testConfig, weatherResource } from "../helpers.js";
+const COUNTER = "contract com.example.Counter: int32 {\n  var state count: int32 = 0\n  count = count + 1\n  return count\n}";
+const callCounter = "request R {\n  const counter: com.example.Counter\n  return counter.run().value\n}";
+/** A free function that waits until the test lets it finish, to hold a call open. */
+function gateResource(gate) {
+    return {
+        id: 3,
+        baseUrl: "http://127.0.0.1:3002",
+        metadata: {},
+        path: "com.example",
+        name: "Gate",
+        functions: [{ name: "wait", parameters: [], returnType: "int32", exec: async () => { await gate.open; return 1; } }],
+    };
+}
+describe.each(DIALECTS)("contract state (%s)", (dialect) => {
+    const operatorKeys = generateKeyPairSync("ed25519");
+    const peer = generateBase64KeyPair();
+    const peerInvoker = new CombinationResourceInvoker(undefined, 100_000, peer.publicKey, peer.privateKey);
+    let db;
+    let config;
+    let service;
+    let fastify;
+    let authorizeContractRun;
+    let letGateOpen;
+    beforeEach(async () => {
+        db = await openTestDatabase(dialect);
+        config = testConfig({ priceMicroUsdPerMillionTokens: 0 });
+        const gate = { open: new Promise(resolve => { letGateOpen = resolve; }) };
+        const jwk = await exportJWK(operatorKeys.publicKey);
+        service = createService(db, [weatherResource(), gateResource(gate)], config, { runTokenKeys: createLocalJWKSet({ keys: [{ ...jwk, alg: "EdDSA" }] }) });
+        const client = service.operatorClient;
+        vi.spyOn(client, "authorizeRun").mockResolvedValue({ ok: true, heldMicroUsd: 50_000, maxTokens: 0 });
+        vi.spyOn(client, "captureRun").mockResolvedValue(undefined);
+        vi.spyOn(client, "releaseRun").mockResolvedValue(undefined);
+        vi.spyOn(client, "authorize").mockResolvedValue({ ok: true });
+        vi.spyOn(client, "capture").mockResolvedValue(undefined);
+        authorizeContractRun = vi.spyOn(client, "authorizeContractRun").mockResolvedValue({ ok: true, free: false, payerOrganizationId: "org_peer" });
+        fastify = Fastify();
+        await fastify.register(routes, { prefix: "/v1", service });
+        await fastify.ready();
+    });
+    afterEach(async () => {
+        letGateOpen();
+        await fastify.close();
+        await db.close();
+        vi.restoreAllMocks();
+    });
+    const runToken = (organizationId) => new SignJWT({ org: organizationId })
+        .setProtectedHeader({ alg: "EdDSA" })
+        .setIssuer("stellarium")
+        .setSubject("cli_test")
+        .setAudience(config.publicKey)
+        .setIssuedAt()
+        .setExpirationTime("15m")
+        .sign(operatorKeys.privateKey);
+    const deploy = async (source, token = "secret") => {
+        const response = await fastify.inject({ method: "POST", url: "/v1/contracts", headers: { authorization: `Bearer ${token}` }, payload: { source } });
+        expect(response.statusCode).toBe(201);
+    };
+    const run = async (source, token = "secret") => (await fastify.inject({ method: "POST", url: "/v1/run", headers: { authorization: `Bearer ${token}` }, payload: { source } })).json();
+    const readState = (ref, token = "secret") => fastify.inject({ method: "GET", url: `/v1/contracts/${ref}/state`, headers: { authorization: `Bearer ${token}` } });
+    /** A call from another node, which the operator says `org_peer` pays for unless the spy says otherwise. */
+    const callFromPeer = async (resourceName, parameters = []) => {
+        const paymentVoucher = peerInvoker.createContractVoucher(ORGANIZATION, 0, 50_000, "com.example", resourceName, "run", parameters);
+        return (await fastify.inject({
+            method: "POST", url: "/v1/run/resource",
+            payload: { resourcePath: "com.example", resourceName, functionName: "run", parameters, paymentVoucher },
+        })).json();
+    };
+    test("keeps counting across calls and new versions", async () => {
+        await deploy(COUNTER);
+        expect((await run(callCounter)).returnValue).toBe(1);
+        expect((await run(callCounter)).returnValue).toBe(2);
+        // A new version can widen the type.
+        await deploy("contract com.example.Counter@2: int64 {\n  var state count: int64 = 0\n  count = count + 10\n  return count\n}");
+        expect((await run(callCounter)).returnValue).toBe(12);
+    });
+    test("caller tells a remote caller's organization and node apart from this node's", async () => {
+        await deploy("contract com.example.Who: object {\n  return caller\n}");
+        expect(await callFromPeer("Who")).toEqual({ value: { org: "org_peer", node: peer.publicKey }, error: null });
+        expect((await run("request R {\n  const who: com.example.Who\n  return who.run().value\n}")).returnValue).toEqual({ org: ORGANIZATION, node: config.publicKey });
+        expect((await run("request R {\n  const who: com.example.Who\n  return who.run().value\n}", await runToken("org_client"))).returnValue)
+            .toEqual({ org: "org_client", node: config.publicKey });
+    });
+    test("state(caller.org) keeps one copy per paying organization", async () => {
+        await deploy("contract com.example.Visits: int32 {\n  var state(caller.org) visits: int32 = 0\n  visits = visits + 1\n  return visits\n}");
+        expect((await callFromPeer("Visits")).value).toBe(1);
+        expect((await callFromPeer("Visits")).value).toBe(2);
+        authorizeContractRun.mockResolvedValue({ ok: true, free: false, payerOrganizationId: "org_other" });
+        expect((await callFromPeer("Visits")).value).toBe(1);
+        expect((await run("request R {\n  const visits: com.example.Visits\n  return visits.run().value\n}", await runToken("org_client"))).returnValue).toBe(1);
+        const variables = (await readState("com.example.Visits")).json().variables;
+        expect(variables.map((v) => [v.scope.key, v.value])).toEqual([["org_client", 1], ["org_other", 1], ["org_peer", 2]]);
+    });
+    test("a call that fails saves nothing", async () => {
+        await deploy("contract com.example.Fragile(d: int32): int32 {\n  var state count: int32 = 0\n  count = count + 1\n  return 1 / d\n}");
+        const result = await callFromPeer("Fragile", [{ name: "d", value: 0 }]);
+        expect(result.error.message).toContain("Fragile@1 failed");
+        expect((await readState("com.example.Fragile")).json()).toEqual({ variables: [] });
+    });
+    test("concurrent calls to a shared counter all count", async () => {
+        await deploy(COUNTER);
+        const results = await Promise.all(Array.from({ length: 8 }, () => run(callCounter)));
+        expect(results.map(result => result.returnValue).sort((a, b) => a - b)).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
+    });
+    test("a call that re-enters its own contract saves first, and the outer call fails rather than lose it", async () => {
+        await deploy("contract com.example.Again(again: boolean): int32 {\n  var state count: int32 = 0\n  const self: com.example.Again\n  if (again) {\n    const inner = self.run(again: false)\n  }\n  count = count + 1\n  return count\n}");
+        const result = (await run("request R {\n  const again: com.example.Again\n  return again.run(again: true)\n}")).returnValue;
+        expect(result.error.message).toContain("its state changed during the call");
+        expect((await readState("com.example.Again")).json().variables).toMatchObject([{ name: "count", value: 1 }]);
+    });
+    test("a call waiting too long for the contract fails, and the earlier call still saves", async () => {
+        await deploy("contract com.example.Slow: int32 {\n  var state count: int32 = 0\n  const gate: com.example.Gate\n  gate.wait()\n  count = count + 1\n  return count\n}");
+        service.contractService.lockTimeoutMs = 50;
+        const callSlow = "request R {\n  const slow: com.example.Slow\n  return slow.run()\n}";
+        const first = run(callSlow);
+        await new Promise(resolve => setTimeout(resolve, 20));
+        const second = (await run(callSlow)).returnValue;
+        letGateOpen();
+        expect(second.error.message).toContain("it is busy");
+        expect((await first).returnValue).toEqual({ value: 1, error: null });
+    });
+    test("a call that would grow its state past the cap fails and saves nothing", async () => {
+        config.maxContractStateBytes = 16;
+        await deploy("contract com.example.Notes(text: string): string {\n  var state note: string = \"\"\n  note = text\n  return note\n}");
+        expect((await callFromPeer("Notes", [{ name: "text", value: "short" }])).value).toBe("short");
+        const result = await callFromPeer("Notes", [{ name: "text", value: "a note much longer than the cap" }]);
+        expect(result.error.message).toContain("more than this node's 16");
+        expect((await readState("com.example.Notes")).json().variables).toMatchObject([{ value: "short" }]);
+    });
+    test("only the owner and the node's admin can read state", async () => {
+        await deploy(COUNTER, await runToken("org_owner"));
+        await run(callCounter);
+        expect((await readState("com.example.Counter", await runToken("org_owner"))).json())
+            .toEqual({ variables: [{ name: "count", scope: null, value: 1, updatedAt: expect.any(String) }] });
+        expect((await readState("com.example.Counter")).statusCode).toBe(200);
+        expect((await readState("com.example.Counter", await runToken("org_other"))).statusCode).toBe(403);
+        expect((await readState("com.example.Counter@1")).statusCode).toBe(400);
+        expect((await readState("com.example.Missing")).statusCode).toBe(404);
+    });
+    test("deleting a version keeps state, and deleting the contract deletes it", async () => {
+        await deploy(COUNTER);
+        await deploy(COUNTER.replace("Counter:", "Counter@2:"));
+        await run(callCounter);
+        const remove = (ref) => fastify.inject({ method: "DELETE", url: `/v1/contracts/${ref}`, headers: { authorization: "Bearer secret" } });
+        await remove("com.example.Counter@2");
+        expect(await service.contractStateRepository.list("com.example", "Counter")).toHaveLength(1);
+        await remove("com.example.Counter");
+        expect(await service.contractStateRepository.list("com.example", "Counter")).toEqual([]);
+    });
+});

package/dist/tests/contract/state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.test.d.ts.map

package/dist/tests/contract/state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.test.d.ts","sourceRoot":"","sources":["../../../src/tests/contract/state.test.ts"],"names":[],"mappings":""}

package/dist/tests/contract/state.test.js

@@ -0,0 +1,57 @@
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { ContractStateRepository, scopeFromKey, scopeKey } from "../../contract/state.js";
+import { DIALECTS, openTestDatabase } from "../helpers.js";
+const INT32 = '{"kind":"int32"}';
+const write = (name, value, overrides = {}) => ({ name, scope: null, value: value, type: INT32, ...overrides });
+describe.each(DIALECTS)("ContractStateRepository (%s)", (dialect) => {
+    let db;
+    let state;
+    beforeEach(async () => {
+        db = await openTestDatabase(dialect);
+        state = new ContractStateRepository(db);
+    });
+    afterEach(async () => {
+        await db.close();
+    });
+    test("stores a new variable, then updates it from the version it was read at", async () => {
+        expect(await state.commit("com.example", "Counter", [write("count", 1)], 1000)).toEqual({ ok: true });
+        const stored = await state.get("com.example", "Counter", "count", null);
+        expect(stored).toEqual({ value: 1, type: INT32, version: 1 });
+        expect(await state.commit("com.example", "Counter", [write("count", 2, { version: stored.version })], 1000)).toEqual({ ok: true });
+        expect(await state.get("com.example", "Counter", "count", null)).toMatchObject({ value: 2, version: 2 });
+    });
+    test("refuses to save over a copy that changed, and saves nothing of that call", async () => {
+        await state.commit("com.example", "Counter", [write("count", 1)], 1000);
+        // Read at version 1, but another call saved in between.
+        await state.commit("com.example", "Counter", [write("count", 2, { version: 1 })], 1000);
+        expect(await state.commit("com.example", "Counter", [write("total", 9), write("count", 3, { version: 1 })], 1000)).toEqual({ ok: false, reason: "conflict" });
+        // A second first save is a conflict too.
+        expect(await state.commit("com.example", "Counter", [write("count", 7)], 1000)).toEqual({ ok: false, reason: "conflict" });
+        expect(await state.get("com.example", "Counter", "count", null)).toMatchObject({ value: 2 });
+        expect(await state.get("com.example", "Counter", "total", null)).toBeUndefined();
+    });
+    test("keeps one copy per scope, and scopes keep their kind", async () => {
+        const scopes = [null, { kind: "string", key: "3" }, { kind: "integer", key: "3" }];
+        await state.commit("com.example", "Tally", scopes.map((scope, index) => write("n", index, { scope })), 1000);
+        expect(await Promise.all(scopes.map(scope => state.get("com.example", "Tally", "n", scope).then(stored => stored?.value)))).toEqual([0, 1, 2]);
+        expect(scopes.map(scope => scopeFromKey(scopeKey(scope)))).toEqual(scopes);
+        expect((await state.list("com.example", "Tally")).map(row => row.scope)).toEqual([null, { kind: "integer", key: "3" }, { kind: "string", key: "3" }]);
+    });
+    test("refuses a save that grows a scope past the cap, counting every variable in it", async () => {
+        const scope = { kind: "string", key: "org_a" };
+        // Each value is 12 bytes of JSON: ten letters and their quotes.
+        await state.commit("com.example", "Notes", [write("a", "x".repeat(10), { scope })], 20);
+        expect(await state.commit("com.example", "Notes", [write("b", "y".repeat(10), { scope })], 20))
+            .toEqual({ ok: false, reason: "too_large", scope, bytes: 24 });
+        expect(await state.get("com.example", "Notes", "b", scope)).toBeUndefined();
+        // Another scope has its own allowance.
+        expect(await state.commit("com.example", "Notes", [write("b", "y".repeat(10), { scope: { kind: "string", key: "org_b" } })], 20)).toEqual({ ok: true });
+    });
+    test("deletes a contract's state, and only that contract's", async () => {
+        await state.commit("com.example", "A", [write("n", 1)], 1000);
+        await state.commit("com.example", "B", [write("n", 1)], 1000);
+        await state.deleteContract("com.example", "A");
+        expect(await state.list("com.example", "A")).toEqual([]);
+        expect(await state.list("com.example", "B")).toHaveLength(1);
+    });
+});

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: 6 });
+        expect(await db.get("PRAGMA user_version")).toEqual({ user_version: 7 });
         await db.close();
     });
     test("rebuilds resource tables from the old schema and keeps peers", async () => {

package/dist/tests/db/postgres.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=postgres.test.d.ts.map

package/dist/tests/db/postgres.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.test.d.ts","sourceRoot":"","sources":["../../../src/tests/db/postgres.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,43 @@
+import { PGlite } from "@electric-sql/pglite";
+import { describe, expect, test, vi } from "vitest";
+import { createTables } from "../../db/db.js";
+import { numberPlaceholders, PostgresDatabase } from "../../db/postgres.js";
+import { pgliteDriver } from "../helpers.js";
+describe("numberPlaceholders", () => {
+    test("numbers placeholders outside quotes", () => {
+        expect(numberPlaceholders("SELECT * FROM t WHERE a = ? AND b = '?' AND \"c?\" = ?")).toBe("SELECT * FROM t WHERE a = $1 AND b = '?' AND \"c?\" = $2");
+    });
+});
+describe("PostgresDatabase", () => {
+    test("creates its tables in the node's schema, and can be reopened", async () => {
+        const pg = new PGlite({ parsers: { 20: Number } });
+        // node-postgres sets the search path per connection; PGlite has the one.
+        await pg.exec("SET search_path TO node_a");
+        const db = await PostgresDatabase.open(pgliteDriver(pg), "node_a");
+        await createTables(db);
+        await db.run("INSERT INTO peer (base_url, public_key, name, created_at, updated_at) VALUES (?, ?, ?, ?, ?)", ["http://p", "key", "p", "now", "now"]);
+        await createTables(db);
+        expect(await db.all("SELECT public_key FROM peer")).toEqual([{ public_key: "key" }]);
+        expect(await db.all("SELECT version FROM stellarium_schema")).toEqual([{ version: 7 }]);
+        const tables = await db.all("SELECT table_name FROM information_schema.tables WHERE table_schema = 'node_a' ORDER BY table_name");
+        expect(tables.map(table => table.table_name)).toContain("resource_function_payment_manifest");
+        await db.close();
+    });
+    test("refuses a schema name that isn't a plain identifier", async () => {
+        const exec = vi.fn();
+        const driver = { query: vi.fn(), exec, transaction: vi.fn(), close: vi.fn() };
+        await expect(PostgresDatabase.open(driver, "a; DROP TABLE peer")).rejects.toThrow(/Invalid database schema/);
+        expect(exec).not.toHaveBeenCalled();
+    });
+    test("rolls a failed transaction back", async () => {
+        const pg = new PGlite({ parsers: { 20: Number } });
+        const db = await PostgresDatabase.open(pgliteDriver(pg));
+        await createTables(db);
+        await expect(db.transaction(async (tx) => {
+            await tx.run("INSERT INTO blocked_caller (public_key, reason, blocked_at) VALUES (?, ?, ?)", ["key", null, "now"]);
+            throw new Error("failed");
+        })).rejects.toThrow("failed");
+        expect(await db.all("SELECT * FROM blocked_caller")).toEqual([]);
+        await db.close();
+    });
+});

package/dist/tests/grant/service.test.js

@@ -1,19 +1,18 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { openDatabase } from "../../db/db.js";
 import { grantHash, grantRequestPayload, signGrant } from "../../grant/grant.js";
 import { signData } from "../../crypto/utils.js";
 import { GrantRepository } from "../../grant/repository.js";
 import { PeerRepository } from "../../peer/repository.js";
 import { GrantService, HELD_GRANT_RETENTION_MS } from "../../grant/service.js";
-import { generateBase64KeyPair } from "../helpers.js";
+import { DIALECTS, generateBase64KeyPair, openTestDatabase } from "../helpers.js";
 const HOUR = 3_600_000;
 const weather = { resourcePath: "com.example", resourceName: "Weather" };
 const target = { resourcePath: "com.example", resourceName: "Weather", functionName: "temperature", parameters: [{ name: "city", value: "Oslo" }] };
-describe("GrantService", () => {
+describe.each(DIALECTS)("GrantService (%s)", (dialect) => {
     const databases = [];
     const nodes = new Map();
     async function node(baseUrl, approveGrant) {
-        const db = await openDatabase(":memory:");
+        const db = await openTestDatabase(dialect);
         databases.push(db);
         const keys = generateBase64KeyPair();
         const service = new GrantService(new GrantRepository(db), { baseUrl, ...keys }, approveGrant);

package/dist/tests/helpers.d.ts

@@ -1,3 +1,6 @@
+import { PGlite, type Transaction } from "@electric-sql/pglite";
+import type { DatabaseDialect, NodeDatabase } from "../db/database.js";
+import { type PostgresDriver } from "../db/postgres.js";
 import type { StellariumResource } from "../resource/repository.js";
 import type { NodeConfig } from "../service.js";
 export declare function generateBase64KeyPair(): {
@@ -20,4 +23,9 @@ export declare const INFERENCE_RATES: {
  */
 export declare function modelResource(baseUrl?: string): StellariumResource;
 export declare const temperatureSource = "request GetTemperature {\n  const weather: com.example.Weather\n\n  return weather.temperature(city: \"Oslo\")\n}";
+/** Both databases a node can use. Suites that touch the database run against each. */
+export declare const DIALECTS: DatabaseDialect[];
+export declare function pgliteDriver(pg: PGlite | Transaction): PostgresDriver;
+/** An empty node database: SQLite in memory, or Postgres in memory through PGlite. */
+export declare function openTestDatabase(dialect?: DatabaseDialect): Promise<NodeDatabase>;
 //# sourceMappingURL=helpers.d.ts.map

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,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"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/tests/helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEvE,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC1E,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;AAEnJ,sFAAsF;AACtF,eAAO,MAAM,QAAQ,EAAE,eAAe,EAA2B,CAAC;AAElE,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,cAAc,CAqBrE;AAED,sFAAsF;AACtF,wBAAsB,gBAAgB,CAAC,OAAO,GAAE,eAA0B,GAAG,OAAO,CAAC,YAAY,CAAC,CAQjG"}