app

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

resume-listing.ts (4535B)


      1 import { operationEnabled } from '../config/operation-flags.ts';
      2 import {
      3   publicPublicationOwner,
      4   readPublicListingIntent,
      5   type PublicPublicationRepository
      6 } from '../persistence/public-publications.ts';
      7 import {
      8   decodePublicRecord,
      9   publicRecordSnapshot
     10 } from '../persistence/records.ts';
     11 import { canonicalLocalId } from '../private-handles.ts';
     12 import {
     13   identityMessagingOwnership,
     14   recheckIdentityOwner,
     15   type IdentitySession
     16 } from '../runtime/identity-session.ts';
     17 import { publicRelayTargets, type RelayPolicy } from '../config/relays.ts';
     18 import { preferencePolicyFingerprint } from '../nostr/inbox-preference-publication.ts';
     19 import type { PublicPool } from '../nostr/public-pool.ts';
     20 import { beginListingRetry } from './retry-listing.ts';
     21 
     22 declare const resumeBrand: unique symbol;
     23 export type ListingResumption = Readonly<{ [resumeBrand]: true }>;
     24 type Ownership = Readonly<{
     25   repository: PublicPublicationRepository;
     26   identity: IdentitySession;
     27   policy: RelayPolicy;
     28   owner: string;
     29   command: string;
     30   recordWire: string;
     31   current(): boolean;
     32 }>;
     33 const resumptions = new WeakMap<ListingResumption, Ownership>();
     34 export function listingResumeOwnership(token: ListingResumption) {
     35   const original = resumptions.get(token);
     36   return original?.current() ? original : undefined;
     37 }
     38 export function listingResumeSnapshot(token: ListingResumption) {
     39   const original = listingResumeOwnership(token);
     40   if (!original) return;
     41   const decoded = decodePublicRecord(
     42     original.recordWire,
     43     original.owner,
     44     original.command
     45   );
     46   const row =
     47     decoded.ok &&
     48     publicRecordSnapshot(decoded.value, original.owner, original.command);
     49   if (!row || row.family !== 'public_operation' || !row.artifact) return;
     50   return {
     51     owner: row.owner,
     52     command: row.id,
     53     hash: row.artifact.eventId,
     54     wire: row.artifact.wire,
     55     targets: row.capture.targets.slice(),
     56     policyFingerprint: row.capture.policyFingerprint
     57   };
     58 }
     59 export async function prepareListingResume(
     60   repository: PublicPublicationRepository,
     61   identity: IdentitySession,
     62   policy: RelayPolicy,
     63   command: unknown,
     64   consent: unknown
     65 ): Promise<
     66   | Readonly<{ status: 'ready'; resume: ListingResumption }>
     67   | Readonly<{ status: 'invalid' | 'unavailable' | 'needs_action' }>
     68 > {
     69   const owner = publicPublicationOwner(repository),
     70     id = canonicalLocalId(command);
     71   if (
     72     !owner ||
     73     !id ||
     74     !identityMessagingOwnership(identity) ||
     75     consent !== 'reviewed_stored_listing_resume'
     76   )
     77     return { status: 'invalid' };
     78   if (typeof window === 'undefined' || !navigator.locks?.request)
     79     return { status: 'unavailable' };
     80   try {
     81     await recheckIdentityOwner(identity);
     82     const capture = identityMessagingOwnership(identity);
     83     if (!capture || capture.owner !== owner) return { status: 'needs_action' };
     84     const current = () =>
     85       capture.current() && publicPublicationOwner(repository) === owner;
     86     const read = await readPublicListingIntent(repository, id);
     87     const row =
     88       read.status === 'found' && publicRecordSnapshot(read.record, owner, id);
     89     const targets = publicRelayTargets(policy, 'write'),
     90       fingerprint = await preferencePolicyFingerprint(policy);
     91     if (
     92       !current() ||
     93       !row ||
     94       row.family !== 'public_operation' ||
     95       row.capture.kind !== 30402 ||
     96       !row.artifact ||
     97       row.revision < 2 ||
     98       !operationEnabled(policy, 'posting') ||
     99       fingerprint !== row.capture.policyFingerprint ||
    100       JSON.stringify(targets) !== JSON.stringify(row.capture.targets)
    101     )
    102       return { status: 'needs_action' };
    103     // Normalize receipt bookkeeping only. Every original capture field and the
    104     // independently verified stored signature remain exact; no signer is minted.
    105     const recordWire = JSON.stringify({ ...row, revision: 2, receipts: [] });
    106     if (!decodePublicRecord(recordWire, owner, id).ok || !current())
    107       return { status: 'needs_action' };
    108     const resume = Object.freeze({}) as ListingResumption;
    109     resumptions.set(resume, {
    110       repository,
    111       identity,
    112       policy,
    113       owner,
    114       command: id,
    115       recordWire,
    116       current
    117     });
    118     return { status: 'ready', resume };
    119   } catch {
    120     return { status: 'needs_action' };
    121   }
    122 }
    123 export function resumeListing(
    124   token: ListingResumption,
    125   pool: PublicPool,
    126   consent: unknown
    127 ) {
    128   const original = listingResumeOwnership(token);
    129   if (!original || consent !== 'resume_stored_listing') return;
    130   return beginListingRetry(token, pool, original.policy, consent);
    131 }