app

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

private-pool.test.ts (32030B)


      1 import { test } from 'node:test';
      2 import assert from 'node:assert/strict';
      3 import { once } from 'node:events';
      4 import WebSocket, { WebSocketServer } from 'ws';
      5 import { RelayPool } from 'applesauce-relay/pool';
      6 import { createRequire } from 'node:module';
      7 import { validateRelayPolicy } from '../../src/lib/config/relays.ts';
      8 import {
      9   createIdentitySession,
     10   connectIdentity,
     11   probeIdentityMessaging,
     12   disconnectIdentity,
     13   recheckIdentityOwner
     14 } from '../../src/lib/runtime/identity-session.ts';
     15 import {
     16   createPrivateSession,
     17   privateSessionSnapshot,
     18   closePrivateSession
     19 } from '../../src/lib/runtime/private-session.ts';
     20 import {
     21   getPrivatePool,
     22   privatePoolOrigins,
     23   subscribePrivatePage,
     24   closePrivatePool,
     25   privatePoolCleanupRequired,
     26   type PrivatePageMessage
     27 } from '../../src/lib/nostr/private-pool.ts';
     28 import {
     29   getPublicPool,
     30   subscribePublicPool,
     31   closePublicPool
     32 } from '../../src/lib/nostr/public-pool.ts';
     33 
     34 // HC_TEST_ONLY_RELAY/provider: genuine pinned SDK, fixed logical origins mapped
     35 // solely here to loopback. Echo cipher and AUTH-state instrumentation qualify
     36 // transport/lifecycle isolation, never encryption, signatures or relay access.
     37 await test('private page transport keeps actual SDK scopes and ownership separate', async (t) => {
     38   // Resolve the SDK's actual pinned transitive RxJS for teardown fault injection;
     39   // it is not a new application dependency or replacement Observable.
     40   const sdkRxjs: unknown = createRequire(
     41     import.meta.resolve('applesauce-relay/pool')
     42   )('rxjs');
     43   const Subscription = (
     44     sdkRxjs as {
     45       Subscription: {
     46         prototype: ReturnType<ReturnType<RelayPool['req']>['subscribe']>;
     47       };
     48     }
     49   ).Subscription;
     50   const owner =
     51     '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
     52   const other =
     53     'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
     54   const origins = [
     55     'wss://relay.example.org',
     56     'wss://relay-two.example.org',
     57     'wss://relay-three.example.org'
     58   ];
     59   const policy = validateRelayPolicy(
     60     JSON.stringify({
     61       schemaVersion: 1,
     62       public: origins.map((origin) => ({
     63         origin,
     64         read: true,
     65         write: false,
     66         nip50: false
     67       })),
     68       inbox: origins.map((origin) => ({ origin, read: true, write: true })),
     69       postingEnabled: false,
     70       messagingEnabled: true,
     71       operatorDenylist: []
     72     })
     73   );
     74   assert.ok(policy);
     75   assert.equal(
     76     await createPrivateSession(
     77       createIdentitySession(),
     78       'reviewed_private_session'
     79     ),
     80     undefined
     81   );
     82   assert.equal(getPrivatePool({} as never, policy, origins), undefined);
     83   const originalSocket = globalThis.WebSocket,
     84     originalFetch = globalThis.fetch,
     85     originalReq = Reflect.get(RelayPool.prototype, 'req'),
     86     originalClose = Reflect.get(RelayPool.prototype, 'close');
     87   assert.equal(
     88     Object.getOwnPropertyDescriptor(globalThis, 'window'),
     89     undefined
     90   );
     91   const server = new WebSocketServer({
     92     host: '127.0.0.1',
     93     port: 0,
     94     maxPayload: 65536
     95   });
     96   const sockets: WebSocket[] = [];
     97   const frames: unknown[][] = [];
     98   let delivery:
     99     | 'normal'
    100     | 'flood'
    101     | 'oversize'
    102     | 'hold'
    103     | 'byte-flood'
    104     | 'rejected-byte-flood'
    105     | 'single' = 'normal';
    106   let eventWritten = false;
    107   let heldReady = () => {};
    108   let heldRequests = 0;
    109   const raw = {
    110     id: '1'.repeat(64),
    111     pubkey: other,
    112     kind: 1059,
    113     created_at: 1,
    114     tags: [['p', owner]],
    115     content: 'untrusted ciphertext',
    116     sig: '0'.repeat(128)
    117   };
    118   server.on('connection', (socket) => {
    119     sockets.push(socket);
    120     socket.send(JSON.stringify(['AUTH', 'unsolicited-challenge']));
    121     socket.on('message', (bytes) => {
    122       const buffer = Array.isArray(bytes)
    123         ? Buffer.concat(bytes)
    124         : Buffer.isBuffer(bytes)
    125           ? bytes
    126           : Buffer.from(bytes);
    127       const frame: unknown = JSON.parse(buffer.toString('utf8'));
    128       assert.ok(Array.isArray(frame));
    129       frames.push(frame);
    130       if (frame[0] !== 'REQ') return;
    131       const filter = frame[2] as { kinds: number[] };
    132       if (filter.kinds[0] === 1059 && delivery === 'hold') {
    133         heldRequests++;
    134         if (heldRequests === 3) heldReady();
    135       } else if (
    136         filter.kinds[0] === 1059 &&
    137         (delivery === 'flood' ||
    138           delivery === 'byte-flood' ||
    139           delivery === 'rejected-byte-flood')
    140       ) {
    141         const candidate =
    142           delivery === 'flood'
    143             ? raw
    144             : {
    145                 ...raw,
    146                 content: 'x'.repeat(delivery === 'byte-flood' ? 20000 : 40000)
    147               };
    148         for (let i = 0; i < 501; i++)
    149           socket.send(JSON.stringify(['EVENT', frame[1], candidate]));
    150       } else if (filter.kinds[0] === 1059 && delivery === 'single') {
    151         eventWritten = true;
    152         socket.send(JSON.stringify(['EVENT', frame[1], raw]));
    153         socket.send(JSON.stringify(['EOSE', frame[1]]));
    154       } else if (filter.kinds[0] === 1059 && delivery === 'oversize') {
    155         socket.send(
    156           JSON.stringify([
    157             'EVENT',
    158             frame[1],
    159             { ...raw, content: 'x'.repeat(32768) }
    160           ])
    161         );
    162         socket.send(JSON.stringify(['EOSE', frame[1]]));
    163       } else socket.send(JSON.stringify(['EOSE', frame[1]]));
    164     });
    165   });
    166   await once(server, 'listening');
    167   const address = server.address();
    168   assert.ok(address && typeof address !== 'string');
    169   const fixturePort = address.port;
    170   let key = owner,
    171     calls = 0,
    172     signs = 0,
    173     constructed = 0;
    174   class FixtureSocket extends WebSocket {
    175     constructor(url: string | URL) {
    176       assert.ok(origins.includes(new URL(String(url)).origin));
    177       constructed++;
    178       super(`ws://127.0.0.1:${fixturePort}`);
    179     }
    180   }
    181   Object.defineProperty(globalThis, 'window', {
    182     configurable: true,
    183     value: {
    184       nostr: {
    185         getPublicKey: () => {
    186           calls++;
    187           return Promise.resolve(key);
    188         },
    189         signEvent: () => {
    190           signs++;
    191           return Promise.reject(new Error('Unexpected signer'));
    192         },
    193         nip44: {
    194           encrypt: (_peer: string, text: string) =>
    195             Promise.resolve('fixture:' + text),
    196           decrypt: (_peer: string, text: string) =>
    197             Promise.resolve(text.slice(8))
    198         }
    199       }
    200     }
    201   });
    202   globalThis.WebSocket =
    203     FixtureSocket as unknown as typeof globalThis.WebSocket;
    204   globalThis.fetch = () =>
    205     Promise.reject(new Error('Unexpected information fetch'));
    206   const sdkScopes = new Map<'public' | 'private', RelayPool>();
    207   const allScopes = new Set<RelayPool>();
    208   let requestCalls = 0;
    209   RelayPool.prototype.req = function (relays, filters, options) {
    210     requestCalls++;
    211     allScopes.add(this);
    212     assert.ok(Array.isArray(filters));
    213     const filter = filters[0] as { kinds: number[] };
    214     sdkScopes.set(filter.kinds[0] === 1059 ? 'private' : 'public', this);
    215     return originalReq.call(this, relays, filters, options);
    216   };
    217   const identity = createIdentitySession();
    218   let privateSession: Awaited<ReturnType<typeof createPrivateSession>>;
    219   let privatePool: ReturnType<typeof getPrivatePool>;
    220   let publicPool: ReturnType<typeof getPublicPool>;
    221   const stops: Array<() => void> = [];
    222   function publicPage() {
    223     return new Promise<void>((resolve) => {
    224       const seen = new Set<string>();
    225       stops.push(
    226         subscribePublicPool(
    227           publicPool!,
    228           [{ kinds: [30402], limit: 1 }],
    229           (message) => {
    230             if (message.type === 'EOSE') {
    231               seen.add(message.from);
    232               if (seen.size === 3) resolve();
    233             }
    234           }
    235         )
    236       );
    237     });
    238   }
    239   async function awaitRetirement() {
    240     while (privatePool && privatePoolCleanupRequired(privatePool)) {
    241       if (privateSessionSnapshot(privateSession!)?.current === false)
    242         closePrivateSession(privateSession!);
    243       await new Promise<void>((resolve) => setImmediate(resolve));
    244     }
    245   }
    246   async function heldPage() {
    247     delivery = 'hold';
    248     heldRequests = 0;
    249     const ready = new Promise<void>((resolve) => {
    250       heldReady = resolve;
    251     });
    252     stops.push(subscribePrivatePage(privatePool!, 200, () => {}));
    253     await ready;
    254   }
    255   try {
    256     await t.test(
    257       'guest, forged and unreviewed session cannot acquire sockets',
    258       async () => {
    259         assert.equal(
    260           await createPrivateSession(identity, 'unreviewed'),
    261           undefined
    262         );
    263         assert.equal(
    264           await createPrivateSession(identity, 'reviewed_private_session'),
    265           undefined
    266         );
    267         assert.throws(
    268           () => getPrivatePool({} as never, policy, origins),
    269           /private_session_invalid/
    270         );
    271         assert.equal(constructed, 0);
    272         assert.equal(calls, 0);
    273       }
    274     );
    275     await connectIdentity(identity);
    276     await probeIdentityMessaging(identity, 'reviewed_self_copy');
    277     await t.test(
    278       'explicit admission rechecks the genuine owner through the shared SDK',
    279       async () => {
    280         const before = calls;
    281         privateSession = await createPrivateSession(
    282           identity,
    283           'reviewed_private_session'
    284         );
    285         assert.ok(privateSession);
    286         assert.equal(calls, before + 1);
    287         assert.deepEqual(Object.keys(privateSession), []);
    288         assert.ok(Object.isFrozen(privateSession));
    289         assert.deepEqual(privateSessionSnapshot(privateSession), {
    290           owner,
    291           current: true
    292         });
    293         assert.equal(constructed, 0);
    294       }
    295     );
    296     await t.test(
    297       'selection refuses hints, duplicates and oversized destination sets before egress',
    298       () => {
    299         assert.throws(
    300           () =>
    301             getPrivatePool(privateSession!, policy, [
    302               ...origins,
    303               'wss://unapproved.example.org'
    304             ]),
    305           /private_pool_origins_invalid/
    306         );
    307         assert.throws(
    308           () =>
    309             getPrivatePool(privateSession!, policy, [
    310               'wss://unapproved.example.org'
    311             ]),
    312           /private_pool_origins_invalid/
    313         );
    314         assert.throws(
    315           () =>
    316             getPrivatePool(privateSession!, policy, [origins[0], origins[0]]),
    317           /private_pool_origins_invalid/
    318         );
    319         const selected = [...origins];
    320         let reentrant: ReturnType<typeof getPrivatePool>;
    321         Object.defineProperty(selected, '0', {
    322           configurable: true,
    323           get: () => {
    324             reentrant = getPrivatePool(privateSession!, policy, origins);
    325             return origins[0];
    326           }
    327         });
    328         privatePool = getPrivatePool(privateSession!, policy, selected);
    329         assert.ok(privatePool);
    330         assert.equal(privatePool, reentrant);
    331         Object.defineProperty(selected, '0', {
    332           configurable: true,
    333           writable: true,
    334           value: origins[0]
    335         });
    336         selected[0] = 'wss://unapproved.example.org';
    337         const detached = privatePoolOrigins(privatePool) as string[];
    338         detached.push('wss://unapproved.example.org');
    339         assert.deepEqual(privatePoolOrigins(privatePool), origins);
    340         assert.equal(
    341           getPrivatePool(privateSession!, policy, origins),
    342           privatePool
    343         );
    344         assert.throws(
    345           () => subscribePrivatePage(privatePool!, 201, () => {}),
    346           /private_page_limit_invalid/
    347         );
    348         assert.equal(constructed, 0);
    349       }
    350     );
    351     await t.test(
    352       'three public and three private same-origin sockets have separate AUTH state',
    353       async () => {
    354         publicPool = getPublicPool(policy);
    355         assert.ok(publicPool);
    356         await publicPage();
    357         await heldPage();
    358         assert.equal(constructed, 6);
    359         assert.equal(server.clients.size, 6);
    360         const pub = sdkScopes.get('public'),
    361           priv = sdkScopes.get('private');
    362         assert.ok(pub && priv);
    363         assert.notEqual(pub, priv);
    364         for (const origin of origins) {
    365           const a = pub.relay(origin),
    366             b = priv.relay(origin);
    367           assert.notEqual(a, b);
    368           assert.notEqual(a.authentication$, b.authentication$);
    369           b.authentication$.next({
    370             ...raw,
    371             kind: 22242,
    372             pubkey: owner
    373           } as never);
    374           assert.equal(a.authentication, null);
    375         }
    376         assert.equal(signs, 0);
    377         assert.ok(
    378           frames.every((frame) => frame[0] !== 'AUTH' && frame[0] !== 'EVENT')
    379         );
    380         const privateReq = frames.filter(
    381           (frame) => (frame[2] as { kinds?: number[] })?.kinds?.[0] === 1059
    382         );
    383         assert.equal(privateReq.length, 3);
    384         for (const frame of privateReq)
    385           assert.deepEqual(frame[2], {
    386             kinds: [1059],
    387             '#p': [owner],
    388             limit: 200
    389           });
    390       }
    391     );
    392     await t.test(
    393       'logout closes actual private sockets and public discovery continues',
    394       async () => {
    395         const privateSockets = sockets.slice(3, 6);
    396         const closed = privateSockets.map((socket) => once(socket, 'close'));
    397         disconnectIdentity(identity);
    398         await Promise.all(closed);
    399         assert.equal(server.clients.size, 3);
    400         assert.equal(privateSessionSnapshot(privateSession!)?.current, false);
    401         assert.throws(
    402           () => subscribePrivatePage(privatePool!, 1, () => {}),
    403           /private_pool_closed/
    404         );
    405         await publicPage();
    406         assert.equal(constructed, 6);
    407       }
    408     );
    409     await t.test(
    410       'same-author reconnect cannot revive an old scope or consume stale callbacks',
    411       async () => {
    412         await awaitRetirement();
    413         await connectIdentity(identity);
    414         await probeIdentityMessaging(identity, 'reviewed_self_copy');
    415         assert.equal(privateSessionSnapshot(privateSession!)?.current, false);
    416         const next = await createPrivateSession(
    417           identity,
    418           'reviewed_private_session'
    419         );
    420         assert.ok(next);
    421         assert.notEqual(next, privateSession);
    422         privateSession = next;
    423         privatePool = getPrivatePool(next, policy, origins);
    424         assert.ok(privatePool);
    425         const before = constructed;
    426         await heldPage();
    427         assert.equal(constructed, before + 3);
    428       }
    429     );
    430     await t.test(
    431       'failed SDK cleanup blocks replacement until exact cleanup retry succeeds',
    432       async () => {
    433         const before = constructed;
    434         const held = sdkScopes.get('private');
    435         assert.ok(held);
    436         RelayPool.prototype.close = function () {
    437           if (this === held) throw new Error('HC_TEST_ONLY_CLOSE_FAILURE');
    438           return originalClose.call(this);
    439         };
    440         // Actual session teardown owns whole-SDK disposal; an operation scope
    441         // may close only its own work and cannot exercise this failure port.
    442         assert.equal(closePrivateSession(privateSession!), false);
    443         assert.throws(
    444           () => getPrivatePool(privateSession!, policy, origins),
    445           /private_session_invalid/
    446         );
    447         assert.equal(
    448           await createPrivateSession(identity, 'reviewed_private_session'),
    449           undefined
    450         );
    451         const successorIdentity = createIdentitySession();
    452         await connectIdentity(successorIdentity);
    453         await probeIdentityMessaging(successorIdentity, 'reviewed_self_copy');
    454         const blockedSuccessor = await createPrivateSession(
    455           successorIdentity,
    456           'reviewed_private_session'
    457         );
    458         assert.ok(blockedSuccessor);
    459         assert.throws(
    460           () => getPrivatePool(blockedSuccessor, policy, origins),
    461           /private_pool_closed/
    462         );
    463         closePrivateSession(blockedSuccessor);
    464         disconnectIdentity(successorIdentity);
    465         assert.equal(constructed, before);
    466         RelayPool.prototype.close = originalClose;
    467         while (!closePrivateSession(privateSession!))
    468           await new Promise<void>((resolve) => setImmediate(resolve));
    469         assert.equal(closePrivateSession(privateSession!), true);
    470         const next = await createPrivateSession(
    471           identity,
    472           'reviewed_private_session'
    473         );
    474         assert.ok(next);
    475         privateSession = next;
    476         privatePool = getPrivatePool(next, policy, origins);
    477         assert.ok(privatePool);
    478       }
    479     );
    480     await t.test(
    481       'observed account loss closes session generation without affecting public scope',
    482       async () => {
    483         privatePool = getPrivatePool(privateSession!, policy, origins);
    484         assert.ok(privatePool);
    485         await heldPage();
    486         const newest = [...server.clients].filter(
    487           (socket) => !sockets.slice(0, 3).includes(socket)
    488         );
    489         const closed = newest.map((socket) => once(socket, 'close'));
    490         key = other;
    491         await recheckIdentityOwner(identity);
    492         await Promise.all(closed);
    493         assert.equal(privateSessionSnapshot(privateSession!)?.current, false);
    494         assert.equal(
    495           await createPrivateSession(identity, 'reviewed_private_session'),
    496           undefined
    497         );
    498         await publicPage();
    499         assert.equal(signs, 0);
    500       }
    501     );
    502     key = owner;
    503     await connectIdentity(identity);
    504     await probeIdentityMessaging(identity, 'reviewed_self_copy');
    505     privateSession = await createPrivateSession(
    506       identity,
    507       'reviewed_private_session'
    508     );
    509     assert.ok(privateSession);
    510     privatePool = getPrivatePool(privateSession, policy, origins);
    511     assert.ok(privatePool);
    512     await t.test(
    513       'oversized raw envelope is counted and rejected before consumer delivery',
    514       async () => {
    515         delivery = 'oversize';
    516         let candidates = 0;
    517         await new Promise<void>((resolve) => {
    518           stops.push(
    519             subscribePrivatePage(privatePool!, 200, (message) => {
    520               if (message.type === 'candidate') candidates++;
    521               else resolve();
    522             })
    523           );
    524         });
    525         assert.equal(candidates, 0);
    526         delivery = 'normal';
    527       }
    528     );
    529     await t.test(
    530       'duplicate deliveries consume the finite 500-candidate budget',
    531       async () => {
    532         delivery = 'flood';
    533         let candidates = 0;
    534         const end = await new Promise<PrivatePageMessage>((resolve) => {
    535           stops.push(
    536             subscribePrivatePage(privatePool!, 200, (message) => {
    537               if (message.type === 'candidate') candidates++;
    538               else resolve(message);
    539             })
    540           );
    541         });
    542         assert.equal(candidates, 500);
    543         assert.deepEqual(end, { type: 'end', reason: 'budget' });
    544         delivery = 'normal';
    545       }
    546     );
    547     await t.test(
    548       'encoded bytes and rejected envelopes consume the exact finite 8MiB budget',
    549       async () => {
    550         delivery = 'byte-flood';
    551         let candidates = 0,
    552           bytes = 0;
    553         const end = await new Promise<PrivatePageMessage>((resolve) => {
    554           stops.push(
    555             subscribePrivatePage(privatePool!, 200, (message) => {
    556               if (message.type === 'candidate') {
    557                 candidates++;
    558                 bytes += Buffer.byteLength(message.wire, 'utf8');
    559               } else resolve(message);
    560             })
    561           );
    562         });
    563         const charge = Buffer.byteLength(
    564           JSON.stringify({ ...raw, content: 'x'.repeat(20000) }),
    565           'utf8'
    566         );
    567         assert.equal(candidates, Math.floor(8388608 / charge));
    568         assert.ok(bytes <= 8388608);
    569         assert.deepEqual(end, { type: 'end', reason: 'budget' });
    570         delivery = 'rejected-byte-flood';
    571         let rejectedCandidates = 0;
    572         const rejectedEnd = await new Promise<PrivatePageMessage>((resolve) => {
    573           stops.push(
    574             subscribePrivatePage(privatePool!, 200, (message) => {
    575               if (message.type === 'candidate') rejectedCandidates++;
    576               else resolve(message);
    577             })
    578           );
    579         });
    580         assert.equal(rejectedCandidates, 0);
    581         assert.deepEqual(rejectedEnd, { type: 'end', reason: 'budget' });
    582         delivery = 'normal';
    583       }
    584     );
    585     await t.test(
    586       'finite network page enforces the original 15second elapsed boundary',
    587       async () => {
    588         delivery = 'hold';
    589         const original = performance.now.bind(performance),
    590           descriptor = Object.getOwnPropertyDescriptor(performance, 'now');
    591         let observations = 0;
    592         Object.defineProperty(performance, 'now', {
    593           configurable: true,
    594           value: () => {
    595             observations++;
    596             return original() + (observations > 1 ? 15000 : 0);
    597           }
    598         });
    599         try {
    600           const end = await new Promise<PrivatePageMessage>((resolve) => {
    601             stops.push(
    602               subscribePrivatePage(privatePool!, 200, (message) => {
    603                 if (message.type === 'end') resolve(message);
    604               })
    605             );
    606           });
    607           assert.ok(observations > 1);
    608           assert.deepEqual(end, { type: 'end', reason: 'elapsed' });
    609         } finally {
    610           if (descriptor) Object.defineProperty(performance, 'now', descriptor);
    611           else Reflect.deleteProperty(performance, 'now');
    612           delivery = 'normal';
    613         }
    614       }
    615     );
    616     await t.test(
    617       'asynchronous EOSE cleanup failure emits error and retains unavailable page without escaping',
    618       async () => {
    619         delivery = 'normal';
    620         const original = Reflect.get(Subscription.prototype, 'unsubscribe');
    621         let failNext = true;
    622         Subscription.prototype.unsubscribe = function () {
    623           if (failNext && new Error().stack?.includes('at release (')) {
    624             failNext = false;
    625             throw new Error('HC_TEST_ONLY_ASYNC_UNSUBSCRIBE_FAILURE');
    626           }
    627           return original.call(this);
    628         };
    629         try {
    630           const end = await new Promise<PrivatePageMessage>((resolve) => {
    631             stops.push(
    632               subscribePrivatePage(privatePool!, 200, (message) => {
    633                 if (message.type === 'end') resolve(message);
    634               })
    635             );
    636           });
    637           assert.deepEqual(end, { type: 'end', reason: 'error' });
    638           assert.throws(
    639             () => subscribePrivatePage(privatePool!, 1, () => {}),
    640             /private_page_cleanup_required/
    641           );
    642           await new Promise<void>((resolve) => setImmediate(resolve));
    643         } finally {
    644           Subscription.prototype.unsubscribe = original;
    645           closePrivatePool(privatePool!);
    646           await awaitRetirement();
    647           privatePool = getPrivatePool(privateSession!, policy, origins);
    648           assert.ok(privatePool);
    649         }
    650       }
    651     );
    652     await t.test(
    653       'failed page unsubscribe keeps new SDK admission blocked until cleanup retry',
    654       async () => {
    655         await heldPage();
    656         const stop = stops[stops.length - 1];
    657         const original = Reflect.get(Subscription.prototype, 'unsubscribe');
    658         let failNext = true;
    659         Subscription.prototype.unsubscribe = function () {
    660           if (failNext) {
    661             failNext = false;
    662             throw new Error('HC_TEST_ONLY_UNSUBSCRIBE_FAILURE');
    663           }
    664           return original.call(this);
    665         };
    666         let unexpected: (() => void) | undefined;
    667         const before = requestCalls;
    668         try {
    669           assert.throws(() => stop(), /HC_TEST_ONLY_UNSUBSCRIBE_FAILURE/);
    670           assert.throws(() => {
    671             unexpected = subscribePrivatePage(privatePool!, 1, () => {});
    672           }, /private_pool_closed|private_page_cleanup_required/);
    673           assert.equal(requestCalls, before);
    674         } finally {
    675           unexpected?.();
    676           Subscription.prototype.unsubscribe = original;
    677           closePrivatePool(privatePool!);
    678           await awaitRetirement();
    679         }
    680       }
    681     );
    682     await t.test(
    683       'clock reentry cannot admit an SDK request after owner logout',
    684       async () => {
    685         await new Promise<void>((resolve) => setImmediate(resolve));
    686         assert.equal(
    687           (await recheckIdentityOwner(identity)).state,
    688           'messaging_capable'
    689         );
    690         privatePool = getPrivatePool(privateSession!, policy, origins);
    691         assert.ok(privatePool);
    692         const original = performance.now.bind(performance);
    693         const descriptor = Object.getOwnPropertyDescriptor(performance, 'now');
    694         const before = requestCalls;
    695         let invalidations = 0;
    696         Object.defineProperty(performance, 'now', {
    697           configurable: true,
    698           value: () => {
    699             invalidations++;
    700             disconnectIdentity(identity);
    701             return original();
    702           }
    703         });
    704         try {
    705           await new Promise<void>((resolve) => {
    706             stops.push(
    707               subscribePrivatePage(privatePool!, 1, (message) => {
    708                 if (message.type === 'end') resolve();
    709               })
    710             );
    711           });
    712           assert.ok(invalidations > 0);
    713           assert.equal(requestCalls, before);
    714         } finally {
    715           if (descriptor) Object.defineProperty(performance, 'now', descriptor);
    716           else Reflect.deleteProperty(performance, 'now');
    717         }
    718       }
    719     );
    720     await t.test(
    721       'candidate clock reentry cannot disclose old-owner ciphertext after logout',
    722       async () => {
    723         await awaitRetirement();
    724         await connectIdentity(identity);
    725         await probeIdentityMessaging(identity, 'reviewed_self_copy');
    726         privateSession = await createPrivateSession(
    727           identity,
    728           'reviewed_private_session'
    729         );
    730         assert.ok(privateSession);
    731         privatePool = getPrivatePool(privateSession, policy, [origins[0]]);
    732         assert.ok(privatePool);
    733         delivery = 'single';
    734         eventWritten = false;
    735         let candidates = 0,
    736           invalidations = 0;
    737         const original = performance.now.bind(performance),
    738           descriptor = Object.getOwnPropertyDescriptor(performance, 'now');
    739         Object.defineProperty(performance, 'now', {
    740           configurable: true,
    741           value: () => {
    742             if (eventWritten) {
    743               invalidations++;
    744               disconnectIdentity(identity);
    745             }
    746             return original();
    747           }
    748         });
    749         try {
    750           await new Promise<void>((resolve) => {
    751             stops.push(
    752               subscribePrivatePage(privatePool!, 1, (message) => {
    753                 if (message.type === 'candidate') candidates++;
    754                 else resolve();
    755               })
    756             );
    757           });
    758           assert.ok(eventWritten && invalidations > 0);
    759           assert.equal(candidates, 0);
    760           assert.equal(privateSessionSnapshot(privateSession)?.current, false);
    761         } finally {
    762           if (descriptor) Object.defineProperty(performance, 'now', descriptor);
    763           else Reflect.deleteProperty(performance, 'now');
    764           delivery = 'normal';
    765         }
    766       }
    767     );
    768     await t.test(
    769       'delayed genuine SDK owner response cannot open old-session sockets after logout',
    770       async () => {
    771         await awaitRetirement();
    772         await connectIdentity(identity);
    773         await probeIdentityMessaging(identity, 'reviewed_self_copy');
    774         privateSession = await createPrivateSession(
    775           identity,
    776           'reviewed_private_session'
    777         );
    778         assert.ok(privateSession);
    779         privatePool = getPrivatePool(privateSession, policy, origins);
    780         assert.ok(privatePool);
    781         const browser = Reflect.get(globalThis, 'window');
    782         const provider: unknown = browser.nostr;
    783         assert.ok(provider && typeof provider === 'object');
    784         const descriptor = Object.getOwnPropertyDescriptor(
    785           provider,
    786           'getPublicKey'
    787         );
    788         assert.ok(descriptor);
    789         let release = (_key: string) => {
    790           void _key;
    791         };
    792         let entered = () => {};
    793         const observed = new Promise<void>((resolve) => {
    794           entered = resolve;
    795         });
    796         Object.defineProperty(provider, 'getPublicKey', {
    797           configurable: true,
    798           value: () => {
    799             entered();
    800             return new Promise<string>((resolve) => {
    801               release = resolve;
    802             });
    803           }
    804         });
    805         const before = requestCalls;
    806         let candidates = 0;
    807         const end = new Promise<PrivatePageMessage>((resolve) => {
    808           stops.push(
    809             subscribePrivatePage(privatePool!, 1, (message) => {
    810               if (message.type === 'candidate') candidates++;
    811               else resolve(message);
    812             })
    813           );
    814         });
    815         try {
    816           await observed;
    817           disconnectIdentity(identity);
    818           assert.deepEqual(await end, { type: 'end', reason: 'closed' });
    819           Object.defineProperty(provider, 'getPublicKey', descriptor);
    820           release(owner);
    821           await new Promise<void>((resolve) => setImmediate(resolve));
    822           assert.equal(requestCalls, before);
    823           assert.equal(candidates, 0);
    824           assert.equal(privateSessionSnapshot(privateSession)?.current, false);
    825           key = other;
    826           await connectIdentity(identity);
    827           await probeIdentityMessaging(identity, 'reviewed_self_copy');
    828           const next = await createPrivateSession(
    829             identity,
    830             'reviewed_private_session'
    831           );
    832           assert.ok(next);
    833           assert.deepEqual(privateSessionSnapshot(next), {
    834             owner: other,
    835             current: true
    836           });
    837           assert.equal(privateSessionSnapshot(privateSession)?.current, false);
    838           closePrivateSession(next);
    839           disconnectIdentity(identity);
    840           key = owner;
    841         } finally {
    842           Object.defineProperty(provider, 'getPublicKey', descriptor);
    843           release(owner);
    844         }
    845       }
    846     );
    847     await t.test(
    848       'capability loss closes actual private transport and signing alone cannot reopen it',
    849       async () => {
    850         await awaitRetirement();
    851         await connectIdentity(identity);
    852         await probeIdentityMessaging(identity, 'reviewed_self_copy');
    853         privateSession = await createPrivateSession(
    854           identity,
    855           'reviewed_private_session'
    856         );
    857         assert.ok(privateSession);
    858         privatePool = getPrivatePool(privateSession, policy, origins);
    859         assert.ok(privatePool);
    860         await heldPage();
    861         const newest = [...server.clients].filter(
    862           (socket) => !sockets.slice(0, 3).includes(socket)
    863         );
    864         const closed = newest.map((socket) => once(socket, 'close'));
    865         const browser = Reflect.get(globalThis, 'window');
    866         const provider: unknown = browser.nostr;
    867         assert.ok(provider && typeof provider === 'object');
    868         Object.defineProperty(provider, 'nip44', {
    869           configurable: true,
    870           value: undefined
    871         });
    872         const checked = await recheckIdentityOwner(identity);
    873         await Promise.all(closed);
    874         assert.equal(checked.state, 'signing_only');
    875         assert.equal(privateSessionSnapshot(privateSession)?.current, false);
    876         const before = constructed;
    877         assert.equal(
    878           await createPrivateSession(identity, 'reviewed_private_session'),
    879           undefined
    880         );
    881         assert.equal(constructed, before);
    882         await publicPage();
    883       }
    884     );
    885   } finally {
    886     RelayPool.prototype.close = originalClose;
    887     if (privatePool) closePrivatePool(privatePool);
    888     if (privateSession) closePrivateSession(privateSession);
    889     disconnectIdentity(identity);
    890     for (const stop of stops) stop();
    891     if (publicPool) closePublicPool(publicPool);
    892     RelayPool.prototype.req = originalReq;
    893     for (const scope of allScopes) scope.close();
    894     for (const socket of server.clients) socket.terminate();
    895     await new Promise<void>((resolve, reject) =>
    896       server.close((error) => (error ? reject(error) : resolve()))
    897     );
    898     globalThis.WebSocket = originalSocket;
    899     globalThis.fetch = originalFetch;
    900     Reflect.deleteProperty(globalThis, 'window');
    901   }
    902 });