retry-send.ts (9408B)
1 import { 2 privateRecordSnapshot, 3 type PrivateRecordHandle 4 } from '../persistence/private-records.ts'; 5 import { 6 loadPrivateRecord, 7 type PrivateStorageRepository 8 } from '../persistence/private-storage.ts'; 9 import { 10 pairedDeliveryAcknowledgementSnapshot, 11 pairedDeliveryRecordMatches, 12 pairedDeliveryTargetAccepted, 13 verifyPairedDeliveryAcknowledgement, 14 commitPairedDeliveryReceipt, 15 type PairedDeliveryAcknowledgement 16 } from '../persistence/private-sends.ts'; 17 import { 18 privateSessionOwnership, 19 type PrivateSession 20 } from '../runtime/private-session.ts'; 21 import { 22 capturePrivatePublicationAction, 23 capturePrivatePublication 24 } from '../nostr/private-publisher.ts'; 25 import { 26 publishPrivateGiftWrapAttempt, 27 type PrivatePool 28 } from '../nostr/private-pool.ts'; 29 import { PRIVATE_PUBLICATION_BUDGETS } from '../config/budgets.ts'; 30 import type { PairedDeliveryContext } from './prepare-send.ts'; 31 import { reconcilePrivateSendAttempt } from '../persistence/private-send-settlements.ts'; 32 // Codec readback metadata alone is not a qualified authenticated remote query. 33 // Only named acceptance suppresses retry here; separate readback remains visible. 34 export function privateRetryTargets( 35 handle: PrivateRecordHandle, 36 owner: unknown, 37 id: unknown 38 ) { 39 const row = privateRecordSnapshot(handle, owner, id); 40 if ( 41 !row || 42 row.family !== 'private_send_operation' || 43 !row.peerArtifact || 44 !row.deliveryPlan 45 ) 46 return undefined; 47 const pair = row.peerArtifact; 48 return [ 49 row.deliveryPlan.routes.peer, 50 row.deliveryPlan.routes.archive 51 ].flatMap((route) => { 52 const eventId = route.role === 'peer' ? pair.eventId : row.self.eventId; 53 return route.targets 54 .filter( 55 (origin) => 56 !(row.receipts ?? []).some( 57 (f) => 58 f.role === route.role && 59 f.origin === origin && 60 f.eventId === eventId && 61 f.status === 'accepted' 62 ) 63 ) 64 .map((origin) => ({ role: route.role, origin, eventId })); 65 }); 66 } 67 declare const retryBrand: unique symbol; 68 export type PrivateRetry = Readonly<{ [retryBrand]: true }>; 69 type Result = Readonly<{ 70 status: 'completed' | 'needs_action' | 'stopped' | 'invalid' | 'busy'; 71 }>; 72 type Controller = { 73 run(review: unknown): Promise<Result>; 74 stop(): void; 75 snapshot(): Readonly<{ 76 owner: string; 77 command: string; 78 state: Result['status'] | 'ready'; 79 attempts: number; 80 }>; 81 }; 82 const retries = new WeakMap<PrivateRetry, Controller>(); 83 // Capture is explicit, memory-only and opens no socket. Genuine custody and 84 // actual whole-wire readback are rechecked before every externally visible step. 85 export function capturePrivateRetry( 86 repository: PrivateStorageRepository, 87 session: PrivateSession, 88 receipt: PairedDeliveryAcknowledgement, 89 context: PairedDeliveryContext, 90 pool: PrivatePool, 91 review: unknown 92 ): PrivateRetry | undefined { 93 if (typeof window === 'undefined' || review !== 'reviewed_private_retry') 94 return undefined; 95 const ownership = privateSessionOwnership(session), 96 row = pairedDeliveryAcknowledgementSnapshot(receipt); 97 if (!ownership?.current() || !row || row.owner !== ownership.owner) 98 return undefined; 99 const action = capturePrivatePublicationAction( 100 repository, 101 session, 102 receipt, 103 context, 104 review 105 ); 106 if (!action) return undefined; 107 const abort = new AbortController(); 108 let consumed = false, 109 busy = false, 110 attempts = 0, 111 state: Result['status'] | 'ready' = 'ready'; 112 const token = Object.freeze({}) as PrivateRetry; 113 function finish(status: Result['status']): Result { 114 state = status; 115 return { status }; 116 } 117 retries.set(token, { 118 stop() { 119 abort.abort(); 120 state = 'stopped'; 121 }, 122 snapshot() { 123 return { owner: row.owner, command: row.id, state, attempts }; 124 }, 125 async run(reviewed) { 126 if (reviewed !== 'reviewed_private_retry') return { status: 'invalid' }; 127 if (abort.signal.aborted || !ownership.current()) 128 return finish('stopped'); 129 if (busy) return { status: 'busy' }; 130 if (consumed) return { status: 'invalid' }; 131 consumed = true; 132 busy = true; 133 try { 134 if (!(await verifyPairedDeliveryAcknowledgement(repository, receipt))) 135 return finish('needs_action'); 136 const loaded = await loadPrivateRecord( 137 repository, 138 'private_sends', 139 row.id 140 ); 141 if (abort.signal.aborted || !ownership.current()) 142 return finish('stopped'); 143 if ( 144 !loaded.ok || 145 !pairedDeliveryRecordMatches(receipt, loaded.value) || 146 !(await verifyPairedDeliveryAcknowledgement(repository, receipt)) 147 ) 148 return finish('needs_action'); 149 if (abort.signal.aborted || !ownership.current()) 150 return finish('stopped'); 151 const targets = 152 loaded.ok && privateRetryTargets(loaded.value, row.owner, row.id); 153 if (!targets) return finish('needs_action'); 154 for (const target of targets) { 155 let accepted = false; 156 for ( 157 let index = 0; 158 index < PRIVATE_PUBLICATION_BUDGETS.attemptsPerTargetAction; 159 index++ 160 ) { 161 if (abort.signal.aborted || !ownership.current()) 162 return finish('stopped'); 163 if ( 164 pairedDeliveryTargetAccepted( 165 receipt, 166 target.role, 167 target.origin, 168 target.eventId 169 ) 170 ) { 171 if ( 172 !(await verifyPairedDeliveryAcknowledgement( 173 repository, 174 receipt 175 )) 176 ) 177 return finish('needs_action'); 178 if (abort.signal.aborted || !ownership.current()) 179 return finish('stopped'); 180 accepted = true; 181 break; 182 } 183 const permission = capturePrivatePublication( 184 repository, 185 session, 186 receipt, 187 context, 188 target.role, 189 target.origin, 190 'reviewed_private_delivery', 191 action 192 ); 193 if (!permission) return finish('needs_action'); 194 const result = await publishPrivateGiftWrapAttempt( 195 pool, 196 permission, 197 abort.signal 198 ); 199 if (abort.signal.aborted || !ownership.current()) { 200 if (result.actionId) attempts++; 201 await reconcilePrivateSendAttempt(result); 202 return finish('stopped'); 203 } 204 if ( 205 !result.actionId && 206 pairedDeliveryTargetAccepted( 207 receipt, 208 target.role, 209 target.origin, 210 target.eventId 211 ) && 212 (await verifyPairedDeliveryAcknowledgement(repository, receipt)) 213 ) { 214 if (abort.signal.aborted || !ownership.current()) 215 return finish('stopped'); 216 accepted = true; 217 break; 218 } 219 if ( 220 !result.actionId || 221 !result.attempt || 222 result.role !== target.role || 223 result.origin !== target.origin || 224 result.eventId !== target.eventId 225 ) 226 return finish('needs_action'); 227 attempts++; 228 const observedAtMilliseconds = Date.now(); 229 if ( 230 !Number.isSafeInteger(observedAtMilliseconds) || 231 observedAtMilliseconds < 0 232 ) 233 return finish('needs_action'); 234 const saved = await commitPairedDeliveryReceipt( 235 repository, 236 receipt, 237 JSON.stringify({ 238 actionId: result.actionId, 239 role: target.role, 240 origin: target.origin, 241 eventId: target.eventId, 242 attempt: result.attempt, 243 status: result.status, 244 observedAtMilliseconds, 245 readbackWire: null 246 }) 247 ); 248 if (abort.signal.aborted || !ownership.current()) { 249 await reconcilePrivateSendAttempt(result); 250 return finish('stopped'); 251 } 252 if (!('record' in saved)) return finish('needs_action'); 253 if (result.status === 'accepted') { 254 accepted = true; 255 break; 256 } 257 if (result.status === 'refused' || result.status === 'stopped') 258 return finish('needs_action'); 259 } 260 if (!accepted) return finish('needs_action'); 261 } 262 return finish('completed'); 263 } catch { 264 return finish( 265 abort.signal.aborted || !ownership.current() 266 ? 'stopped' 267 : 'needs_action' 268 ); 269 } finally { 270 busy = false; 271 } 272 } 273 }); 274 return token; 275 } 276 export function runPrivateRetry( 277 token: PrivateRetry, 278 review: unknown 279 ): Promise<Result> { 280 return ( 281 retries.get(token)?.run(review) ?? Promise.resolve({ status: 'invalid' }) 282 ); 283 } 284 export function stopPrivateRetry(token: PrivateRetry): void { 285 retries.get(token)?.stop(); 286 } 287 export function privateRetrySnapshot(token: PrivateRetry) { 288 return retries.get(token)?.snapshot(); 289 }