stellarium-ts 0.12.0 → 0.14.0

package/dist/server.js

@@ -1,32 +1,133 @@
 import 'dotenv/config';
-import { createTables } from './db/db.js';
+import { DEFAULT_DATABASE_PATH, openDatabase } from './db/db.js';
 import routes from './routes.js';
 import { createService } from './service.js';
 import { StartupService } from './startup.js';
+export const DEFAULT_COST_LIMIT_LAMPORTS = 10_000;
+export const DEFAULT_GRANT_REFRESH_INTERVAL_MS = 1000 * 60 * 5;
+function required(name, value) {
+    if (!value) {
+        throw new Error(`${name} is required: pass it to StellariumNode.start or set it in the environment`);
+    }
+    return value;
+}
+function hostsPaidFunctions(resources) {
+    return resources.some(resource => resource.functions.some(fn => fn.paymentManifest));
+}
+export function resolveConfig(options, resources = []) {
+    const costLimit = options.costLimitLamports ?? (process.env.COST_LIMIT_LAMPORTS ? Number(process.env.COST_LIMIT_LAMPORTS) : DEFAULT_COST_LIMIT_LAMPORTS);
+    if (!Number.isSafeInteger(costLimit) || costLimit < 0) {
+        throw new Error('costLimitLamports must be a nonnegative integer');
+    }
+    return {
+        baseUrl: required('BASE_URL', options.baseUrl ?? process.env.BASE_URL),
+        publicKey: required('SIGNING_PUBLIC_KEY', options.publicKey ?? process.env.SIGNING_PUBLIC_KEY),
+        privateKey: required('SIGNING_PRIVATE_KEY', options.privateKey ?? process.env.SIGNING_PRIVATE_KEY),
+        apiKey: options.apiKey ?? process.env.API_KEY,
+        // Only a node hosting paid functions settles payments.
+        operatorUrl: hostsPaidFunctions(resources)
+            ? required('OPERATOR_URL', options.operatorUrl ?? process.env.OPERATOR_URL)
+            : options.operatorUrl ?? process.env.OPERATOR_URL,
+        costLimitLamports: costLimit,
+    };
+}
 export class StellariumNode {
     resources = [];
+    service;
     async register(resource) {
         this.resources.push(resource);
     }
+    /**
+     * Listens, then bootstraps from `startingPeer` if one is given.
+     * Rejects if the server can't listen or bootstrapping fails.
+     */
     async start(fastify, options) {
-        ;
-        const service = createService(this.resources);
-        await createTables();
-        fastify.register(routes, { prefix: '/v1', service });
-        // Run the server!
-        fastify.listen({ port: options.port ?? 3000, host: options.host ?? '0.0.0.0' }, function (err, address) {
-            if (err) {
-                fastify.log.error(err);
-                process.exit(1);
-            }
-            if (options.startingPeer) {
-                const startupService = new StartupService(fastify.log, service, options.startingPeer, process.env.BASE_URL, process.env.SIGNING_PUBLIC_KEY, process.env.SIGNING_PRIVATE_KEY);
-                Promise.resolve(startupService.seedFromPeer()).catch(err => {
-                    fastify.log.error(err);
-                    process.exit(1);
-                });
+        const config = resolveConfig(options, this.resources);
+        const db = await openDatabase(options.databasePath ?? DEFAULT_DATABASE_PATH);
+        fastify.addHook('onClose', async () => db.close());
+        const service = createService(db, this.resources, config, { approveGrant: options.approveGrant });
+        // A configured chain may be older than its stored renewal, or long expired; neither should stop the node.
+        for (const chain of options.grants ?? []) {
+            if (!await service.grantService.seed(chain)) {
+                fastify.log.warn(`Skipped expired grant ${chain[chain.length - 1]?.id} from the start options`);
             }
-            fastify.log.info(`server listening on ${address}`);
+        }
+        this.service = service;
+        // Each run is scheduled after the previous one finishes, so slow renewals never overlap.
+        const refreshIntervalMs = options.grantRefreshIntervalMs ?? DEFAULT_GRANT_REFRESH_INTERVAL_MS;
+        let refresher;
+        let closed = false;
+        const scheduleRefresh = () => {
+            refresher = setTimeout(async () => {
+                try {
+                    const { failed, removed } = await service.grantService.refreshDue();
+                    for (const { id, error } of failed) {
+                        fastify.log.warn(`Failed to renew grant ${id}: ${error}`);
+                    }
+                    for (const id of removed) {
+                        fastify.log.info(`Removed long-expired grant ${id}: its issuer refused renewal`);
+                    }
+                }
+                catch (error) {
+                    fastify.log.error(error, 'Failed to renew grants');
+                }
+                if (!closed) {
+                    scheduleRefresh();
+                }
+            }, refreshIntervalMs);
+            refresher.unref();
+        };
+        scheduleRefresh();
+        fastify.addHook('onClose', async () => {
+            closed = true;
+            clearTimeout(refresher);
         });
+        await fastify.register(routes, { prefix: '/v1', service, rateLimit: options.rateLimit });
+        const address = await fastify.listen({ port: options.port ?? 3000, host: options.host ?? '0.0.0.0' });
+        fastify.log.info(`server listening on ${address}`);
+        if (options.startingPeer) {
+            const startupService = new StartupService(fastify.log, service, options.startingPeer, config.baseUrl, config.publicKey, config.privateKey);
+            await startupService.seedFromPeer();
+        }
+    }
+    /** Issues a root grant for this node's resources. Hand the returned chain to the audience. */
+    async issueGrant(audience, capabilities, options) {
+        return this.started().grantService.issue(audience, capabilities, options);
+    }
+    /**
+     * Narrows a grant this node holds for another audience. Hand the returned chain to the audience.
+     * Name the held grant by its id, or by its issuer and id when two issuers used the same id.
+     */
+    async delegateGrant(heldGrant, audience, capabilities, options) {
+        return this.started().grantService.delegate(heldGrant, audience, capabilities, options);
+    }
+    /** Asks another node for a grant on its resources, and stores it. Throws if refused. */
+    async requestGrant(providerBaseUrl, capabilities, details) {
+        return this.started().grantService.request(providerBaseUrl, capabilities, details);
+    }
+    /** Stores a grant chain addressed to this node. */
+    async addGrant(chain) {
+        return this.started().grantService.add(chain);
+    }
+    /**
+     * Refuses the grant, and every grant delegated from it, in calls to this node, and stops its renewal.
+     * Name a grant this node issued by its id, and any other grant by its issuer and id.
+     */
+    async revokeGrant(grant) {
+        return this.started().grantService.revoke(grant);
+    }
+    /** Refuses this caller key in restricted calls, renewals, grant requests and paid calls. */
+    async blockCaller(publicKey, reason) {
+        return this.started().grantService.block(publicKey, reason);
+    }
+    /** False when the key wasn't blocked. */
+    async unblockCaller(publicKey) {
+        return this.started().grantService.unblock(publicKey);
+    }
+    started() {
+        if (!this.service) {
+            throw new Error('StellariumNode.start must be called first');
+        }
+        return this.service;
     }
 }

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: 3 });
+        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();
+    });
+});