stellarium-ts 0.11.0 → 0.13.0

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

@@ -0,0 +1,188 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import Fastify from "fastify";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { verifyData } from "../../crypto/utils.js";
+import { paymentVoucherPayload } from "../../resource/invoker.js";
+import { StellariumNode } from "../../server.js";
+import { COST, generateBase64KeyPair, RECIPIENT, temperatureSource, weatherResource } from "../helpers.js";
+/** A free function only callers with a grant from the provider may run. */
+function vaultResource(baseUrl) {
+    return {
+        id: 2,
+        baseUrl,
+        metadata: {},
+        path: "com.example",
+        name: "Vault",
+        functions: [{ name: "open", parameters: [{ name: "city", type: "string" }], returnType: "int32", exec: async () => 7, restricted: true }],
+    };
+}
+const vaultSource = 'request OpenVault {\n  const vault: com.example.Vault\n\n  return vault.open(city: "Oslo")\n}';
+const vault = { resourcePath: "com.example", resourceName: "Vault" };
+const HOUR = 3_600_000;
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const { port } = server.address();
+            server.close(() => resolve(port));
+        });
+    });
+}
+/**
+ * A provider node hosting the paid weather resource, a caller node that bootstraps from it,
+ * and a fake operator that records settlements. Everything runs in-process over real HTTP.
+ */
+describe("two-node network", () => {
+    const servers = [];
+    const settlements = [];
+    const callerKeys = generateBase64KeyPair();
+    let dir;
+    let operatorUrl;
+    let providerUrl;
+    let provider;
+    async function startNode(node, options) {
+        const fastify = Fastify();
+        servers.push(fastify);
+        await node.start(fastify, { host: "127.0.0.1", baseUrl: `http://127.0.0.1:${options.port}`, ...options });
+        return fastify;
+    }
+    async function startCaller(options = {}) {
+        const port = await freePort();
+        const node = new StellariumNode();
+        const fastify = await startNode(node, {
+            port,
+            startingPeer: providerUrl,
+            ...callerKeys,
+            apiKey: "caller-key",
+            databasePath: path.join(dir, "caller.db"),
+            ...options,
+        });
+        return { node, fastify, url: `http://127.0.0.1:${port}` };
+    }
+    const run = (url, source = temperatureSource) => fetch(`${url}/v1/run`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: "Bearer caller-key" },
+        body: JSON.stringify({ source }),
+    }).then(response => response.json());
+    const getJson = (url) => fetch(url).then(response => response.json());
+    beforeEach(async () => {
+        dir = await mkdtemp(path.join(tmpdir(), "stellarium-network-"));
+        settlements.length = 0;
+        const operator = Fastify();
+        servers.push(operator);
+        operator.post("/v1/payment", async (request) => {
+            settlements.push(request.body.voucher);
+            return { status: "confirmed" };
+        });
+        operatorUrl = `${await operator.listen({ port: 0, host: "127.0.0.1" })}/v1`;
+        const providerPort = await freePort();
+        providerUrl = `http://127.0.0.1:${providerPort}`;
+        provider = new StellariumNode();
+        await provider.register(weatherResource(providerUrl));
+        await provider.register(vaultResource(providerUrl));
+        await startNode(provider, {
+            port: providerPort,
+            ...generateBase64KeyPair(),
+            operatorUrl,
+            databasePath: ":memory:",
+            apiKey: "provider-admin",
+            approveGrant: ({ details }) => details?.invite === "letmein" ? { lifetimeMs: HOUR } : undefined,
+        });
+    });
+    afterEach(async () => {
+        await Promise.all(servers.splice(0).map(server => server.close()));
+        await rm(dir, { recursive: true, force: true });
+    });
+    test("the caller discovers the provider, pays for a call and the provider settles it", async () => {
+        const caller = await startCaller();
+        // The provider learned about the caller from its signed announcement.
+        const providerPeers = await getJson(`${providerUrl}/v1/peers`);
+        expect(providerPeers.peers).toEqual([{ baseUrl: caller.url, name: caller.url, publicKey: callerKeys.publicKey }]);
+        const callerResources = await getJson(`${caller.url}/v1/resources`);
+        expect(callerResources.resources).toContainEqual(expect.objectContaining({
+            name: "Weather",
+            baseUrl: providerUrl,
+            functions: expect.arrayContaining([expect.objectContaining({ name: "temperature", paymentManifest: { costLamports: COST, recipientAddress: RECIPIENT } })]),
+        }));
+        expect(await run(caller.url)).toEqual({ returnValue: { value: 12, error: null } });
+        await vi.waitFor(() => expect(settlements).toHaveLength(1));
+        const [voucher] = settlements;
+        expect(voucher).toMatchObject({ amount: COST, recipientAddress: RECIPIENT, publicKey: callerKeys.publicKey });
+        expect(verifyData(paymentVoucherPayload(voucher), voucher.publicKey, voucher.signature)).toBe(true);
+    });
+    test("the caller restarts on the same database without failing", async () => {
+        const first = await startCaller();
+        await first.fastify.close();
+        const second = await startCaller();
+        expect(await run(second.url)).toEqual({ returnValue: { value: 12, error: null } });
+    });
+    describe("restricted functions", () => {
+        test("the caller needs a grant from the provider, then calls with it", async () => {
+            const caller = await startCaller();
+            const refused = await run(caller.url, vaultSource);
+            expect(refused.returnValue.error.message).toContain(`requires a grant from ${providerUrl}`);
+            await caller.node.addGrant(await provider.issueGrant(callerKeys.publicKey, [vault], { lifetimeMs: HOUR }));
+            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+        });
+        test("the caller asks the provider for a grant, then calls with it", async () => {
+            const caller = await startCaller();
+            await expect(caller.node.requestGrant(providerUrl, [vault], { invite: "wrong" })).rejects.toThrow("Grant request refused");
+            await caller.node.requestGrant(providerUrl, [vault], { invite: "letmein" });
+            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+        });
+        test("the provider's admin blocks a caller over HTTP, then unblocks it", async () => {
+            const caller = await startCaller();
+            await caller.node.requestGrant(providerUrl, [vault], { invite: "letmein" });
+            const adminRequest = (method) => fetch(`${providerUrl}/v1/admin/blocked-callers/${callerKeys.publicKey}`, {
+                method,
+                // Fastify refuses a JSON content type with an empty body, so the DELETE sends neither.
+                headers: method === "PUT" ? { "Content-Type": "application/json", Authorization: "Bearer provider-admin" } : { Authorization: "Bearer provider-admin" },
+                body: method === "PUT" ? JSON.stringify({ reason: "abuse" }) : undefined,
+            });
+            expect((await adminRequest("PUT")).status).toBe(200);
+            const refused = await run(caller.url, vaultSource);
+            expect(refused.returnValue.error.message).toContain("Invalid authorization");
+            await expect(caller.node.requestGrant(providerUrl, [vault], { invite: "letmein" })).rejects.toThrow("refused");
+            expect((await adminRequest("DELETE")).status).toBe(200);
+            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+        });
+        test("grants passed at start are loaded, and revocation at the provider cuts them off", async () => {
+            const chain = await provider.issueGrant(callerKeys.publicKey, [vault], { lifetimeMs: HOUR });
+            const caller = await startCaller({ grants: [chain] });
+            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+            await provider.revokeGrant(chain[0].id);
+            const refused = await run(caller.url, vaultSource);
+            expect(refused.returnValue.error.message).toContain("Invalid authorization");
+        });
+        test("a third node calls through a grant the caller delegated to it", async () => {
+            const caller = await startCaller();
+            const [root] = await provider.issueGrant(callerKeys.publicKey, [{ resourcePath: "com.example.*" }], { lifetimeMs: HOUR });
+            await caller.node.addGrant([root]);
+            const userKeys = generateBase64KeyPair();
+            const user = await startCaller({ ...userKeys, databasePath: path.join(dir, "user.db") });
+            await user.node.addGrant(await caller.node.delegateGrant(root.id, userKeys.publicKey, [vault], { lifetimeMs: HOUR }));
+            expect(await run(user.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+        });
+        test("the refresher renews a grant past half its lifetime", async () => {
+            const fetchSpy = vi.spyOn(globalThis, "fetch");
+            const chain = await provider.issueGrant(callerKeys.publicKey, [vault], { lifetimeMs: 400 });
+            const caller = await startCaller({ grants: [chain], grantRefreshIntervalMs: 50 });
+            await vi.waitFor(() => expect(fetchSpy.mock.calls.some(([url]) => String(url) === `${providerUrl}/v1/grants/renew`)).toBe(true), { timeout: 2000 });
+            fetchSpy.mockRestore();
+            // Well past the first copy's expiry, the renewed one still works.
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            expect(await run(caller.url, vaultSource)).toEqual({ returnValue: { value: 7, error: null } });
+        });
+    });
+    test("the caller refuses a call that costs more than its limit", async () => {
+        const caller = await startCaller({ costLimitLamports: COST - 1 });
+        const result = await run(caller.url);
+        expect(result.returnValue.value).toBeNull();
+        expect(result.returnValue.error.message).toContain("exceeds the cost limit");
+        expect(settlements).toEqual([]);
+    });
+});

package/dist/tests/peer/repository.test.d.ts

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

package/dist/tests/peer/repository.test.d.ts.map

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

package/dist/tests/peer/repository.test.js

@@ -0,0 +1,50 @@
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { signData } from "../../crypto/utils.js";
+import { openDatabase } from "../../db/db.js";
+import { PeerRepository, peerAnnouncementPayload } from "../../peer/repository.js";
+import { generateBase64KeyPair } from "../helpers.js";
+describe("PeerRepository", () => {
+    const keys = generateBase64KeyPair();
+    const peer = { baseUrl: "http://peer.example", name: "peer", publicKey: keys.publicKey };
+    const expiry = () => new Date(Date.now() + 60_000).toISOString();
+    let db;
+    let repository;
+    beforeEach(async () => {
+        db = await openDatabase(":memory:");
+        repository = new PeerRepository(db);
+    });
+    afterEach(async () => {
+        await db.close();
+    });
+    function announce(announced, privateKey = keys.privateKey) {
+        const at = expiry();
+        return repository.announce(announced, signData(peerAnnouncementPayload(announced, at), privateKey), at);
+    }
+    test("getPeerByPublicKey maps columns to camel case", async () => {
+        await repository.create(peer);
+        expect(await repository.getPeerByPublicKey(peer.publicKey)).toEqual({ id: expect.any(Number), ...peer });
+        expect(await repository.getPeerByPublicKey("unknown")).toBeUndefined();
+    });
+    test("create ignores a peer that is already known", async () => {
+        await repository.create(peer);
+        await repository.create(peer);
+        await repository.create({ ...peer, publicKey: "other-key" });
+        expect(await repository.getPeerList()).toEqual([peer]);
+    });
+    test("announce inserts, then updates the same key in place", async () => {
+        expect(await announce(peer)).toEqual({ ok: true });
+        const { id } = (await repository.getPeerByPublicKey(peer.publicKey));
+        const renamed = { ...peer, name: "renamed" };
+        expect(await announce(renamed)).toEqual({ ok: true });
+        expect(await repository.getPeerByPublicKey(peer.publicKey)).toEqual({ id, ...renamed });
+    });
+    test("announce rejects a name held by another peer", async () => {
+        await announce(peer);
+        const other = generateBase64KeyPair();
+        expect(await announce({ baseUrl: "http://other.example", name: peer.name, publicKey: other.publicKey }, other.privateKey))
+            .toEqual({ ok: false, error: "conflict" });
+    });
+    test("announce rejects a malformed public key instead of throwing", async () => {
+        expect(await announce({ ...peer, publicKey: "not-a-key" })).toEqual({ ok: false, error: "invalid_signature" });
+    });
+});

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

@@ -1,7 +1,7 @@
 import { generateKeyPairSync } from "node:crypto";
-import { describe, expect, test } from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { verifyData } from "../../crypto/utils.js";
-import { CombinationResourceInvoker, paymentVoucherPayload } from "../../resource/invoker.js";
+import { CombinationResourceInvoker, EXTERNAL_INVOKE_MAX_RETRIES, invocationHash, paymentVoucherPayload } from "../../resource/invoker.js";
 function generateBase64KeyPair() {
     const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
         publicKeyEncoding: { type: "spki", format: "der" },
@@ -13,12 +13,139 @@ function generateBase64KeyPair() {
     };
 }
 describe("payment voucher", () => {
-    test("verifies the signed invocation payload, not the voucher object", () => {
+    test("signs the voucher fields, binding the call through invocationHash", () => {
         const { publicKey, privateKey } = generateBase64KeyPair();
         const invoker = new CombinationResourceInvoker({}, 100_000, publicKey, privateKey);
         const parameters = [{ name: "city", value: "Oslo" }];
-        const voucher = invoker.createPaymentVoucher("4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2", 10000, "com.example", "Weather", parameters);
-        expect(verifyData(paymentVoucherPayload(voucher, "com.example", "Weather", parameters), voucher.publicKey, voucher.signature)).toBe(true);
+        const voucher = invoker.createPaymentVoucher("4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2", 10000, "com.example", "Weather", "forecast", parameters);
+        expect(voucher.invocationHash).toBe(invocationHash("com.example", "Weather", "forecast", parameters));
+        expect(verifyData(paymentVoucherPayload(voucher), voucher.publicKey, voucher.signature)).toBe(true);
         expect(verifyData(voucher, voucher.publicKey, voucher.signature)).toBe(false);
     });
+    test("invocationHash changes with the function name or parameters", () => {
+        const parameters = [{ name: "city", value: "Oslo" }];
+        const hash = invocationHash("com.example", "Weather", "forecast", parameters);
+        expect(invocationHash("com.example", "Weather", "history", parameters)).not.toBe(hash);
+        expect(invocationHash("com.example", "Weather", "forecast", [{ name: "city", value: "Bergen" }])).not.toBe(hash);
+    });
+});
+describe("external invoke retries", () => {
+    const resource = { path: "com.example", name: "Weather", metadata: { baseUrl: "https://remote.example" }, functions: [] };
+    const parameters = [{ name: "city", value: "Oslo" }];
+    function createInvoker(paymentManifest) {
+        const { publicKey, privateKey } = generateBase64KeyPair();
+        const repository = { getResourceFunction: async () => ({ paymentManifest }) };
+        return new CombinationResourceInvoker(repository, 100_000, publicKey, privateKey);
+    }
+    const ok = () => new Response(JSON.stringify({ value: 42, error: null }), { status: 200 });
+    const status = (code) => new Response(null, { status: code });
+    let fetchMock;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        fetchMock = vi.fn();
+        vi.stubGlobal("fetch", fetchMock);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.unstubAllGlobals();
+    });
+    test("retries 5xx and network errors with exponential backoff, then succeeds", async () => {
+        fetchMock
+            .mockResolvedValueOnce(status(503))
+            .mockRejectedValueOnce(new TypeError("fetch failed"))
+            .mockResolvedValueOnce(status(500))
+            .mockResolvedValueOnce(ok());
+        const pending = createInvoker().invoke(resource, "forecast", parameters);
+        await vi.advanceTimersByTimeAsync(0);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(500);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        await vi.advanceTimersByTimeAsync(999);
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        await vi.advanceTimersByTimeAsync(1);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
+        await vi.advanceTimersByTimeAsync(2000);
+        expect(fetchMock).toHaveBeenCalledTimes(4);
+        await expect(pending).resolves.toEqual({ value: 42, error: null });
+    });
+    test("does not retry 4xx responses other than 429", async () => {
+        fetchMock.mockResolvedValue(status(400));
+        const result = await createInvoker().invoke(resource, "forecast", parameters);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(result.error).not.toBeNull();
+    });
+    test("gives up after the maximum number of retries", async () => {
+        fetchMock.mockResolvedValue(status(502));
+        const pending = createInvoker().invoke(resource, "forecast", parameters);
+        await vi.runAllTimersAsync();
+        const result = await pending;
+        expect(fetchMock).toHaveBeenCalledTimes(1 + EXTERNAL_INVOKE_MAX_RETRIES);
+        expect(result.value).toBeNull();
+        expect(result.error).not.toBeNull();
+    });
+    test("rethrows the last network error once retries are exhausted", async () => {
+        fetchMock.mockRejectedValue(new TypeError("fetch failed"));
+        const pending = createInvoker().invoke(resource, "forecast", parameters);
+        const assertion = expect(pending).rejects.toThrow("fetch failed");
+        await vi.runAllTimersAsync();
+        await assertion;
+        expect(fetchMock).toHaveBeenCalledTimes(1 + EXTERNAL_INVOKE_MAX_RETRIES);
+    });
+    test("reuses the same payment voucher on every attempt", async () => {
+        fetchMock.mockResolvedValueOnce(status(503)).mockResolvedValueOnce(status(503)).mockResolvedValueOnce(ok());
+        const invoker = createInvoker({ costLamports: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
+        const pending = invoker.invoke(resource, "forecast", parameters);
+        await vi.runAllTimersAsync();
+        await pending;
+        const bodies = fetchMock.mock.calls.map(([, init]) => init.body);
+        expect(bodies).toHaveLength(3);
+        expect(new Set(bodies).size).toBe(1);
+        expect(JSON.parse(bodies[0]).paymentVoucher.requestId).toBeDefined();
+        expect(JSON.parse(bodies[0]).paymentVoucher.invocationHash).toBe(invocationHash("com.example", "Weather", "forecast", parameters));
+    });
+});
+describe("restricted functions", () => {
+    const resource = { path: "com.example", name: "Weather", metadata: { baseUrl: "https://remote.example" }, functions: [] };
+    const parameters = [{ name: "city", value: "Oslo" }];
+    const chain = [{ id: "grant" }];
+    function createInvoker(grantService, paymentManifest) {
+        const { publicKey, privateKey } = generateBase64KeyPair();
+        const repository = { getResourceFunction: async () => ({ restricted: true, paymentManifest }) };
+        return new CombinationResourceInvoker(repository, 100_000, publicKey, privateKey, grantService);
+    }
+    let fetchMock;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        fetchMock = vi.fn();
+        vi.stubGlobal("fetch", fetchMock);
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.unstubAllGlobals();
+    });
+    test("fails without a network call when no held grant covers the call", async () => {
+        const chainFor = vi.fn(async () => undefined);
+        const result = await createInvoker({ chainFor }).invoke(resource, "forecast", parameters);
+        expect(chainFor).toHaveBeenCalledWith("https://remote.example", { resourcePath: "com.example", resourceName: "Weather", functionName: "forecast", parameters });
+        expect(result).toEqual({ value: null, error: { message: expect.stringContaining("requires a grant from https://remote.example") } });
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+    test("fails without a network call when the node has no grant service", async () => {
+        const result = await createInvoker(undefined).invoke(resource, "forecast", parameters);
+        expect(result.error).not.toBeNull();
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+    test("signs a new authorization per attempt and keeps the voucher", async () => {
+        fetchMock.mockResolvedValueOnce(new Response(null, { status: 503 })).mockResolvedValueOnce(new Response(JSON.stringify({ value: 42, error: null }), { status: 200 }));
+        let nonce = 0;
+        const authorize = vi.fn(() => ({ nonce: `nonce-${nonce++}` }));
+        const invoker = createInvoker({ chainFor: async () => chain, authorize }, { costLamports: 10000, recipientAddress: "4HkmXgXCJ8tw1ih5VFHetRt4kWdo1VLBVmV7B5p6ctK2" });
+        const pending = invoker.invoke(resource, "forecast", parameters);
+        await vi.runAllTimersAsync();
+        await expect(pending).resolves.toEqual({ value: 42, error: null });
+        const bodies = fetchMock.mock.calls.map(([, init]) => JSON.parse(init.body));
+        expect(bodies.map(body => body.authorization.nonce)).toEqual(["nonce-0", "nonce-1"]);
+        expect(bodies[0].paymentVoucher).toEqual(bodies[1].paymentVoucher);
+        expect(authorize).toHaveBeenCalledWith(chain, { resourcePath: "com.example", resourceName: "Weather", functionName: "forecast", parameters });
+    });
 });

package/dist/tests/resource/repository.test.d.ts

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

package/dist/tests/resource/repository.test.d.ts.map

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

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

@@ -0,0 +1,151 @@
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { signData } from "../../crypto/utils.js";
+import { openDatabase } from "../../db/db.js";
+import { PeerRepository } from "../../peer/repository.js";
+import { resourceAnnouncementPayload, ResourceRepository } from "../../resource/repository.js";
+import { generateBase64KeyPair, RECIPIENT, weatherResource } from "../helpers.js";
+const SELF = "http://self.example";
+const PROVIDER = "http://provider.example";
+function resource(name, functions, baseUrl = PROVIDER) {
+    return {
+        id: 0,
+        baseUrl,
+        metadata: {},
+        path: "com.provider",
+        name,
+        functions: functions.map(fn => ({ name: "fn", parameters: [], returnType: "string", exec: async () => undefined, ...fn })),
+    };
+}
+describe("ResourceRepository", () => {
+    let db;
+    let repository;
+    beforeEach(async () => {
+        db = await openDatabase(":memory:");
+        repository = new ResourceRepository(db, [weatherResource(SELF)], SELF);
+    });
+    afterEach(async () => {
+        await db.close();
+    });
+    describe("learn", () => {
+        test("keeps which functions are restricted", async () => {
+            await repository.learn(resource("Vault", [{ name: "open", restricted: true }, { name: "peek" }]));
+            const functions = (await repository.getResource("com.provider.Vault"))?.functions;
+            expect(functions.map(fn => [fn.name, fn.restricted])).toEqual([["open", true], ["peek", undefined]]);
+            expect((await repository.getResourceFunction("com.provider", "Vault", "open"))?.restricted).toBe(true);
+        });
+        test("is idempotent, so startup can run on every boot", async () => {
+            const learned = resource("Forecast", [{ name: "tomorrow" }]);
+            await repository.learn(learned);
+            await repository.learn(learned);
+            expect(await repository.getExternalResources()).toHaveLength(1);
+        });
+        test("stores several resources served from the same base URL", async () => {
+            await repository.learn(resource("Forecast", [{ name: "tomorrow" }]));
+            await repository.learn(resource("Radar", [{ name: "image" }]));
+            expect((await repository.getExternalResources()).map(r => r.name)).toEqual(["Forecast", "Radar"]);
+        });
+        test("skips resources hosted by this node", async () => {
+            await repository.learn(weatherResource(PROVIDER));
+            await repository.learn(resource("Echo", [{ name: "fn" }], SELF));
+            expect(await repository.getExternalResources()).toEqual([]);
+        });
+    });
+    describe("getResources", () => {
+        beforeEach(async () => {
+            for (const name of ["A", "B", "C"]) {
+                await repository.learn(resource(name, []));
+            }
+        });
+        const names = async (offset, limit) => (await repository.getResources(offset, limit)).map(r => r.name);
+        test("pages across hosted and learned resources", async () => {
+            expect(await names(0, 2)).toEqual(["Weather", "A"]);
+            expect(await names(2, 2)).toEqual(["B", "C"]);
+            expect(await names(4, 2)).toEqual([]);
+        });
+        test("pages within the hosted resources alone", async () => {
+            expect(await names(0, 1)).toEqual(["Weather"]);
+        });
+    });
+    describe("getResource", () => {
+        test("returns each function's own payment manifest", async () => {
+            await repository.learn(resource("Forecast", [
+                { name: "free" },
+                { name: "paid", paymentManifest: { costLamports: 250, recipientAddress: RECIPIENT } },
+            ]));
+            const found = await repository.getResource("com.provider.Forecast");
+            expect(found.metadata).toEqual({ baseUrl: PROVIDER });
+            expect(found.functions.find(f => f.name === "free")?.paymentManifest).toBeUndefined();
+            expect(found.functions.find(f => f.name === "paid")?.paymentManifest).toMatchObject({ costLamports: 250, recipientAddress: RECIPIENT });
+        });
+        test("prefers the internal resource", async () => {
+            const found = await repository.getResource("com.example.Weather");
+            expect(found?.metadata).toEqual({});
+        });
+        test("returns undefined for an unknown key", async () => {
+            expect(await repository.getResource("com.provider.Missing")).toBeUndefined();
+        });
+    });
+    describe("saveAll", () => {
+        const keys = generateBase64KeyPair();
+        let peer;
+        beforeEach(async () => {
+            const peers = new PeerRepository(db);
+            await peers.create({ baseUrl: PROVIDER, name: PROVIDER, publicKey: keys.publicKey });
+            peer = (await peers.getPeerByPublicKey(keys.publicKey));
+        });
+        function save(resources, as = peer, privateKey = keys.privateKey) {
+            const expiry = new Date(Date.now() + 60_000).toISOString();
+            const sent = JSON.parse(JSON.stringify(resources));
+            return repository.saveAll(sent, as, signData(resourceAnnouncementPayload(sent, expiry), privateKey), expiry);
+        }
+        test("adds new functions, parameters and payment manifests to a known resource", async () => {
+            await save([resource("Forecast", [{ name: "today" }])]);
+            const result = await save([resource("Forecast", [
+                    { name: "today", parameters: [{ name: "city", type: "string" }], paymentManifest: { costLamports: 100, recipientAddress: RECIPIENT } },
+                    { name: "tomorrow" },
+                ])]);
+            expect(result).toEqual({ ok: true, rejected: [] });
+            const today = await repository.getResourceFunction("com.provider", "Forecast", "today");
+            expect(today?.parameters).toEqual([{ name: "city", type: "string" }]);
+            expect(today?.paymentManifest).toMatchObject({ costLamports: 100 });
+            expect(await repository.getResourceFunction("com.provider", "Forecast", "tomorrow")).toBeDefined();
+        });
+        test("removes functions and payment manifests the peer no longer advertises", async () => {
+            await save([resource("Forecast", [{ name: "today", paymentManifest: { costLamports: 100, recipientAddress: RECIPIENT } }, { name: "old" }])]);
+            await save([resource("Forecast", [{ name: "today" }])]);
+            expect((await repository.getResourceFunction("com.provider", "Forecast", "today"))?.paymentManifest).toBeUndefined();
+            expect(await repository.getResourceFunction("com.provider", "Forecast", "old")).toBeUndefined();
+        });
+        test("claims a resource learned at startup that points at the peer", async () => {
+            await repository.learn(resource("Forecast", [{ name: "today" }]));
+            expect(await save([resource("Forecast", [{ name: "tomorrow" }])])).toEqual({ ok: true, rejected: [] });
+            expect(await repository.getResourceFunction("com.provider", "Forecast", "tomorrow")).toBeDefined();
+        });
+        test("will not let one peer take over another peer's resource", async () => {
+            await save([resource("Forecast", [{ name: "today" }])]);
+            const other = generateBase64KeyPair();
+            const peers = new PeerRepository(db);
+            await peers.create({ baseUrl: "http://other.example", name: "other", publicKey: other.publicKey });
+            const otherPeer = (await peers.getPeerByPublicKey(other.publicKey));
+            const result = await save([resource("Forecast", [{ name: "hijacked" }], "http://other.example")], otherPeer, other.privateKey);
+            expect(result).toEqual({ ok: true, rejected: ["com.provider.Forecast"] });
+            expect((await repository.getResource("com.provider.Forecast"))?.metadata).toEqual({ baseUrl: PROVIDER });
+        });
+        test("rejects a bad signature, an expired broadcast and a malformed key without throwing", async () => {
+            const sent = [resource("Forecast", [])];
+            const past = new Date(Date.now() - 1000).toISOString();
+            expect(await save(sent, peer, generateBase64KeyPair().privateKey)).toEqual({ ok: false });
+            expect(await repository.saveAll(sent, peer, signData(resourceAnnouncementPayload(sent, past), keys.privateKey), past)).toEqual({ ok: false });
+            expect(await save(sent, { ...peer, publicKey: "not-a-key" })).toEqual({ ok: false });
+        });
+        test("rolls back the whole broadcast when a write fails", async () => {
+            const result = save([
+                resource("Forecast", [{ name: "today" }]),
+                // Duplicate function names violate UNIQUE (resource_id, name).
+                resource("Radar", [{ name: "image" }, { name: "image" }]),
+            ]);
+            await expect(result).rejects.toThrow();
+            expect(await repository.getExternalResources()).toEqual([]);
+        });
+    });
+});

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

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

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

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