app

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

private-envelope-capability.test.ts (4353B)


      1 import { test } from 'node:test';
      2 import assert from 'node:assert/strict';
      3 import * as boundary from '../../src/lib/nostr/private-envelope-capability.ts';
      4 import {
      5   createIdentitySession,
      6   connectIdentity,
      7   probeIdentityMessaging,
      8   disconnectIdentity,
      9   recheckIdentityOwner
     10 } from '../../src/lib/runtime/identity-session.ts';
     11 import { createPrivateSession } from '../../src/lib/runtime/private-session.ts';
     12 
     13 // HC_TEST_ONLY_PROVIDER: actual SDK ownership; echo is not encryption qualification.
     14 await test('outer-only construction permission follows actual SDK private-session generations without creating keys', async () => {
     15   const owner =
     16     '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
     17   const other =
     18     'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
     19   assert.equal(typeof window, 'undefined');
     20   assert.equal(boundary.getPrivateEnvelopeCapability({} as never), undefined);
     21   let key = owner,
     22     prompts = 0,
     23     signatures = 0;
     24   Object.defineProperty(globalThis, 'window', {
     25     configurable: true,
     26     value: {
     27       nostr: {
     28         getPublicKey: () => {
     29           prompts++;
     30           return Promise.resolve(key);
     31         },
     32         signEvent: () => {
     33           signatures++;
     34           return Promise.reject(new Error('HC_TEST_ONLY_UNEXPECTED_SIGN'));
     35         },
     36         nip44: {
     37           encrypt: (_peer: string, text: string) =>
     38             Promise.resolve('fixture:' + text),
     39           decrypt: (_peer: string, text: string) =>
     40             Promise.resolve(text.slice(8))
     41         }
     42       }
     43     }
     44   });
     45   const identity = createIdentitySession();
     46   async function connect() {
     47     assert.equal((await connectIdentity(identity)).state, 'signing_only');
     48     assert.equal(
     49       (await probeIdentityMessaging(identity, 'reviewed_self_copy')).state,
     50       'messaging_capable'
     51     );
     52     const session = await createPrivateSession(
     53       identity,
     54       'reviewed_private_session'
     55     );
     56     assert.ok(session);
     57     return session;
     58   }
     59   try {
     60     assert.throws(
     61       () => boundary.getPrivateEnvelopeCapability({} as never),
     62       /private_session_invalid/
     63     );
     64     assert.throws(
     65       () => boundary.getPrivateEnvelopeCapability(identity as never),
     66       /private_session_invalid/
     67     );
     68     assert.equal(prompts, 0);
     69     const session = await connect();
     70     const before = prompts;
     71     const token = boundary.getPrivateEnvelopeCapability(session);
     72     assert.ok(token);
     73     assert.equal(boundary.getPrivateEnvelopeCapability(session), token);
     74     assert.deepEqual(Reflect.ownKeys(token), []);
     75     const captured = boundary.privateEnvelopeConstructionOwnership(token);
     76     assert.ok(captured);
     77     assert.equal(captured.kind, 1059);
     78     assert.equal(captured.owner, owner);
     79     assert.equal(captured.current(), true);
     80     assert.deepEqual(Object.keys(captured).sort(), [
     81       'current',
     82       'kind',
     83       'owner',
     84       'session'
     85     ]);
     86     assert.equal(prompts, before);
     87     assert.equal(signatures, 0);
     88     disconnectIdentity(identity);
     89     assert.equal(captured.current(), false);
     90     assert.equal(
     91       boundary.privateEnvelopeConstructionOwnership(token),
     92       undefined
     93     );
     94     const again = boundary.getPrivateEnvelopeCapability(await connect());
     95     assert.ok(again);
     96     assert.notEqual(again, token);
     97     assert.equal(
     98       boundary.privateEnvelopeConstructionOwnership(token),
     99       undefined
    100     );
    101     key = other;
    102     assert.equal((await recheckIdentityOwner(identity)).state, 'guest');
    103     assert.equal(
    104       boundary.privateEnvelopeConstructionOwnership(again),
    105       undefined
    106     );
    107     const replacementSession = await connect();
    108     const replacement =
    109       boundary.getPrivateEnvelopeCapability(replacementSession);
    110     assert.ok(replacement);
    111     assert.equal(
    112       boundary.privateEnvelopeConstructionOwnership(replacement)?.owner,
    113       other
    114     );
    115     boundary.closePrivateEnvelopeCapability(replacement);
    116     boundary.closePrivateEnvelopeCapability(replacement);
    117     assert.equal(
    118       boundary.privateEnvelopeConstructionOwnership(replacement),
    119       undefined
    120     );
    121     assert.throws(
    122       () => boundary.getPrivateEnvelopeCapability(replacementSession),
    123       /private_envelope_capability_closed/
    124     );
    125     assert.equal(signatures, 0);
    126   } finally {
    127     disconnectIdentity(identity);
    128     Reflect.deleteProperty(globalThis, 'window');
    129   }
    130 });