local-data-review.ts (29853B)
1 // HC_TEST_ONLY_RELAY: original production UI/storage with a controlled SDK. 2 // No loopback or controlled provider result represents live extension Q. 3 import { mount, unmount } from 'svelte'; 4 import { validateRelayPolicy } from '../../../src/lib/config/relays.ts'; 5 import { verifyEnvelope } from '../../../src/lib/nostr/verified-envelope.ts'; 6 import { captureEnquiryContext } from '../../../src/lib/messaging/enquiry-context.ts'; 7 import { 8 captureEnquiryRumor, 9 stopRumorPlan 10 } from '../../../src/lib/messaging/rumor-plan.ts'; 11 import { 12 reserveSendIdentity, 13 reservedSendSnapshot 14 } from '../../../src/lib/messaging/send-identity.ts'; 15 import { 16 captureSelfRecoveryPreparation, 17 prepareSelfRecovery, 18 preparePairedDelivery, 19 preparedPairedDelivery, 20 stopSelfRecoveryPreparation 21 } from '../../../src/lib/messaging/prepare-send.ts'; 22 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; 23 import { createInboxRoutePlan } from '../../../src/lib/messaging/inbox-routing.ts'; 24 import { 25 createPublicScheduler, 26 createPublicRun, 27 openInboxRequest, 28 closePublicScheduler 29 } from '../../../src/lib/nostr/request-scope.ts'; 30 31 import Panel from '../../../src/lib/components/LocalDataReview.svelte'; 32 import { makeFixture } from './approved-signing.ts'; 33 import { finalizeEvent, getEventHash } from 'applesauce-core/helpers'; 34 import { nip44 } from 'applesauce-core/helpers/encryption'; 35 import { 36 createIdentityViewContext, 37 mountIdentityView, 38 connectIdentityView, 39 probeIdentityViewMessaging, 40 identityViewSession, 41 disconnectIdentityView, 42 closeIdentityView 43 } from '../../../src/lib/runtime/view-context.ts'; 44 import { 45 createLocalDataReview, 46 reviewLocalData, 47 localDataReviewSnapshot, 48 previewLocalDataRemoval, 49 confirmLocalDataRemoval, 50 closeLocalDataReview 51 } from '../../../src/lib/persistence/local-data-review.ts'; 52 import { 53 openBrowserDatabase, 54 closeBrowserDatabase, 55 browserDatabaseTransaction 56 } from '../../../src/lib/persistence/database.ts'; 57 import { 58 createPublicDraftRepository, 59 createPublicDraft, 60 savePublicDraft 61 } from '../../../src/lib/persistence/drafts.ts'; 62 import { 63 createPublicQuotaRepository, 64 admitPublicOperation 65 } from '../../../src/lib/persistence/quota.ts'; 66 import { identityLocalOwnership } from '../../../src/lib/runtime/identity-session.ts'; 67 import { 68 createPrivateSession, 69 withIdlePrivateLocalStorage 70 } from '../../../src/lib/runtime/private-session.ts'; 71 import { 72 createPrivateSendReservationRepository, 73 reservePrivateSendReservation 74 } from '../../../src/lib/persistence/private-send-reservations.ts'; 75 import { 76 createPrivateStorageRepository, 77 commitPrivateRecord, 78 listPrivateReceivedRecords 79 } from '../../../src/lib/persistence/private-storage.ts'; 80 import { 81 decodePrivateRecord, 82 privateRecordIdentity, 83 privateRecordSnapshot, 84 type PrivateSendOperation 85 } from '../../../src/lib/persistence/private-records.ts'; 86 87 export async function createFixture(mode = 'normal') { 88 const signer = makeFixture(), 89 foreign = makeFixture(), 90 owner = signer.owner; 91 const prior = Object.getOwnPropertyDescriptor(window, 'nostr'); 92 let changedKey = false; 93 let counts = { reads: 0, signs: 0, encrypts: 0, decrypts: 0 }; 94 Object.defineProperty(window, 'nostr', { 95 configurable: true, 96 value: { 97 getPublicKey() { 98 counts.reads++; 99 return Promise.resolve(changedKey ? foreign.owner : owner); 100 }, 101 signEvent(template: Parameters<typeof signer.sign>[0]) { 102 counts.signs++; 103 return Promise.resolve(signer.sign(template)); 104 }, 105 nip44: { 106 encrypt(peer: string, text: string) { 107 counts.encrypts++; 108 return Promise.resolve(signer.encrypt(peer, text)); 109 }, 110 decrypt(peer: string, text: string) { 111 counts.decrypts++; 112 return Promise.resolve(signer.decrypt(peer, text)); 113 } 114 } 115 } 116 }); 117 const identity = createIdentityViewContext(); 118 mountIdentityView(identity); 119 await connectIdentityView(identity); 120 if (mode === 'messaging' || mode === 'outbox') 121 await probeIdentityViewMessaging(identity, 'reviewed_self_copy'); 122 if (!identityViewSession(identity)) 123 throw Error('original connected identity absent'); 124 const opened = await openBrowserDatabase(); 125 if (opened.state !== 'ready') throw Error('native database absent'); 126 const database = opened.owner, 127 drafts = createPublicDraftRepository(database, owner), 128 foreignDrafts = createPublicDraftRepository(database, foreign.owner), 129 quota = createPublicQuotaRepository(database, owner), 130 priv = createPrivateStorageRepository(database, owner), 131 foreignPriv = createPrivateStorageRepository(database, foreign.owner); 132 if (!drafts || !foreignDrafts || !quota || !priv || !foreignPriv) 133 throw Error('original namespaces absent'); 134 const form = { 135 title: 'PUBLIC DRAFT BODY SENTINEL', 136 description: '', 137 location: '', 138 amount: '', 139 currency: '', 140 unit: '', 141 quantity: '', 142 contactType: '' as const, 143 contactValue: '' 144 }; 145 const first = await createPublicDraft(drafts, form), 146 second = await createPublicDraft(drafts, form), 147 other = await createPublicDraft(foreignDrafts, { 148 ...form, 149 title: 'PRIVATE OWNER B SENTINEL' 150 }); 151 if ( 152 !first.ok || 153 !second.ok || 154 !other.ok || 155 !(await admitPublicOperation(quota, signer.id, signer.record)).ok 156 ) 157 throw Error('original public data absent'); 158 const outerSecret = new Uint8Array(32).fill(69), 159 ids: string[] = []; 160 try { 161 for (const [target, repository, offset] of [ 162 [owner, priv, 0], 163 [owner, priv, 1], 164 [foreign.owner, foreignPriv, 2] 165 ] as const) { 166 const key = nip44.v2.utils.getConversationKey(outerSecret, target); 167 let content: string; 168 try { 169 content = nip44.v2.encrypt('controlled opaque seal bytes', key); 170 } finally { 171 key.fill(0); 172 } 173 const outer = finalizeEvent( 174 { 175 kind: 1059, 176 created_at: 1700000000 + offset, 177 tags: [['p', target]], 178 content 179 }, 180 outerSecret 181 ); 182 const row = decodePrivateRecord( 183 JSON.stringify({ 184 schema: 1, 185 family: 'received_envelope', 186 owner: target, 187 id: outer.id, 188 revision: 0, 189 outer: JSON.stringify(outer), 190 observedAtMilliseconds: 100, 191 sources: ['wss://archive.example.org'], 192 read: null 193 }), 194 target, 195 outer.id 196 ); 197 if ( 198 !row.ok || 199 !(await commitPrivateRecord(repository, row.value, null)).ok 200 ) 201 throw Error('real encrypted structural copy absent'); 202 if (target === owner) ids.push(outer.id); 203 } 204 } finally { 205 outerSecret.fill(0); 206 } 207 const reservationId = crypto.randomUUID(); 208 const reservationWire = JSON.stringify({ 209 schema: 1, 210 family: 'private_send_reservation', 211 owner, 212 id: reservationId, 213 revision: 0, 214 peer: foreign.owner, 215 rumorHash: 'b'.repeat(64), 216 createdAt: 1700000000 217 }); 218 const reservationRepository = createPrivateSendReservationRepository( 219 database, 220 owner 221 ); 222 const originalIdentity = identityViewSession(identity); 223 const ownership = 224 originalIdentity && identityLocalOwnership(originalIdentity); 225 if (!reservationRepository || !ownership) 226 throw Error('original outbox scope absent'); 227 if ( 228 mode !== 'outbox' && 229 !( 230 await reservePrivateSendReservation( 231 reservationRepository, 232 reservationWire, 233 1700000000, 234 ownership.current 235 ) 236 ).ok 237 ) 238 throw Error('original protected outbox absent'); 239 const settledIds = Array.from<string>([]); 240 function pairedRecord(index: number): PrivateSendOperation { 241 const id = crypto.randomUUID(), 242 rumorTemplate = { 243 pubkey: owner, 244 kind: 14, 245 created_at: 1700000000 + index, 246 tags: [['p', foreign.owner]], 247 content: 'CR004_TEST_ONLY_nested_capacity_' + index 248 }, 249 rumor = { ...rumorTemplate, id: getEventHash(rumorTemplate) }; 250 const artifact = (destination: string) => { 251 const seal = signer.sign({ 252 kind: 13, 253 created_at: 1700000000 + index, 254 tags: [], 255 content: signer.encrypt(destination, JSON.stringify(rumor)) 256 }); 257 const wrapper = crypto.getRandomValues(new Uint8Array(32)), 258 conversation = nip44.v2.utils.getConversationKey(wrapper, destination); 259 try { 260 const outer = finalizeEvent( 261 { 262 kind: 1059, 263 created_at: 1700000000 + index, 264 tags: [['p', destination]], 265 content: nip44.v2.encrypt(JSON.stringify(seal), conversation) 266 }, 267 wrapper 268 ); 269 return { eventId: outer.id, wire: JSON.stringify(outer) }; 270 } finally { 271 wrapper.fill(0); 272 conversation.fill(0); 273 } 274 }; 275 const self = artifact(owner), 276 peerArtifact = artifact(foreign.owner); 277 const route = ( 278 role: 'peer' | 'self_archive', 279 author: string, 280 origin: string 281 ) => ({ 282 role, 283 author, 284 targets: [origin], 285 knownBase: { author, id: 'c'.repeat(64), createdAt: 100 }, 286 sources: [ 287 { 288 source: 'wss://discovery.example.org', 289 state: 'eose' as const, 290 head: { id: 'c'.repeat(64), createdAt: 100 } 291 } 292 ] 293 }); 294 // Seeded local receipt bookkeeping only, not genuine remote ACK/operator Q. 295 return { 296 schema: 1, 297 family: 'private_send_operation', 298 owner, 299 id, 300 revision: 1, 301 peer: foreign.owner, 302 rumorHash: rumor.id, 303 createdAt: rumor.created_at, 304 self, 305 peerArtifact, 306 deliveryPlan: { 307 state: 'prepared', 308 routes: { 309 peer: route('peer', foreign.owner, 'wss://peer.example.org'), 310 archive: route('self_archive', owner, 'wss://archive.example.org') 311 } 312 }, 313 receipts: [ 314 { 315 actionId: crypto.randomUUID(), 316 origin: 'wss://peer.example.org', 317 role: 'peer', 318 attempt: 1, 319 eventId: peerArtifact.eventId, 320 status: 'accepted', 321 observedAtMilliseconds: 1700000000000, 322 readbackWire: null 323 }, 324 { 325 actionId: crypto.randomUUID(), 326 origin: 'wss://archive.example.org', 327 role: 'self_archive', 328 attempt: 1, 329 eventId: self.eventId, 330 status: 'accepted', 331 observedAtMilliseconds: 1700000000000, 332 readbackWire: null 333 } 334 ] 335 }; 336 } 337 if (mode === 'outbox') { 338 const rows = Array.from({ length: 100 }, (_, index) => pairedRecord(index)); 339 for (const row of rows) { 340 if (!decodePrivateRecord(JSON.stringify(row), owner, row.id).ok) 341 throw Error('strict nested-pair journal fixture rejected'); 342 settledIds.push(row.id); 343 } 344 const tx = browserDatabaseTransaction( 345 database, 346 ['private_sends'], 347 'readwrite' 348 ); 349 for (const row of rows) 350 tx.objectStore('private_sends').put({ 351 owner, 352 id: row.id, 353 wire: JSON.stringify(row) 354 }); 355 await new Promise<void>((resolve, reject) => { 356 tx.addEventListener('complete', () => resolve()); 357 tx.addEventListener('abort', () => reject(Error('capacity seed abort'))); 358 }); 359 } 360 const corruptId = crypto.randomUUID(); 361 async function transactionRows() { 362 const tx = browserDatabaseTransaction( 363 database, 364 [ 365 'public_drafts', 366 'public_operations', 367 'received_envelopes', 368 'private_sends' 369 ], 370 'readonly' 371 ); 372 const requests = [ 373 'public_drafts', 374 'public_operations', 375 'received_envelopes', 376 'private_sends' 377 ].map((name) => tx.objectStore(name).getAll()); 378 await new Promise<void>((resolve, reject) => { 379 tx.addEventListener('complete', () => resolve()); 380 tx.addEventListener('abort', () => 381 reject(Error('native observation abort')) 382 ); 383 }); 384 return requests.map( 385 (request) => 386 request.result as { owner: string; id: string; wire: string }[] 387 ); 388 } 389 if (mode === 'corrupt') { 390 const tx = browserDatabaseTransaction( 391 database, 392 ['public_operations'], 393 'readwrite' 394 ); 395 tx.objectStore('public_operations').put({ 396 owner, 397 id: corruptId, 398 wire: '{"schema":99}' 399 }); 400 await new Promise<void>((resolve, reject) => { 401 tx.addEventListener('complete', () => resolve()); 402 tx.addEventListener('abort', () => reject(Error('fixture seed abort'))); 403 }); 404 } 405 counts = { reads: 0, signs: 0, encrypts: 0, decrypts: 0 }; 406 const review = createLocalDataReview(identity); 407 const target = document.createElement('div'); 408 target.id = 'hcp125-panel'; 409 document.body.append(target); 410 const component = mount(Panel, { target, props: { review } }); 411 const inspect = () => reviewLocalData(review, 'reviewed_local_inventory'); 412 const preview = () => 413 previewLocalDataRemoval( 414 review, 415 'public', 416 JSON.stringify(['public_draft:' + first.value.id]) 417 ); 418 const confirm = () => 419 confirmLocalDataRemoval(review, 'reviewed_local_removal'); 420 return { 421 owner, 422 settledIds: () => settledIds.slice(), 423 async reviewAndPreviewOutbox() { 424 await inspect(); 425 return previewLocalDataRemoval( 426 review, 427 'outbox', 428 JSON.stringify([settledIds[0]]) 429 ); 430 }, 431 // Actual local sender factories; controlled discovery/SDK inputs are not 432 // remote delivery, an installed extension, or operator qualification. 433 async freshSend() { 434 const session = identityViewSession(identity); 435 if (!session) throw Error('original sender identity absent'); 436 const food = foreign.sign({ 437 kind: 30402, 438 created_at: Math.floor(Date.now() / 1000), 439 content: 'Fresh capacity fixture carrots', 440 tags: [ 441 ['d', 'capacity-carrots'], 442 ['title', 'Carrots'], 443 ['summary', 'Fresh carrots'], 444 ['published_at', '1700000000'], 445 ['location', 'Victoria'], 446 ['price', '3.5', 'CAD'], 447 ['radroots:price_unit', 'lb'], 448 ['status', 'active'] 449 ] 450 }); 451 const verified = verifyEnvelope(JSON.stringify(food)), 452 context = verified.ok && captureEnquiryContext(verified.value), 453 rumor = 454 context && 455 captureEnquiryRumor( 456 session, 457 context, 458 'CR004 fresh factory send', 459 Math.floor(Date.now() / 1000) 460 ); 461 if (!rumor) throw Error('genuine fresh rumor absent'); 462 const schedulers: ReturnType<typeof createPublicScheduler>[] = []; 463 let preparation: ReturnType<typeof captureSelfRecoveryPreparation>; 464 try { 465 const reserved = await reserveSendIdentity( 466 reservationRepository, 467 session, 468 crypto.randomUUID(), 469 rumor, 470 'reviewed_private_intent' 471 ); 472 if (!('identity' in reserved)) return { reservation: reserved.status }; 473 const id = reservedSendSnapshot(reserved.identity)?.id; 474 preparation = captureSelfRecoveryPreparation( 475 priv, 476 session, 477 reserved.identity, 478 'reviewed_self_recovery' 479 ); 480 if (!preparation) throw Error('actual self-first factory absent'); 481 const self = await prepareSelfRecovery( 482 preparation, 483 'reviewed_self_recovery' 484 ); 485 const discovery = 'wss://discovery.example.org', 486 peerOrigin = 'wss://peer.example.org', 487 archiveOrigin = 'wss://archive.example.org'; 488 const policy = validateRelayPolicy( 489 JSON.stringify({ 490 schemaVersion: 1, 491 public: [ 492 { origin: discovery, read: true, write: false, nip50: false } 493 ], 494 inbox: [peerOrigin, archiveOrigin].map((origin) => ({ 495 origin, 496 read: true, 497 write: true 498 })), 499 postingEnabled: false, 500 messagingEnabled: true, 501 operatorDenylist: [] 502 }) 503 ); 504 if (!policy) throw Error('controlled discovery policy absent'); 505 function resolve(signer: typeof foreign, origin: string) { 506 const event = signer.sign({ 507 kind: 10050, 508 created_at: Math.floor(Date.now() / 1000), 509 tags: [['relay', origin]], 510 content: '' 511 }), 512 scheduler = createPublicScheduler(), 513 run = createPublicRun(scheduler, policy!); 514 schedulers.push(scheduler); 515 return createInboxResolver( 516 run, 517 signer.owner, 518 (next) => 519 openInboxRequest( 520 run, 521 signer.owner, 522 (sink) => { 523 sink({ 524 type: 'EVENT', 525 from: discovery, 526 id: 'CR004_TEST_ONLY', 527 event 528 }); 529 sink({ 530 type: 'EOSE', 531 from: discovery, 532 id: 'CR004_TEST_ONLY' 533 }); 534 return () => {}; 535 }, 536 next 537 ), 538 () => ownership?.current() === true 539 ); 540 } 541 const own = resolve(signer, archiveOrigin), 542 other = resolve(foreign, peerOrigin), 543 plan = createInboxRoutePlan(policy, owner, foreign.owner, own, other); 544 if (!plan) throw Error('actual reviewed route plan absent'); 545 const pair = await preparePairedDelivery( 546 preparation, 547 { policy, own, other, plan }, 548 'reviewed_pair_preparation' 549 ); 550 return { 551 reservation: reserved.status, 552 self: self.status, 553 pair: pair.status, 554 paired: !!preparedPairedDelivery(preparation), 555 id 556 }; 557 } finally { 558 if (preparation) stopSelfRecoveryPreparation(preparation); 559 stopRumorPlan(rumor); 560 for (const scheduler of schedulers) closePublicScheduler(scheduler); 561 } 562 }, 563 async reserveNext() { 564 const result = await reservePrivateSendReservation( 565 reservationRepository, 566 JSON.stringify({ 567 schema: 1, 568 family: 'private_send_reservation', 569 owner, 570 id: crypto.randomUUID(), 571 revision: 0, 572 peer: foreign.owner, 573 rumorHash: '8'.repeat(64), 574 createdAt: 1700000000 575 }), 576 1700000000, 577 ownership.current 578 ); 579 return result.ok ? 'reserved' : result.reason; 580 }, 581 async changeOutbox() { 582 const stored = (await transactionRows())[3].find( 583 (row) => row.id === settledIds[0] 584 ); 585 if (!stored) throw Error('original outbox row absent'); 586 const decoded = decodePrivateRecord(stored.wire, owner, stored.id), 587 record = 588 decoded.ok && privateRecordSnapshot(decoded.value, owner, stored.id); 589 if ( 590 !decoded.ok || 591 !record || 592 record.family !== 'private_send_operation' || 593 !record.receipts?.length 594 ) 595 throw Error('original paired record absent'); 596 const next = decodePrivateRecord( 597 JSON.stringify({ 598 ...record, 599 revision: record.revision + 1, 600 receipts: [ 601 ...record.receipts, 602 { 603 ...record.receipts[0], 604 actionId: crypto.randomUUID(), 605 status: 'unknown' 606 } 607 ] 608 }), 609 owner, 610 record.id 611 ); 612 if ( 613 !next.ok || 614 !(await commitPrivateRecord(priv, next.value, decoded.value)).ok 615 ) 616 throw Error('actual outbox CAS change absent'); 617 }, 618 switchKey: () => { 619 changedKey = true; 620 }, 621 async confirmWhileSdkBusy() { 622 const original = identityViewSession(identity); 623 if (!original) throw Error('actual identity absent'); 624 const session = await createPrivateSession( 625 original, 626 'reviewed_private_session' 627 ); 628 if (!session) throw Error('actual private session absent'); 629 let entered = () => {}, 630 release = () => {}; 631 const ready = new Promise<void>((resolve) => { 632 entered = resolve; 633 }); 634 const held = withIdlePrivateLocalStorage( 635 session, 636 () => 637 new Promise<void>((resolve) => { 638 release = resolve; 639 entered(); 640 }) 641 ); 642 await ready; 643 try { 644 return await confirm(); 645 } finally { 646 release(); 647 await held; 648 } 649 }, 650 async abortOutboxDelete(unknown = false) { 651 const descriptor = Object.getOwnPropertyDescriptor( 652 IDBObjectStore.prototype, 653 'delete' 654 ); 655 if (!descriptor) throw Error('actual delete descriptor absent'); 656 const nativeDelete = descriptor.value as IDBObjectStore['delete'], 657 nativeAbort = Reflect.get<IDBTransaction, 'abort'>( 658 IDBTransaction.prototype, 659 'abort' 660 ); 661 let deletes = 0, 662 aborts = 0; 663 let terminal: Promise<'abort' | 'complete'> | undefined; 664 IDBObjectStore.prototype.delete = function (...args) { 665 const request = Reflect.apply(nativeDelete, this, args); 666 if (this.name === 'private_sends') { 667 const transaction = this.transaction; 668 terminal = new Promise((resolve) => { 669 transaction.addEventListener('abort', () => { 670 aborts++; 671 resolve('abort'); 672 }); 673 transaction.addEventListener('complete', () => resolve('complete')); 674 }); 675 if (unknown) { 676 this.transaction.abort = () => { 677 throw Error('controlled lost abort capability'); 678 }; 679 throw Error( 680 'controlled lost delete result after actual queued request' 681 ); 682 } 683 request.addEventListener( 684 'success', 685 () => { 686 deletes++; 687 Reflect.apply(nativeAbort, this.transaction, []); 688 }, 689 { once: true } 690 ); 691 } 692 return request; 693 }; 694 try { 695 const confirmed = await confirm(), 696 nativeTerminal = terminal && (await terminal); 697 return { confirmed, deletes, aborts, nativeTerminal }; 698 } finally { 699 Object.defineProperty(IDBObjectStore.prototype, 'delete', descriptor); 700 } 701 }, 702 effects: () => ({ ...counts }), 703 snapshot: () => localDataReviewSnapshot(review), 704 review: inspect, 705 confirm, 706 async reviewAndPreview() { 707 await inspect(); 708 if (!(await preview())) throw Error('original public preview absent'); 709 }, 710 async reviewAndPreviewReceived() { 711 await inspect(); 712 if ( 713 !(await previewLocalDataRemoval( 714 review, 715 'received', 716 JSON.stringify([ids[0]]) 717 )) 718 ) 719 throw Error('original received preview absent'); 720 }, 721 changeDraft: () => 722 savePublicDraft(drafts, first.value.id, 0, { 723 ...form, 724 title: 'new actual revision' 725 }), 726 async changeReceived() { 727 const scan = await listPrivateReceivedRecords(priv); 728 if (!scan.ok) throw Error('native scan absent'); 729 const handle = scan.value.find( 730 (row) => privateRecordIdentity(row)?.id === ids[0] 731 ); 732 const row = handle && privateRecordSnapshot(handle, owner, ids[0]); 733 if (!handle || row?.family !== 'received_envelope') 734 throw Error('native selected copy absent'); 735 const next = decodePrivateRecord( 736 JSON.stringify({ 737 ...row, 738 revision: row.revision + 1, 739 sources: [...row.sources, 'wss://other.example.org'] 740 }), 741 owner, 742 row.id 743 ); 744 if (!next.ok || !(await commitPrivateRecord(priv, next.value, handle)).ok) 745 throw Error('real received CAS change absent'); 746 }, 747 async rows() { 748 const [publicRows, operations, received, outbox] = 749 await transactionRows(); 750 return { 751 publicDrafts: publicRows.filter((row) => row.owner === owner).length, 752 foreignDrafts: publicRows.filter((row) => row.owner === foreign.owner) 753 .length, 754 publicOperations: operations.filter((row) => row.owner === owner) 755 .length, 756 received: received.filter((row) => row.owner === owner).length, 757 foreignReceived: received.filter((row) => row.owner === foreign.owner) 758 .length, 759 outbox: outbox.filter((row) => row.owner === owner).length 760 }; 761 }, 762 async rawCorrupt() { 763 return (await transactionRows())[1].find((row) => row.id === corruptId) 764 ?.wire; 765 }, 766 logout: () => disconnectIdentityView(identity), 767 dispose: () => closeLocalDataReview(review), 768 async hostileSelections() { 769 const key = 'public_draft:' + first.value.id; 770 const values = [ 771 'not JSON', 772 '[]', 773 JSON.stringify([key, key]), 774 JSON.stringify(['public_operation:' + signer.id]), 775 JSON.stringify(['public_draft:' + other.value.id]) 776 ]; 777 const results: boolean[] = []; 778 for (const value of values) 779 results.push(await previewLocalDataRemoval(review, 'public', value)); 780 return results; 781 }, 782 async confirmWhileLocked() { 783 let release = () => {}, 784 entered = () => {}; 785 const ready = new Promise<void>((resolve) => { 786 entered = resolve; 787 }); 788 const held = navigator.locks.request( 789 'harvestcircle:owner:' + owner, 790 async () => { 791 entered(); 792 await new Promise<void>((resolve) => { 793 release = resolve; 794 }); 795 } 796 ); 797 await ready; 798 try { 799 return await confirm(); 800 } finally { 801 release(); 802 await held; 803 } 804 }, 805 async abortDuringDelete() { 806 const descriptor = Object.getOwnPropertyDescriptor( 807 IDBObjectStore.prototype, 808 'delete' 809 ); 810 if (!descriptor) throw Error('native delete descriptor absent'); 811 const nativeDelete = descriptor.value as IDBObjectStore['delete']; 812 let deleteSuccesses = 0, 813 nativeAborts = 0; 814 let terminal: Promise<'abort' | 'complete'> | undefined; 815 IDBObjectStore.prototype.delete = function (...args) { 816 const request = nativeDelete.apply(this, args); 817 if (this.name === 'public_drafts') { 818 const transaction = this.transaction; 819 terminal = new Promise((resolve) => { 820 transaction.addEventListener('abort', () => { 821 nativeAborts++; 822 resolve('abort'); 823 }); 824 transaction.addEventListener('complete', () => resolve('complete')); 825 }); 826 request.addEventListener('success', () => { 827 deleteSuccesses++; 828 disconnectIdentityView(identity); 829 }); 830 } 831 return request; 832 }; 833 try { 834 const confirmed = await confirm(); 835 const nativeTerminal = terminal && (await terminal); 836 return { confirmed, deleteSuccesses, nativeAborts, nativeTerminal }; 837 } finally { 838 Object.defineProperty(IDBObjectStore.prototype, 'delete', descriptor); 839 } 840 }, 841 async oldConfirmationThenNewPreview() { 842 await inspect(); 843 if ( 844 !(await previewLocalDataRemoval( 845 review, 846 'received', 847 JSON.stringify([ids[0]]) 848 )) 849 ) 850 throw Error('old actual selection absent'); 851 const native = navigator.locks.request.bind(navigator.locks); 852 let release = () => {}, 853 markHeld = () => {}, 854 held = false; 855 const reached = new Promise<void>((resolve) => { 856 markHeld = resolve; 857 }); 858 const pause = new Promise<void>((resolve) => { 859 release = resolve; 860 }); 861 const originalMethod = Reflect.get<LockManager, 'request'>( 862 navigator.locks, 863 'request' 864 ); 865 navigator.locks.request = ( 866 name: string, 867 options: LockOptions | LockGrantedCallback<unknown>, 868 callback?: LockGrantedCallback<unknown> 869 ) => { 870 if (typeof options === 'function') return native(name, options); 871 if (!callback) throw Error('real callback absent'); 872 return native(name, options, async (lock) => { 873 const result: unknown = await callback(lock); 874 if (!held && name === 'harvestcircle:owner:' + owner && lock) { 875 held = true; 876 markHeld(); 877 await pause; 878 } 879 return result; 880 }); 881 }; 882 let old: Promise<boolean> | undefined; 883 try { 884 old = confirm(); 885 await reached; 886 disconnectIdentityView(identity); 887 await connectIdentityView(identity); 888 await probeIdentityViewMessaging(identity, 'reviewed_self_copy'); 889 await inspect(); 890 const newer = await previewLocalDataRemoval( 891 review, 892 'received', 893 JSON.stringify([ids[1]]) 894 ); 895 release(); 896 const oldConfirmed = await old; 897 const currentPreview = localDataReviewSnapshot(review); 898 const newConfirmed = await confirm(); 899 return { held, newer, oldConfirmed, currentPreview, newConfirmed }; 900 } finally { 901 release(); 902 if (old) await old; 903 navigator.locks.request = originalMethod; 904 } 905 }, 906 async close() { 907 closeLocalDataReview(review); 908 await unmount(component); 909 target.remove(); 910 closeIdentityView(identity); 911 closeBrowserDatabase(database); 912 signer.close(); 913 foreign.close(); 914 if (prior) Object.defineProperty(window, 'nostr', prior); 915 else Reflect.deleteProperty(window, 'nostr'); 916 } 917 }; 918 }