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 }