app

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

private-publisher.ts (8317B)


      1 import {
      2   makeFixture as makePairFixture,
      3   prepareSelfRecovery,
      4   preparePairedDelivery,
      5   preparedPairedDelivery
      6 } from './paired-delivery.ts';
      7 import {
      8   createPrivateSession,
      9   closePrivateSession
     10 } from '../../../src/lib/runtime/private-session.ts';
     11 import {
     12   getPrivatePool,
     13   publishPrivateGiftWrapAttempt,
     14   subscribePrivatePage,
     15   closePrivatePool
     16 } from '../../../src/lib/nostr/private-pool.ts';
     17 import {
     18   capturePrivatePublication,
     19   capturePrivatePublicationAction,
     20   type PrivatePublicationAction,
     21   privatePublicationSnapshot,
     22   type PrivatePublication
     23 } from '../../../src/lib/nostr/private-publisher.ts';
     24 import { deliverPrivateSend } from '../../../src/lib/messaging/deliver-send.ts';
     25 import { browserDatabaseTransaction } from '../../../src/lib/persistence/database.ts';
     26 import {
     27   reservedSendSnapshot,
     28   reservedSendRumorWire
     29 } from '../../../src/lib/messaging/send-identity.ts';
     30 import {
     31   createPrivateComposer,
     32   updatePrivateComposerText,
     33   bindPrivateComposerPreparation,
     34   privateComposerText,
     35   privateComposerSnapshot,
     36   closePrivateComposer,
     37   type PrivateComposer
     38 } from '../../../src/lib/messaging/composer-state.ts';
     39 import { disconnectIdentity } from '../../../src/lib/runtime/identity-session.ts';
     40 export { privatePublicationSnapshot, publishPrivateGiftWrapAttempt };
     41 import { RelayPool } from 'applesauce-relay/pool';
     42 export async function makeFixture(writeOnly = false, sharedOrigin = false) {
     43   const f = await makePairFixture({
     44     messaging: true,
     45     peerRead: !writeOnly,
     46     sharedOrigin
     47   });
     48   const session = await createPrivateSession(
     49     f.identity,
     50     'reviewed_private_session'
     51   );
     52   if (!session) throw Error('missing genuine private session');
     53   const peerOrigin = 'wss://peer.example.org',
     54     archiveOrigin = sharedOrigin ? peerOrigin : 'wss://archive.example.org';
     55   const pool = getPrivatePool(
     56     session,
     57     f.context.policy,
     58     Array.from(new Set([peerOrigin, archiveOrigin]))
     59   );
     60   if (!pool) throw Error('missing actual private pool');
     61   const controller = new AbortController();
     62   let composer: PrivateComposer | undefined;
     63   function bindComposer(newer = false) {
     64     const wire = reservedSendRumorWire(f.reserved);
     65     if (!wire) throw Error('missing genuine captured rumor');
     66     const content = (JSON.parse(wire) as { content: unknown }).content;
     67     composer = createPrivateComposer(f.identity, 'reviewed_private_composer');
     68     if (
     69       !composer ||
     70       !updatePrivateComposerText(composer, content, 'reviewed_private_text') ||
     71       !bindPrivateComposerPreparation(
     72         composer,
     73         f.reserved,
     74         f.preparation,
     75         undefined,
     76         'reviewed_composer_preparation'
     77       )
     78     )
     79       throw Error('missing genuine composer binding');
     80     if (
     81       newer &&
     82       !updatePrivateComposerText(
     83         composer,
     84         'HCP085_NEWER_PRIVATE_TEXT_MEMORY_ONLY',
     85         'reviewed_private_text'
     86       )
     87     )
     88       throw Error('newer text update failed');
     89     return {
     90       text: privateComposerText(composer),
     91       snapshot: privateComposerSnapshot(composer)
     92     };
     93   }
     94   function composerState() {
     95     return composer
     96       ? {
     97           text: privateComposerText(composer),
     98           snapshot: privateComposerSnapshot(composer)
     99         }
    100       : undefined;
    101   }
    102   async function prepare() {
    103     const self = await prepareSelfRecovery(
    104       f.preparation,
    105       'reviewed_self_recovery'
    106     );
    107     if (self.status !== 'saved') throw Error('missing self: ' + self.status);
    108     const pair = await preparePairedDelivery(
    109       f.preparation,
    110       f.context,
    111       'reviewed_pair_preparation'
    112     );
    113     if (pair.status !== 'prepared') throw Error('missing pair: ' + pair.status);
    114     return f.storedPair();
    115   }
    116   function permission(
    117     role: 'peer' | 'self_archive',
    118     origin = role === 'peer' ? peerOrigin : archiveOrigin,
    119     review: unknown = 'reviewed_private_delivery',
    120     action?: PrivatePublicationAction
    121   ) {
    122     const receipt = preparedPairedDelivery(f.preparation);
    123     return receipt
    124       ? capturePrivatePublication(
    125           f.repository,
    126           session!,
    127           receipt,
    128           f.context,
    129           role,
    130           origin,
    131           review,
    132           action
    133         )
    134       : undefined;
    135   }
    136   async function publish(
    137     token: PrivatePublication,
    138     signal = controller.signal
    139   ) {
    140     return publishPrivateGiftWrapAttempt(pool!, token, signal);
    141   }
    142   function action() {
    143     const receipt = preparedPairedDelivery(f.preparation);
    144     return receipt
    145       ? capturePrivatePublicationAction(
    146           f.repository,
    147           session!,
    148           receipt,
    149           f.context,
    150           'reviewed_private_retry'
    151         )
    152       : undefined;
    153   }
    154   function failAcquisition() {
    155     const original = Reflect.get<RelayPool, 'relay'>(
    156       RelayPool.prototype,
    157       'relay'
    158     );
    159     RelayPool.prototype.relay = function (origin) {
    160       if (new URL(origin).origin === peerOrigin)
    161         throw Error('controlled original SDK acquisition failure');
    162       return original.call(this, origin);
    163     };
    164     return () => {
    165       RelayPool.prototype.relay = original;
    166     };
    167   }
    168   function abortOnActualNetworkClock(abort: AbortController) {
    169     const original = performance.now.bind(performance);
    170     let observed = false;
    171     performance.now = () => {
    172       const value = original();
    173       if (!observed && /at clock \(/.test(new Error().stack ?? '')) {
    174         observed = true;
    175         abort.abort();
    176       }
    177       return value;
    178     };
    179     return {
    180       observed: () => observed,
    181       restore: () => {
    182         performance.now = original;
    183       }
    184     };
    185   }
    186   async function deliver(
    187     role: 'peer' | 'self_archive',
    188     origin = role === 'peer' ? peerOrigin : archiveOrigin
    189   ) {
    190     const receipt = preparedPairedDelivery(f.preparation);
    191     return receipt
    192       ? deliverPrivateSend(
    193           f.repository,
    194           session!,
    195           receipt,
    196           f.context,
    197           pool!,
    198           role,
    199           origin,
    200           'reviewed_private_delivery',
    201           controller.signal
    202         )
    203       : { status: 'invalid' as const };
    204   }
    205   async function remove() {
    206     const record = reservedSendSnapshot(f.reserved);
    207     if (!record) throw Error('missing command');
    208     const tx = browserDatabaseTransaction(
    209       f.database,
    210       ['private_sends'],
    211       'readwrite'
    212     );
    213     tx.objectStore('private_sends').delete([f.owner, record.id]);
    214     await new Promise<void>((resolve, reject) => {
    215       tx.addEventListener('complete', () => resolve());
    216       tx.addEventListener('abort', () =>
    217         reject(Error('fixture deletion aborted'))
    218       );
    219     });
    220   }
    221   let restore = () => {};
    222   function failReadback() {
    223     const cursor = Reflect.get<IDBIndex, 'openCursor'>(
    224       IDBIndex.prototype,
    225       'openCursor'
    226     );
    227     IDBIndex.prototype.openCursor = function (
    228       ...args: Parameters<IDBIndex['openCursor']>
    229     ) {
    230       if (this.objectStore.name === 'private_sends')
    231         throw Error('controlled actual private readback failure');
    232       return cursor.apply(this, args);
    233     };
    234     restore = () => {
    235       IDBIndex.prototype.openCursor = cursor;
    236     };
    237   }
    238   function readOrigins() {
    239     return new Promise<string[]>((resolve, reject) => {
    240       const seen = new Set<string>();
    241       try {
    242         subscribePrivatePage(pool!, 1, (message) => {
    243           if (message.type === 'candidate') seen.add(message.from);
    244           else if (message.reason === 'complete') resolve([...seen]);
    245           else reject(Error(message.reason));
    246         });
    247       } catch (error) {
    248         reject(
    249           error instanceof Error ? error : Error('fixture private read failed')
    250         );
    251       }
    252     });
    253   }
    254   return {
    255     ...f,
    256     session,
    257     pool,
    258     peerOrigin,
    259     archiveOrigin,
    260     prepare,
    261     prepareSelfOnly: () =>
    262       prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'),
    263     permission,
    264     action,
    265     failAcquisition,
    266     abortOnActualNetworkClock,
    267     publish,
    268     deliver,
    269     remove,
    270     failReadback,
    271     readOrigins,
    272     bindComposer,
    273     composerState,
    274     stop: () => controller.abort(),
    275     disconnect: () => disconnectIdentity(f.identity),
    276     close() {
    277       if (composer) closePrivateComposer(composer);
    278       restore();
    279       controller.abort();
    280       closePrivatePool(pool);
    281       closePrivateSession(session);
    282       f.close();
    283     }
    284   };
    285 }