private-sends.ts (32362B)
1 import { 2 identityMessagingOwnership, 3 recheckIdentityOwner, 4 type IdentitySession 5 } from '../runtime/identity-session.ts'; 6 import { 7 reservedSendSnapshot, 8 type ReservedSendIdentity 9 } from '../messaging/send-identity.ts'; 10 import { 11 verifiedOutboundSnapshot, 12 verifiedOutboundRecoverySource, 13 type VerifiedOutboundEnvelope 14 } from '../nostr/verify-outbound-envelope.ts'; 15 import { 16 verifyEnvelope, 17 verifiedEnvelopeSnapshot 18 } from '../nostr/verified-envelope.ts'; 19 import { 20 decodePrivateRecord, 21 privateRecordSnapshot, 22 privateRecordWire, 23 type PrivateRecordHandle, 24 type PrivateSendReservation, 25 type PrivateSendOperation 26 } from './private-records.ts'; 27 import { 28 inboxRoutePlanSnapshot, 29 createInboxRoutePlan, 30 recheckInboxRoutePlan, 31 type InboxRoutePlan 32 } from '../messaging/inbox-routing.ts'; 33 import type { PairedDeliveryContext } from '../messaging/prepare-send.ts'; 34 import { 35 loadPrivateRecord, 36 commitPrivateRecord, 37 type PrivateStorageRepository, 38 type PrivateStorageFailure, 39 type PrivateStorageResult 40 } from './private-storage.ts'; 41 import { 42 preparePrivateReceiptTransition, 43 commitPrivateReceiptTransition, 44 type PrivateReceiptCommitResult 45 } from './private-receipts.ts'; 46 47 declare const acknowledgementBrand: unique symbol; 48 export type SelfRecoveryAcknowledgement = Readonly<{ 49 [acknowledgementBrand]: true; 50 }>; 51 type Saved = Readonly<{ 52 record: PrivateSendReservation; 53 revision: number; 54 wire: string; 55 self: Readonly<{ eventId: string; wire: string }>; 56 current(): boolean; 57 }>; 58 const acknowledgements = new WeakMap<SelfRecoveryAcknowledgement, Saved>(); 59 export type SelfRecoveryCommitResult = 60 | Readonly<{ 61 status: 'saved' | 'existing' | 'reconciled'; 62 receipt: SelfRecoveryAcknowledgement; 63 }> 64 | Readonly<{ status: PrivateStorageFailure | 'invalid' | 'stopped' }>; 65 66 // A namespace read is not a crypto proof or acknowledgement. Defensive owner, 67 // command and immutable-rumor matching precedes any future SDK preparation. 68 export async function readSelfRecoveryBase( 69 repository: PrivateStorageRepository, 70 reserved: ReservedSendIdentity 71 ): Promise<PrivateStorageResult<PrivateRecordHandle>> { 72 const record = reservedSendSnapshot(reserved); 73 if (!record) return { ok: false, reason: 'invalid_record' }; 74 const loaded = await loadPrivateRecord( 75 repository, 76 'private_sends', 77 record.id 78 ); 79 if (!loaded.ok) 80 return { 81 ok: false, 82 reason: loaded.reason === 'invalid_scope' ? 'unavailable' : loaded.reason 83 }; 84 const row = privateRecordSnapshot(loaded.value, record.owner, record.id); 85 if ( 86 !row || 87 (row.family !== 'private_send_reservation' && 88 row.family !== 'private_send_operation') || 89 row.peer !== record.peer || 90 row.rumorHash !== record.rumorHash || 91 row.createdAt !== record.createdAt 92 ) 93 return { ok: false, reason: 'invalid_record' }; 94 if (!reservedSendSnapshot(reserved)) 95 return { ok: false, reason: 'invalid_record' }; 96 return loaded; 97 } 98 99 function input( 100 session: IdentitySession, 101 reserved: ReservedSendIdentity, 102 proof: VerifiedOutboundEnvelope 103 ) { 104 const record = reservedSendSnapshot(reserved), 105 ownership = identityMessagingOwnership(session), 106 observed = verifiedOutboundSnapshot(proof); 107 if ( 108 !record || 109 !ownership?.current() || 110 !observed || 111 ownership.owner !== record.owner || 112 observed.role !== 'self' || 113 observed.destination !== record.owner || 114 observed.command !== record.id || 115 observed.owner !== record.owner || 116 observed.peer !== record.peer || 117 observed.rumorHash !== record.rumorHash 118 ) 119 return undefined; 120 const verified = verifyEnvelope(observed.wire), 121 event = verified.ok && verifiedEnvelopeSnapshot(verified.value); 122 if (!event || event.kind !== 1059) return undefined; 123 const current = () => { 124 const original = reservedSendSnapshot(reserved), 125 outer = verifiedOutboundSnapshot(proof); 126 return ( 127 ownership.current() && 128 original?.owner === record.owner && 129 original.id === record.id && 130 original.peer === record.peer && 131 original.rumorHash === record.rumorHash && 132 original.createdAt === record.createdAt && 133 outer?.role === 'self' && 134 outer.destination === record.owner && 135 outer.wire === observed.wire 136 ); 137 }; 138 return current() 139 ? { 140 record, 141 current, 142 ownerCurrent: () => ownership.current(), 143 self: { eventId: event.id, wire: observed.wire }, 144 recoveryWire: verifiedOutboundRecoverySource(proof) 145 } 146 : undefined; 147 } 148 149 // No signer/network await occurs in an IDB transaction. Only genuine current 150 // factory association plus acknowledged exact ciphertext readback mints this 151 // local fact. It grants no relay readiness, pair plan or transmission permission. 152 export async function commitSelfRecovery( 153 repository: PrivateStorageRepository, 154 session: IdentitySession, 155 reserved: ReservedSendIdentity, 156 proof: VerifiedOutboundEnvelope, 157 review: unknown 158 ): Promise<SelfRecoveryCommitResult> { 159 if (typeof window === 'undefined' || review !== 'reviewed_self_commit') 160 return { status: 'invalid' }; 161 const captured = input(session, reserved, proof); 162 if (!captured) return { status: 'invalid' }; 163 try { 164 const loaded = await readSelfRecoveryBase(repository, reserved); 165 if (!captured.current()) return { status: 'stopped' }; 166 if (!loaded.ok) return { status: loaded.reason }; 167 const base = privateRecordSnapshot( 168 loaded.value, 169 captured.record.owner, 170 captured.record.id 171 ); 172 if ( 173 !base || 174 (base.family !== 'private_send_reservation' && 175 base.family !== 'private_send_operation') 176 ) 177 return { status: 'invalid_record' }; 178 if ( 179 captured.recoveryWire !== undefined && 180 privateRecordWire( 181 loaded.value, 182 captured.record.owner, 183 captured.record.id 184 ) !== captured.recoveryWire 185 ) 186 return { status: 'conflict' }; 187 let expected: PrivateRecordHandle, 188 status: 'saved' | 'existing' | 'reconciled'; 189 if (base.family === 'private_send_operation') { 190 if ( 191 base.self.eventId !== captured.self.eventId || 192 base.self.wire !== captured.self.wire 193 ) 194 return { status: 'conflict' }; 195 expected = loaded.value; 196 status = 'existing'; 197 } else { 198 const raw = JSON.stringify({ 199 schema: 1, 200 family: 'private_send_operation', 201 owner: base.owner, 202 id: base.id, 203 revision: base.revision + 1, 204 peer: base.peer, 205 rumorHash: base.rumorHash, 206 createdAt: base.createdAt, 207 self: { eventId: captured.self.eventId, wire: captured.self.wire }, 208 peerArtifact: null 209 }); 210 const decoded = decodePrivateRecord(raw, base.owner, base.id); 211 if (!decoded.ok) return { status: 'invalid_record' }; 212 expected = decoded.value; 213 if (!captured.current()) return { status: 'stopped' }; 214 const committed = await commitPrivateRecord( 215 repository, 216 expected, 217 loaded.value 218 ); 219 if (!captured.current()) return { status: 'stopped' }; 220 if (!committed.ok && committed.reason !== 'unknown_completion') 221 return { status: committed.reason }; 222 status = !committed.ok 223 ? 'reconciled' 224 : committed.value.state === 'existing' 225 ? 'existing' 226 : 'saved'; 227 } 228 const expectedWire = privateRecordWire( 229 expected, 230 captured.record.owner, 231 captured.record.id 232 ); 233 const readback = await loadPrivateRecord( 234 repository, 235 'private_sends', 236 captured.record.id 237 ); 238 if (!captured.current()) return { status: 'stopped' }; 239 if (!readback.ok) return { status: 'unknown_completion' }; 240 const wire = privateRecordWire( 241 readback.value, 242 captured.record.owner, 243 captured.record.id 244 ), 245 record = privateRecordSnapshot( 246 readback.value, 247 captured.record.owner, 248 captured.record.id 249 ); 250 if ( 251 !wire || 252 wire !== expectedWire || 253 !record || 254 record.family !== 'private_send_operation' || 255 record.self.eventId !== captured.self.eventId || 256 record.self.wire !== captured.self.wire 257 ) 258 return { status: 'conflict' }; 259 const receipt = Object.freeze({}) as SelfRecoveryAcknowledgement; 260 acknowledgements.set(receipt, { 261 record: captured.record, 262 revision: record.revision, 263 wire, 264 self: captured.self, 265 // The acknowledged local fact survives clearing the crypto preparation. 266 // Effect permission remains separately gated by the live workflow. 267 current: captured.ownerCurrent 268 }); 269 return { status, receipt }; 270 } catch { 271 return { status: captured.current() ? 'unavailable' : 'stopped' }; 272 } 273 } 274 275 export function selfRecoveryAcknowledgementSnapshot( 276 receipt: SelfRecoveryAcknowledgement 277 ) { 278 const saved = acknowledgements.get(receipt); 279 return saved?.current() 280 ? { 281 owner: saved.record.owner, 282 id: saved.record.id, 283 peer: saved.record.peer, 284 rumorHash: saved.record.rumorHash, 285 createdAt: saved.record.createdAt, 286 revision: saved.revision, 287 self: { eventId: saved.self.eventId, wire: saved.self.wire }, 288 copy: 'Saved encrypted in this browser' as const, 289 fact: 'acknowledged_local_ciphertext_only' as const 290 } 291 : undefined; 292 } 293 294 // Recheck exact local evidence before a workflow advances. This does not 295 // promise retention after the read; clearing/eviction and later CAS remain real. 296 export async function verifySelfRecoveryAcknowledgement( 297 repository: PrivateStorageRepository, 298 receipt: SelfRecoveryAcknowledgement 299 ): Promise<boolean> { 300 const saved = acknowledgements.get(receipt); 301 if (!saved?.current()) return false; 302 const loaded = await loadPrivateRecord( 303 repository, 304 'private_sends', 305 saved.record.id 306 ); 307 return ( 308 saved.current() && 309 loaded.ok && 310 privateRecordWire(loaded.value, saved.record.owner, saved.record.id) === 311 saved.wire 312 ); 313 } 314 315 declare const pairedAcknowledgementBrand: unique symbol; 316 export type PairedDeliveryAcknowledgement = Readonly<{ 317 [pairedAcknowledgementBrand]: true; 318 }>; 319 type Paired = Readonly<{ 320 record: PrivateSendOperation; 321 wire: string; 322 current(): boolean; 323 }>; 324 const pairedAcknowledgements = new WeakMap< 325 PairedDeliveryAcknowledgement, 326 Paired 327 >(); 328 declare const routingReviewBrand: unique symbol; 329 export type PairedRoutingReview = Readonly<{ [routingReviewBrand]: true }>; 330 type RoutingReview = Readonly<{ 331 repository: PrivateStorageRepository; 332 session: IdentitySession; 333 receipt: PairedDeliveryAcknowledgement; 334 saved: Paired; 335 context: PairedDeliveryContext; 336 changed: boolean; 337 current(): boolean; 338 }>; 339 const routingReviewStates = new WeakMap<PairedRoutingReview, RoutingReview>(); 340 const pendingRoutingReviews = new WeakMap< 341 PairedDeliveryAcknowledgement, 342 PairedRoutingReview 343 >(); 344 // Genuine current discovery is a reviewed destination candidate, not Send. 345 // Detection immediately fences previously captured retry/publication custody. 346 export function capturePairedRoutingReview( 347 repository: PrivateStorageRepository, 348 session: IdentitySession, 349 receipt: PairedDeliveryAcknowledgement, 350 candidate: Pick<PairedDeliveryContext, 'policy' | 'own' | 'other'>, 351 review: unknown 352 ): PairedRoutingReview | undefined { 353 if ( 354 typeof window === 'undefined' || 355 review !== 'reviewed_private_route_resolution' 356 ) 357 return undefined; 358 const saved = pairedAcknowledgements.get(receipt), 359 ownership = identityMessagingOwnership(session); 360 if ( 361 !saved?.current() || 362 !saved.record.deliveryPlan || 363 !saved.record.peerArtifact || 364 !ownership?.current() || 365 ownership.owner !== saved.record.owner 366 ) 367 return undefined; 368 // Unready current resolution must also fence the old destination. No 369 // fallback capability survives merely because there is no new usable plan. 370 const token = Object.freeze({}) as PairedRoutingReview; 371 pendingRoutingReviews.set(receipt, token); 372 const plan = createInboxRoutePlan( 373 candidate.policy, 374 saved.record.owner, 375 saved.record.peer, 376 candidate.own, 377 candidate.other 378 ); 379 if (!plan) return undefined; 380 const context = { 381 plan, 382 policy: candidate.policy, 383 own: candidate.own, 384 other: candidate.other 385 }; 386 const routes = inboxRoutePlanSnapshot(plan); 387 if ( 388 !routes || 389 routes.peer.author !== saved.record.peer || 390 routes.archive.author !== saved.record.owner || 391 recheckInboxRoutePlan( 392 context.plan, 393 context.policy, 394 context.own, 395 context.other 396 ) !== 'unchanged' 397 ) 398 return undefined; 399 const current = () => 400 saved.current() && 401 ownership.current() && 402 pendingRoutingReviews.get(receipt) === token && 403 recheckInboxRoutePlan( 404 context.plan, 405 context.policy, 406 context.own, 407 context.other 408 ) === 'unchanged'; 409 routingReviewStates.set(token, { 410 repository, 411 session, 412 receipt, 413 saved, 414 context, 415 changed: 416 JSON.stringify(routes) !== 417 JSON.stringify(saved.record.deliveryPlan.routes), 418 current 419 }); 420 return token; 421 } 422 export function pairedRoutingReviewSnapshot(token: PairedRoutingReview) { 423 const state = routingReviewStates.get(token); 424 if (!state?.current() || !state.saved.record.deliveryPlan) return undefined; 425 const previous = state.saved.record.deliveryPlan.routes, 426 next = inboxRoutePlanSnapshot(state.context.plan); 427 if (!next) return undefined; 428 function changes(role: 'peer' | 'archive') { 429 return { 430 removed: previous[role].targets.filter( 431 (origin) => !next![role].targets.includes(origin) 432 ), 433 added: next![role].targets.filter( 434 (origin) => !previous[role].targets.includes(origin) 435 ) 436 }; 437 } 438 return { 439 owner: state.saved.record.owner, 440 peer: state.saved.record.peer, 441 command: state.saved.record.id, 442 status: state.changed 443 ? ('review_required' as const) 444 : ('unchanged' as const), 445 previous: JSON.parse(JSON.stringify(previous)) as typeof previous, 446 next, 447 changes: { peer: changes('peer'), archive: changes('archive') }, 448 fact: 'destination_review_only' as const 449 }; 450 } 451 export type PairedRoutingResult = 452 | Readonly<{ 453 status: 'updated' | 'unchanged'; 454 receipt: PairedDeliveryAcknowledgement; 455 }> 456 | Readonly<{ status: PrivateStorageFailure | 'invalid' | 'stopped' }>; 457 export async function approvePairedRoutingReview( 458 token: PairedRoutingReview, 459 review: unknown 460 ): Promise<PairedRoutingResult> { 461 const state = routingReviewStates.get(token); 462 if ( 463 !state || 464 review !== 'reviewed_private_destination_update' || 465 !navigator.locks?.request 466 ) 467 return { status: 'invalid' }; 468 if (!state.current()) return { status: 'stopped' }; 469 const { repository, session, receipt, saved, context } = state; 470 try { 471 const owner = await recheckIdentityOwner(session); 472 if ( 473 owner.state !== 'messaging_capable' || 474 owner.publicKey !== saved.record.owner || 475 owner.admission === 'busy' || 476 !state.current() 477 ) 478 return { status: 'stopped' }; 479 return await navigator.locks.request( 480 'harvestcircle:owner:' + saved.record.owner, 481 { mode: 'exclusive', ifAvailable: true }, 482 async (lock) => { 483 if (!lock || !state.current()) return { status: 'stopped' as const }; 484 const base = await loadPrivateRecord( 485 repository, 486 'private_sends', 487 saved.record.id 488 ); 489 if (!state.current()) return { status: 'stopped' as const }; 490 if (!base.ok) return { status: base.reason }; 491 if ( 492 privateRecordWire(base.value, saved.record.owner, saved.record.id) !== 493 saved.wire 494 ) 495 return { status: 'conflict' as const }; 496 const routes = inboxRoutePlanSnapshot(context.plan), 497 row = saved.record; 498 if (!routes || !row.deliveryPlan) return { status: 'invalid' as const }; 499 let expected = base.value; 500 if (state.changed) { 501 if (row.revision === Number.MAX_SAFE_INTEGER) 502 return { status: 'invalid_record' as const }; 503 const decoded = decodePrivateRecord( 504 JSON.stringify({ 505 ...row, 506 revision: row.revision + 1, 507 deliveryPlan: { 508 state: 'prepared', 509 routes, 510 previousRoutes: [ 511 ...(row.deliveryPlan.previousRoutes ?? []), 512 row.deliveryPlan.routes 513 ] 514 } 515 }), 516 row.owner, 517 row.id 518 ); 519 if (!decoded.ok) return { status: 'invalid_record' as const }; 520 expected = decoded.value; 521 if (!state.current()) return { status: 'stopped' as const }; 522 const committed = await commitPrivateRecord( 523 repository, 524 expected, 525 base.value 526 ); 527 if (!state.current()) 528 return { status: 'unknown_completion' as const }; 529 if (!committed.ok) return { status: committed.reason }; 530 } 531 const loaded = await loadPrivateRecord( 532 repository, 533 'private_sends', 534 row.id 535 ); 536 if (!state.current() || !loaded.ok) 537 return { status: 'unknown_completion' as const }; 538 const wire = privateRecordWire(loaded.value, row.owner, row.id), 539 next = privateRecordSnapshot(loaded.value, row.owner, row.id); 540 if ( 541 !wire || 542 wire !== privateRecordWire(expected, row.owner, row.id) || 543 !next || 544 next.family !== 'private_send_operation' || 545 JSON.stringify(next.self) !== JSON.stringify(row.self) || 546 JSON.stringify(next.peerArtifact) !== JSON.stringify(row.peerArtifact) 547 ) 548 return { status: 'conflict' as const }; 549 pairedAcknowledgements.set(receipt, { 550 record: next, 551 wire, 552 current: saved.current 553 }); 554 pendingRoutingReviews.delete(receipt); 555 routingReviewStates.delete(token); 556 return { 557 status: state.changed ? ('updated' as const) : ('unchanged' as const), 558 receipt 559 }; 560 } 561 ); 562 } catch { 563 return { status: state.current() ? 'unavailable' : 'stopped' }; 564 } 565 } 566 // Explicit restart admission authenticates the self recovery copy and verifies 567 // exact durable pair custody. It does not decrypt or newly authenticate the 568 // nested peer ciphertext, regenerate either artifact, or perform publication. 569 export async function acknowledgeRecoveredPairedDelivery( 570 repository: PrivateStorageRepository, 571 session: IdentitySession, 572 reserved: ReservedSendIdentity, 573 self: SelfRecoveryAcknowledgement, 574 context: PairedDeliveryContext, 575 review: unknown 576 ): Promise<PairedDeliveryCommitResult> { 577 if ( 578 typeof window === 'undefined' || 579 review !== 'reviewed_stored_private_retry' || 580 !navigator.locks?.request 581 ) 582 return { status: 'invalid' }; 583 const saved = acknowledgements.get(self), 584 original = reservedSendSnapshot(reserved), 585 ownership = identityMessagingOwnership(session); 586 if ( 587 !saved?.current() || 588 !original || 589 !ownership?.current() || 590 JSON.stringify(saved.record) !== JSON.stringify(original) || 591 original.owner !== ownership.owner 592 ) 593 return { status: 'invalid' }; 594 const current = () => 595 ownership.current() && 596 saved.current() && 597 !!reservedSendSnapshot(reserved) && 598 recheckInboxRoutePlan( 599 context.plan, 600 context.policy, 601 context.own, 602 context.other 603 ) === 'unchanged'; 604 try { 605 const checked = await recheckIdentityOwner(session); 606 if ( 607 checked.state !== 'messaging_capable' || 608 checked.publicKey !== ownership.owner || 609 checked.admission === 'busy' || 610 !current() 611 ) 612 return { status: 'stopped' }; 613 return await navigator.locks.request( 614 'harvestcircle:owner:' + ownership.owner, 615 { mode: 'exclusive', ifAvailable: true }, 616 async (lock) => { 617 if (!lock || !current()) return { status: 'stopped' as const }; 618 const loaded = await loadPrivateRecord( 619 repository, 620 'private_sends', 621 original.id 622 ); 623 if (!current()) return { status: 'stopped' as const }; 624 if (!loaded.ok) return { status: loaded.reason }; 625 const row = privateRecordSnapshot( 626 loaded.value, 627 original.owner, 628 original.id 629 ), 630 wire = privateRecordWire(loaded.value, original.owner, original.id), 631 routes = inboxRoutePlanSnapshot(context.plan); 632 if ( 633 !row || 634 row.family !== 'private_send_operation' || 635 !row.peerArtifact || 636 !row.deliveryPlan || 637 !wire || 638 wire !== saved.wire || 639 JSON.stringify(row.deliveryPlan.routes) !== JSON.stringify(routes) 640 ) 641 return { status: 'conflict' as const }; 642 const verified = verifyEnvelope(row.peerArtifact.wire), 643 event = verified.ok && verifiedEnvelopeSnapshot(verified.value); 644 if ( 645 !event || 646 event.kind !== 1059 || 647 event.id !== row.peerArtifact.eventId || 648 event.tags.length !== 1 || 649 event.tags[0].length !== 2 || 650 event.tags[0][0] !== 'p' || 651 event.tags[0][1] !== row.peer || 652 !current() 653 ) 654 return { status: 'invalid' as const }; 655 const receipt = Object.freeze({}) as PairedDeliveryAcknowledgement; 656 pairedAcknowledgements.set(receipt, { 657 record: row, 658 wire, 659 current: () => ownership.current() 660 }); 661 return { status: 'existing' as const, receipt }; 662 } 663 ); 664 } catch { 665 return { status: current() ? 'unavailable' : 'stopped' }; 666 } 667 } 668 export type PairedDeliveryCommitResult = 669 | Readonly<{ 670 status: 'prepared' | 'existing' | 'reconciled'; 671 receipt: PairedDeliveryAcknowledgement; 672 }> 673 | Readonly<{ status: PrivateStorageFailure | 'invalid' | 'stopped' }>; 674 675 // Requires genuine current self acknowledgement, peer factory proof and route 676 // capture. Structural local record admission alone cannot mint this receipt. 677 // Caller owns WebLock and current route recheck; this function owns short CAS. 678 export async function commitPairedDelivery( 679 repository: PrivateStorageRepository, 680 session: IdentitySession, 681 reserved: ReservedSendIdentity, 682 self: SelfRecoveryAcknowledgement, 683 peer: VerifiedOutboundEnvelope, 684 plan: InboxRoutePlan, 685 review: unknown 686 ): Promise<PairedDeliveryCommitResult> { 687 if (typeof window === 'undefined' || review !== 'reviewed_pair_commit') 688 return { status: 'invalid' }; 689 const savedSelf = acknowledgements.get(self), 690 original = reservedSendSnapshot(reserved), 691 ownership = identityMessagingOwnership(session), 692 proof = verifiedOutboundSnapshot(peer), 693 routes = inboxRoutePlanSnapshot(plan); 694 if ( 695 !savedSelf?.current() || 696 !original || 697 !ownership?.current() || 698 !proof || 699 !routes || 700 original.owner !== ownership.owner || 701 savedSelf.record.owner !== original.owner || 702 savedSelf.record.id !== original.id || 703 savedSelf.record.peer !== original.peer || 704 savedSelf.record.rumorHash !== original.rumorHash || 705 savedSelf.record.createdAt !== original.createdAt || 706 proof.role !== 'peer' || 707 proof.destination !== original.peer || 708 proof.owner !== original.owner || 709 proof.command !== original.id || 710 proof.peer !== original.peer || 711 proof.rumorHash !== original.rumorHash || 712 routes.peer.author !== original.peer || 713 routes.archive.author !== original.owner 714 ) 715 return { status: 'invalid' }; 716 const verified = verifyEnvelope(proof.wire), 717 event = verified.ok && verifiedEnvelopeSnapshot(verified.value); 718 if (!event || event.kind !== 1059) return { status: 'invalid' }; 719 const current = () => { 720 const fresh = reservedSendSnapshot(reserved), 721 peerNow = verifiedOutboundSnapshot(peer); 722 return ( 723 ownership.current() && 724 savedSelf.current() && 725 fresh?.owner === original.owner && 726 fresh.id === original.id && 727 fresh.peer === original.peer && 728 fresh.rumorHash === original.rumorHash && 729 fresh.createdAt === original.createdAt && 730 peerNow?.role === 'peer' && 731 peerNow.wire === proof.wire 732 ); 733 }; 734 try { 735 const loaded = await readSelfRecoveryBase(repository, reserved); 736 if (!current()) return { status: 'stopped' }; 737 if (!loaded.ok) return { status: loaded.reason }; 738 const base = privateRecordSnapshot( 739 loaded.value, 740 original.owner, 741 original.id 742 ), 743 baseWire = privateRecordWire(loaded.value, original.owner, original.id); 744 if ( 745 !base || 746 base.family !== 'private_send_operation' || 747 base.self.eventId !== savedSelf.self.eventId || 748 base.self.wire !== savedSelf.self.wire 749 ) 750 return { status: 'conflict' }; 751 const peerArtifact = { eventId: event.id, wire: proof.wire }, 752 deliveryPlan = { state: 'prepared' as const, routes }; 753 let expected: PrivateRecordHandle, 754 status: 'prepared' | 'existing' | 'reconciled'; 755 if (base.peerArtifact || base.deliveryPlan) { 756 if ( 757 base.peerArtifact?.eventId !== peerArtifact.eventId || 758 base.peerArtifact.wire !== peerArtifact.wire || 759 JSON.stringify(base.deliveryPlan) !== JSON.stringify(deliveryPlan) 760 ) 761 return { status: 'conflict' }; 762 expected = loaded.value; 763 status = 'existing'; 764 } else { 765 if (baseWire !== savedSelf.wire) return { status: 'conflict' }; 766 const decoded = decodePrivateRecord( 767 JSON.stringify({ 768 schema: 1, 769 family: 'private_send_operation', 770 owner: base.owner, 771 id: base.id, 772 revision: base.revision + 1, 773 peer: base.peer, 774 rumorHash: base.rumorHash, 775 createdAt: base.createdAt, 776 self: { eventId: base.self.eventId, wire: base.self.wire }, 777 peerArtifact, 778 deliveryPlan 779 }), 780 base.owner, 781 base.id 782 ); 783 if (!decoded.ok) return { status: 'invalid_record' }; 784 expected = decoded.value; 785 if (!current()) return { status: 'stopped' }; 786 const committed = await commitPrivateRecord( 787 repository, 788 expected, 789 loaded.value 790 ); 791 if (!current()) return { status: 'stopped' }; 792 if (!committed.ok && committed.reason !== 'unknown_completion') 793 return { status: committed.reason }; 794 status = !committed.ok 795 ? 'reconciled' 796 : committed.value.state === 'existing' 797 ? 'existing' 798 : 'prepared'; 799 } 800 const wire = privateRecordWire(expected, original.owner, original.id), 801 readback = await loadPrivateRecord( 802 repository, 803 'private_sends', 804 original.id 805 ); 806 if (!current()) return { status: 'stopped' }; 807 if (!readback.ok) return { status: 'unknown_completion' }; 808 const observed = privateRecordSnapshot( 809 readback.value, 810 original.owner, 811 original.id 812 ); 813 if ( 814 !wire || 815 privateRecordWire(readback.value, original.owner, original.id) !== wire || 816 !observed || 817 observed.family !== 'private_send_operation' || 818 !observed.peerArtifact || 819 !observed.deliveryPlan 820 ) 821 return { status: 'conflict' }; 822 const receipt = Object.freeze({}) as PairedDeliveryAcknowledgement; 823 pairedAcknowledgements.set(receipt, { 824 record: observed, 825 wire, 826 current: () => ownership.current() 827 }); 828 return { status, receipt }; 829 } catch { 830 return { status: current() ? 'unavailable' : 'stopped' }; 831 } 832 } 833 export function pairedDeliveryAcknowledgementSnapshot( 834 receipt: PairedDeliveryAcknowledgement 835 ) { 836 const saved = pairedAcknowledgements.get(receipt); 837 if ( 838 !saved?.current() || 839 pendingRoutingReviews.has(receipt) || 840 !saved.record.peerArtifact || 841 !saved.record.deliveryPlan 842 ) 843 return undefined; 844 const row = saved.record; 845 return { 846 owner: row.owner, 847 id: row.id, 848 revision: row.revision, 849 peer: row.peer, 850 rumorHash: row.rumorHash, 851 createdAt: row.createdAt, 852 self: { ...row.self }, 853 peerArtifact: { ...saved.record.peerArtifact }, 854 deliveryPlan: JSON.parse( 855 JSON.stringify(saved.record.deliveryPlan) 856 ) as NonNullable<PrivateSendOperation['deliveryPlan']>, 857 fact: 'acknowledged_local_pair_only' as const 858 }; 859 } 860 export async function verifyPairedDeliveryAcknowledgement( 861 repository: PrivateStorageRepository, 862 receipt: PairedDeliveryAcknowledgement 863 ): Promise<boolean> { 864 const saved = pairedAcknowledgements.get(receipt); 865 if (!saved?.current() || pendingRoutingReviews.has(receipt)) return false; 866 const loaded = await loadPrivateRecord( 867 repository, 868 'private_sends', 869 saved.record.id 870 ); 871 return ( 872 saved.current() && 873 !pendingRoutingReviews.has(receipt) && 874 loaded.ok && 875 privateRecordWire(loaded.value, saved.record.owner, saved.record.id) === 876 saved.wire 877 ); 878 } 879 // A separately decoded row cannot supply acceptance facts merely because the 880 // owner and local ID match. Require the full wire acknowledged by this genuine 881 // current custody, then let the workflow recheck actual storage before use. 882 export function pairedDeliveryRecordMatches( 883 receipt: PairedDeliveryAcknowledgement, 884 record: PrivateRecordHandle 885 ): boolean { 886 const saved = pairedAcknowledgements.get(receipt); 887 return ( 888 !!saved?.current() && 889 !pendingRoutingReviews.has(receipt) && 890 privateRecordWire(record, saved.record.owner, saved.record.id) === 891 saved.wire 892 ); 893 } 894 // Pure genuine custody metadata. A workflow must still verify full readback 895 // under the owner lock before suppressing or admitting a network effect. 896 export function pairedDeliveryTargetAccepted( 897 receipt: PairedDeliveryAcknowledgement, 898 role: 'peer' | 'self_archive', 899 origin: string, 900 eventId: string 901 ): boolean { 902 const saved = pairedAcknowledgements.get(receipt); 903 return ( 904 !!saved?.current() && 905 !pendingRoutingReviews.has(receipt) && 906 (saved.record.receipts ?? []).some( 907 (fact) => 908 fact.role === role && 909 fact.origin === origin && 910 fact.eventId === eventId && 911 fact.status === 'accepted' 912 ) 913 ); 914 } 915 // Only the already genuine current pair can renew its exact custody after a 916 // controlled append of named receipt metadata. A decoded namespace row alone 917 // cannot mint this acknowledgment. Earlier permissions invalidate on revision. 918 export async function commitPairedDeliveryReceipt( 919 repository: PrivateStorageRepository, 920 receipt: PairedDeliveryAcknowledgement, 921 receiptWire: unknown 922 ): Promise<PrivateReceiptCommitResult> { 923 const saved = pairedAcknowledgements.get(receipt); 924 if (!saved?.current() || pendingRoutingReviews.has(receipt)) 925 return { status: 'invalid' }; 926 try { 927 const loaded = await loadPrivateRecord( 928 repository, 929 'private_sends', 930 saved.record.id 931 ); 932 if (!loaded.ok) return { status: loaded.reason }; 933 if ( 934 !saved.current() || 935 privateRecordWire(loaded.value, saved.record.owner, saved.record.id) !== 936 saved.wire 937 ) 938 return { status: 'conflict' }; 939 const transition = preparePrivateReceiptTransition( 940 loaded.value, 941 saved.record.owner, 942 saved.record.id, 943 receiptWire 944 ); 945 if (!transition.ok) return { status: 'invalid' }; 946 const committed = await commitPrivateReceiptTransition( 947 repository, 948 transition.value 949 ); 950 if (!('record' in committed)) return committed; 951 const row = privateRecordSnapshot( 952 committed.record, 953 saved.record.owner, 954 saved.record.id 955 ), 956 wire = privateRecordWire( 957 committed.record, 958 saved.record.owner, 959 saved.record.id 960 ); 961 if (!saved.current()) return { status: 'unknown_completion' }; 962 if ( 963 !row || 964 row.family !== 'private_send_operation' || 965 !wire || 966 !row.peerArtifact || 967 !row.deliveryPlan 968 ) 969 return { status: 'conflict' }; 970 pairedAcknowledgements.set(receipt, { 971 record: row, 972 wire, 973 current: saved.current 974 }); 975 return committed; 976 } catch { 977 return { status: 'unknown_completion' }; 978 } 979 }