app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

inbox-probe-nonce.ts (4975B)


      1 import { makeReadbackFixture } from './inbox-probe-readback.ts';
      2 import {
      3   captureInboxProbeNonceReader,
      4   readInboxProbeNonce,
      5   inboxProbeNonceProofBinding,
      6   stopInboxProbeNonceReader,
      7   type InboxProbeNonceReader,
      8   type InboxProbeNonceProof
      9 } from '../../../src/lib/nostr/self-recovery-reader.ts';
     10 import type { UnsignedEvent } from 'applesauce-core/helpers';
     11 export * from './inbox-probe-readback.ts';
     12 export * from '../../../src/lib/nostr/self-recovery-reader.ts';
     13 export * from '../../../src/lib/nostr/extension-scheduler.ts';
     14 export * from '../../../src/lib/runtime/identity-session.ts';
     15 export async function makeNonceFixture() {
     16   const f = await makeReadbackFixture();
     17   let reader: InboxProbeNonceReader | undefined,
     18     proof: InboxProbeNonceProof | undefined;
     19   const restores = new Map<symbol, () => void>();
     20   function capture(review: unknown = 'reviewed_inbox_probe_nonce_decryption') {
     21     const observed = f.lastRead();
     22     return observed
     23       ? captureInboxProbeNonceReader(
     24           f.repository,
     25           f.identity,
     26           f.session,
     27           f.policy,
     28           observed,
     29           review
     30         )
     31       : undefined;
     32   }
     33   type Provider = {
     34     getPublicKey(): Promise<string>;
     35     signEvent(input: UnsignedEvent): Promise<Record<string, unknown>>;
     36     nip44: { decrypt(target: string, content: string): Promise<string> };
     37   };
     38   const provider = Reflect.get(window, 'nostr') as Provider;
     39   function retain(restore: () => void) {
     40     const id = Symbol();
     41     restores.set(id, restore);
     42     return () => {
     43       restore();
     44       restores.delete(id);
     45     };
     46   }
     47   return {
     48     ...f,
     49     nonceCapture: capture,
     50     nonceReader: () => reader,
     51     nonceProof: () => proof,
     52     proofBinding: () =>
     53       proof &&
     54       inboxProbeNonceProofBinding(proof, f.repository, f.session, f.policy),
     55     async nonce(selected = (reader ??= capture())) {
     56       if (!selected) return { status: 'invalid' as const };
     57       reader ??= selected;
     58       const result = await readInboxProbeNonce(selected);
     59       if ('proof' in result) proof = result.proof;
     60       return {
     61         status: result.status,
     62         proof: 'proof' in result ? result.proof : undefined
     63       };
     64     },
     65     keyCallback(hit: number, callback: () => void | Promise<void>) {
     66       const original = Object.getOwnPropertyDescriptor(
     67         provider,
     68         'getPublicKey'
     69       )!.value as Provider['getPublicKey'];
     70       let n = 0;
     71       provider.getPublicKey = async function () {
     72         n++;
     73         if (n === hit) await callback();
     74         return original.call(this);
     75       };
     76       return retain(() => {
     77         provider.getPublicKey = original;
     78       });
     79     },
     80     cipherGetter(callback: () => void) {
     81       const descriptor = Object.getOwnPropertyDescriptor(provider, 'nip44')!,
     82         cipher = provider.nip44;
     83       Object.defineProperty(provider, 'nip44', {
     84         configurable: true,
     85         get() {
     86           callback();
     87           return cipher;
     88         }
     89       });
     90       return retain(() => {
     91         Object.defineProperty(provider, 'nip44', descriptor);
     92       });
     93     },
     94     decryptCallback(
     95       hit: number,
     96       transform: (wire: string) => string | Promise<string>
     97     ) {
     98       const cipher = provider.nip44,
     99         descriptor = Object.getOwnPropertyDescriptor(cipher, 'decrypt')!,
    100         original = cipher.decrypt.bind(cipher);
    101       let n = 0,
    102         receivers = 0;
    103       Object.defineProperty(cipher, 'decrypt', {
    104         configurable: true,
    105         value: async function (
    106           this: Provider['nip44'],
    107           target: string,
    108           content: string
    109         ) {
    110           if (this !== cipher) throw Error('wrong actual cipher receiver');
    111           receivers++;
    112           const wire = await original(target, content);
    113           n++;
    114           return n === hit ? transform(wire) : wire;
    115         }
    116       });
    117       return {
    118         receivers: () => receivers,
    119         restore: retain(() => {
    120           Object.defineProperty(cipher, 'decrypt', descriptor);
    121         })
    122       };
    123     },
    124     async changedNativeFact() {
    125       const rows = await f.stored(),
    126         row = rows.find((x) => x.id === f.snapshot()!.record.id)!;
    127       const record = JSON.parse(row.wire) as {
    128         revision: number;
    129         receipts: unknown[];
    130       };
    131       record.revision++;
    132       record.receipts.push(record.receipts[0]);
    133       await f.inject([{ ...row, wire: JSON.stringify(record) }]);
    134     },
    135     async signSeal(wire: string, change: Record<string, unknown>) {
    136       const seal = JSON.parse(wire) as UnsignedEvent;
    137       const event = await provider.signEvent({
    138         pubkey: seal.pubkey,
    139         kind: seal.kind,
    140         created_at: seal.created_at,
    141         tags: seal.tags,
    142         content: seal.content,
    143         ...change
    144       });
    145       return JSON.stringify(event);
    146     },
    147     close() {
    148       if (reader) stopInboxProbeNonceReader(reader);
    149       for (const [id, off] of restores) {
    150         off();
    151         restores.delete(id);
    152       }
    153       f.close();
    154     }
    155   };
    156 }