app

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

inbox-probe-exclusion.ts (16897B)


      1 import { makeQualificationFixture } from './inbox-access-qualification.ts';
      2 import type { openRecoveryContext } from './inbox-probe-recovery.ts';
      3 import {
      4   admitInboxEnvelope,
      5   inboxEnvelopeSnapshot,
      6   retainInboxEnvelope
      7 } from '../../../src/lib/persistence/inbox-envelope-repository.ts';
      8 import type { PrivateAccessProbe } from '../../../src/lib/persistence/private-records.ts';
      9 import { observeQualifiedInboxAccess } from '../../../src/lib/messaging/inbox-access-qualification.ts';
     10 import {
     11   captureInboxIngress,
     12   startInboxIngress,
     13   stopInboxIngress,
     14   inboxIngressSnapshot,
     15   type InboxIngress
     16 } from '../../../src/lib/nostr/inbox-ingress.ts';
     17 import {
     18   captureInboxSync,
     19   startInboxSync,
     20   stopInboxSync,
     21   inboxSyncSnapshot,
     22   type InboxSync
     23 } from '../../../src/lib/messaging/inbox-sync.ts';
     24 import {
     25   captureOlderInbox,
     26   loadOlderInbox,
     27   olderInboxSnapshot,
     28   stopOlderInbox,
     29   type OlderInbox
     30 } from '../../../src/lib/messaging/history-pagination.ts';
     31 import {
     32   captureUnlockedSession,
     33   type UnlockedSession
     34 } from '../../../src/lib/messaging/unlocked-session.ts';
     35 import {
     36   captureDecryptionQueue,
     37   runDecryptionBatch,
     38   stopDecryptionQueue,
     39   decryptionQueueSnapshot,
     40   decryptionQueueConversations,
     41   type DecryptionQueue
     42 } from '../../../src/lib/messaging/decryption-queue.ts';
     43 import {
     44   createPublicView,
     45   beginPublicViewRun,
     46   disposePublicView
     47 } from '../../../src/lib/runtime/public-runtime.ts';
     48 import {
     49   resolveInboxPreference,
     50   settleInboxResolver
     51 } from '../../../src/lib/messaging/resolve-inbox.ts';
     52 import {
     53   openBrowserDatabase,
     54   browserDatabaseTransaction,
     55   closeBrowserDatabase
     56 } from '../../../src/lib/persistence/database.ts';
     57 import { inboxProbeRumorWire } from '../../../src/lib/nostr/inbox-access.ts';
     58 import { recoveredInboxProbeRumorWire } from '../../../src/lib/nostr/self-recovery-reader.ts';
     59 import {
     60   generateSecretKey,
     61   getPublicKey,
     62   getEventHash,
     63   finalizeEvent
     64 } from 'applesauce-core/helpers';
     65 import { nip44 } from 'applesauce-core/helpers/encryption';
     66 export {
     67   observeInboxProbeDelivery,
     68   consumeInboxProbeDelivery
     69 } from '../../../src/lib/persistence/inbox-probes.ts';
     70 export * from './inbox-access-qualification.ts';
     71 export { admitInboxEnvelope, retainInboxEnvelope };
     72 export { openBrowserDatabase, closeBrowserDatabase };
     73 // Observe real native transactions and mutation calls without changing results.
     74 export function watchExclusionNative() {
     75   const transaction = Object.getOwnPropertyDescriptor(
     76       IDBDatabase.prototype,
     77       'transaction'
     78     )!.value as IDBDatabase['transaction'],
     79     put = Object.getOwnPropertyDescriptor(IDBObjectStore.prototype, 'put')!
     80       .value as IDBObjectStore['put'],
     81     remove = Object.getOwnPropertyDescriptor(
     82       IDBObjectStore.prototype,
     83       'delete'
     84     )!.value as IDBObjectStore['delete'];
     85   let readonly = 0,
     86     readwrite = 0,
     87     puts = 0,
     88     deletes = 0;
     89   IDBDatabase.prototype.transaction = function (
     90     ...args: Parameters<IDBDatabase['transaction']>
     91   ) {
     92     if (args[1] === 'readwrite') readwrite++;
     93     else readonly++;
     94     return transaction.apply(this, args);
     95   };
     96   IDBObjectStore.prototype.put = function (
     97     ...args: Parameters<IDBObjectStore['put']>
     98   ) {
     99     puts++;
    100     return put.apply(this, args);
    101   };
    102   IDBObjectStore.prototype.delete = function (
    103     ...args: Parameters<IDBObjectStore['delete']>
    104   ) {
    105     deletes++;
    106     return remove.apply(this, args);
    107   };
    108   return {
    109     counts: () => ({ readonly, readwrite, puts, deletes }),
    110     restore() {
    111       IDBDatabase.prototype.transaction = transaction;
    112       IDBObjectStore.prototype.put = put;
    113       IDBObjectStore.prototype.delete = remove;
    114     }
    115   };
    116 }
    117 // Delay delivery of the FIRST actual native complete notification. The real
    118 // cursor, result and trusted completion event still run; no success is fabricated.
    119 export function holdExclusionNativeCompletion() {
    120   const transaction = Object.getOwnPropertyDescriptor(
    121     IDBDatabase.prototype,
    122     'transaction'
    123   )!.value as IDBDatabase['transaction'];
    124   let selected = false,
    125     waiting = false,
    126     released = false;
    127   const deliveries: (() => void)[] = [];
    128   IDBDatabase.prototype.transaction = function (
    129     ...args: Parameters<IDBDatabase['transaction']>
    130   ) {
    131     const tx = transaction.apply(this, args);
    132     if (
    133       !selected &&
    134       tx.mode === 'readonly' &&
    135       tx.objectStoreNames.contains('private_sends')
    136     ) {
    137       selected = true;
    138       const add = tx.addEventListener.bind(tx);
    139       Object.defineProperty(tx, 'addEventListener', {
    140         configurable: true,
    141         value(
    142           type: string,
    143           listener: EventListenerOrEventListenerObject | null,
    144           options?: boolean | AddEventListenerOptions
    145         ) {
    146           if (!listener) return;
    147           if (type !== 'complete') return add(type, listener, options);
    148           add(
    149             type,
    150             (event) => {
    151               const deliver = () => {
    152                 if (typeof listener === 'function') listener.call(tx, event);
    153                 else listener.handleEvent(event);
    154               };
    155               if (released) deliver();
    156               else {
    157                 waiting = true;
    158                 deliveries.push(deliver);
    159               }
    160             },
    161             options
    162           );
    163         }
    164       });
    165     }
    166     return tx;
    167   };
    168   return {
    169     waiting: () => waiting,
    170     release() {
    171       released = true;
    172       waiting = false;
    173       IDBDatabase.prototype.transaction = transaction;
    174       for (const deliver of deliveries.splice(0)) deliver();
    175     }
    176   };
    177 }
    178 // Real child documents use the surviving extension host while all product
    179 // actors and their private provenance belong to the child's fresh module realm.
    180 export async function retainInRecoveryContext(
    181   context: Awaited<ReturnType<typeof openRecoveryContext>>,
    182   wire: string
    183 ) {
    184   const envelope = admitInboxEnvelope(
    185     wire,
    186     context.owner,
    187     'wss://inbox.example.org',
    188     Date.now()
    189   );
    190   return envelope
    191     ? (await retainInboxEnvelope(context.repository, context.session, envelope))
    192         .status
    193     : 'invalid';
    194 }
    195 export async function decryptInRecoveryContext(
    196   context: Awaited<ReturnType<typeof openRecoveryContext>>
    197 ) {
    198   const unlocked = captureUnlockedSession(
    199     context.session,
    200     'reviewed_messages_unlock'
    201   );
    202   if (!unlocked) throw Error('actual child explicit unlock');
    203   const queue = captureDecryptionQueue(
    204     context.repository,
    205     context.session,
    206     context.identity,
    207     unlocked,
    208     'reviewed_inbox_unlock'
    209   );
    210   if (!queue) throw Error('actual child decryption queue');
    211   try {
    212     const result = await runDecryptionBatch(
    213       queue,
    214       'reviewed_decrypt_batch',
    215       []
    216     );
    217     return {
    218       result,
    219       snapshot: decryptionQueueSnapshot(queue),
    220       rooms: decryptionQueueConversations(queue).length
    221     };
    222   } finally {
    223     stopDecryptionQueue(queue);
    224   }
    225 }
    226 export async function makeExclusionFixture() {
    227   const base = await makeQualificationFixture();
    228   const views: ReturnType<typeof createPublicView>[] = [];
    229   let finite: InboxIngress | undefined,
    230     sync: InboxSync | undefined,
    231     older: OlderInbox | undefined,
    232     unlocked: UnlockedSession | undefined,
    233     queue: DecryptionQueue | undefined;
    234   async function selfWire() {
    235     const row = (await base.host.stored()).find(
    236       (value) => value.id === base.command()
    237     );
    238     if (!row) throw Error('actual source-admitted original probe row');
    239     const record = JSON.parse(row.wire) as PrivateAccessProbe;
    240     if (!record.self) throw Error('actual original self ciphertext');
    241     return record.self.wire;
    242   }
    243   return {
    244     ...base,
    245     selfWire,
    246     async seedReceived(count = 1999) {
    247       if (!Number.isSafeInteger(count) || count < 0 || count > 2000)
    248         throw Error('bounded native quota fixture');
    249       const probe = JSON.parse(await selfWire()) as { created_at: number };
    250       const secret = generateSecretKey(),
    251         key = nip44.v2.utils.getConversationKey(secret, base.host.owner);
    252       const rows: { owner: string; id: string; wire: string }[] = [];
    253       try {
    254         const content = nip44.v2.encrypt(
    255           'bounded native outer-only quota fixture',
    256           key
    257         );
    258         for (let n = 0; n < count; n++) {
    259           const event = finalizeEvent(
    260             {
    261               kind: 1059,
    262               created_at: probe.created_at + n + 1,
    263               tags: [['p', base.host.owner]],
    264               content
    265             },
    266             secret
    267           );
    268           const envelope = admitInboxEnvelope(
    269             JSON.stringify(event),
    270             base.host.owner,
    271             'wss://inbox.example.org',
    272             Date.now()
    273           );
    274           const record = envelope && inboxEnvelopeSnapshot(envelope);
    275           if (!record)
    276             throw Error('actual stock signed outer fixture admission');
    277           rows.push({
    278             owner: base.host.owner,
    279             id: event.id,
    280             wire: JSON.stringify(record)
    281           });
    282         }
    283       } finally {
    284         key.fill(0);
    285         secret.fill(0);
    286       }
    287       const opened = await openBrowserDatabase();
    288       if (opened.state !== 'ready')
    289         throw Error('actual received quota database');
    290       try {
    291         const tx = browserDatabaseTransaction(
    292           opened.owner,
    293           ['received_envelopes'],
    294           'readwrite'
    295         );
    296         for (const row of rows) tx.objectStore('received_envelopes').put(row);
    297         await new Promise<void>((resolve, reject) => {
    298           tx.addEventListener('complete', () => resolve());
    299           tx.addEventListener('abort', () =>
    300             reject(Error('actual received quota seed abort'))
    301           );
    302         });
    303       } finally {
    304         closeBrowserDatabase(opened.owner);
    305       }
    306       return probe.created_at + 1;
    307     },
    308     async deleteReceived(id: string) {
    309       const opened = await openBrowserDatabase();
    310       if (opened.state !== 'ready')
    311         throw Error('actual received fixture deletion');
    312       try {
    313         const tx = browserDatabaseTransaction(
    314           opened.owner,
    315           ['received_envelopes'],
    316           'readwrite'
    317         );
    318         tx.objectStore('received_envelopes').delete([base.host.owner, id]);
    319         await new Promise<void>((resolve, reject) => {
    320           tx.addEventListener('complete', () => resolve());
    321           tx.addEventListener('abort', () =>
    322             reject(Error('actual received fixture delete abort'))
    323           );
    324         });
    325       } finally {
    326         closeBrowserDatabase(opened.owner);
    327       }
    328     },
    329     async rowWire() {
    330       const row = (await base.host.stored()).find(
    331         (value) => value.id === base.command()
    332       );
    333       if (!row) throw Error('actual source journal row');
    334       return row.wire;
    335     },
    336     async replaceRow(
    337       wire: string,
    338       id = base.command()!,
    339       owner = base.host.owner
    340     ) {
    341       const opened = await openBrowserDatabase();
    342       if (opened.state !== 'ready')
    343         throw Error('actual fixture native database');
    344       try {
    345         const tx = browserDatabaseTransaction(
    346           opened.owner,
    347           ['private_sends'],
    348           'readwrite'
    349         );
    350         tx.objectStore('private_sends').put({ owner, id, wire });
    351         await new Promise<void>((resolve, reject) => {
    352           tx.addEventListener('complete', () => resolve());
    353           tx.addEventListener('abort', () =>
    354             reject(Error('actual fixture native write abort'))
    355           );
    356         });
    357       } finally {
    358         closeBrowserDatabase(opened.owner);
    359       }
    360     },
    361     ordinaryWire(recovered: boolean, time?: number) {
    362       const a = base.actors(),
    363         original = base.originalIdentity(),
    364         proof = base.proof();
    365       const rumorWire =
    366         recovered && proof
    367           ? recoveredInboxProbeRumorWire(
    368               proof,
    369               base.repository,
    370               a.session,
    371               a.access,
    372               base.host.policy,
    373               base.host.qualification
    374             )
    375           : original && inboxProbeRumorWire(original, a.session);
    376       if (!rumorWire) throw Error('actual original diagnostic rumor source');
    377       const diagnostic = JSON.parse(rumorWire) as {
    378         content: string;
    379         created_at: number;
    380       };
    381       const peer = generateSecretKey(),
    382         outer = generateSecretKey();
    383       function encrypt(secret: Uint8Array, plain: string) {
    384         const key = nip44.v2.utils.getConversationKey(secret, base.host.owner);
    385         try {
    386           return nip44.v2.encrypt(plain, key);
    387         } finally {
    388           key.fill(0);
    389         }
    390       }
    391       try {
    392         const template = {
    393           pubkey: getPublicKey(peer),
    394           kind: 14,
    395           created_at: diagnostic.created_at,
    396           tags: [['p', base.host.owner]],
    397           content: diagnostic.content
    398         };
    399         const rumor = { id: getEventHash(template), ...template };
    400         const seal = finalizeEvent(
    401           {
    402             kind: 13,
    403             created_at: diagnostic.created_at,
    404             tags: [],
    405             content: encrypt(peer, JSON.stringify(rumor))
    406           },
    407           peer
    408         );
    409         return JSON.stringify(
    410           finalizeEvent(
    411             {
    412               kind: 1059,
    413               created_at: time ?? diagnostic.created_at,
    414               tags: [['p', base.host.owner]],
    415               content: encrypt(outer, JSON.stringify(seal))
    416             },
    417             outer
    418           )
    419         );
    420       } finally {
    421         peer.fill(0);
    422         outer.fill(0);
    423       }
    424     },
    425     async startReceive(lane: 'finite' | 'sync') {
    426       const qualification = base.qualification();
    427       if (!qualification)
    428         throw Error('actual genuine access qualification missing');
    429       const a = base.actors(),
    430         view = createPublicView(base.sharedPublicRuntime());
    431       views.push(view);
    432       const own = resolveInboxPreference(
    433         view,
    434         beginPublicViewRun(view),
    435         base.host.owner
    436       );
    437       await settleInboxResolver(own);
    438       const observe = observeQualifiedInboxAccess(qualification);
    439       if (lane === 'finite') {
    440         finite = captureInboxIngress(
    441           base.repository,
    442           a.session,
    443           base.host.policy,
    444           own,
    445           observe,
    446           'reviewed_private_inbox_receive'
    447         );
    448         return (
    449           !!finite &&
    450           startInboxIngress(finite, 'reviewed_private_inbox_receive')
    451         );
    452       }
    453       unlocked = captureUnlockedSession(a.session, 'reviewed_messages_unlock');
    454       if (!unlocked) throw Error('actual owner unlocked scope');
    455       sync = captureInboxSync(
    456         base.repository,
    457         a.session,
    458         base.host.policy,
    459         own,
    460         unlocked,
    461         observe,
    462         'reviewed_foreground_inbox'
    463       );
    464       return !!sync && startInboxSync(sync, 'reviewed_foreground_inbox');
    465     },
    466     receiveSnapshot: () =>
    467       finite ? inboxIngressSnapshot(finite) : sync && inboxSyncSnapshot(sync),
    468     async older() {
    469       if (!sync) throw Error('actual foreground sync');
    470       older ??= captureOlderInbox(sync, 'reviewed_load_older');
    471       return !!older && loadOlderInbox(older, 'reviewed_load_older');
    472     },
    473     olderSnapshot: () => older && olderInboxSnapshot(older),
    474     stopReceive() {
    475       if (older) stopOlderInbox(older);
    476       if (finite) stopInboxIngress(finite);
    477       if (sync) stopInboxSync(sync);
    478     },
    479     async decryptStored() {
    480       const a = base.actors();
    481       unlocked ??= captureUnlockedSession(
    482         a.session,
    483         'reviewed_messages_unlock'
    484       );
    485       if (!unlocked) throw Error('actual explicit unlock');
    486       queue ??= captureDecryptionQueue(
    487         base.repository,
    488         a.session,
    489         a.identity,
    490         unlocked,
    491         'reviewed_inbox_unlock'
    492       );
    493       if (!queue) throw Error('actual explicit decryption queue');
    494       const before = base.host.counts();
    495       const result = await runDecryptionBatch(
    496         queue,
    497         'reviewed_decrypt_batch',
    498         []
    499       );
    500       return {
    501         result,
    502         snapshot: decryptionQueueSnapshot(queue),
    503         rooms: decryptionQueueConversations(queue).length,
    504         before,
    505         after: base.host.counts()
    506       };
    507     },
    508     async retain(raw?: string, cancellation?: AbortSignal) {
    509       const a = base.actors();
    510       const envelope = admitInboxEnvelope(
    511         raw ?? (await selfWire()),
    512         base.host.owner,
    513         'wss://inbox.example.org',
    514         Date.now()
    515       );
    516       return envelope
    517         ? (
    518             await retainInboxEnvelope(
    519               base.repository,
    520               a.session,
    521               envelope,
    522               cancellation
    523             )
    524           ).status
    525         : 'invalid';
    526     },
    527     close() {
    528       if (queue) stopDecryptionQueue(queue);
    529       if (older) stopOlderInbox(older);
    530       if (finite) stopInboxIngress(finite);
    531       if (sync) stopInboxSync(sync);
    532       for (const view of views) disposePublicView(view);
    533       base.close();
    534     }
    535   };
    536 }