stellarium-ts 0.12.0 → 0.13.0

package/dist/service.d.ts

@@ -1,13 +1,36 @@
 import { ResourceInvoker, ResourceResolver } from "requestscript";
+import type { Database } from "sqlite";
 import { PeerRepository } from "./peer/repository.js";
 import { ResourceRepository, type StellariumResource } from "./resource/repository.js";
 import { OperatorClient } from "./client/operatorClient.js";
+import { type ApproveGrant, GrantService } from "./grant/service.js";
+/** Settings a node runs with. `StellariumNode.start` fills these from its options, then the environment. */
+export interface NodeConfig {
+    /** URL peers use to reach this node. Also its peer name. */
+    baseUrl: string;
+    /** Ed25519 SPKI DER, base64url. */
+    publicKey: string;
+    /** Ed25519 PKCS#8 DER, base64url. */
+    privateKey: string;
+    /** Bearer token for `POST /v1/run`. When unset, `/v1/run` rejects every request. */
+    apiKey?: string;
+    /** Operator base URL, including `/v1`. Required when the node hosts paid functions. */
+    operatorUrl?: string;
+    /** Most this node will pay for one remote call. */
+    costLimitLamports: number;
+}
 export interface Service {
+    config: NodeConfig;
     peerRepository: PeerRepository;
     resourceRepository: ResourceRepository;
     resourceResolver: ResourceResolver;
     resourceInvoker: ResourceInvoker;
     operatorClient: OperatorClient;
+    grantService: GrantService;
+}
+export interface ServiceOptions {
+    /** Decides `POST /v1/grants/request`. Without it, every request is refused. */
+    approveGrant?: ApproveGrant;
 }
-export declare function createService(resources: StellariumResource[]): Service;
+export declare function createService(db: Database, resources: StellariumResource[], config: NodeConfig, options?: ServiceOptions): Service;
 //# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,MAAM,WAAW,OAAO;IACpB,cAAc,EAAE,cAAc,CAAC;IAC/B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,eAAe,EAAE,eAAe,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;CAClC;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAiBtE"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,OAAO,EAAE,KAAK,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAErE,4GAA4G;AAC5G,MAAM,WAAW,UAAU;IACvB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uFAAuF;IACvF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mDAAmD;IACnD,iBAAiB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,OAAO;IACpB,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,EAAE,cAAc,CAAC;IAC/B,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,eAAe,EAAE,eAAe,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,YAAY,CAAC;CAC9B;AAED,MAAM,WAAW,cAAc;IAC3B,+EAA+E;IAC/E,YAAY,CAAC,EAAE,YAAY,CAAC;CAC/B;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,kBAAkB,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAoBtI"}

package/dist/service.js

@@ -1,20 +1,23 @@
-import db from "./db/db.js";
 import { PeerRepository } from "./peer/repository.js";
 import { CombinationResourceResolver } from "./resource/resolver.js";
 import { ResourceRepository } from "./resource/repository.js";
 import { CombinationResourceInvoker } from "./resource/invoker.js";
 import { OperatorClient } from "./client/operatorClient.js";
-export function createService(resources) {
-    const resourceRepository = new ResourceRepository(db, resources);
+import { GrantRepository } from "./grant/repository.js";
+import { GrantService } from "./grant/service.js";
+export function createService(db, resources, config, options = {}) {
+    const resourceRepository = new ResourceRepository(db, resources, config.baseUrl);
     const resourceResolver = new CombinationResourceResolver(resourceRepository);
-    // TODO: Replace with actual values.
-    const resourceInvoker = new CombinationResourceInvoker(resourceRepository, 10000, process.env.SIGNING_PUBLIC_KEY, process.env.SIGNING_PRIVATE_KEY);
-    const operatorClient = new OperatorClient(process.env.OPERATOR_URL);
+    const grantService = new GrantService(new GrantRepository(db), config, options.approveGrant);
+    const resourceInvoker = new CombinationResourceInvoker(resourceRepository, config.costLimitLamports, config.publicKey, config.privateKey, grantService);
+    const operatorClient = new OperatorClient(config.operatorUrl);
     return {
+        config,
         peerRepository: new PeerRepository(db),
         resourceRepository,
         resourceResolver,
         resourceInvoker,
         operatorClient,
+        grantService,
     };
 }

package/dist/startup.d.ts

@@ -1,5 +1,9 @@
 import { FastifyBaseLogger } from "fastify";
 import { Service } from "./service.js";
+/** Per request to a peer during startup. */
+export declare const STARTUP_REQUEST_TIMEOUT_MS = 10000;
+/** Peers and resources requested per page from the starting peer. It may return fewer. */
+export declare const STARTUP_PAGE_SIZE = 100;
 export declare class StartupService {
     private readonly log;
     private readonly service;
@@ -9,8 +13,18 @@ export declare class StartupService {
     private readonly privateKey;
     constructor(log: FastifyBaseLogger, service: Service, startingPeer: string, baseUrl: string, publicKey: string, privateKey: string);
     seedFromPeer(): Promise<void>;
+    /** GET a JSON document from the starting peer, failing on a non-2xx response. */
+    private getFromStartingPeer;
+    /**
+     * Walks a paginated list on the starting peer, handing each page to `handlePage` before
+     * fetching the next, so the whole list is never held at once. Returns the item count.
+     */
+    private forEachPageFromStartingPeer;
+    private isSelf;
     populatePeers(): Promise<void>;
     populateResources(): Promise<void>;
+    /** PUT to every peer, logging failures instead of throwing so one bad peer doesn't stop the rest. */
+    private putToPeers;
     broadcastSelf(): Promise<void>;
 }
 //# sourceMappingURL=startup.d.ts.map

package/dist/startup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"startup.d.ts","sourceRoot":"","sources":["../src/startup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAI5C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,qBAAa,cAAc;IAEnB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAN/B,YACqB,GAAG,EAAE,iBAAiB,EACtB,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EACnC;IAGE,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAUlC;IAEK,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA8BnC;IAEK,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAgBvC;IAEK,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAqEnC;CACJ"}
+{"version":3,"file":"startup.d.ts","sourceRoot":"","sources":["../src/startup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAI5C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,4CAA4C;AAC5C,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAEjD,0FAA0F;AAC1F,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAKrC,qBAAa,cAAc;IAEnB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAN/B,YACqB,GAAG,EAAE,iBAAiB,EACtB,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EACnC;IAGE,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAUlC;IAED,iFAAiF;YACnE,mBAAmB;IAQjC;;;OAGG;YACW,2BAA2B;IAsBzC,OAAO,CAAC,MAAM;IAIR,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAkBnC;IAEK,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAWvC;IAED,qGAAqG;YACvF,UAAU;IAqBlB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CA8BnC;CACJ"}

package/dist/startup.js

@@ -1,4 +1,12 @@
 import { signData } from "./crypto/utils.js";
+import { peerAnnouncementPayload } from "./peer/repository.js";
+import { resourceAnnouncementPayload } from "./resource/repository.js";
+/** Per request to a peer during startup. */
+export const STARTUP_REQUEST_TIMEOUT_MS = 10_000;
+/** Peers and resources requested per page from the starting peer. It may return fewer. */
+export const STARTUP_PAGE_SIZE = 100;
+// 10 minutes
+const SIGNATURE_LIFETIME_MS = 1000 * 60 * 10;
 export class StartupService {
     log;
     service;
@@ -14,7 +22,7 @@ export class StartupService {
         this.publicKey = publicKey;
         this.privateKey = privateKey;
     }
-    // If the peer list is empty, populate it using the peer start parameter.
+    // Learn peers and resources from the starting peer, then announce this node to every peer.
     async seedFromPeer() {
         this.log.info(`Seeding from peer ${this.startingPeer}`);
         await this.populatePeers();
@@ -23,101 +31,107 @@ export class StartupService {
         await this.broadcastSelf();
         this.log.info(`Finished seeding from peer ${this.startingPeer}`);
     }
-    async populatePeers() {
-        this.log.info(`Populating peers from ${this.startingPeer}`);
-        const peerList = await this.service.peerRepository.getPeerList();
-        if (peerList.length > 0) {
-            return;
+    /** GET a JSON document from the starting peer, failing on a non-2xx response. */
+    async getFromStartingPeer(path) {
+        const response = await fetch(`${this.startingPeer}/v1${path}`, { signal: AbortSignal.timeout(STARTUP_REQUEST_TIMEOUT_MS) });
+        if (!response.ok) {
+            throw new Error(`Starting peer ${this.startingPeer} responded ${response.status} to GET /v1${path}`);
         }
-        const response = await fetch(`${this.startingPeer}/v1/peers`);
-        const data = await response.json();
-        if (!data.peers) {
-            throw new Error('Invalid response from peer');
+        return await response.json();
+    }
+    /**
+     * Walks a paginated list on the starting peer, handing each page to `handlePage` before
+     * fetching the next, so the whole list is never held at once. Returns the item count.
+     */
+    async forEachPageFromStartingPeer(path, key, handlePage) {
+        let offset = 0;
+        let count = 0;
+        while (true) {
+            const data = await this.getFromStartingPeer(`${path}?offset=${offset}&limit=${STARTUP_PAGE_SIZE}`);
+            const items = data[key];
+            const nextOffset = data.nextOffset ?? null;
+            // The next offset must move forward, or a bad peer could keep startup looping forever.
+            if (!Array.isArray(items) || (nextOffset !== null && (!Number.isInteger(nextOffset) || nextOffset <= offset))) {
+                throw new Error('Invalid response from peer');
+            }
+            await handlePage(items);
+            count += items.length;
+            if (nextOffset === null) {
+                return count;
+            }
+            offset = nextOffset;
         }
-        if (data.peers) {
-            for (const peer of data.peers) {
+    }
+    isSelf(peer) {
+        return peer.publicKey === this.publicKey || peer.baseUrl === this.baseUrl;
+    }
+    async populatePeers() {
+        this.log.info(`Populating peers from ${this.startingPeer}`);
+        // Known peers are skipped, so this is safe to repeat on every restart, and a run cut off
+        // partway through the pages is completed on the next one.
+        let count = 0;
+        const savePeers = async (peers) => {
+            for (const peer of peers.filter(peer => !this.isSelf(peer))) {
                 await this.service.peerRepository.create(peer);
+                count++;
             }
-        }
+        };
         // Save the starting peer to the database.
-        const startingPeerResponse = await fetch(`${this.startingPeer}/v1/self`);
-        const startingPeerData = await startingPeerResponse.json();
-        await this.service.peerRepository.create({
-            baseUrl: startingPeerData.baseUrl,
-            publicKey: startingPeerData.publicKey,
-            name: startingPeerData.name,
-        });
-        this.log.info(`Populated ${data.peers.length + 1} peers`);
+        await savePeers([await this.getFromStartingPeer('/self')]);
+        await this.forEachPageFromStartingPeer('/peers', 'peers', savePeers);
+        this.log.info(`Populated ${count} peers`);
     }
     async populateResources() {
         this.log.info(`Populating resources from ${this.startingPeer}`);
-        const response = await fetch(`${this.startingPeer}/v1/resources`);
-        const data = await response.json();
-        if (!data.resources) {
-            throw new Error('Invalid response from peer');
-        }
-        if (data.resources) {
-            for (const resource of data.resources) {
-                await this.service.resourceRepository.create(resource);
+        // Known resources are skipped, so this is safe to repeat on every restart.
+        const count = await this.forEachPageFromStartingPeer('/resources', 'resources', async (resources) => {
+            for (const resource of resources) {
+                await this.service.resourceRepository.learn(resource);
+            }
+        });
+        this.log.info(`Learned up to ${count} resources`);
+    }
+    /** PUT to every peer, logging failures instead of throwing so one bad peer doesn't stop the rest. */
+    async putToPeers(peers, path, body, description) {
+        for (const peer of peers) {
+            try {
+                const response = await fetch(`${peer.baseUrl}/v1${path}`, {
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(STARTUP_REQUEST_TIMEOUT_MS),
+                });
+                if (!response.ok) {
+                    this.log.warn(`Failed to broadcast ${description} to node ${peer.baseUrl}: ${response.status} ${await response.text()}`);
+                }
+            }
+            catch (error) {
+                this.log.warn(error, `Failed to broadcast ${description} to node ${peer.baseUrl}`);
             }
         }
-        this.log.info(`Populated ${data.resources.length} resources`);
     }
     async broadcastSelf() {
         this.log.info(`Broadcasting self to peers`);
         // Let the peers know about this node.
-        const peers = await this.service.peerRepository.getPeerList();
-        // 10 minutes
-        const peerSignatureExpiry = new Date(Date.now() + 1000 * 60 * 10).toISOString();
-        const peerSignature = signData({
-            baseUrl: this.baseUrl,
-            name: this.baseUrl,
-            expiry: peerSignatureExpiry,
-        }, this.privateKey);
-        for (const peer of peers) {
-            const response = await fetch(`${peer.baseUrl}/v1/peers`, {
-                method: 'PUT',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    baseUrl: this.baseUrl,
-                    name: this.baseUrl,
-                    publicKey: this.publicKey,
-                    signature: peerSignature,
-                    expiry: peerSignatureExpiry,
-                }),
-            });
-            if (!response.ok) {
-                this.log.warn(`Failed to broadcast self to node ${peer.baseUrl}: ${response.statusText}`);
-            }
-        }
+        const peers = (await this.service.peerRepository.getPeerList()).filter(peer => !this.isSelf(peer));
+        const self = { baseUrl: this.baseUrl, name: this.baseUrl, publicKey: this.publicKey };
+        const peerSignatureExpiry = new Date(Date.now() + SIGNATURE_LIFETIME_MS).toISOString();
+        const peerSignature = signData(peerAnnouncementPayload(self, peerSignatureExpiry), this.privateKey);
+        await this.putToPeers(peers, '/peers', { ...self, signature: peerSignature, expiry: peerSignatureExpiry }, 'self');
         this.log.info(`Broadcasted self to ${peers.length} peers`);
         this.log.info(`Broadcasting resources to peers`);
         // Let the peers know about the resources available on this node.
         const resources = await this.service.resourceRepository.getInternalResources();
-        // 10 minutes
-        const resourceSignatureExpiry = new Date(Date.now() + 1000 * 60 * 10).toISOString();
-        const resourceSignature = signData({
+        const resourceSignatureExpiry = new Date(Date.now() + SIGNATURE_LIFETIME_MS).toISOString();
+        const resourceSignature = signData(resourceAnnouncementPayload(resources, resourceSignatureExpiry), this.privateKey);
+        await this.putToPeers(peers, '/all-resources', {
+            publicKey: this.publicKey,
             resources,
             expiry: resourceSignatureExpiry,
-        }, this.privateKey);
-        for (const peer of peers) {
-            const response = await fetch(`${peer.baseUrl}/v1/all-resources`, {
-                method: 'PUT',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    resources,
-                    expiry: resourceSignatureExpiry,
-                    signature: resourceSignature,
-                }),
-            });
-            if (!response.ok) {
-                this.log.warn(`Failed to broadcast resources to node ${peer.baseUrl}: ${response.statusText}`);
-            }
-        }
+            signature: resourceSignature,
+        }, 'resources');
         this.log.info(`Broadcasted ${resources.length} resources to ${peers.length} peers`);
     }
 }

package/dist/tests/client/operatorClient.test.d.ts

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

package/dist/tests/client/operatorClient.test.d.ts.map

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

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

@@ -0,0 +1,96 @@
+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);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.unstubAllGlobals();
+        vi.restoreAllMocks();
+    });
+    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);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(999);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(1);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        await vi.advanceTimersByTimeAsync(2000);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        await pending;
+        expect(console.error).not.toHaveBeenCalled();
+        const bodies = fetchMock.mock.calls.map(([, init]) => init.body);
+        expect(new Set(bodies).size).toBe(1);
+    });
+    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);
+        await vi.advanceTimersByTimeAsync(29_999);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(1);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        await pending;
+    });
+    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);
+        await vi.runAllTimersAsync();
+        await pending;
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(console.error).not.toHaveBeenCalled();
+    });
+    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);
+        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);
+        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 assertion = expect(pending).rejects.toThrow("fetch failed");
+        await vi.runAllTimersAsync();
+        await assertion;
+        expect(fetchMock).toHaveBeenCalledTimes(1 + SETTLE_PAYMENT_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);
+        await vi.runAllTimersAsync();
+        await pending;
+        expect(fetchMock).toHaveBeenCalledTimes(1 + SETTLE_PAYMENT_MAX_RETRIES);
+        expect(console.error).toHaveBeenCalledOnce();
+    });
+});

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

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

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

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

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

@@ -0,0 +1,64 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { open } from "sqlite";
+import sqlite3 from "sqlite3";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { openDatabase } from "../../db/db.js";
+describe("openDatabase", () => {
+    let dir;
+    beforeEach(async () => {
+        dir = await mkdtemp(path.join(tmpdir(), "stellarium-db-"));
+    });
+    afterEach(async () => {
+        await rm(dir, { recursive: true, force: true });
+    });
+    test("can be reopened without errors", async () => {
+        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: 2 });
+        await db.close();
+    });
+    test("rebuilds resource tables from the old schema and keeps peers", async () => {
+        const filename = path.join(dir, "old.db");
+        const old = await open({ filename, driver: sqlite3.Database });
+        await old.exec(`
+            CREATE TABLE peer (id INTEGER PRIMARY KEY AUTOINCREMENT, base_url TEXT NOT NULL, public_key TEXT NOT NULL, name TEXT NOT NULL,
+                created_at TEXT NOT NULL, updated_at TEXT NOT NULL, UNIQUE (public_key), UNIQUE (base_url), UNIQUE (name));
+            CREATE TABLE resource (id INTEGER PRIMARY KEY AUTOINCREMENT, peer_id INTEGER, path TEXT NOT NULL, name TEXT NOT NULL,
+                base_url TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, UNIQUE (path, name), UNIQUE (base_url));
+            INSERT INTO peer (base_url, public_key, name, created_at, updated_at) VALUES ('http://p', 'key', 'p', 'now', 'now');
+            INSERT INTO resource (path, name, base_url, created_at, updated_at) VALUES ('com.p', 'A', 'http://p', 'now', 'now');
+        `);
+        await old.close();
+        const db = await openDatabase(filename);
+        expect(await db.all("SELECT public_key FROM peer")).toEqual([{ public_key: "key" }]);
+        expect(await db.all("SELECT * FROM resource")).toEqual([]);
+        // Two resources on one base URL failed under the old UNIQUE (base_url).
+        await db.exec(`
+            INSERT INTO resource (path, name, base_url, created_at, updated_at) VALUES ('com.p', 'A', 'http://p', 'now', 'now');
+            INSERT INTO resource (path, name, base_url, created_at, updated_at) VALUES ('com.p', 'B', 'http://p', 'now', 'now');
+        `);
+        await db.close();
+    });
+    test("adds the restricted column to a version 1 database and keeps held grants on later opens", async () => {
+        const filename = path.join(dir, "v1.db");
+        const old = await open({ filename, driver: sqlite3.Database });
+        await old.exec(`
+            CREATE TABLE resource_function (id INTEGER PRIMARY KEY AUTOINCREMENT, resource_id INTEGER NOT NULL, name TEXT NOT NULL,
+                return_type TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, UNIQUE (resource_id, name));
+            PRAGMA user_version = 1;
+        `);
+        await old.close();
+        const db = await openDatabase(filename);
+        const columns = await db.all("PRAGMA table_info(resource_function)");
+        expect(columns.map(column => column.name)).toContain("restricted");
+        await db.run("INSERT INTO held_grant (issuer, id, root_issuer_base_url, chain, issued_at, expires_at, updated_at) VALUES ('k', 'g', 'http://p', '[]', 'now', 'now', 'now')");
+        await db.close();
+        // Grants are not a cache of anything a peer resends, so a reopen must not drop them.
+        const reopened = await openDatabase(filename);
+        expect(await reopened.all("SELECT id FROM held_grant")).toEqual([{ id: "g" }]);
+        await reopened.close();
+    });
+});

package/dist/tests/grant/grant.test.d.ts

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

package/dist/tests/grant/grant.test.d.ts.map

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

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

@@ -0,0 +1,133 @@
+import { describe, expect, test } from "vitest";
+import { capabilityCovers, capabilityMatches, grantHash, grantPayload, MAX_GRANT_CHAIN_LENGTH, signGrant, verifyChain, } from "../../grant/grant.js";
+import { verifyData } from "../../crypto/utils.js";
+import { generateBase64KeyPair } from "../helpers.js";
+const inHours = (hours) => new Date(Date.now() + hours * 3_600_000).toISOString();
+const weather = { resourcePath: "com.example", resourceName: "Weather" };
+// Shared, so a child computed a millisecond later doesn't outlive its parent.
+const expiresAt = inHours(1);
+function grantFrom(issuer, audience, capabilities, parent = null, overrides = {}) {
+    return signGrant({
+        id: crypto.randomUUID(),
+        issuer: issuer.publicKey,
+        issuerBaseUrl: "http://issuer",
+        audience: audience.publicKey,
+        capabilities,
+        issuedAt: new Date().toISOString(),
+        expiresAt,
+        parent: parent ? grantHash(parent) : null,
+        ...overrides,
+    }, issuer.privateKey);
+}
+describe("verifyChain", () => {
+    const provider = generateBase64KeyPair();
+    const gateway = generateBase64KeyPair();
+    const user = generateBase64KeyPair();
+    const other = generateBase64KeyPair();
+    test("accepts a root grant and returns it as the leaf", () => {
+        const root = grantFrom(provider, gateway, [weather]);
+        expect(verifyChain([root], provider.publicKey)).toEqual({ ok: true, leaf: root });
+        expect(verifyData(grantPayload(root), provider.publicKey, root.signature)).toBe(true);
+    });
+    test("accepts a three-grant chain that narrows at each link", () => {
+        const root = grantFrom(provider, gateway, [{ resourcePath: "com.*" }]);
+        const middle = grantFrom(gateway, user, [weather], root);
+        const leaf = grantFrom(user, other, [{ ...weather, functionName: "temperature", constraints: { city: "Oslo" } }], middle);
+        expect(verifyChain([root, middle, leaf], provider.publicKey)).toEqual({ ok: true, leaf });
+    });
+    test.each([
+        ["an empty chain", () => []],
+        ["a non-array", () => "nope"],
+        ["a malformed grant", () => [{ ...grantFrom(provider, gateway, [weather]), capabilities: [] }]],
+    ])("rejects %s", (_, chain) => {
+        expect(verifyChain(chain(), provider.publicKey).ok).toBe(false);
+    });
+    test("rejects a root issued by another key", () => {
+        expect(verifyChain([grantFrom(other, gateway, [weather])], provider.publicKey).ok).toBe(false);
+    });
+    test("rejects a root that claims a parent", () => {
+        const root = grantFrom(provider, gateway, [weather], null, { parent: "something" });
+        expect(verifyChain([root], provider.publicKey).ok).toBe(false);
+    });
+    test("rejects a tampered grant", () => {
+        const root = grantFrom(provider, gateway, [weather]);
+        expect(verifyChain([{ ...root, capabilities: [{ resourcePath: "*" }] }], provider.publicKey).ok).toBe(false);
+    });
+    test("rejects an expired grant and one that lives too long", () => {
+        expect(verifyChain([grantFrom(provider, gateway, [weather], null, { expiresAt: inHours(-1) })], provider.publicKey).ok).toBe(false);
+        expect(verifyChain([grantFrom(provider, gateway, [weather], null, { expiresAt: inHours(24 * 31) })], provider.publicKey).ok).toBe(false);
+    });
+    test("rejects a link signed by someone other than the parent's audience", () => {
+        const root = grantFrom(provider, gateway, [weather]);
+        expect(verifyChain([root, grantFrom(other, user, [weather], root)], provider.publicKey).ok).toBe(false);
+    });
+    test("rejects a link naming a different parent", () => {
+        const root = grantFrom(provider, gateway, [weather]);
+        const sibling = grantFrom(provider, gateway, [weather]);
+        expect(verifyChain([root, grantFrom(gateway, user, [weather], sibling)], provider.publicKey).ok).toBe(false);
+    });
+    test("rejects a link that outlives its parent", () => {
+        const root = grantFrom(provider, gateway, [weather]);
+        expect(verifyChain([root, grantFrom(gateway, user, [weather], root, { expiresAt: inHours(2) })], provider.publicKey).ok).toBe(false);
+    });
+    test.each([
+        ["a wider path", { resourcePath: "com.*" }],
+        ["another resource", { resourcePath: "com.example", resourceName: "Traffic" }],
+    ])("rejects a link that widens to %s", (_, capability) => {
+        const root = grantFrom(provider, gateway, [weather]);
+        expect(verifyChain([root, grantFrom(gateway, user, [capability], root)], provider.publicKey).ok).toBe(false);
+    });
+    test("rejects a link that drops a constraint", () => {
+        const root = grantFrom(provider, gateway, [{ ...weather, constraints: { city: "Oslo" } }]);
+        expect(verifyChain([root, grantFrom(gateway, user, [weather], root)], provider.publicKey).ok).toBe(false);
+    });
+    test("rejects a chain longer than the limit", () => {
+        const keys = Array.from({ length: MAX_GRANT_CHAIN_LENGTH + 1 }, () => generateBase64KeyPair());
+        const chain = [grantFrom(provider, keys[0], [weather])];
+        for (let i = 1; i <= MAX_GRANT_CHAIN_LENGTH; i++) {
+            chain.push(grantFrom(keys[i - 1], keys[i], [weather], chain[i - 1]));
+        }
+        expect(verifyChain(chain.slice(0, MAX_GRANT_CHAIN_LENGTH), provider.publicKey).ok).toBe(true);
+        expect(verifyChain(chain, provider.publicKey).ok).toBe(false);
+    });
+});
+describe("capabilityMatches", () => {
+    const oslo = [{ name: "city", value: "Oslo" }];
+    test.each([
+        [{ resourcePath: "com.example" }, "com.example", true],
+        [{ resourcePath: "com.example.*" }, "com.example", true],
+        [{ resourcePath: "com.example.*" }, "com.example.sub", true],
+        [{ resourcePath: "com.example.*" }, "com.examplefoo", false],
+        [{ resourcePath: "com.*" }, "com.example", true],
+        [{ resourcePath: "*" }, "org.anything", true],
+        [{ resourcePath: "com.example" }, "com.example.sub", false],
+    ])("%o on path %s is %s", (capability, path, expected) => {
+        expect(capabilityMatches(capability, path, "Weather", "temperature", oslo)).toBe(expected);
+    });
+    test("checks names and constraints", () => {
+        expect(capabilityMatches({ ...weather, functionName: "temperature" }, "com.example", "Weather", "humidity", oslo)).toBe(false);
+        expect(capabilityMatches({ ...weather, constraints: { city: "Oslo" } }, "com.example", "Weather", "temperature", oslo)).toBe(true);
+        expect(capabilityMatches({ ...weather, constraints: { city: "Paris" } }, "com.example", "Weather", "temperature", oslo)).toBe(false);
+        expect(capabilityMatches({ ...weather, constraints: { units: "C" } }, "com.example", "Weather", "temperature", oslo)).toBe(false);
+    });
+    test("refuses a constrained parameter that appears more than once", () => {
+        const duplicated = [...oslo, { name: "city", value: "Paris" }];
+        expect(capabilityMatches({ ...weather, constraints: { city: "Oslo" } }, "com.example", "Weather", "temperature", duplicated)).toBe(false);
+    });
+});
+describe("capabilityCovers", () => {
+    test.each([
+        [{ resourcePath: "*" }, { resourcePath: "*" }, true],
+        [{ resourcePath: "*" }, { resourcePath: "com.example" }, true],
+        [{ resourcePath: "com.*" }, { resourcePath: "com.example.*" }, true],
+        [{ resourcePath: "com.*" }, { resourcePath: "*" }, false],
+        [{ resourcePath: "com.example.*" }, { resourcePath: "com.examplefoo" }, false],
+        [{ resourcePath: "com.example" }, { resourcePath: "com.example.*" }, false],
+        [weather, { ...weather, functionName: "temperature" }, true],
+        [{ ...weather, functionName: "temperature" }, weather, false],
+        [{ ...weather, constraints: { city: "Oslo" } }, { ...weather, constraints: { city: "Oslo", units: "C" } }, true],
+        [{ ...weather, constraints: { city: "Oslo" } }, { ...weather, constraints: { city: "Paris" } }, false],
+    ])("%o covers %o: %s", (parent, child, expected) => {
+        expect(capabilityCovers(parent, child)).toBe(expected);
+    });
+});

package/dist/tests/grant/service.test.d.ts

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