app

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

private-store.ts (5220B)


      1 import {
      2   privateSessionOwnership,
      3   subscribePrivateSessionClose,
      4   type PrivateSession
      5 } from '../runtime/private-session.ts';
      6 import {
      7   getPrivateCacheScope,
      8   retainPrivateCacheWire,
      9   privateCacheWire,
     10   privateCacheSnapshot,
     11   closePrivateCacheScope
     12 } from '../nostr/private-cache-scope.ts';
     13 import {
     14   verifyEnvelope,
     15   verifiedEnvelopeSnapshot,
     16   type VerifiedEnvelope
     17 } from '../nostr/verified-envelope.ts';
     18 import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts';
     19 import { PRIVATE_TRANSPORT_BUDGETS } from '../config/budgets.ts';
     20 
     21 declare const storeBrand: unique symbol;
     22 export type PrivateStore = Readonly<{ [storeBrand]: true }>;
     23 type Snapshot = Readonly<{ closed: boolean; count: number; bytes: number }>;
     24 type Result = 'accepted' | 'duplicate' | 'rejected' | 'limit' | 'closed';
     25 type Controller = {
     26   insert(token: VerifiedEnvelope): Result;
     27   envelope(id: string): VerifiedEnvelope | undefined;
     28   snapshot(): Snapshot;
     29   close(): void;
     30 };
     31 const stores = new WeakMap<PrivateStore, Controller>();
     32 const sessions = new WeakMap<PrivateSession, PrivateStore>();
     33 // Only raw signed ciphertext is exposed now. Generic private memory ownership
     34 // is not plaintext admission: seal/rumor/room proofs and projection consumers
     35 // remain with the later validation owners. No public EventStore or shared SDK
     36 // memoized decrypt cache ever receives these objects.
     37 export function getPrivateStore(
     38   session: PrivateSession
     39 ): PrivateStore | undefined {
     40   if (typeof window === 'undefined') return undefined;
     41   const observed = privateSessionOwnership(session);
     42   if (!observed) throw new Error('private_session_invalid');
     43   const capture = observed;
     44   const prior = sessions.get(session);
     45   if (prior) {
     46     if (controller(prior).snapshot().closed)
     47       throw new Error('private_store_closed');
     48     return prior;
     49   }
     50   const selectedCache = getPrivateCacheScope(session, 'raw_ciphertext');
     51   if (!selectedCache) return undefined;
     52   const cache = selectedCache;
     53   const token = Object.freeze({}) as PrivateStore;
     54   let closed = false;
     55   let off = () => {};
     56   function close() {
     57     if (closed) return;
     58     closed = true;
     59     closePrivateCacheScope(cache);
     60     off();
     61     stores.set(token, {
     62       insert: () => 'closed',
     63       envelope: () => undefined,
     64       snapshot: () => ({ closed: true, count: 0, bytes: 0 }),
     65       close: () => {}
     66     });
     67   }
     68   function current() {
     69     if (closed || !capture.current() || privateCacheSnapshot(cache).closed) {
     70       close();
     71       return false;
     72     }
     73     return true;
     74   }
     75   function admitted(
     76     proof: VerifiedEnvelope
     77   ):
     78     | Readonly<{ id: string; wire: string; proof: VerifiedEnvelope }>
     79     | undefined {
     80     const event = verifiedEnvelopeSnapshot(proof);
     81     if (
     82       !event ||
     83       event.kind !== 1059 ||
     84       event.tags.length !== 1 ||
     85       event.tags[0].length !== 2 ||
     86       event.tags[0][0] !== 'p' ||
     87       event.tags[0][1] !== capture.owner
     88     )
     89       return undefined;
     90     const wire = JSON.stringify({
     91       id: event.id,
     92       pubkey: event.pubkey,
     93       kind: event.kind,
     94       created_at: event.created_at,
     95       tags: event.tags.map((tag) => [...tag]),
     96       content: event.content,
     97       sig: event.sig
     98     });
     99     if (!boundedUtf8(wire, PRIVATE_TRANSPORT_BUDGETS.envelopeBytes))
    100       return undefined;
    101     const checked = verifyEnvelope(wire);
    102     return checked.ok
    103       ? { id: event.id, wire, proof: checked.value }
    104       : undefined;
    105   }
    106   stores.set(token, {
    107     insert(proof) {
    108       if (!current()) return 'closed';
    109       const accepted = admitted(proof);
    110       if (!accepted) return 'rejected';
    111       if (!current()) return 'closed';
    112       const result = retainPrivateCacheWire(cache, accepted.id, accepted.wire);
    113       return result === 'conflict' ? 'rejected' : result;
    114     },
    115     envelope(id) {
    116       if (!current()) return undefined;
    117       const raw = privateCacheWire(cache, id);
    118       if (raw === undefined) return undefined;
    119       // Internal memory ownership never substitutes for actual signed admission.
    120       const checked = verifyEnvelope(raw);
    121       if (!checked.ok) return undefined;
    122       const accepted = admitted(checked.value);
    123       return accepted?.id === id && current() ? accepted.proof : undefined;
    124     },
    125     snapshot: () =>
    126       current()
    127         ? privateCacheSnapshot(cache)
    128         : { closed: true, count: 0, bytes: 0 },
    129     close
    130   });
    131   sessions.set(session, token);
    132   off = subscribePrivateSessionClose(session, close);
    133   if (!current()) {
    134     close();
    135     throw new Error('private_session_invalid');
    136   }
    137   return token;
    138 }
    139 function controller(store: PrivateStore): Controller {
    140   const state = stores.get(store);
    141   if (!state) throw new Error('private_store_invalid');
    142   return state;
    143 }
    144 export function insertPrivateEnvelope(
    145   store: PrivateStore,
    146   proof: VerifiedEnvelope
    147 ): Result {
    148   return controller(store).insert(proof);
    149 }
    150 export function privateStoreEnvelope(
    151   store: PrivateStore,
    152   id: string
    153 ): VerifiedEnvelope | undefined {
    154   return controller(store).envelope(id);
    155 }
    156 export function privateStoreSnapshot(store: PrivateStore): Snapshot {
    157   return controller(store).snapshot();
    158 }
    159 export function closePrivateStore(store: PrivateStore): void {
    160   controller(store).close();
    161 }