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 });