app

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

ingress.test.ts (9624B)


      1 import { describe, expect, it } from 'vitest';
      2 import { readFileSync } from 'node:fs';
      3 import { verifiedSymbol, verifyEvent } from 'applesauce-core/helpers';
      4 import { PUBLIC_INGRESS_BUDGETS } from '../../src/lib/config/budgets.ts';
      5 import {
      6   createPublicIngress,
      7   admitPublicEvent,
      8   publicIngressStats,
      9   type PublicIngress
     10 } from '../../src/lib/nostr/ingress.ts';
     11 import { verifiedEnvelopeSnapshot } from '../../src/lib/nostr/verified-envelope.ts';
     12 const corpus = JSON.parse(
     13   readFileSync(
     14     new URL(
     15       '../../../contracts/interop/food_availability/corpus.v1.json',
     16       import.meta.url
     17     ),
     18     'utf8'
     19   )
     20 ) as { vectors: { id: string; signed_wires: Record<string, string> }[] };
     21 const wire = corpus.vectors.find((row) => row.id.endsWith('_014'))!.signed_wires
     22   .event;
     23 const candidate = () => JSON.parse(wire) as Record<string | symbol, unknown>;
     24 
     25 describe('bounded generic public ingress', () => {
     26   it('isolates a bad signature and admits the following valid candidate', () => {
     27     const owner = createPublicIngress();
     28     expect(
     29       admitPublicEvent(owner, { ...candidate(), sig: '0'.repeat(128) }).status
     30     ).toBe('rejected');
     31     const good = admitPublicEvent(owner, wire);
     32     expect(good.status).toBe('accepted');
     33     if (good.status === 'accepted')
     34       expect(verifiedEnvelopeSnapshot(good.value)).toEqual(JSON.parse(wire));
     35     expect(publicIngressStats(owner).deliveries).toBe(2);
     36   });
     37   it('rejects a mutated object even when actual SDK verification trusts its cached symbol', () => {
     38     const cached = candidate();
     39     expect(verifyEvent(cached as Parameters<typeof verifyEvent>[0])).toBe(true);
     40     expect(cached[verifiedSymbol]).toBe(true);
     41     cached.content = 'mutation after verification';
     42     expect(verifyEvent(cached as Parameters<typeof verifyEvent>[0])).toBe(true);
     43     expect(admitPublicEvent(createPublicIngress(), cached).status).toBe(
     44       'rejected'
     45     );
     46   });
     47   it('reconstructs signed data without cache symbols or caller mutation crossing retained proof', () => {
     48     const input = candidate();
     49     input[verifiedSymbol] = true;
     50     input[Symbol.for('seen-relays')] = new Set(['wss://untrusted.example.org']);
     51     const result = admitPublicEvent(createPublicIngress(), input);
     52     expect(result.status).toBe('accepted');
     53     if (result.status !== 'accepted') return;
     54     input.content = 'later mutation';
     55     const snapshot = verifiedEnvelopeSnapshot(result.value)!;
     56     expect(snapshot).toEqual(JSON.parse(wire));
     57     expect(Object.getOwnPropertySymbols(snapshot)).toEqual([]);
     58     snapshot.content = 'changed detached snapshot';
     59     expect(verifiedEnvelopeSnapshot(result.value)).toEqual(JSON.parse(wire));
     60   });
     61   it.each([NaN, Infinity, -Infinity, -0, -1, 1.5, Number.MAX_SAFE_INTEGER + 1])(
     62     'rejects unsupported decoded timestamp %s',
     63     (created_at) => {
     64       expect(
     65         admitPublicEvent(createPublicIngress(), { ...candidate(), created_at })
     66           .status
     67       ).toBe('rejected');
     68     }
     69   );
     70   it('retains numeric lexical checks when actual raw JSON is available', () => {
     71     const altered = wire.replace(
     72       /"created_at":\s*[0-9]+/u,
     73       '"created_at":1700000060.0'
     74     );
     75     expect(altered).not.toBe(wire);
     76     expect(admitPublicEvent(createPublicIngress(), altered).status).toBe(
     77       'rejected'
     78     );
     79   });
     80   it('never calls own field getters, toJSON or untrusted tag iterators', () => {
     81     let calls = 0;
     82     const input = candidate();
     83     Object.defineProperty(input, 'content', {
     84       get() {
     85         calls++;
     86         return 'untrusted';
     87       }
     88     });
     89     expect(admitPublicEvent(createPublicIngress(), input).status).toBe(
     90       'rejected'
     91     );
     92     const safe = candidate();
     93     safe.toJSON = () => {
     94       calls++;
     95       throw new Error('untrusted');
     96     };
     97     const tags = safe.tags as string[][];
     98     Object.defineProperty(tags, Symbol.iterator, {
     99       value() {
    100         calls++;
    101         throw new Error('untrusted');
    102       }
    103     });
    104     expect(admitPublicEvent(createPublicIngress(), safe).status).toBe(
    105       'accepted'
    106     );
    107     expect(calls).toBe(0);
    108   });
    109   it('charges repeated valid candidates before deduplication', () => {
    110     const owner = createPublicIngress();
    111     expect(admitPublicEvent(owner, wire).status).toBe('accepted');
    112     expect(admitPublicEvent(owner, wire).status).toBe('duplicate');
    113     expect(publicIngressStats(owner)).toEqual({
    114       deliveries: 2,
    115       chargedBytes: new TextEncoder().encode(wire).length * 2,
    116       stopped: false
    117     });
    118   });
    119   it('stops a rejected-input storm at the inclusive delivery limit', () => {
    120     const owner = createPublicIngress();
    121     for (let index = 0; index < PUBLIC_INGRESS_BUDGETS.deliveries; index++)
    122       expect(admitPublicEvent(owner, 'null').status).toBe('rejected');
    123     const before = publicIngressStats(owner);
    124     expect(before).toEqual({
    125       deliveries: 2000,
    126       chargedBytes: 8000,
    127       stopped: true
    128     });
    129     expect(admitPublicEvent(owner, wire).status).toBe('limit');
    130     expect(publicIngressStats(owner)).toEqual(before);
    131   });
    132   it('stops an oversized stream at the aggregate byte cap without admitting its payload', () => {
    133     const owner = createPublicIngress();
    134     const oversized = ' '.repeat(PUBLIC_INGRESS_BUDGETS.eventBytes + 1);
    135     for (let index = 0; index < 32; index++) {
    136       const outcome = admitPublicEvent(owner, oversized);
    137       expect(outcome.status).toBe(index === 31 ? 'limit' : 'rejected');
    138     }
    139     expect(publicIngressStats(owner)).toEqual({
    140       deliveries: 32,
    141       chargedBytes: 8388608,
    142       stopped: true
    143     });
    144     expect(admitPublicEvent(owner, wire).status).toBe('limit');
    145   });
    146   it('counts UTF8 expansion and malformed input against one shared owner', () => {
    147     const owner = createPublicIngress();
    148     const rejected = JSON.stringify({
    149       ...candidate(),
    150       content: 'é'.repeat(1000)
    151     });
    152     expect(admitPublicEvent(owner, rejected).status).toBe('rejected');
    153     expect(publicIngressStats(owner).chargedBytes).toBe(
    154       new TextEncoder().encode(rejected).length
    155     );
    156     expect(admitPublicEvent(owner, wire).status).toBe('accepted');
    157     expect(publicIngressStats(owner).deliveries).toBe(2);
    158   });
    159   it('refuses forged owners and provides detached immutable accounting', () => {
    160     expect(() => admitPublicEvent({} as PublicIngress, wire)).toThrow(
    161       'public_ingress_invalid'
    162     );
    163     const owner = createPublicIngress();
    164     const before = publicIngressStats(owner);
    165     expect(Reflect.set(before, 'deliveries', 99)).toBe(false);
    166     admitPublicEvent(owner, 'null');
    167     expect(before.deliveries).toBe(0);
    168     expect(publicIngressStats(owner).deliveries).toBe(1);
    169   });
    170   it('stops at exact aggregate byte equality before inspecting another candidate', () => {
    171     const owner = createPublicIngress();
    172     const raw = ' '.repeat(PUBLIC_INGRESS_BUDGETS.eventBytes);
    173     for (let index = 0; index < 32; index++)
    174       expect(admitPublicEvent(owner, raw).status).toBe('rejected');
    175     const before = publicIngressStats(owner);
    176     expect(before).toEqual({
    177       deliveries: 32,
    178       chargedBytes: 8388608,
    179       stopped: true
    180     });
    181     let inspected = 0;
    182     const next = new Proxy(candidate(), {
    183       getOwnPropertyDescriptor(target, key) {
    184         inspected++;
    185         return Reflect.getOwnPropertyDescriptor(target, key);
    186       }
    187     });
    188     expect(admitPublicEvent(owner, next).status).toBe('limit');
    189     expect(inspected).toBe(0);
    190     expect(publicIngressStats(owner)).toEqual(before);
    191   });
    192   it('charges and stops reentrant descriptor admission before nested reconstruction', () => {
    193     const owner = createPublicIngress();
    194     let entered = false;
    195     let descriptors = 0;
    196     let nested: ReturnType<typeof admitPublicEvent> | undefined;
    197     const input = new Proxy(candidate(), {
    198       getOwnPropertyDescriptor(target, key) {
    199         descriptors++;
    200         if (!entered) {
    201           entered = true;
    202           nested = admitPublicEvent(owner, 'null');
    203         }
    204         return Reflect.getOwnPropertyDescriptor(target, key);
    205       }
    206     });
    207     const outer = admitPublicEvent(owner, input);
    208     expect(nested?.status).toBe('limit');
    209     expect(outer.status).toBe('limit');
    210     expect(descriptors).toBe(1);
    211     const before = publicIngressStats(owner);
    212     expect(before.deliveries).toBe(2);
    213     expect(before.chargedBytes).toBeGreaterThan(0);
    214     expect(before.chargedBytes).toBeLessThanOrEqual(8388608);
    215     expect(before.stopped).toBe(true);
    216     expect(admitPublicEvent(owner, wire).status).toBe('limit');
    217     expect(publicIngressStats(owner)).toEqual(before);
    218   });
    219 
    220   it('allows the inclusive final valid event and then stops at exact bytes', () => {
    221     const owner = createPublicIngress();
    222     const raw = ' '.repeat(PUBLIC_INGRESS_BUDGETS.eventBytes);
    223     for (let index = 0; index < 31; index++)
    224       expect(admitPublicEvent(owner, raw).status).toBe('rejected');
    225     const final =
    226       wire +
    227       ' '.repeat(
    228         PUBLIC_INGRESS_BUDGETS.eventBytes -
    229           new TextEncoder().encode(wire).length
    230       );
    231     expect(admitPublicEvent(owner, final).status).toBe('accepted');
    232     expect(publicIngressStats(owner)).toEqual({
    233       deliveries: 32,
    234       chargedBytes: 8388608,
    235       stopped: true
    236     });
    237   });
    238 
    239   it('isolates revoked object reflection and preserves the next valid candidate', () => {
    240     const owner = createPublicIngress();
    241     const revoked = Proxy.revocable(candidate(), {});
    242     revoked.revoke();
    243     expect(admitPublicEvent(owner, revoked.proxy).status).toBe('rejected');
    244     expect(admitPublicEvent(owner, wire).status).toBe('accepted');
    245     expect(publicIngressStats(owner).deliveries).toBe(2);
    246   });
    247 });