@orangecheck/chat-core 0.2.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangecheck/chat-core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Verify OC Chat's public artifacts: channel descriptors and posts, directory listings and did:oc session devices. See https://github.com/orangecheck/oc-chat-protocol.",
   "keywords": [
     "bitcoin",

package/src/directory.test.ts

@@ -283,6 +283,65 @@ describe('resolveDirectoryHandle', () => {
         });
     });
 
+    it('a full page of junk the reader drops is still a full page: the read goes on past it', async () => {
+        const { w, deps, anchorAt } = world();
+        const a = claim('alice', ALICE, TIP - 100);
+        anchorAt(a, ALICE);
+        w.bound.set(ALICE, [pk(1)]);
+        const newer = listing(2, 'alice', BOB, claim('alice', BOB, TIP - 50, 'bob'), {}, 1_790_000_900);
+        w.relays.set('wss://relay.ochk.io', [newer, listing(1, 'alice', ALICE, a, {}, 1_790_000_000)]);
+        const real = deps.page;
+        // The relay sends a full page: one listing that verifies, and 199 the reader
+        // drops for their signatures. Only the next page reaches alice's claim.
+        deps.page = async (relay, filter) => {
+            const got = await real(relay, filter);
+            if (relay !== 'wss://relay.ochk.io' || filter.until !== undefined) return got;
+            return { events: got.events.slice(0, 1), complete: true, sent: filter.limit };
+        };
+        expect(await resolveDirectoryHandle('alice', 'people', deps)).toMatchObject({
+            result: 'holds',
+            holder: ALICE,
+        });
+    });
+
+    it('a full page that is all junk has not been read completely, never "not listed"', async () => {
+        const { w, deps } = world();
+        w.relays.set('wss://relay.ochk.io', []);
+        const real = deps.page;
+        deps.page = async (relay, filter) =>
+            relay === 'wss://relay.ochk.io'
+                ? { events: [], complete: true, sent: filter.limit }
+                : real(relay, filter);
+        expect(await resolveDirectoryHandle('alice', 'people', deps)).toEqual({
+            result: 'E_DIR_UNRESOLVED',
+        });
+    });
+
+    it('an audit relay that pads a page with junk is read past it, so the earlier claim it holds counts', async () => {
+        const { w, deps, anchorAt, publish } = world();
+        const a = claim('alice', ALICE, TIP - 100);
+        const b = claim('alice', BOB, TIP - 50, 'bob');
+        anchorAt(a, ALICE);
+        anchorAt(b, BOB);
+        w.bound.set(ALICE, [pk(1)]);
+        w.bound.set(BOB, [pk(2)]);
+        publish(listing(2, 'alice', BOB, b));
+        w.relays.set('wss://nos.lol', [
+            listing(2, 'alice', BOB, b, {}, 1_790_000_900),
+            listing(1, 'alice', ALICE, a, {}, 1_790_000_000),
+        ]);
+        const real = deps.page;
+        deps.page = async (relay, filter) => {
+            const got = await real(relay, filter);
+            if (relay !== 'wss://nos.lol' || filter.until !== undefined) return got;
+            return { events: got.events.slice(0, 1), complete: true, sent: filter.limit };
+        };
+        expect(await resolveDirectoryHandle('alice', 'people', deps)).toMatchObject({
+            result: 'holds',
+            holder: ALICE,
+        });
+    });
+
     it('a directory relay that stalls on a full page has not been read completely', async () => {
         const { w, deps } = world();
         const same = Array.from({ length: 200 }, (_, i) =>

package/src/directory.ts

@@ -49,11 +49,21 @@ const AUDIT_PAGES = 2;
 /** Distinct header reads one resolution may make; past this a header is unread. */
 const HEADER_BUDGET = 128;
 
-/** One page from one relay: its events, and whether the relay finished answering (EOSE). */
+/**
+ * One page from one relay: its events, whether the relay finished answering
+ * (EOSE), and `sent`, how many events the relay sent, the ones the reader dropped
+ * (a bad signature) included. A page is full by what the relay sent, not by what
+ * was kept: a relay that pads a page with junk has more behind it. Without
+ * `sent`, the events kept are the count.
+ */
 export type PageRead = (
     relay: string,
     filter: { kinds: number[]; '#d': string[]; limit: number; until?: number }
-) => Promise<{ events: NostrEvent[]; complete: boolean }>;
+) => Promise<{ events: NostrEvent[]; complete: boolean; sent?: number }>;
+
+/** How many events a page's relay sent: `sent`, or the events kept when it is not given. */
+const sentOn = (got: { events: NostrEvent[]; sent?: number }) =>
+    Math.max(got.sent ?? 0, got.events.length);
 
 export interface WalkDeps {
     page: PageRead;
@@ -148,7 +158,7 @@ async function readAll(
             until = until === undefined ? ev.created_at : Math.min(until, ev.created_at);
         }
         // A short page is the end; a full page that adds nothing is a stalled read.
-        if (got.events.length < PAGE) return [...seen.values()];
+        if (sentOn(got) < PAGE) return [...seen.values()];
         if (added === 0) return null;
     }
     return null;
@@ -164,7 +174,7 @@ async function readSome(
     const seen = new Map<string, NostrEvent>();
     let until: number | undefined;
     for (let i = 0; i < pages; i++) {
-        let got: { events: NostrEvent[]; complete: boolean };
+        let got: Awaited<ReturnType<PageRead>>;
         try {
             got = await page(relay, {
                 kinds: [30114],
@@ -179,7 +189,7 @@ async function readSome(
             seen.set(ev.id, ev);
             until = until === undefined ? ev.created_at : Math.min(until, ev.created_at);
         }
-        if (!got.complete || got.events.length < PAGE) break;
+        if (!got.complete || sentOn(got) < PAGE) break;
     }
     return [...seen.values()];
 }