app

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

inbox-probe-recovery.test.ts (5328B)


      1 import { afterEach, expect, it, vi } from 'vitest';
      2 import { getEventHash, type UnsignedEvent } from 'applesauce-core/helpers';
      3 import type { IdentitySession } from '../../src/lib/runtime/identity-session.ts';
      4 import type { PrivateSession } from '../../src/lib/runtime/private-session.ts';
      5 import type { PrivateStorageRepository } from '../../src/lib/persistence/private-storage.ts';
      6 import type { RelayPolicy } from '../../src/lib/config/relays.ts';
      7 import type { InboxOperatorQualification } from '../../src/lib/config/inbox-operators.ts';
      8 import type { InboxAccessController } from '../../src/lib/messaging/inbox-access-controller.ts';
      9 import type {
     10   InboxProbeRecoveryReader,
     11   RecoveredInboxProbe,
     12   InboxProbeNonceProof
     13 } from '../../src/lib/nostr/self-recovery-reader.ts';
     14 import { inboxProbeRumorMatches } from '../../src/lib/nostr/inbox-access.ts';
     15 
     16 afterEach(() => vi.unstubAllGlobals());
     17 const owner =
     18     '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
     19   time = 1700000000;
     20 const event: UnsignedEvent = {
     21   pubkey: owner,
     22   created_at: time,
     23   kind: 14,
     24   tags: [['p', owner]],
     25   content: 'Harvestcircle private inbox access check v1: ' + 'b'.repeat(64)
     26 };
     27 const hash = getEventHash(event),
     28   raw = JSON.stringify({ id: hash, ...event });
     29 it('the canonical pure diagnostic validator admits only exact original own hash/time/nonce', () => {
     30   expect(inboxProbeRumorMatches(raw, owner, hash, time)).toBe(true);
     31   expect(inboxProbeRumorMatches(raw, owner.toUpperCase(), hash, time)).toBe(
     32     false
     33   );
     34   for (const malformed of [
     35     undefined,
     36     null,
     37     false,
     38     {},
     39     raw + ' ',
     40     '{',
     41     raw.replace('"kind":14', '"kind":1.4e1'),
     42     raw.replace('"kind":14', '"kind":14,"kind":14'),
     43     raw.replace('"id":', '"extra":0,"id":'),
     44     raw.replace('"content":', '"\\u0063ontent":')
     45   ])
     46     expect(inboxProbeRumorMatches(malformed, owner, hash, time)).toBe(false);
     47   for (const change of [
     48     { kind: 1 },
     49     { pubkey: 'c'.repeat(64) },
     50     { created_at: time + 1 },
     51     { tags: [] },
     52     { tags: [['p', 'c'.repeat(64)]] },
     53     {
     54       tags: [
     55         ['p', owner],
     56         ['p', owner]
     57       ]
     58     },
     59     { content: 'ordinary message' },
     60     { content: event.content + 'b' },
     61     { content: event.content.slice(0, -1) + 'B' },
     62     { content: 'x'.repeat(8193) }
     63   ]) {
     64     const altered = { ...event, ...change };
     65     const id = getEventHash(altered);
     66     expect(
     67       inboxProbeRumorMatches(
     68         JSON.stringify({ id, ...altered }),
     69         owner,
     70         id,
     71         time
     72       )
     73     ).toBe(false);
     74   }
     75   for (const bad of [
     76     -1,
     77     1.5,
     78     Number.MAX_SAFE_INTEGER + 1,
     79     NaN,
     80     Infinity,
     81     String(time),
     82     null
     83   ])
     84     expect(inboxProbeRumorMatches(raw, owner, hash, bad)).toBe(false);
     85   for (const bad of ['A'.repeat(64), 'c'.repeat(64), 'a'.repeat(63), null])
     86     expect(inboxProbeRumorMatches(raw, owner, bad, time)).toBe(false);
     87 });
     88 for (const browser of [false, true])
     89   it(`cold ${browser ? 'browser-shaped' : 'SSR'} recovery rejects fabricated families before effects`, async () => {
     90     vi.resetModules();
     91     let effects = 0;
     92     const trap = () => {
     93       effects++;
     94       throw Error('unadmitted effect');
     95     };
     96     if (browser) {
     97       vi.stubGlobal('window', {
     98         get nostr() {
     99           return trap();
    100         }
    101       });
    102       vi.stubGlobal('navigator', {
    103         get locks() {
    104           return trap();
    105         }
    106       });
    107       vi.stubGlobal('WebSocket', trap);
    108       vi.stubGlobal('indexedDB', { open: trap });
    109     }
    110     const m = await import('../../src/lib/nostr/self-recovery-reader.ts');
    111     const repository = {} as PrivateStorageRepository,
    112       identity = {} as IdentitySession,
    113       session = {} as PrivateSession,
    114       policy = {} as RelayPolicy,
    115       operator = {} as InboxOperatorQualification;
    116     for (const fake of [
    117       undefined,
    118       null,
    119       0,
    120       false,
    121       '',
    122       Symbol(),
    123       {},
    124       { current: () => true, nonce_verified: true },
    125       { status: 'recovered', proof: {} }
    126     ]) {
    127       expect(
    128         m.captureInboxProbeRecoveryReader(
    129           repository,
    130           identity,
    131           session,
    132           policy,
    133           fake as InboxAccessController,
    134           operator,
    135           '11111111-1111-4111-8111-111111111111',
    136           'reviewed_inbox_probe_recovery'
    137         )
    138       ).toBeUndefined();
    139       expect(
    140         await m.recoverInboxProbe(fake as InboxProbeRecoveryReader)
    141       ).toEqual({ status: 'invalid' });
    142       expect(
    143         m.recoveredInboxProbeBinding(
    144           fake as RecoveredInboxProbe,
    145           repository,
    146           session,
    147           fake as InboxAccessController,
    148           policy,
    149           operator
    150         )
    151       ).toBeUndefined();
    152       expect(
    153         m.recoveredInboxProbeRumorWire(
    154           fake as RecoveredInboxProbe,
    155           repository,
    156           session,
    157           fake as InboxAccessController,
    158           policy,
    159           operator
    160         )
    161       ).toBeUndefined();
    162       expect(
    163         m.inboxProbeNonceProofBinding(
    164           fake as InboxProbeNonceProof,
    165           repository,
    166           session,
    167           policy
    168         )
    169       ).toBeUndefined();
    170       m.stopInboxProbeRecoveryReader(fake as InboxProbeRecoveryReader);
    171       m.expireInboxProbeRecoveryReaderWait(fake as InboxProbeRecoveryReader);
    172     }
    173     expect(effects).toBe(0);
    174   });