app

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

public-store.ts (5906B)


      1 import { EventStore, type EventStoreOptions } from 'applesauce-core';
      2 import {
      3   verifyEnvelope,
      4   verifiedEnvelopeSnapshot,
      5   type VerifiedEnvelope
      6 } from './verified-envelope.ts';
      7 import type { NostrEvent } from 'applesauce-core/helpers';
      8 import { isPublicEnvelopeKind } from './public-kinds.ts';
      9 export { isPublicEnvelopeKind } from './public-kinds.ts';
     10 import {
     11   createPublicRetention,
     12   retainPublicEnvelope,
     13   publicRetentionEnvelope,
     14   publicRetentionSnapshot,
     15   publicRetentionKnown,
     16   closePublicRetention,
     17   type RetentionSnapshot,
     18   type KnownPublicEvidence
     19 } from '../catalog/retention.ts';
     20 import type { PublicHead } from '../catalog/heads.ts';
     21 
     22 declare const ownedStore: unique symbol;
     23 export type PublicStore = Readonly<{ readonly [ownedStore]: true }>;
     24 interface Owner {
     25   readonly closed: () => boolean;
     26   readonly insert: (
     27     token: VerifiedEnvelope
     28   ) =>
     29     'accepted' | 'duplicate' | 'not_public' | 'rejected' | 'limit' | 'closed';
     30   readonly envelope: (id: string) => VerifiedEnvelope | undefined;
     31   readonly versions: (
     32     kind: number,
     33     pubkey: string,
     34     identifier: string
     35   ) => readonly VerifiedEnvelope[];
     36   readonly retention: () => RetentionSnapshot;
     37   readonly known: (head: PublicHead) => KnownPublicEvidence;
     38   readonly close: () => void;
     39 }
     40 const owners = new WeakMap<PublicStore, Owner>();
     41 let lifetime: PublicStore | undefined;
     42 
     43 function signedFields(event: NostrEvent): NostrEvent {
     44   return {
     45     id: event.id,
     46     pubkey: event.pubkey,
     47     kind: event.kind,
     48     created_at: event.created_at,
     49     tags: event.tags.map((tag) => [...tag]),
     50     content: event.content,
     51     sig: event.sig
     52   };
     53 }
     54 // Only fresh signed fields cross SDK verification: verified/cache/decrypt/relay
     55 // symbols and unprocessed extra metadata are never verification or cache proof.
     56 function verifyStoredEvent(event: NostrEvent): boolean {
     57   return verifyEnvelope(JSON.stringify(signedFields(event))).ok;
     58 }
     59 const options: Readonly<EventStoreOptions> & {
     60   readonly verifyEvent: typeof verifyStoredEvent;
     61 } = {
     62   keepOldVersions: true,
     63   keepDeleted: true,
     64   keepExpired: true,
     65   verifyEvent: verifyStoredEvent
     66 };
     67 // Import/SSR is inert. The private SDK instance and mutable verifier setter are
     68 // never exposed; acquisition accepts no caller options or private session state.
     69 export function getPublicStore(): PublicStore | undefined {
     70   if (typeof window === 'undefined') return undefined;
     71   if (lifetime) {
     72     if (ownerOf(lifetime).closed()) throw new Error('public_store_closed');
     73     return lifetime;
     74   }
     75   const sdk = new EventStore(options);
     76   const retention = createPublicRetention();
     77   let closed = false;
     78   const owner: Owner = {
     79     closed: () => closed,
     80     insert(token) {
     81       if (closed) return 'closed';
     82       const snapshot = verifiedEnvelopeSnapshot(token);
     83       if (!snapshot) return 'rejected';
     84       // This application's approved public inventory. Private wrappers, inner
     85       // plaintext and connection AUTH belong to separate owners, never here.
     86       if (!isPublicEnvelopeKind(snapshot.kind)) return 'not_public';
     87       const event = signedFields(snapshot);
     88       const sanitized = verifyEnvelope(JSON.stringify(event));
     89       if (!sanitized.ok) return 'rejected';
     90       // Kind5 is retained proof without activating SDK DeleteManager.
     91       // Admission reserves bounded coherent evidence BEFORE SDK installation.
     92       return retainPublicEnvelope(
     93         retention,
     94         sanitized.value,
     95         () => event.kind === 5 || sdk.add(event) !== null
     96       );
     97     },
     98     envelope(id) {
     99       return closed ? undefined : publicRetentionEnvelope(retention, id);
    100     },
    101     versions(kind, pubkey, identifier) {
    102       if (closed || publicRetentionSnapshot(retention).stopped) return [];
    103       return (
    104         sdk.getReplaceableHistory(kind, pubkey, identifier) ?? []
    105       ).flatMap((event) => {
    106         const proof = publicRetentionEnvelope(retention, event.id);
    107         return proof ? [proof] : [];
    108       });
    109     },
    110     retention: () => publicRetentionSnapshot(retention),
    111     known: (head) => publicRetentionKnown(retention, head),
    112     close() {
    113       if (closed) return;
    114       closed = true;
    115       closePublicRetention(retention);
    116       try {
    117         sdk.dispose();
    118       } finally {
    119         // Remove the owner's closures retaining the SDK and its signed data.
    120         // Terminal disposal is not a JavaScript secure-memory-erasure claim.
    121         const final = publicRetentionSnapshot(retention);
    122         owners.set(token, {
    123           closed: () => true,
    124           insert: () => 'closed',
    125           envelope: () => undefined,
    126           versions: () => [],
    127           retention: () => ({ ...final }),
    128           known: (head) => ({ head, requests: [] }),
    129           close: () => undefined
    130         });
    131       }
    132     }
    133   };
    134   const token = Object.freeze({}) as PublicStore;
    135   owners.set(token, owner);
    136   lifetime = token;
    137   return token;
    138 }
    139 function ownerOf(token: PublicStore): Owner {
    140   const owner = owners.get(token);
    141   if (!owner) throw new Error('public_store_invalid');
    142   return owner;
    143 }
    144 export function insertPublicEnvelope(
    145   owner: PublicStore,
    146   token: VerifiedEnvelope
    147 ): ReturnType<Owner['insert']> {
    148   return ownerOf(owner).insert(token);
    149 }
    150 export function publicStoreEnvelope(
    151   owner: PublicStore,
    152   id: string
    153 ): VerifiedEnvelope | undefined {
    154   return ownerOf(owner).envelope(id);
    155 }
    156 export function publicStoreVersions(
    157   owner: PublicStore,
    158   kind: number,
    159   pubkey: string,
    160   identifier: string
    161 ): readonly VerifiedEnvelope[] {
    162   return ownerOf(owner).versions(kind, pubkey, identifier);
    163 }
    164 export function closePublicStore(owner: PublicStore): void {
    165   ownerOf(owner).close();
    166 }
    167 
    168 export function publicStoreRetention(owner: PublicStore): RetentionSnapshot {
    169   return ownerOf(owner).retention();
    170 }
    171 export function publicStoreKnownEvidence(
    172   owner: PublicStore,
    173   head: PublicHead
    174 ): KnownPublicEvidence {
    175   return ownerOf(owner).known(head);
    176 }