app

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

history-pagination.ts (15180B)


      1 import {
      2   captureOlderInbox,
      3   loadOlderInbox,
      4   olderInboxSnapshot,
      5   stopOlderInbox,
      6   type OlderInbox
      7 } from '../../../src/lib/messaging/history-pagination.ts';
      8 import {
      9   admitInboxEnvelope,
     10   retainInboxEnvelope
     11 } from '../../../src/lib/persistence/inbox-envelope-repository.ts';
     12 import {
     13   createPublicScheduler,
     14   createPublicRun,
     15   openInboxRequest,
     16   closePublicScheduler
     17 } from '../../../src/lib/nostr/request-scope.ts';
     18 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
     19 import { outerHistoryPlan } from '../../../src/lib/messaging/history-cursor.ts';
     20 import { finalizeEvent } from 'applesauce-core/helpers';
     21 import {
     22   browserDatabaseTransaction,
     23   openBrowserDatabase,
     24   closeBrowserDatabase
     25 } from '../../../src/lib/persistence/database.ts';
     26 import { decodePrivateRecord } from '../../../src/lib/persistence/private-records.ts';
     27 import { nip44 } from 'applesauce-core/helpers/encryption';
     28 import {
     29   captureUnlockedSession,
     30   closeUnlockedSession
     31 } from '../../../src/lib/messaging/unlocked-session.ts';
     32 import { identitySessionSnapshot } from '../../../src/lib/runtime/identity-session.ts';
     33 import {
     34   browserExtensionScheduler,
     35   extensionSchedulerSnapshot
     36 } from '../../../src/lib/nostr/extension-scheduler.ts';
     37 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts';
     38 import {
     39   validateRelayPolicy,
     40   readRelayPolicy
     41 } from '../../../src/lib/config/relays.ts';
     42 import {
     43   createPrivateSession,
     44   closePrivateSession,
     45   privateSessionOwnership
     46 } from '../../../src/lib/runtime/private-session.ts';
     47 import {
     48   captureInboxSync,
     49   startInboxSync,
     50   stopInboxSync,
     51   inboxSyncSnapshot,
     52   type InboxSync
     53 } from '../../../src/lib/messaging/inbox-sync.ts';
     54 import {
     55   loadPrivateRecord,
     56   inspectPrivateStorage
     57 } from '../../../src/lib/persistence/private-storage.ts';
     58 import { privateRecordSnapshot } from '../../../src/lib/persistence/private-records.ts';
     59 import {
     60   getPublicStore,
     61   publicStoreEnvelope
     62 } from '../../../src/lib/nostr/public-store.ts';
     63 export async function makeFixture(
     64   previousOuterCheck?: number,
     65   artifactAgeSeconds = 0,
     66   newStorage = true
     67 ) {
     68   outerHistoryPlan(Math.floor(Date.now() / 1000), previousOuterCheck);
     69   const originalClock = Date.now;
     70   const f = await (async () => {
     71     try {
     72       if (artifactAgeSeconds)
     73         Date.now = () => originalClock() - artifactAgeSeconds * 1000;
     74       // Actual SDK creates/signs/persists the original send while this isolated
     75       // fixture clock is old. Never edit a signed timestamp or regenerate it at delivery.
     76       return await makeRecoveryFixture(newStorage);
     77     } finally {
     78       Date.now = originalClock;
     79     }
     80   })();
     81   const policy = validateRelayPolicy(
     82     JSON.stringify({
     83       ...readRelayPolicy(f.context.policy),
     84       messagingEnabled: true
     85     })
     86   );
     87   if (!policy) throw Error('fixture policy unavailable');
     88   const session = await createPrivateSession(
     89     f.identity,
     90     'reviewed_private_session'
     91   );
     92   if (!session) throw Error('missing genuine session');
     93   const capturedSession = session;
     94   const capture = privateSessionOwnership(session)!;
     95   const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock');
     96   if (!unlocked) throw Error('missing genuine unlock');
     97   const scheduler = createPublicScheduler({
     98     now: () => 0,
     99     schedule: () => () => {}
    100   });
    101   const fixtureSecret = new Uint8Array(32).fill(83);
    102   let ownEvent: ReturnType<typeof finalizeEvent>;
    103   try {
    104     ownEvent = finalizeEvent(
    105       {
    106         kind: 10050,
    107         created_at: 101,
    108         tags: [
    109           ['relay', 'wss://archive.example.org'],
    110           ['relay', 'wss://peer.example.org']
    111         ],
    112         content: ''
    113       },
    114       fixtureSecret
    115     );
    116   } finally {
    117     fixtureSecret.fill(0);
    118   }
    119   const publicRun = createPublicRun(scheduler, policy);
    120   const own = createInboxResolver(
    121     publicRun,
    122     f.owner,
    123     (next) =>
    124       openInboxRequest(
    125         publicRun,
    126         f.owner,
    127         (sink) => {
    128           sink({
    129             type: 'EVENT',
    130             from: 'wss://discovery.example.org',
    131             id: 'fixture',
    132             event: ownEvent
    133           });
    134           sink({
    135             type: 'EOSE',
    136             from: 'wss://discovery.example.org',
    137             id: 'fixture'
    138           });
    139           return () => {};
    140         },
    141         next
    142       ),
    143     () => capture.current()
    144   );
    145   const publicStore = getPublicStore()!;
    146   const self = (await f.row())!.record.self;
    147   let ingress: InboxSync | undefined;
    148   async function retireOriginalSync() {
    149     for (;;) {
    150       let incomplete = false;
    151       try {
    152         if (ingress) stopInboxSync(ingress);
    153       } catch (error) {
    154         if (
    155           !(error instanceof Error) ||
    156           error.message !== 'private_inbox_cleanup_required'
    157         )
    158           throw error;
    159         incomplete = true;
    160       }
    161       const sessionClean = closePrivateSession(capturedSession);
    162       if (!incomplete && sessionClean) {
    163         if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired)
    164           throw Error('actual original sync cleanup remains incomplete');
    165         return;
    166       }
    167       // Retry exact original disposal after its actual SDK close observers;
    168       // this wait starts no retrieval, permission or replacement session.
    169       await new Promise<void>((resolve) => setTimeout(resolve, 0));
    170     }
    171   }
    172 
    173   let older: OlderInbox | undefined;
    174   let capacityWires: string[] = [],
    175     capacityWrites = 0;
    176   let authorized = true;
    177   let restoreFault = () => {};
    178   let releaseKey: (() => void) | undefined;
    179   let restoreKey = () => {};
    180   return {
    181     ...f,
    182     outer: self.wire,
    183     outerId: self.eventId,
    184     oldSignedOuter(createdAt: number) {
    185       const ownerSecret = new Uint8Array(32).fill(83),
    186         randomSecret = new Uint8Array(32).fill(86);
    187       let oldKey: Uint8Array | undefined, nextKey: Uint8Array | undefined;
    188       try {
    189         const old = JSON.parse(self.wire) as {
    190           pubkey: string;
    191           content: string;
    192         };
    193         oldKey = nip44.v2.utils.getConversationKey(ownerSecret, old.pubkey);
    194         const seal = nip44.v2.decrypt(old.content, oldKey);
    195         nextKey = nip44.v2.utils.getConversationKey(randomSecret, f.owner);
    196         return JSON.stringify(
    197           finalizeEvent(
    198             {
    199               kind: 1059,
    200               created_at: createdAt,
    201               tags: [['p', f.owner]],
    202               content: nip44.v2.encrypt(seal, nextKey)
    203             },
    204             randomSecret
    205           )
    206         );
    207       } finally {
    208         ownerSecret.fill(0);
    209         randomSecret.fill(0);
    210         oldKey?.fill(0);
    211         nextKey?.fill(0);
    212       }
    213     },
    214     capture(
    215       access = true,
    216       review: unknown = 'reviewed_foreground_inbox',
    217       outerCheck = previousOuterCheck
    218     ) {
    219       const candidate = captureInboxSync(
    220         f.repository,
    221         session,
    222         policy,
    223         own,
    224         unlocked,
    225         access
    226           ? (context) => ({
    227               ...context,
    228               receive: 'qualified_exercised',
    229               archive: 'qualified_exercised',
    230               current: () => authorized && capture.current()
    231             })
    232           : undefined,
    233         review,
    234         outerCheck
    235       );
    236       if (candidate) ingress = candidate;
    237       return !!candidate;
    238     },
    239     start(review: unknown = 'reviewed_foreground_inbox') {
    240       if (!ingress) return false;
    241       return startInboxSync(ingress, review);
    242     },
    243     stop: retireOriginalSync,
    244     snapshot: () => ingress && inboxSyncSnapshot(ingress),
    245     captureOlder(review: unknown = 'reviewed_load_older') {
    246       if (!ingress) return false;
    247       const candidate = captureOlderInbox(ingress, review);
    248       if (candidate) older = candidate;
    249       return !!candidate;
    250     },
    251     loadOlder(review: unknown = 'reviewed_load_older') {
    252       return older ? loadOlderInbox(older, review) : Promise.resolve(false);
    253     },
    254     oldStopAfterSuccessor() {
    255       if (!older || !ingress) throw Error('original history controller absent');
    256       const old = older;
    257       stopOlderInbox(old);
    258       const successor = captureOlderInbox(ingress, 'reviewed_load_older');
    259       if (!successor) throw Error('genuine successor absent');
    260       older = successor;
    261       stopOlderInbox(old);
    262       const third = captureOlderInbox(ingress, 'reviewed_load_older');
    263       if (third) stopOlderInbox(third);
    264       return {
    265         successor: !!successor,
    266         third: !!third,
    267         current: olderInboxSnapshot(successor)
    268       };
    269     },
    270     copiedOlderStart() {
    271       return older
    272         ? loadOlderInbox(Object.freeze({ ...older }), 'reviewed_load_older')
    273         : Promise.resolve(false);
    274     },
    275     olderSnapshot: () => older && olderInboxSnapshot(older),
    276     stopOlder() {
    277       if (older) stopOlderInbox(older);
    278     },
    279     // Source-only bulk strict ciphertext, not new inner-message/delivery proof.
    280     async seedCapacity(source = 'wss://archive.example.org') {
    281       const records = Array.from({ length: 2000 }, (_, index) => {
    282         const outer =
    283             index === 0
    284               ? self.wire
    285               : this.oldSignedOuter(Math.floor(Date.now() / 1000) - index),
    286           event = JSON.parse(outer) as { id: string };
    287         const wire = JSON.stringify({
    288           schema: 1,
    289           family: 'received_envelope',
    290           owner: f.owner,
    291           id: event.id,
    292           revision: 0,
    293           outer,
    294           observedAtMilliseconds: Date.now(),
    295           sources: [source],
    296           read: null
    297         });
    298         if (!decodePrivateRecord(wire, f.owner, event.id).ok)
    299           throw Error('strict capacity outer rejected');
    300         return { owner: f.owner, id: event.id, wire };
    301       });
    302       capacityWires = records.map(
    303         (row) => (JSON.parse(row.wire) as { outer: string }).outer
    304       );
    305       if (new Set(records.map((row) => row.id)).size !== 2000)
    306         throw Error('capacity fixture IDs collide');
    307       const opened = await openBrowserDatabase();
    308       if (opened.state !== 'ready')
    309         throw Error('owned capacity connection unavailable');
    310       try {
    311         const tx = browserDatabaseTransaction(
    312           opened.owner,
    313           ['received_envelopes'],
    314           'readwrite'
    315         );
    316         for (const row of records)
    317           tx.objectStore('received_envelopes').put(row);
    318         await new Promise<void>((resolve, reject) => {
    319           tx.addEventListener('complete', () => resolve());
    320           tx.addEventListener('abort', () =>
    321             reject(Error('capacity seed aborted'))
    322           );
    323         });
    324       } finally {
    325         closeBrowserDatabase(opened.owner);
    326       }
    327       const checked = await inspectPrivateStorage(
    328         f.repository,
    329         'received_envelopes'
    330       );
    331       if (!checked.ok || checked.value.count !== 2000)
    332         throw Error('actual committed capacity absent');
    333       return checked.value;
    334     },
    335     capacityOuterWires: () => capacityWires.slice(0, 500),
    336     capacityWriteCount: () => capacityWrites,
    337     observeCapacityWrites() {
    338       const nativePut = Reflect.get<IDBObjectStore, 'put'>(
    339           IDBObjectStore.prototype,
    340           'put'
    341         ),
    342         priorRestore = restoreFault;
    343       IDBObjectStore.prototype.put = function (...args) {
    344         const request = Reflect.apply(nativePut, this, args);
    345         if (this.name === 'received_envelopes') capacityWrites++;
    346         return request;
    347       };
    348       restoreFault = () => {
    349         IDBObjectStore.prototype.put = nativePut;
    350         priorRestore();
    351       };
    352     },
    353     async seed(wire: string, origin = 'wss://archive.example.org') {
    354       const envelope = admitInboxEnvelope(wire, f.owner, origin, Date.now());
    355       if (!envelope) throw Error('invalid genuinefixture envelope');
    356       const result = await retainInboxEnvelope(f.repository, session, envelope);
    357       if (result.status !== 'retained' && result.status !== 'duplicate')
    358         throw Error('genuinefixture retention failed');
    359     },
    360     async stored(id = self.eventId) {
    361       const row = await loadPrivateRecord(
    362         f.repository,
    363         'received_envelopes',
    364         id
    365       );
    366       return row.ok ? privateRecordSnapshot(row.value, f.owner, id) : undefined;
    367     },
    368     publicContains: (id = self.eventId) =>
    369       !!publicStoreEnvelope(publicStore, id),
    370     countsValue: () => f.counts(),
    371     closeUnlock() {
    372       closeUnlockedSession(unlocked);
    373     },
    374     navigateAway: retireOriginalSync,
    375     changeKey() {
    376       f.mode('changed_key');
    377     },
    378     holdNextKey() {
    379       const provider = window.nostr as
    380         { getPublicKey: () => Promise<string> } | undefined;
    381       if (!provider) throw Error('missing genuine fixture provider');
    382       const original = provider.getPublicKey;
    383       provider.getPublicKey = async () => {
    384         const owner = await original.call(provider);
    385         return await new Promise<string>((resolve) => {
    386           releaseKey = () => resolve(owner);
    387         });
    388       };
    389       restoreKey = () => {
    390         provider.getPublicKey = original;
    391       };
    392     },
    393     pendingKey: () => !!releaseKey,
    394     keyJobOccupied() {
    395       const scheduler = browserExtensionScheduler();
    396       const slot = scheduler && extensionSchedulerSnapshot(scheduler);
    397       return slot?.state === 'active' && slot.pending === 'key';
    398     },
    399     identityState: () => identitySessionSnapshot(f.identity).state,
    400     settleKey() {
    401       const release = releaseKey;
    402       releaseKey = undefined;
    403       restoreKey();
    404       release?.();
    405     },
    406     revokeAccess() {
    407       authorized = false;
    408     },
    409     logout() {
    410       closePrivateSession(session);
    411     },
    412     logoutIdentity() {
    413       f.disconnect();
    414       closePrivateSession(session);
    415     },
    416     restoreFault() {
    417       restoreFault();
    418     },
    419     faultRetention(kind: 'abort' | 'readback') {
    420       const put = Reflect.get<IDBObjectStore, 'put'>(
    421         IDBObjectStore.prototype,
    422         'put'
    423       );
    424       const cursor = Reflect.get<IDBIndex, 'openCursor'>(
    425         IDBIndex.prototype,
    426         'openCursor'
    427       );
    428       let written = false;
    429       IDBObjectStore.prototype.put = function (
    430         ...args: Parameters<IDBObjectStore['put']>
    431       ) {
    432         const request = put.apply(this, args);
    433         if (this.name === 'received_envelopes') {
    434           written = true;
    435           if (kind === 'abort') this.transaction.abort();
    436         }
    437         return request;
    438       };
    439       IDBIndex.prototype.openCursor = function (
    440         ...args: Parameters<IDBIndex['openCursor']>
    441       ) {
    442         if (
    443           kind === 'readback' &&
    444           written &&
    445           this.objectStore.name === 'received_envelopes' &&
    446           this.objectStore.transaction.mode === 'readonly'
    447         )
    448           throw Error('actual post-put inbox readback failure');
    449         return cursor.apply(this, args);
    450       };
    451       restoreFault = () => {
    452         IDBObjectStore.prototype.put = put;
    453         IDBIndex.prototype.openCursor = cursor;
    454       };
    455     },
    456     async close() {
    457       const release = releaseKey;
    458       releaseKey = undefined;
    459       restoreKey();
    460       release?.();
    461       restoreFault();
    462       if (older) stopOlderInbox(older);
    463       closePublicScheduler(scheduler);
    464       await retireOriginalSync();
    465       closePrivateSession(session);
    466       f.close();
    467     }
    468   };
    469 }