app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

inbox-routing.test.ts (11567B)


      1 import { describe, it, expect } from 'vitest';
      2 import { finalizeEvent } from 'applesauce-core/helpers';
      3 import {
      4   validateRelayPolicy,
      5   type RelayPolicy
      6 } from '../../src/lib/config/relays.ts';
      7 import {
      8   createPublicScheduler,
      9   createPublicRun,
     10   openInboxRequest,
     11   closePublicScheduler
     12 } from '../../src/lib/nostr/request-scope.ts';
     13 import {
     14   createInboxResolver,
     15   type InboxResolver
     16 } from '../../src/lib/messaging/resolve-inbox.ts';
     17 import { inboxPreferenceSnapshot } from '../../src/lib/nostr/inbox-preferences.ts';
     18 import { inboxResolutionSnapshot } from '../../src/lib/messaging/resolve-inbox.ts';
     19 import {
     20   createInboxRoutePlan,
     21   inboxRoutePlanSnapshot,
     22   recheckInboxRoutePlan
     23 } from '../../src/lib/messaging/inbox-routing.ts';
     24 const discovery = 'wss://discovery.example.org',
     25   peerOrigin = 'wss://peer.example.org',
     26   archiveOrigin = 'wss://archive.example.org',
     27   common = 'wss://common.example.org',
     28   unapproved = 'wss://hint.example.org';
     29 function policy(targets = [peerOrigin, archiveOrigin, common]): RelayPolicy {
     30   return validateRelayPolicy(
     31     JSON.stringify({
     32       schemaVersion: 1,
     33       public: [{ origin: discovery, read: true, write: false, nip50: false }],
     34       inbox: targets.map((origin) => ({ origin, read: true, write: true })),
     35       postingEnabled: false,
     36       messagingEnabled: false,
     37       operatorDenylist: []
     38     })
     39   )!;
     40 }
     41 function author(relays: string[]) {
     42   const key = crypto.getRandomValues(new Uint8Array(32));
     43   try {
     44     const tags = relays.map((origin) => ['relay', origin]);
     45     const original = finalizeEvent(
     46       {
     47         kind: 10050,
     48         created_at: 100,
     49         tags: [...tags, ['unknown', 'preserve']],
     50         content: ''
     51       },
     52       key
     53     );
     54     const removed = finalizeEvent(
     55       { kind: 10050, created_at: 200, tags: tags.slice(1), content: '' },
     56       key
     57     );
     58     const changed = finalizeEvent(
     59       {
     60         kind: 10050,
     61         created_at: 201,
     62         tags: [...tags, ['unknown', 'changed']],
     63         content: ''
     64       },
     65       key
     66     );
     67     return { original, removed, changed };
     68   } finally {
     69     key.fill(0);
     70   }
     71 }
     72 function resolved(
     73   event: ReturnType<typeof author>['original'],
     74   complete = true,
     75   now: () => number = () => 0
     76 ) {
     77   const scheduler = createPublicScheduler({
     78       now,
     79       schedule: () => () => {}
     80     }),
     81     run = createPublicRun(scheduler, policy());
     82   let current = true;
     83   const resolver = createInboxResolver(
     84     run,
     85     event.pubkey,
     86     (next) =>
     87       openInboxRequest(
     88         run,
     89         event.pubkey,
     90         (sink) => {
     91           sink({ type: 'EVENT', from: discovery, id: 'fixture', event });
     92           if (complete) sink({ type: 'EOSE', from: discovery, id: 'fixture' });
     93           return () => {};
     94         },
     95         next
     96       ),
     97     () => current
     98   );
     99   return {
    100     resolver,
    101     close: () => closePublicScheduler(scheduler),
    102     stale() {
    103       current = false;
    104     }
    105   };
    106 }
    107 function fixture(
    108   peerRelays = [peerOrigin, common],
    109   selfRelays = [archiveOrigin]
    110 ) {
    111   const self = author(selfRelays),
    112     peer = author(peerRelays),
    113     own = resolved(self.original),
    114     other = resolved(peer.original);
    115   return {
    116     self,
    117     peer,
    118     own,
    119     other,
    120     close() {
    121       own.close();
    122       other.close();
    123     }
    124   };
    125 }
    126 describe('recipient and sender archive routing', () => {
    127   it('selects recipient advertised allowed writes and computes sender archive independently', () => {
    128     const f = fixture();
    129     try {
    130       const plan = createInboxRoutePlan(
    131         policy(),
    132         f.self.original.pubkey,
    133         f.peer.original.pubkey,
    134         f.own.resolver,
    135         f.other.resolver
    136       )!;
    137       const r = inboxRoutePlanSnapshot(plan)!;
    138       expect(r.peer).toMatchObject({
    139         role: 'peer',
    140         author: f.peer.original.pubkey,
    141         targets: [peerOrigin, common],
    142         knownBase: { id: f.peer.original.id }
    143       });
    144       expect(r.archive).toMatchObject({
    145         role: 'self_archive',
    146         author: f.self.original.pubkey,
    147         targets: [archiveOrigin],
    148         knownBase: { id: f.self.original.id }
    149       });
    150       expect(Object.keys(plan)).toEqual([]);
    151       expect(Object.isFrozen(plan)).toBe(true);
    152     } finally {
    153       f.close();
    154     }
    155   });
    156   it('empty peer intersection never falls back to sender archive or public discovery', () => {
    157     const f = fixture([unapproved]);
    158     try {
    159       expect(
    160         createInboxRoutePlan(
    161           policy(),
    162           f.self.original.pubkey,
    163           f.peer.original.pubkey,
    164           f.own.resolver,
    165           f.other.resolver
    166         )
    167       ).toBeUndefined();
    168     } finally {
    169       f.close();
    170     }
    171   });
    172   it('empty sender archive never falls back to peer destinations', () => {
    173     const f = fixture([peerOrigin], [unapproved]);
    174     try {
    175       expect(
    176         createInboxRoutePlan(
    177           policy(),
    178           f.self.original.pubkey,
    179           f.peer.original.pubkey,
    180           f.own.resolver,
    181           f.other.resolver
    182         )
    183       ).toBeUndefined();
    184     } finally {
    185       f.close();
    186     }
    187   });
    188   it('keeps all advertised preference data while limiting selected routes to the fixed allowlist', () => {
    189     const f = fixture([
    190       unapproved,
    191       peerOrigin,
    192       common,
    193       archiveOrigin,
    194       'wss://fifth.example.org'
    195     ]);
    196     try {
    197       const before = inboxPreferenceSnapshot(
    198         inboxResolutionSnapshot(f.other.resolver).head!
    199       )!;
    200       expect(before.relays).toHaveLength(5);
    201       const plan = createInboxRoutePlan(
    202         policy(),
    203         f.self.original.pubkey,
    204         f.peer.original.pubkey,
    205         f.own.resolver,
    206         f.other.resolver
    207       )!;
    208       expect(inboxRoutePlanSnapshot(plan)?.peer.targets).toEqual([
    209         peerOrigin,
    210         archiveOrigin,
    211         common
    212       ]);
    213       expect(
    214         inboxPreferenceSnapshot(inboxResolutionSnapshot(f.other.resolver).head!)
    215       ).toEqual(before);
    216     } finally {
    217       f.close();
    218     }
    219   });
    220   it('rejects forged resolution/policy, invalid identities, swapped authors and self messaging', () => {
    221     const f = fixture();
    222     try {
    223       expect(
    224         createInboxRoutePlan(
    225           policy(),
    226           f.self.original.pubkey,
    227           f.peer.original.pubkey,
    228           {} as InboxResolver,
    229           f.other.resolver
    230         )
    231       ).toBeUndefined();
    232       expect(
    233         createInboxRoutePlan(
    234           {} as RelayPolicy,
    235           f.self.original.pubkey,
    236           f.peer.original.pubkey,
    237           f.own.resolver,
    238           f.other.resolver
    239         )
    240       ).toBeUndefined();
    241       expect(
    242         createInboxRoutePlan(
    243           policy(),
    244           'f'.repeat(64),
    245           f.peer.original.pubkey,
    246           f.own.resolver,
    247           f.other.resolver
    248         )
    249       ).toBeUndefined();
    250       expect(
    251         createInboxRoutePlan(
    252           policy(),
    253           f.peer.original.pubkey,
    254           f.self.original.pubkey,
    255           f.own.resolver,
    256           f.other.resolver
    257         )
    258       ).toBeUndefined();
    259       expect(
    260         createInboxRoutePlan(
    261           policy(),
    262           f.self.original.pubkey,
    263           f.self.original.pubkey,
    264           f.own.resolver,
    265           f.own.resolver
    266         )
    267       ).toBeUndefined();
    268       expect(
    269         inboxRoutePlanSnapshot(
    270           {} as NonNullable<ReturnType<typeof createInboxRoutePlan>>
    271         )
    272       ).toBeUndefined();
    273     } finally {
    274       f.close();
    275     }
    276   });
    277   it('partial, unsupported or stale preference evidence cannot produce routes', () => {
    278     const f = fixture(),
    279       partial = resolved(f.peer.original, false);
    280     try {
    281       expect(
    282         createInboxRoutePlan(
    283           policy(),
    284           f.self.original.pubkey,
    285           f.peer.original.pubkey,
    286           f.own.resolver,
    287           partial.resolver
    288         )
    289       ).toBeUndefined();
    290       f.other.stale();
    291       expect(
    292         createInboxRoutePlan(
    293           policy(),
    294           f.self.original.pubkey,
    295           f.peer.original.pubkey,
    296           f.own.resolver,
    297           f.other.resolver
    298         )
    299       ).toBeUndefined();
    300     } finally {
    301       f.close();
    302       partial.close();
    303     }
    304     const g = fixture([peerOrigin]),
    305       bad = resolved(g.peer.removed);
    306     try {
    307       expect(
    308         createInboxRoutePlan(
    309           policy(),
    310           g.self.original.pubkey,
    311           g.peer.original.pubkey,
    312           g.own.resolver,
    313           bad.resolver
    314         )
    315       ).toBeUndefined();
    316     } finally {
    317       g.close();
    318       bad.close();
    319     }
    320   });
    321   it('detached snapshots cannot retarget the opaque plan', () => {
    322     const f = fixture();
    323     try {
    324       const p = createInboxRoutePlan(
    325         policy(),
    326         f.self.original.pubkey,
    327         f.peer.original.pubkey,
    328         f.own.resolver,
    329         f.other.resolver
    330       )!;
    331       const r = inboxRoutePlanSnapshot(p)!;
    332       r.peer.targets.push(unapproved);
    333       r.peer.sources.pop();
    334       expect(inboxRoutePlanSnapshot(p)?.peer.targets).toEqual([
    335         peerOrigin,
    336         common
    337       ]);
    338       expect(inboxRoutePlanSnapshot(p)?.peer.sources).toHaveLength(1);
    339       expect(
    340         recheckInboxRoutePlan(p, policy(), f.own.resolver, f.other.resolver)
    341       ).toBe('unchanged');
    342     } finally {
    343       f.close();
    344     }
    345   });
    346   it('removed approved destinations and changed known preference versions require explicit review', () => {
    347     const f = fixture(),
    348       removed = resolved(f.peer.removed),
    349       version = resolved(f.peer.changed);
    350     try {
    351       const p = createInboxRoutePlan(
    352         policy(),
    353         f.self.original.pubkey,
    354         f.peer.original.pubkey,
    355         f.own.resolver,
    356         f.other.resolver
    357       )!;
    358       expect(
    359         recheckInboxRoutePlan(
    360           p,
    361           policy([archiveOrigin, common]),
    362           f.own.resolver,
    363           f.other.resolver
    364         )
    365       ).toBe('review_required');
    366       expect(
    367         recheckInboxRoutePlan(p, policy(), f.own.resolver, removed.resolver)
    368       ).toBe('review_required');
    369       expect(
    370         recheckInboxRoutePlan(p, policy(), f.own.resolver, version.resolver)
    371       ).toBe('review_required');
    372       expect(inboxRoutePlanSnapshot(p)?.peer.targets).toEqual([
    373         peerOrigin,
    374         common
    375       ]);
    376       f.other.stale();
    377       expect(
    378         recheckInboxRoutePlan(p, policy(), f.own.resolver, f.other.resolver)
    379       ).toBe('unavailable');
    380     } finally {
    381       f.close();
    382       removed.close();
    383       version.close();
    384     }
    385   });
    386 });
    387 
    388 it('peer clock reentry cannot admit a stale sender archive captured first', () => {
    389   const f = fixture();
    390   let armed = false;
    391   const peer = resolved(f.peer.original, true, () => {
    392     if (armed) f.own.stale();
    393     return 0;
    394   });
    395   try {
    396     armed = true;
    397     expect(
    398       createInboxRoutePlan(
    399         policy(),
    400         f.self.original.pubkey,
    401         f.peer.original.pubkey,
    402         f.own.resolver,
    403         peer.resolver
    404       )
    405     ).toBeUndefined();
    406   } finally {
    407     f.close();
    408     peer.close();
    409   }
    410 });
    411 
    412 it('peer clock reentry cannot report unchanged after sender scheduler closes', () => {
    413   const f = fixture();
    414   let armed = false;
    415   const peer = resolved(f.peer.original, true, () => {
    416     if (armed) f.own.close();
    417     return 0;
    418   });
    419   try {
    420     const p = createInboxRoutePlan(
    421       policy(),
    422       f.self.original.pubkey,
    423       f.peer.original.pubkey,
    424       f.own.resolver,
    425       peer.resolver
    426     )!;
    427     expect(p).toBeDefined();
    428     armed = true;
    429     expect(
    430       recheckInboxRoutePlan(p, policy(), f.own.resolver, peer.resolver)
    431     ).toBe('unavailable');
    432     expect(inboxRoutePlanSnapshot(p)?.archive.targets).toEqual([archiveOrigin]);
    433   } finally {
    434     f.close();
    435     peer.close();
    436   }
    437 });