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 }