app

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

retry-listing.ts (17019B)


      1 export const secondOrigin = 'wss://second.example.org';
      2 function retryPolicy(twoTargets = false, changed = false) {
      3   const manifest = readRelayPolicy(fixturePolicy());
      4   const policy = validateRelayPolicy(
      5     JSON.stringify({
      6       ...manifest,
      7       public: twoTargets
      8         ? [
      9             ...manifest.public,
     10             {
     11               origin: changed ? 'wss://changed.example.org' : secondOrigin,
     12               read: true,
     13               write: true,
     14               nip50: false
     15             }
     16           ]
     17         : manifest.public
     18     })
     19   );
     20   if (!policy) throw Error('controlled policy invalid');
     21   return policy;
     22 }
     23 import { deliverListing } from '../../../src/lib/publishing/deliver-listing.ts';
     24 import {
     25   getPublicPool,
     26   closePublicPool
     27 } from '../../../src/lib/nostr/public-pool.ts';
     28 import {
     29   readRelayPolicy,
     30   publicRelayTargets,
     31   validateRelayPolicy
     32 } from '../../../src/lib/config/relays.ts';
     33 import {
     34   beginListingRetry,
     35   listingRetryResult,
     36   stopListingRetry,
     37   type ListingRetry
     38 } from '../../../src/lib/publishing/retry-listing.ts';
     39 import {
     40   prepareListingResume,
     41   resumeListing,
     42   listingResumeSnapshot
     43 } from '../../../src/lib/publishing/resume-listing.ts';
     44 import { makeFixture } from './approved-signing.ts';
     45 import { fixturePolicy, discovery, inbox } from './inbox-setup.ts';
     46 import {
     47   createIdentitySession,
     48   connectIdentity,
     49   probeIdentityMessaging,
     50   disconnectIdentity
     51 } from '../../../src/lib/runtime/identity-session.ts';
     52 import {
     53   createPublicScheduler,
     54   createPublicRun,
     55   openInboxRequest,
     56   closePublicScheduler
     57 } from '../../../src/lib/nostr/request-scope.ts';
     58 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
     59 import {
     60   createInboxSetupView,
     61   checkInboxSetupView,
     62   unlockInboxSetupView,
     63   closeInboxSetupView
     64 } from '../../../src/lib/messaging/inbox-setup-view.ts';
     65 import { captureNewListingReadiness } from '../../../src/lib/publishing/new-listing-readiness.ts';
     66 import {
     67   openBrowserDatabase,
     68   closeBrowserDatabase
     69 } from '../../../src/lib/persistence/database.ts';
     70 import {
     71   createPublicPublicationRepository,
     72   publicPublicationDraftRepository,
     73   readPublicListingIntent
     74 } from '../../../src/lib/persistence/public-publications.ts';
     75 import {
     76   createPublicDraftController,
     77   closePublicDraftController
     78 } from '../../../src/lib/publishing/draft-controller.ts';
     79 import {
     80   reviewNewListing,
     81   reserveNewListing,
     82   listingReviewSnapshot
     83 } from '../../../src/lib/publishing/prepare-listing.ts';
     84 import { publicRecordSnapshot } from '../../../src/lib/persistence/records.ts';
     85 import {
     86   beginListingSigning,
     87   runListingSigning,
     88   listingPublicationSnapshot
     89 } from '../../../src/lib/publishing/sign-listing.ts';
     90 
     91 export async function createFixture(twoTargets = false) {
     92   const trace: string[] = [];
     93   const tracePut = Object.getOwnPropertyDescriptor(
     94       IDBObjectStore.prototype,
     95       'put'
     96     ),
     97     traceSend = Object.getOwnPropertyDescriptor(WebSocket.prototype, 'send');
     98   if (!tracePut) throw Error('native trace descriptors missing');
     99   const nativeTracePut = tracePut.value as IDBObjectStore['put'],
    100     nativeTraceSend = Reflect.get<WebSocket, 'send'>(
    101       WebSocket.prototype,
    102       'send'
    103     );
    104   Object.defineProperty(IDBObjectStore.prototype, 'put', {
    105     ...tracePut,
    106     value: function (
    107       this: IDBObjectStore,
    108       ...args: Parameters<IDBObjectStore['put']>
    109     ) {
    110       const value: unknown = args[0];
    111       if (
    112         this.name === 'public_operations' &&
    113         typeof value === 'object' &&
    114         value &&
    115         'wire' in value &&
    116         typeof value.wire === 'string'
    117       ) {
    118         const revision = (JSON.parse(value.wire) as { revision: number })
    119           .revision;
    120         this.transaction.addEventListener(
    121           'complete',
    122           () => trace.push('ack:' + revision),
    123           { once: true }
    124         );
    125       }
    126       return nativeTracePut.apply(this, args);
    127     }
    128   });
    129   Object.defineProperty(WebSocket.prototype, 'send', {
    130     configurable: true,
    131     writable: true,
    132     ...traceSend,
    133     value: function (this: WebSocket, ...args: Parameters<WebSocket['send']>) {
    134       if (
    135         typeof args[0] === 'string' &&
    136         (JSON.parse(args[0]) as unknown[])[0] === 'EVENT'
    137       )
    138         trace.push('EVENT');
    139       return nativeTraceSend.apply(this, args);
    140     }
    141   });
    142   const signer = makeFixture(10050),
    143     identity = createIdentitySession(),
    144     policy = retryPolicy(twoTargets);
    145   const preference = signer.sign({
    146     ...signer.template,
    147     kind: 10050,
    148     created_at: 100,
    149     tags: [['relay', inbox]],
    150     content: ''
    151   });
    152   const prior = Object.getOwnPropertyDescriptor(window, 'nostr');
    153   let signs = 0,
    154     keys = 0;
    155   const observedOwner = signer.owner;
    156   Object.defineProperty(window, 'nostr', {
    157     configurable: true,
    158     value: {
    159       getPublicKey: () => {
    160         keys++;
    161         return Promise.resolve(observedOwner);
    162       },
    163       signEvent: (input: Parameters<typeof signer.sign>[0]) => {
    164         signs++;
    165         return Promise.resolve(signer.sign(input));
    166       },
    167       nip44: {
    168         encrypt: (_peer: string, text: string) =>
    169           Promise.resolve('fixture:' + text),
    170         decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8))
    171       }
    172     }
    173   });
    174   await connectIdentity(identity);
    175   await probeIdentityMessaging(identity, 'reviewed_self_copy');
    176   const scheduler = createPublicScheduler({
    177     now: () => 0,
    178     schedule: () => () => {}
    179   });
    180   const run = createPublicRun(scheduler, policy);
    181   const resolver = createInboxResolver(
    182     run,
    183     signer.owner,
    184     (next) =>
    185       openInboxRequest(
    186         run,
    187         signer.owner,
    188         (sink) => {
    189           sink({
    190             type: 'EVENT',
    191             from: discovery,
    192             id: 'fixture',
    193             event: preference
    194           });
    195           for (const origin of publicRelayTargets(policy, 'read'))
    196             sink({ type: 'EOSE', from: origin, id: 'fixture' });
    197           return () => {};
    198         },
    199         next
    200       ),
    201     () => true
    202   );
    203   // HC_TEST_ONLY_QUALIFICATION_PORT: original SDK owners, controlled exercised
    204   // access observation; no real extension/operator/relay qualification.
    205   const setup = createInboxSetupView({
    206     identity,
    207     policy,
    208     lookup: () => Promise.resolve(resolver),
    209     observeAccess: (context) => ({
    210       ...context,
    211       readTargets: context.readTargets.slice(),
    212       archiveTargets: context.archiveTargets.slice(),
    213       receive: 'qualified_exercised',
    214       archive: 'qualified_exercised',
    215       current: () => true
    216     })
    217   });
    218   if (!setup) throw Error('original setup missing');
    219   await checkInboxSetupView(setup);
    220   await unlockInboxSetupView(setup);
    221   const ready = captureNewListingReadiness(
    222     identity,
    223     setup,
    224     'reviewed_new_listing_inbox'
    225   );
    226   if (!ready) throw Error('original readiness missing');
    227   const opened = await openBrowserDatabase();
    228   if (opened.state !== 'ready') throw Error(opened.reason);
    229   const database = opened.owner,
    230     repository = createPublicPublicationRepository(database, signer.owner);
    231   const drafts = repository && publicPublicationDraftRepository(repository);
    232   if (!repository || !drafts) throw Error('original repository missing');
    233   const originalRepository = repository;
    234   const controller = await createPublicDraftController(drafts, {
    235     title: 'Carrots',
    236     description: 'Exact signed description',
    237     location: 'Local farm',
    238     amount: '2',
    239     currency: 'USD',
    240     unit: 'kg',
    241     quantity: '',
    242     contactType: '',
    243     contactValue: ''
    244   });
    245   if (!controller) throw Error('original controller missing');
    246   const command = crypto.randomUUID();
    247   const reviewed = await reviewNewListing(
    248     repository,
    249     controller,
    250     ready,
    251     command,
    252     'reviewed_new_listing'
    253   );
    254   if (reviewed.status !== 'review') throw Error(reviewed.reason);
    255   const original = reviewed.review,
    256     preview = listingReviewSnapshot(original);
    257   if (!preview) throw Error('original preview missing');
    258   const reserved = await reserveNewListing(
    259     original,
    260     'publish_reviewed_listing'
    261   );
    262   if (reserved.status !== 'saved') throw Error(reserved.status);
    263   const signing = beginListingSigning(original, 'sign_reviewed_listing');
    264   if (!signing) throw Error('original signing missing');
    265   const originalSigning = signing;
    266   async function stored() {
    267     const read = await readPublicListingIntent(originalRepository, command);
    268     const row =
    269       read.status === 'found' &&
    270       publicRecordSnapshot(read.record, signer.owner, command);
    271     if (!row || row.family !== 'public_operation')
    272       throw Error('original stored command missing');
    273     return row;
    274   }
    275   function invoke() {
    276     return runListingSigning(originalSigning, 'sign_reviewed_listing');
    277   }
    278   const signed = await invoke();
    279   if (signed.status !== 'prepared') throw Error(signed.status);
    280   const publication = signed.publication,
    281     pool = getPublicPool(policy);
    282   if (!pool) throw Error('original public pool missing');
    283   const cleanupPool = pool;
    284   let control: ListingRetry | undefined;
    285   let closed = false;
    286   function close() {
    287     if (closed) return;
    288     closed = true;
    289     if (control) stopListingRetry(control);
    290     closePublicPool(cleanupPool);
    291     if (controller) closePublicDraftController(controller);
    292     closeBrowserDatabase(database);
    293     closeInboxSetupView(setup);
    294     disconnectIdentity(identity);
    295     closePublicScheduler(scheduler);
    296     signer.close();
    297     if (prior) Object.defineProperty(window, 'nostr', prior);
    298     else Reflect.deleteProperty(window, 'nostr');
    299     if (tracePut)
    300       Object.defineProperty(IDBObjectStore.prototype, 'put', tracePut);
    301     else Reflect.deleteProperty(IDBObjectStore.prototype, 'put');
    302     if (traceSend)
    303       Object.defineProperty(WebSocket.prototype, 'send', traceSend);
    304     else Reflect.deleteProperty(WebSocket.prototype, 'send');
    305   }
    306   return {
    307     owner: signer.owner,
    308     command,
    309     policy,
    310     async details() {
    311       const row = await stored();
    312       return {
    313         row,
    314         signs,
    315         keys,
    316         trace: trace.slice(),
    317         wire: listingPublicationSnapshot(publication)?.wire
    318       };
    319     },
    320     start() {
    321       control = beginListingRetry(
    322         publication,
    323         pool,
    324         policy,
    325         'retry_stored_listing'
    326       );
    327       return !!control;
    328     },
    329     async result() {
    330       if (!control) throw Error('original retry missing');
    331       return await listingRetryResult(control);
    332     },
    333     stop() {
    334       if (control) stopListingRetry(control);
    335     },
    336     copiedStop() {
    337       if (control) stopListingRetry({ ...control });
    338     },
    339     async initial() {
    340       return await deliverListing(
    341         publication,
    342         pool,
    343         policy,
    344         'publish_stored_listing'
    345       );
    346     },
    347     close
    348   };
    349 }
    350 export async function openResumeFixture(
    351   owner: string,
    352   command: string,
    353   twoTargets = false,
    354   changed = false
    355 ) {
    356   const prior = Object.getOwnPropertyDescriptor(window, 'nostr');
    357   let observedOwner = owner,
    358     signs = 0,
    359     keys = 0,
    360     heldKeys = 0,
    361     completed = false;
    362   let keyHold: Promise<string> | undefined, release: (() => void) | undefined;
    363   Object.defineProperty(window, 'nostr', {
    364     configurable: true,
    365     value: {
    366       getPublicKey() {
    367         keys++;
    368         if (keyHold) heldKeys++;
    369         return keyHold ?? Promise.resolve(observedOwner);
    370       },
    371       signEvent() {
    372         signs++;
    373         return Promise.reject(
    374           Error(
    375             'HC_TEST_ONLY resumed artifact must never request another signature'
    376           )
    377         );
    378       },
    379       nip44: {
    380         encrypt: (_peer: string, text: string) =>
    381           Promise.resolve('fixture:' + text),
    382         decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8))
    383       }
    384     }
    385   });
    386   const identity = createIdentitySession();
    387   await connectIdentity(identity);
    388   await probeIdentityMessaging(identity, 'reviewed_self_copy');
    389   const opened = await openBrowserDatabase();
    390   if (opened.state !== 'ready') throw Error(opened.reason);
    391   const database = opened.owner,
    392     repository = createPublicPublicationRepository(database, owner),
    393     policy = retryPolicy(twoTargets, changed),
    394     pool = getPublicPool(policy);
    395   if (!repository || !pool) throw Error('actual reopened custody missing');
    396   const originalRepository = repository,
    397     originalPool = pool;
    398   let heldReadAcknowledgements = 0;
    399   let releaseRead = () => {};
    400   let restoreReadListener = () => {};
    401   function holdNextNativeReadAcknowledgement() {
    402     const prototype = IDBTransaction.prototype;
    403     const descriptor = Object.getOwnPropertyDescriptor(
    404       prototype,
    405       'addEventListener'
    406     );
    407     const nativeDescriptor =
    408       descriptor ??
    409       Object.getOwnPropertyDescriptor(
    410         EventTarget.prototype,
    411         'addEventListener'
    412       );
    413     if (!nativeDescriptor)
    414       throw Error('native event registration descriptor missing');
    415     const native = nativeDescriptor.value as IDBTransaction['addEventListener'];
    416     restoreReadListener = () => {
    417       if (descriptor)
    418         Object.defineProperty(prototype, 'addEventListener', descriptor);
    419       else Reflect.deleteProperty(prototype, 'addEventListener');
    420     };
    421     prototype.addEventListener = function (
    422       type: string,
    423       listener: EventListenerOrEventListenerObject,
    424       options?: boolean | AddEventListenerOptions
    425     ) {
    426       if (
    427         type !== 'complete' ||
    428         !listener ||
    429         this.mode !== 'readonly' ||
    430         !this.objectStoreNames.contains('public_operations')
    431       )
    432         return native.call(this, type, listener, options);
    433       restoreReadListener();
    434       return native.call(
    435         this,
    436         type,
    437         function (event: Event) {
    438           const transaction = event.currentTarget;
    439           if (!(transaction instanceof IDBTransaction))
    440             throw Error('native completion target missing');
    441           heldReadAcknowledgements++;
    442           let released = false;
    443           releaseRead = () => {
    444             if (released) return;
    445             released = true;
    446             if (typeof listener === 'function')
    447               listener.call(transaction, event);
    448             else listener.handleEvent(event);
    449           };
    450         },
    451         options
    452       );
    453     };
    454   }
    455   let control: ListingRetry | undefined;
    456   async function read() {
    457     const got = await readPublicListingIntent(originalRepository, command);
    458     const row =
    459       got.status === 'found' &&
    460       publicRecordSnapshot(got.record, owner, command);
    461     if (!row || row.family !== 'public_operation')
    462       throw Error('reopened original operation missing');
    463     return row;
    464   }
    465   return {
    466     async start(
    467       consent: unknown = 'resume_stored_listing',
    468       holdAfterPrepare = false,
    469       holdReadAfterPrepare = false
    470     ) {
    471       const prepared = await prepareListingResume(
    472         originalRepository,
    473         identity,
    474         policy,
    475         command,
    476         'reviewed_stored_listing_resume'
    477       );
    478       if (prepared.status !== 'ready') return prepared.status;
    479       if (holdReadAfterPrepare) holdNextNativeReadAcknowledgement();
    480       if (holdAfterPrepare)
    481         keyHold = new Promise<string>((resolve) => {
    482           release = () => resolve(observedOwner);
    483         });
    484       control = resumeListing(prepared.resume, originalPool, consent);
    485       if (control) {
    486         completed = false;
    487         void listingRetryResult(control).then(() => {
    488           completed = true;
    489         });
    490       }
    491       return control ? 'started' : 'invalid';
    492     },
    493     async preview() {
    494       const p = await prepareListingResume(
    495         originalRepository,
    496         identity,
    497         policy,
    498         command,
    499         'reviewed_stored_listing_resume'
    500       );
    501       return p.status === 'ready' ? listingResumeSnapshot(p.resume) : p;
    502     },
    503     async result() {
    504       if (!control) throw Error('original resume missing');
    505       return await listingRetryResult(control);
    506     },
    507     stop() {
    508       if (control) stopListingRetry(control);
    509     },
    510     copiedStop() {
    511       if (control) stopListingRetry({ ...control });
    512     },
    513     holdKey() {
    514       keyHold = new Promise<string>((resolve) => {
    515         release = () => resolve(observedOwner);
    516       });
    517     },
    518     releaseKey() {
    519       release?.();
    520       keyHold = undefined;
    521     },
    522     heldReadCount() {
    523       return heldReadAcknowledgements;
    524     },
    525     releaseRead() {
    526       releaseRead();
    527       restoreReadListener();
    528     },
    529     changeKey() {
    530       const other = makeFixture(10050);
    531       observedOwner = other.owner;
    532       other.close();
    533     },
    534     logout() {
    535       disconnectIdentity(identity);
    536     },
    537     async details() {
    538       return { row: await read(), signs, keys, heldKeys, completed };
    539     },
    540     close() {
    541       if (control) stopListingRetry(control);
    542       release?.();
    543       releaseRead();
    544       restoreReadListener();
    545       closePublicPool(originalPool);
    546       closeBrowserDatabase(database);
    547       disconnectIdentity(identity);
    548       if (prior) Object.defineProperty(window, 'nostr', prior);
    549       else Reflect.deleteProperty(window, 'nostr');
    550     }
    551   };
    552 }