private-publisher.ts (8317B)
1 import { 2 makeFixture as makePairFixture, 3 prepareSelfRecovery, 4 preparePairedDelivery, 5 preparedPairedDelivery 6 } from './paired-delivery.ts'; 7 import { 8 createPrivateSession, 9 closePrivateSession 10 } from '../../../src/lib/runtime/private-session.ts'; 11 import { 12 getPrivatePool, 13 publishPrivateGiftWrapAttempt, 14 subscribePrivatePage, 15 closePrivatePool 16 } from '../../../src/lib/nostr/private-pool.ts'; 17 import { 18 capturePrivatePublication, 19 capturePrivatePublicationAction, 20 type PrivatePublicationAction, 21 privatePublicationSnapshot, 22 type PrivatePublication 23 } from '../../../src/lib/nostr/private-publisher.ts'; 24 import { deliverPrivateSend } from '../../../src/lib/messaging/deliver-send.ts'; 25 import { browserDatabaseTransaction } from '../../../src/lib/persistence/database.ts'; 26 import { 27 reservedSendSnapshot, 28 reservedSendRumorWire 29 } from '../../../src/lib/messaging/send-identity.ts'; 30 import { 31 createPrivateComposer, 32 updatePrivateComposerText, 33 bindPrivateComposerPreparation, 34 privateComposerText, 35 privateComposerSnapshot, 36 closePrivateComposer, 37 type PrivateComposer 38 } from '../../../src/lib/messaging/composer-state.ts'; 39 import { disconnectIdentity } from '../../../src/lib/runtime/identity-session.ts'; 40 export { privatePublicationSnapshot, publishPrivateGiftWrapAttempt }; 41 import { RelayPool } from 'applesauce-relay/pool'; 42 export async function makeFixture(writeOnly = false, sharedOrigin = false) { 43 const f = await makePairFixture({ 44 messaging: true, 45 peerRead: !writeOnly, 46 sharedOrigin 47 }); 48 const session = await createPrivateSession( 49 f.identity, 50 'reviewed_private_session' 51 ); 52 if (!session) throw Error('missing genuine private session'); 53 const peerOrigin = 'wss://peer.example.org', 54 archiveOrigin = sharedOrigin ? peerOrigin : 'wss://archive.example.org'; 55 const pool = getPrivatePool( 56 session, 57 f.context.policy, 58 Array.from(new Set([peerOrigin, archiveOrigin])) 59 ); 60 if (!pool) throw Error('missing actual private pool'); 61 const controller = new AbortController(); 62 let composer: PrivateComposer | undefined; 63 function bindComposer(newer = false) { 64 const wire = reservedSendRumorWire(f.reserved); 65 if (!wire) throw Error('missing genuine captured rumor'); 66 const content = (JSON.parse(wire) as { content: unknown }).content; 67 composer = createPrivateComposer(f.identity, 'reviewed_private_composer'); 68 if ( 69 !composer || 70 !updatePrivateComposerText(composer, content, 'reviewed_private_text') || 71 !bindPrivateComposerPreparation( 72 composer, 73 f.reserved, 74 f.preparation, 75 undefined, 76 'reviewed_composer_preparation' 77 ) 78 ) 79 throw Error('missing genuine composer binding'); 80 if ( 81 newer && 82 !updatePrivateComposerText( 83 composer, 84 'HCP085_NEWER_PRIVATE_TEXT_MEMORY_ONLY', 85 'reviewed_private_text' 86 ) 87 ) 88 throw Error('newer text update failed'); 89 return { 90 text: privateComposerText(composer), 91 snapshot: privateComposerSnapshot(composer) 92 }; 93 } 94 function composerState() { 95 return composer 96 ? { 97 text: privateComposerText(composer), 98 snapshot: privateComposerSnapshot(composer) 99 } 100 : undefined; 101 } 102 async function prepare() { 103 const self = await prepareSelfRecovery( 104 f.preparation, 105 'reviewed_self_recovery' 106 ); 107 if (self.status !== 'saved') throw Error('missing self: ' + self.status); 108 const pair = await preparePairedDelivery( 109 f.preparation, 110 f.context, 111 'reviewed_pair_preparation' 112 ); 113 if (pair.status !== 'prepared') throw Error('missing pair: ' + pair.status); 114 return f.storedPair(); 115 } 116 function permission( 117 role: 'peer' | 'self_archive', 118 origin = role === 'peer' ? peerOrigin : archiveOrigin, 119 review: unknown = 'reviewed_private_delivery', 120 action?: PrivatePublicationAction 121 ) { 122 const receipt = preparedPairedDelivery(f.preparation); 123 return receipt 124 ? capturePrivatePublication( 125 f.repository, 126 session!, 127 receipt, 128 f.context, 129 role, 130 origin, 131 review, 132 action 133 ) 134 : undefined; 135 } 136 async function publish( 137 token: PrivatePublication, 138 signal = controller.signal 139 ) { 140 return publishPrivateGiftWrapAttempt(pool!, token, signal); 141 } 142 function action() { 143 const receipt = preparedPairedDelivery(f.preparation); 144 return receipt 145 ? capturePrivatePublicationAction( 146 f.repository, 147 session!, 148 receipt, 149 f.context, 150 'reviewed_private_retry' 151 ) 152 : undefined; 153 } 154 function failAcquisition() { 155 const original = Reflect.get<RelayPool, 'relay'>( 156 RelayPool.prototype, 157 'relay' 158 ); 159 RelayPool.prototype.relay = function (origin) { 160 if (new URL(origin).origin === peerOrigin) 161 throw Error('controlled original SDK acquisition failure'); 162 return original.call(this, origin); 163 }; 164 return () => { 165 RelayPool.prototype.relay = original; 166 }; 167 } 168 function abortOnActualNetworkClock(abort: AbortController) { 169 const original = performance.now.bind(performance); 170 let observed = false; 171 performance.now = () => { 172 const value = original(); 173 if (!observed && /at clock \(/.test(new Error().stack ?? '')) { 174 observed = true; 175 abort.abort(); 176 } 177 return value; 178 }; 179 return { 180 observed: () => observed, 181 restore: () => { 182 performance.now = original; 183 } 184 }; 185 } 186 async function deliver( 187 role: 'peer' | 'self_archive', 188 origin = role === 'peer' ? peerOrigin : archiveOrigin 189 ) { 190 const receipt = preparedPairedDelivery(f.preparation); 191 return receipt 192 ? deliverPrivateSend( 193 f.repository, 194 session!, 195 receipt, 196 f.context, 197 pool!, 198 role, 199 origin, 200 'reviewed_private_delivery', 201 controller.signal 202 ) 203 : { status: 'invalid' as const }; 204 } 205 async function remove() { 206 const record = reservedSendSnapshot(f.reserved); 207 if (!record) throw Error('missing command'); 208 const tx = browserDatabaseTransaction( 209 f.database, 210 ['private_sends'], 211 'readwrite' 212 ); 213 tx.objectStore('private_sends').delete([f.owner, record.id]); 214 await new Promise<void>((resolve, reject) => { 215 tx.addEventListener('complete', () => resolve()); 216 tx.addEventListener('abort', () => 217 reject(Error('fixture deletion aborted')) 218 ); 219 }); 220 } 221 let restore = () => {}; 222 function failReadback() { 223 const cursor = Reflect.get<IDBIndex, 'openCursor'>( 224 IDBIndex.prototype, 225 'openCursor' 226 ); 227 IDBIndex.prototype.openCursor = function ( 228 ...args: Parameters<IDBIndex['openCursor']> 229 ) { 230 if (this.objectStore.name === 'private_sends') 231 throw Error('controlled actual private readback failure'); 232 return cursor.apply(this, args); 233 }; 234 restore = () => { 235 IDBIndex.prototype.openCursor = cursor; 236 }; 237 } 238 function readOrigins() { 239 return new Promise<string[]>((resolve, reject) => { 240 const seen = new Set<string>(); 241 try { 242 subscribePrivatePage(pool!, 1, (message) => { 243 if (message.type === 'candidate') seen.add(message.from); 244 else if (message.reason === 'complete') resolve([...seen]); 245 else reject(Error(message.reason)); 246 }); 247 } catch (error) { 248 reject( 249 error instanceof Error ? error : Error('fixture private read failed') 250 ); 251 } 252 }); 253 } 254 return { 255 ...f, 256 session, 257 pool, 258 peerOrigin, 259 archiveOrigin, 260 prepare, 261 prepareSelfOnly: () => 262 prepareSelfRecovery(f.preparation, 'reviewed_self_recovery'), 263 permission, 264 action, 265 failAcquisition, 266 abortOnActualNetworkClock, 267 publish, 268 deliver, 269 remove, 270 failReadback, 271 readOrigins, 272 bindComposer, 273 composerState, 274 stop: () => controller.abort(), 275 disconnect: () => disconnectIdentity(f.identity), 276 close() { 277 if (composer) closePrivateComposer(composer); 278 restore(); 279 controller.abort(); 280 closePrivatePool(pool); 281 closePrivateSession(session); 282 f.close(); 283 } 284 }; 285 }