app

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

history-cursor.ts (8707B)


      1 import { outerHistoryPlan } from '../../../src/lib/messaging/history-cursor.ts';
      2 import { finalizeEvent } from 'applesauce-core/helpers';
      3 import { nip44 } from 'applesauce-core/helpers/encryption';
      4 import {
      5   captureUnlockedSession,
      6   closeUnlockedSession
      7 } from '../../../src/lib/messaging/unlocked-session.ts';
      8 import { identitySessionSnapshot } from '../../../src/lib/runtime/identity-session.ts';
      9 import {
     10   browserExtensionScheduler,
     11   extensionSchedulerSnapshot
     12 } from '../../../src/lib/nostr/extension-scheduler.ts';
     13 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts';
     14 import {
     15   validateRelayPolicy,
     16   readRelayPolicy
     17 } from '../../../src/lib/config/relays.ts';
     18 import {
     19   createPrivateSession,
     20   closePrivateSession,
     21   privateSessionOwnership
     22 } from '../../../src/lib/runtime/private-session.ts';
     23 import {
     24   captureInboxSync,
     25   startInboxSync,
     26   stopInboxSync,
     27   inboxSyncSnapshot,
     28   type InboxSync
     29 } from '../../../src/lib/messaging/inbox-sync.ts';
     30 import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts';
     31 import { privateRecordSnapshot } from '../../../src/lib/persistence/private-records.ts';
     32 import {
     33   getPublicStore,
     34   publicStoreEnvelope
     35 } from '../../../src/lib/nostr/public-store.ts';
     36 export async function makeFixture(
     37   previousOuterCheck?: number,
     38   artifactAgeSeconds = 0
     39 ) {
     40   outerHistoryPlan(Math.floor(Date.now() / 1000), previousOuterCheck);
     41   const originalClock = Date.now;
     42   const f = await (async () => {
     43     try {
     44       if (artifactAgeSeconds)
     45         Date.now = () => originalClock() - artifactAgeSeconds * 1000;
     46       // Actual SDK creates/signs/persists the original send while this isolated
     47       // fixture clock is old. Never edit a signed timestamp or regenerate it at delivery.
     48       return await makeRecoveryFixture();
     49     } finally {
     50       Date.now = originalClock;
     51     }
     52   })();
     53   const policy = validateRelayPolicy(
     54     JSON.stringify({
     55       ...readRelayPolicy(f.context.policy),
     56       messagingEnabled: true
     57     })
     58   );
     59   if (!policy) throw Error('fixture policy unavailable');
     60   const session = await createPrivateSession(
     61     f.identity,
     62     'reviewed_private_session'
     63   );
     64   if (!session) throw Error('missing genuine session');
     65   const capturedSession = session;
     66   const capture = privateSessionOwnership(session)!;
     67   const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock');
     68   if (!unlocked) throw Error('missing genuine unlock');
     69   const publicStore = getPublicStore()!;
     70   const self = (await f.row())!.record.self;
     71   let ingress: InboxSync | undefined;
     72   async function retireOriginalSync() {
     73     for (;;) {
     74       let incomplete = false;
     75       try {
     76         if (ingress) stopInboxSync(ingress);
     77       } catch (error) {
     78         if (
     79           !(error instanceof Error) ||
     80           error.message !== 'private_inbox_cleanup_required'
     81         )
     82           throw error;
     83         incomplete = true;
     84       }
     85       const sessionClean = closePrivateSession(capturedSession);
     86       if (!incomplete && sessionClean) {
     87         if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired)
     88           throw Error('actual original sync cleanup remains incomplete');
     89         return;
     90       }
     91       // Retry exact original disposal after its actual SDK close observers;
     92       // this wait starts no retrieval, permission or replacement session.
     93       await new Promise<void>((resolve) => setTimeout(resolve, 0));
     94     }
     95   }
     96 
     97   let authorized = true;
     98   let restoreFault = () => {};
     99   let releaseKey: (() => void) | undefined;
    100   let restoreKey = () => {};
    101   return {
    102     ...f,
    103     outer: self.wire,
    104     outerId: self.eventId,
    105     oldSignedOuter(createdAt: number) {
    106       const ownerSecret = new Uint8Array(32).fill(83),
    107         randomSecret = new Uint8Array(32).fill(86);
    108       let oldKey: Uint8Array | undefined, nextKey: Uint8Array | undefined;
    109       try {
    110         const old = JSON.parse(self.wire) as {
    111           pubkey: string;
    112           content: string;
    113         };
    114         oldKey = nip44.v2.utils.getConversationKey(ownerSecret, old.pubkey);
    115         const seal = nip44.v2.decrypt(old.content, oldKey);
    116         nextKey = nip44.v2.utils.getConversationKey(randomSecret, f.owner);
    117         return JSON.stringify(
    118           finalizeEvent(
    119             {
    120               kind: 1059,
    121               created_at: createdAt,
    122               tags: [['p', f.owner]],
    123               content: nip44.v2.encrypt(seal, nextKey)
    124             },
    125             randomSecret
    126           )
    127         );
    128       } finally {
    129         ownerSecret.fill(0);
    130         randomSecret.fill(0);
    131         oldKey?.fill(0);
    132         nextKey?.fill(0);
    133       }
    134     },
    135     capture(
    136       access = true,
    137       review: unknown = 'reviewed_foreground_inbox',
    138       outerCheck = previousOuterCheck
    139     ) {
    140       const candidate = captureInboxSync(
    141         f.repository,
    142         session,
    143         policy,
    144         f.context.own,
    145         unlocked,
    146         access
    147           ? (context) => ({
    148               ...context,
    149               receive: 'qualified_exercised',
    150               archive: 'qualified_exercised',
    151               current: () => authorized && capture.current()
    152             })
    153           : undefined,
    154         review,
    155         outerCheck
    156       );
    157       if (candidate) ingress = candidate;
    158       return !!candidate;
    159     },
    160     start(review: unknown = 'reviewed_foreground_inbox') {
    161       if (!ingress) return false;
    162       return startInboxSync(ingress, review);
    163     },
    164     stop: retireOriginalSync,
    165     snapshot: () => ingress && inboxSyncSnapshot(ingress),
    166     async stored(id = self.eventId) {
    167       const row = await loadPrivateRecord(
    168         f.repository,
    169         'received_envelopes',
    170         id
    171       );
    172       return row.ok ? privateRecordSnapshot(row.value, f.owner, id) : undefined;
    173     },
    174     publicContains: (id = self.eventId) =>
    175       !!publicStoreEnvelope(publicStore, id),
    176     countsValue: () => f.counts(),
    177     closeUnlock() {
    178       closeUnlockedSession(unlocked);
    179     },
    180     navigateAway: retireOriginalSync,
    181     changeKey() {
    182       f.mode('changed_key');
    183     },
    184     holdNextKey() {
    185       const provider = window.nostr as
    186         { getPublicKey: () => Promise<string> } | undefined;
    187       if (!provider) throw Error('missing genuine fixture provider');
    188       const original = provider.getPublicKey;
    189       provider.getPublicKey = async () => {
    190         const owner = await original.call(provider);
    191         return await new Promise<string>((resolve) => {
    192           releaseKey = () => resolve(owner);
    193         });
    194       };
    195       restoreKey = () => {
    196         provider.getPublicKey = original;
    197       };
    198     },
    199     pendingKey: () => !!releaseKey,
    200     keyJobOccupied() {
    201       const scheduler = browserExtensionScheduler();
    202       const slot = scheduler && extensionSchedulerSnapshot(scheduler);
    203       return slot?.state === 'active' && slot.pending === 'key';
    204     },
    205     identityState: () => identitySessionSnapshot(f.identity).state,
    206     settleKey() {
    207       const release = releaseKey;
    208       releaseKey = undefined;
    209       restoreKey();
    210       release?.();
    211     },
    212     revokeAccess() {
    213       authorized = false;
    214     },
    215     logout() {
    216       closePrivateSession(session);
    217     },
    218     logoutIdentity() {
    219       f.disconnect();
    220       closePrivateSession(session);
    221     },
    222     restoreFault() {
    223       restoreFault();
    224     },
    225     faultRetention(kind: 'abort' | 'readback') {
    226       const put = Reflect.get<IDBObjectStore, 'put'>(
    227         IDBObjectStore.prototype,
    228         'put'
    229       );
    230       const cursor = Reflect.get<IDBIndex, 'openCursor'>(
    231         IDBIndex.prototype,
    232         'openCursor'
    233       );
    234       let written = false;
    235       IDBObjectStore.prototype.put = function (
    236         ...args: Parameters<IDBObjectStore['put']>
    237       ) {
    238         const request = put.apply(this, args);
    239         if (this.name === 'received_envelopes') {
    240           written = true;
    241           if (kind === 'abort') this.transaction.abort();
    242         }
    243         return request;
    244       };
    245       IDBIndex.prototype.openCursor = function (
    246         ...args: Parameters<IDBIndex['openCursor']>
    247       ) {
    248         if (
    249           kind === 'readback' &&
    250           written &&
    251           this.objectStore.name === 'received_envelopes' &&
    252           this.objectStore.transaction.mode === 'readonly'
    253         )
    254           throw Error('actual post-put inbox readback failure');
    255         return cursor.apply(this, args);
    256       };
    257       restoreFault = () => {
    258         IDBObjectStore.prototype.put = put;
    259         IDBIndex.prototype.openCursor = cursor;
    260       };
    261     },
    262     async close() {
    263       const release = releaseKey;
    264       releaseKey = undefined;
    265       restoreKey();
    266       release?.();
    267       restoreFault();
    268       await retireOriginalSync();
    269       closePrivateSession(session);
    270       f.close();
    271     }
    272   };
    273 }