app

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

outbound-envelope-layers.test.ts (3622B)


      1 import test from 'node:test';
      2 import assert from 'node:assert/strict';
      3 import {
      4   generateSecretKey,
      5   getPublicKey,
      6   getEventHash,
      7   finalizeEvent,
      8   type UnsignedEvent
      9 } from 'applesauce-core/helpers';
     10 import { verifyOutboundLayerData } from '../../src/lib/nostr/outbound-envelope-layers.ts';
     11 
     12 // Detached real SDK signature vectors only; no genuine preparation authority.
     13 function fixture() {
     14   const keys = [generateSecretKey(), generateSecretKey(), generateSecretKey()];
     15   const owner = getPublicKey(keys[0]),
     16     peer = getPublicKey(keys[1]);
     17   const template: UnsignedEvent = {
     18     pubkey: owner,
     19     kind: 14,
     20     created_at: 1700000000,
     21     tags: [['p', peer]],
     22     content: 'Original enquiry'
     23   };
     24   const rumor = { id: getEventHash(template), ...template };
     25   const seal = finalizeEvent(
     26     {
     27       kind: 13,
     28       created_at: 1699999900,
     29       tags: [],
     30       content: 'bounded ciphertext fixture'
     31     },
     32     keys[0]
     33   );
     34   const outer = finalizeEvent(
     35     {
     36       kind: 1059,
     37       created_at: 1699999800,
     38       tags: [['p', peer]],
     39       content: 'bounded outer fixture'
     40     },
     41     keys[2]
     42   );
     43   const original = JSON.stringify(rumor);
     44   const check = (
     45     r: unknown = rumor,
     46     s: unknown = seal,
     47     w: unknown = outer,
     48     role: 'peer' | 'self' = 'peer'
     49   ) =>
     50     verifyOutboundLayerData(
     51       original,
     52       JSON.stringify(r),
     53       JSON.stringify(s),
     54       JSON.stringify(w),
     55       owner,
     56       peer,
     57       role
     58     );
     59   return {
     60     keys,
     61     owner,
     62     peer,
     63     rumor,
     64     seal,
     65     outer,
     66     check,
     67     close: () => keys.forEach((k) => k.fill(0))
     68   };
     69 }
     70 await test('fresh SDK hashes and both signed layers preserve the exact original pair rumor', () => {
     71   const f = fixture();
     72   try {
     73     assert.equal(f.check(), true);
     74     const self = finalizeEvent(
     75       {
     76         kind: 1059,
     77         created_at: f.outer.created_at,
     78         tags: [['p', f.owner]],
     79         content: f.outer.content
     80       },
     81       f.keys[2]
     82     );
     83     assert.equal(f.check(f.rumor, f.seal, self, 'self'), true);
     84   } finally {
     85     f.close();
     86   }
     87 });
     88 await test('valid signatures do not admit wrong sender, seal tags or outer target', () => {
     89   const f = fixture();
     90   try {
     91     assert.equal(
     92       f.check(f.rumor, finalizeEvent({ ...f.seal }, f.keys[1])),
     93       false
     94     );
     95     assert.equal(
     96       f.check(
     97         f.rumor,
     98         finalizeEvent({ ...f.seal, tags: [['client', 'leak']] }, f.keys[0])
     99       ),
    100       false
    101     );
    102     assert.equal(
    103       f.check(
    104         f.rumor,
    105         f.seal,
    106         finalizeEvent({ ...f.outer, tags: [['p', f.owner]] }, f.keys[2])
    107       ),
    108       false
    109     );
    110     assert.equal(
    111       f.check(
    112         f.rumor,
    113         f.seal,
    114         finalizeEvent(
    115           {
    116             ...f.outer,
    117             tags: [
    118               ['p', f.peer],
    119               ['p', f.owner]
    120             ]
    121           },
    122           f.keys[2]
    123         )
    124       ),
    125       false
    126     );
    127   } finally {
    128     f.close();
    129   }
    130 });
    131 await test('rehashed substitute rumor, third-party fanout and cached wrong ids fail', () => {
    132   const f = fixture();
    133   try {
    134     const substitute = { ...f.rumor, content: 'different enquiry' };
    135     substitute.id = getEventHash(substitute);
    136     assert.equal(f.check(substitute), false);
    137     const fanout = {
    138       ...f.rumor,
    139       tags: [
    140         ['p', f.peer],
    141         ['p', f.owner]
    142       ]
    143     };
    144     fanout.id = getEventHash(fanout);
    145     assert.equal(f.check(fanout), false);
    146     assert.equal(f.check({ ...f.rumor, id: '0'.repeat(64) }), false);
    147     assert.equal(
    148       f.check(f.rumor, { ...f.seal, id: '0'.repeat(64), verified: true }),
    149       false
    150     );
    151   } finally {
    152     f.close();
    153   }
    154 });