app

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

deliver-listing.ts (14224B)


      1 import { deliverListing } from '../../../src/lib/publishing/deliver-listing.ts';
      2 import {
      3   getPublicPool,
      4   closePublicPool
      5 } from '../../../src/lib/nostr/public-pool.ts';
      6 import {
      7   authorizeListingAttempt,
      8   withListingDeliveryOwnership,
      9   takeListingPublication
     10 } from '../../../src/lib/nostr/listing-publisher.ts';
     11 import {
     12   readRelayPolicy,
     13   validateRelayPolicy
     14 } from '../../../src/lib/config/relays.ts';
     15 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts';
     16 import {
     17   getPublicStore,
     18   insertPublicEnvelope,
     19   publicStoreEnvelope
     20 } from '../../../src/lib/nostr/public-store.ts';
     21 export { deliverListing, authorizeListingAttempt, takeListingPublication };
     22 import { makeFixture } from './approved-signing.ts';
     23 import { EventStore } from 'applesauce-core';
     24 import { getSeenRelays, type NostrEvent } from 'applesauce-core/helpers';
     25 import { fixturePolicy, discovery, inbox } from './inbox-setup.ts';
     26 import {
     27   createIdentitySession,
     28   connectIdentity,
     29   probeIdentityMessaging,
     30   disconnectIdentity
     31 } from '../../../src/lib/runtime/identity-session.ts';
     32 import {
     33   createPublicScheduler,
     34   createPublicRun,
     35   openInboxRequest,
     36   closePublicScheduler
     37 } from '../../../src/lib/nostr/request-scope.ts';
     38 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
     39 import {
     40   createInboxSetupView,
     41   checkInboxSetupView,
     42   unlockInboxSetupView,
     43   closeInboxSetupView
     44 } from '../../../src/lib/messaging/inbox-setup-view.ts';
     45 import { captureNewListingReadiness } from '../../../src/lib/publishing/new-listing-readiness.ts';
     46 import {
     47   openBrowserDatabase,
     48   closeBrowserDatabase
     49 } from '../../../src/lib/persistence/database.ts';
     50 import {
     51   createPublicPublicationRepository,
     52   publicPublicationDraftRepository,
     53   readPublicListingIntent
     54 } from '../../../src/lib/persistence/public-publications.ts';
     55 import {
     56   createPublicDraftController,
     57   closePublicDraftController
     58 } from '../../../src/lib/publishing/draft-controller.ts';
     59 import {
     60   reviewNewListing,
     61   reserveNewListing,
     62   listingReviewSnapshot
     63 } from '../../../src/lib/publishing/prepare-listing.ts';
     64 import { publicRecordSnapshot } from '../../../src/lib/persistence/records.ts';
     65 import {
     66   beginListingSigning,
     67   runListingSigning,
     68   listingPublicationSnapshot
     69 } from '../../../src/lib/publishing/sign-listing.ts';
     70 
     71 export async function createFixture() {
     72   const trace: string[] = [];
     73   const tracePut = Object.getOwnPropertyDescriptor(
     74       IDBObjectStore.prototype,
     75       'put'
     76     ),
     77     traceSend = Object.getOwnPropertyDescriptor(WebSocket.prototype, 'send');
     78   if (!tracePut) throw Error('native trace descriptors missing');
     79   const nativeTracePut = tracePut.value as IDBObjectStore['put'],
     80     nativeTraceSend = Reflect.get<WebSocket, 'send'>(
     81       WebSocket.prototype,
     82       'send'
     83     );
     84   Object.defineProperty(IDBObjectStore.prototype, 'put', {
     85     ...tracePut,
     86     value: function (
     87       this: IDBObjectStore,
     88       ...args: Parameters<IDBObjectStore['put']>
     89     ) {
     90       const value: unknown = args[0];
     91       if (
     92         this.name === 'public_operations' &&
     93         typeof value === 'object' &&
     94         value &&
     95         'wire' in value &&
     96         typeof value.wire === 'string'
     97       ) {
     98         const revision = (JSON.parse(value.wire) as { revision: number })
     99           .revision;
    100         this.transaction.addEventListener(
    101           'complete',
    102           () => trace.push('ack:' + revision),
    103           { once: true }
    104         );
    105       }
    106       return nativeTracePut.apply(this, args);
    107     }
    108   });
    109   Object.defineProperty(WebSocket.prototype, 'send', {
    110     configurable: true,
    111     writable: true,
    112     ...traceSend,
    113     value: function (this: WebSocket, ...args: Parameters<WebSocket['send']>) {
    114       if (
    115         typeof args[0] === 'string' &&
    116         (JSON.parse(args[0]) as unknown[])[0] === 'EVENT'
    117       )
    118         trace.push('EVENT');
    119       return nativeTraceSend.apply(this, args);
    120     }
    121   });
    122   const signer = makeFixture(10050),
    123     identity = createIdentitySession(),
    124     policy = fixturePolicy();
    125   const preference = signer.sign({
    126     ...signer.template,
    127     kind: 10050,
    128     created_at: 100,
    129     tags: [['relay', inbox]],
    130     content: ''
    131   });
    132   const prior = Object.getOwnPropertyDescriptor(window, 'nostr');
    133   let signs = 0,
    134     keys = 0,
    135     observedOwner = signer.owner;
    136   Object.defineProperty(window, 'nostr', {
    137     configurable: true,
    138     value: {
    139       getPublicKey: () => {
    140         keys++;
    141         return Promise.resolve(observedOwner);
    142       },
    143       signEvent: (input: Parameters<typeof signer.sign>[0]) => {
    144         signs++;
    145         return Promise.resolve(signer.sign(input));
    146       },
    147       nip44: {
    148         encrypt: (_peer: string, text: string) =>
    149           Promise.resolve('fixture:' + text),
    150         decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8))
    151       }
    152     }
    153   });
    154   await connectIdentity(identity);
    155   await probeIdentityMessaging(identity, 'reviewed_self_copy');
    156   const scheduler = createPublicScheduler({
    157     now: () => 0,
    158     schedule: () => () => {}
    159   });
    160   const run = createPublicRun(scheduler, policy);
    161   const resolver = createInboxResolver(
    162     run,
    163     signer.owner,
    164     (next) =>
    165       openInboxRequest(
    166         run,
    167         signer.owner,
    168         (sink) => {
    169           sink({
    170             type: 'EVENT',
    171             from: discovery,
    172             id: 'fixture',
    173             event: preference
    174           });
    175           sink({ type: 'EOSE', from: discovery, id: 'fixture' });
    176           return () => {};
    177         },
    178         next
    179       ),
    180     () => true
    181   );
    182   // HC_TEST_ONLY_QUALIFICATION_PORT: original SDK owners, controlled exercised
    183   // access observation; no real extension/operator/relay qualification.
    184   const setup = createInboxSetupView({
    185     identity,
    186     policy,
    187     lookup: () => Promise.resolve(resolver),
    188     observeAccess: (context) => ({
    189       ...context,
    190       readTargets: context.readTargets.slice(),
    191       archiveTargets: context.archiveTargets.slice(),
    192       receive: 'qualified_exercised',
    193       archive: 'qualified_exercised',
    194       current: () => true
    195     })
    196   });
    197   if (!setup) throw Error('original setup missing');
    198   await checkInboxSetupView(setup);
    199   await unlockInboxSetupView(setup);
    200   const ready = captureNewListingReadiness(
    201     identity,
    202     setup,
    203     'reviewed_new_listing_inbox'
    204   );
    205   if (!ready) throw Error('original readiness missing');
    206   const opened = await openBrowserDatabase();
    207   if (opened.state !== 'ready') throw Error(opened.reason);
    208   const database = opened.owner,
    209     repository = createPublicPublicationRepository(database, signer.owner);
    210   const drafts = repository && publicPublicationDraftRepository(repository);
    211   if (!repository || !drafts) throw Error('original repository missing');
    212   const originalRepository = repository;
    213   const controller = await createPublicDraftController(drafts, {
    214     title: 'Carrots',
    215     description: 'Exact signed description',
    216     location: 'Local farm',
    217     amount: '2',
    218     currency: 'USD',
    219     unit: 'kg',
    220     quantity: '',
    221     contactType: '',
    222     contactValue: ''
    223   });
    224   if (!controller) throw Error('original controller missing');
    225   const command = crypto.randomUUID();
    226   const reviewed = await reviewNewListing(
    227     repository,
    228     controller,
    229     ready,
    230     command,
    231     'reviewed_new_listing'
    232   );
    233   if (reviewed.status !== 'review') throw Error(reviewed.reason);
    234   const original = reviewed.review,
    235     preview = listingReviewSnapshot(original);
    236   if (!preview) throw Error('original preview missing');
    237   const reserved = await reserveNewListing(
    238     original,
    239     'publish_reviewed_listing'
    240   );
    241   if (reserved.status !== 'saved') throw Error(reserved.status);
    242   const signing = beginListingSigning(original, 'sign_reviewed_listing');
    243   if (!signing) throw Error('original signing missing');
    244   const originalSigning = signing;
    245   async function stored() {
    246     const read = await readPublicListingIntent(originalRepository, command);
    247     const row =
    248       read.status === 'found' &&
    249       publicRecordSnapshot(read.record, signer.owner, command);
    250     if (!row || row.family !== 'public_operation')
    251       throw Error('original stored command missing');
    252     return row;
    253   }
    254   function invoke() {
    255     return runListingSigning(originalSigning, 'sign_reviewed_listing');
    256   }
    257   const signed = await invoke();
    258   if (signed.status !== 'prepared') throw Error(signed.status);
    259   const publication = signed.publication,
    260     pool = getPublicPool(policy);
    261   if (!pool) throw Error('original public pool missing');
    262   return {
    263     owner: signer.owner,
    264     command,
    265     publication,
    266     pool,
    267     policy,
    268     async run(consent: unknown = 'publish_stored_listing') {
    269       const a = deliverListing(publication, pool, policy, consent),
    270         b = deliverListing(publication, pool, policy, consent);
    271       const result = await a,
    272         row = await stored();
    273       return {
    274         result,
    275         trace: trace.slice(),
    276         same: a === b,
    277         row,
    278         signs,
    279         keys,
    280         owner: signer.owner,
    281         expectedWire: listingPublicationSnapshot(publication)?.wire,
    282         originalCapture: row.capture.wire === preview.templateWire
    283       };
    284     },
    285     async read() {
    286       return await stored();
    287     },
    288     copied() {
    289       return deliverListing(
    290         { ...listingPublicationSnapshot(publication) } as typeof publication,
    291         pool,
    292         policy,
    293         'publish_stored_listing'
    294       );
    295     },
    296     async foreignTarget() {
    297       return await withListingDeliveryOwnership(
    298         publication,
    299         policy,
    300         'publish_stored_listing',
    301         async (lease) =>
    302           !!(await authorizeListingAttempt(
    303             lease,
    304             'wss://other.example.org',
    305             'publish'
    306           ))
    307       );
    308     },
    309     retargeted() {
    310       const manifest = readRelayPolicy(policy),
    311         changed = validateRelayPolicy(
    312           JSON.stringify({
    313             ...manifest,
    314             public: [
    315               {
    316                 origin: 'wss://other.example.org',
    317                 read: true,
    318                 write: true,
    319                 nip50: false
    320               }
    321             ]
    322           })
    323         );
    324       if (!changed) throw Error('changed fixture policy invalid');
    325       return deliverListing(
    326         publication,
    327         pool,
    328         changed,
    329         'publish_stored_listing'
    330       );
    331     },
    332     async cacheArtifact() {
    333       const row = await stored();
    334       const sdkStore = new EventStore();
    335       let seen: string[];
    336       try {
    337         sdkStore.add(JSON.parse(row.artifact!.wire) as NostrEvent, discovery);
    338         sdkStore.add(
    339           JSON.parse(row.artifact!.wire) as NostrEvent,
    340           'wss://other.example.org'
    341         );
    342         const merged = sdkStore.getEvent(row.artifact!.eventId);
    343         if (!merged) throw Error('actual SDK merge failed');
    344         seen = [...(getSeenRelays(merged) ?? [])].sort();
    345         if (seen.length !== 2)
    346           throw Error('actual SDK seen metadata not merged');
    347       } finally {
    348         sdkStore.dispose();
    349       }
    350       const verified = verifyEnvelope(row.artifact!.wire),
    351         store = getPublicStore();
    352       if (
    353         !verified.ok ||
    354         !store ||
    355         insertPublicEnvelope(store, verified.value) !== 'accepted' ||
    356         !publicStoreEnvelope(store, row.artifact!.eventId)
    357       )
    358         throw Error('actual shared public cache admission failed');
    359       return { id: row.artifact!.eventId, seen };
    360     },
    361     async receiptFault(unknown: boolean) {
    362       const put = Object.getOwnPropertyDescriptor(
    363           IDBObjectStore.prototype,
    364           'put'
    365         ),
    366         abort = Object.getOwnPropertyDescriptor(
    367           IDBTransaction.prototype,
    368           'abort'
    369         );
    370       if (!put || !abort) throw Error('native descriptors missing');
    371       const nativePut = put.value as IDBObjectStore['put'];
    372       let faultPuts = 0;
    373       Object.defineProperty(IDBObjectStore.prototype, 'put', {
    374         ...put,
    375         value: function (
    376           this: IDBObjectStore,
    377           ...args: Parameters<IDBObjectStore['put']>
    378         ) {
    379           const v: unknown = args[0];
    380           if (
    381             this.name === 'public_operations' &&
    382             typeof v === 'object' &&
    383             v &&
    384             'wire' in v &&
    385             typeof v.wire === 'string' &&
    386             (JSON.parse(v.wire) as { revision: number }).revision === 3
    387           ) {
    388             faultPuts++;
    389             if (unknown) {
    390               nativePut.apply(this, args);
    391               throw Error(
    392                 'HC_TEST_ONLY real receipt put lost JS acknowledgement'
    393               );
    394             }
    395             this.transaction.abort();
    396             throw Error('HC_TEST_ONLY definite receipt abort');
    397           }
    398           return nativePut.apply(this, args);
    399         }
    400       });
    401       if (unknown)
    402         Object.defineProperty(IDBTransaction.prototype, 'abort', {
    403           ...abort,
    404           value() {
    405             throw Error('HC_TEST_ONLY unavailable abort channel');
    406           }
    407         });
    408       try {
    409         const result = await deliverListing(
    410             publication,
    411             pool,
    412             policy,
    413             'publish_stored_listing'
    414           ),
    415           row = await stored();
    416         return { result, row, signs, faultPuts };
    417       } finally {
    418         Object.defineProperty(IDBObjectStore.prototype, 'put', put);
    419         Object.defineProperty(IDBTransaction.prototype, 'abort', abort);
    420       }
    421     },
    422     logout() {
    423       disconnectIdentity(identity);
    424     },
    425     stop() {
    426       closeInboxSetupView(setup);
    427     },
    428     changeKey() {
    429       const other = makeFixture(10050);
    430       observedOwner = other.owner;
    431       other.close();
    432     },
    433     close() {
    434       closePublicPool(pool);
    435       closePublicDraftController(controller);
    436       closeBrowserDatabase(database);
    437       closeInboxSetupView(setup);
    438       disconnectIdentity(identity);
    439       closePublicScheduler(scheduler);
    440       signer.close();
    441       if (prior) Object.defineProperty(window, 'nostr', prior);
    442       else Reflect.deleteProperty(window, 'nostr');
    443       Object.defineProperty(IDBObjectStore.prototype, 'put', tracePut);
    444       if (traceSend)
    445         Object.defineProperty(WebSocket.prototype, 'send', traceSend);
    446       else Reflect.deleteProperty(WebSocket.prototype, 'send');
    447     }
    448   };
    449 }