nirium 0.16.0 → 0.17.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +118 -33
- package/dist/index.d.ts +11 -2
- package/dist/index.js +21 -3
- package/dist/x402-policy-conformance.d.ts +64 -0
- package/dist/x402-policy-conformance.js +269 -0
- package/dist/x402-spend-cap.js +2 -2
- package/package.json +19 -3
- package/dist/metrics.test.d.ts +0 -1
- package/dist/metrics.test.js +0 -614
- package/dist/x402-guard.test.d.ts +0 -11
- package/dist/x402-guard.test.js +0 -145
- package/dist/x402serve-smoke.test.d.ts +0 -9
- package/dist/x402serve-smoke.test.js +0 -158
package/dist/metrics.test.js
DELETED
|
@@ -1,614 +0,0 @@
|
|
|
1
|
-
"use strict";
|
|
2
|
-
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
-
const metrics_1 = require("./metrics");
|
|
4
|
-
// Real @x402/core PaymentRequired schema — used for schema validation
|
|
5
|
-
// This catches field-name mismatches between our fixtures and the actual protocol.
|
|
6
|
-
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
|
7
|
-
const { parsePaymentRequired } = require('@x402/core/schemas');
|
|
8
|
-
// ─── Helpers: Build schema-faithful PAYMENT-REQUIRED headers ────────────
|
|
9
|
-
//
|
|
10
|
-
// @x402/core encodes the full PaymentRequired object as base64 JSON in
|
|
11
|
-
// the PAYMENT-REQUIRED response header. These helpers build real objects
|
|
12
|
-
// that satisfy the Zod schema, then base64-encode them — exactly the way
|
|
13
|
-
// createPaymentRequiredResponse → encodePaymentRequiredHeader works in
|
|
14
|
-
// the actual dependency.
|
|
15
|
-
const VALID_G_ADDRESS = 'GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF';
|
|
16
|
-
/**
|
|
17
|
-
* Build a V2 PaymentRequired object matching @x402/core's schema.
|
|
18
|
-
* This is the object that goes into the PAYMENT-REQUIRED header.
|
|
19
|
-
*/
|
|
20
|
-
function buildPaymentRequiredV2(overrides) {
|
|
21
|
-
return {
|
|
22
|
-
x402Version: 2,
|
|
23
|
-
// error is always present per createPaymentRequiredResponse — it's
|
|
24
|
-
// nullish in the schema but @x402/core always sets it.
|
|
25
|
-
...(overrides?.error !== undefined ? { error: overrides.error } : {}),
|
|
26
|
-
resource: {
|
|
27
|
-
url: '/signals',
|
|
28
|
-
description: 'Access to signals',
|
|
29
|
-
},
|
|
30
|
-
accepts: [
|
|
31
|
-
{
|
|
32
|
-
scheme: 'exact',
|
|
33
|
-
network: 'stellar:testnet',
|
|
34
|
-
amount: overrides?.amount || '20000',
|
|
35
|
-
payTo: VALID_G_ADDRESS,
|
|
36
|
-
maxTimeoutSeconds: 60,
|
|
37
|
-
asset: overrides?.asset || 'USDC',
|
|
38
|
-
},
|
|
39
|
-
],
|
|
40
|
-
};
|
|
41
|
-
}
|
|
42
|
-
/** Encode a PaymentRequired object into the base64 header value */
|
|
43
|
-
function encodePaymentRequiredHeader(paymentRequired) {
|
|
44
|
-
return Buffer.from(JSON.stringify(paymentRequired), 'utf-8').toString('base64');
|
|
45
|
-
}
|
|
46
|
-
/** Build a base64 PAYMENT-REQUIRED header value for a challenge */
|
|
47
|
-
function challengeHeader(overrides) {
|
|
48
|
-
return encodePaymentRequiredHeader(buildPaymentRequiredV2({
|
|
49
|
-
error: 'Payment required',
|
|
50
|
-
...overrides,
|
|
51
|
-
}));
|
|
52
|
-
}
|
|
53
|
-
/** Build a base64 PAYMENT-REQUIRED header value for a verify failure */
|
|
54
|
-
function verifyFailHeader() {
|
|
55
|
-
return encodePaymentRequiredHeader(buildPaymentRequiredV2({
|
|
56
|
-
error: 'payment verification failed',
|
|
57
|
-
}));
|
|
58
|
-
}
|
|
59
|
-
// ─── Test Helpers ──────────────────────────────────────────────
|
|
60
|
-
function createMockReqRes(method, path) {
|
|
61
|
-
const listeners = {};
|
|
62
|
-
const setHeaderCalls = [];
|
|
63
|
-
const res = {
|
|
64
|
-
statusCode: 200,
|
|
65
|
-
_body: undefined,
|
|
66
|
-
status(code) {
|
|
67
|
-
res.statusCode = code;
|
|
68
|
-
return res;
|
|
69
|
-
},
|
|
70
|
-
json(body) {
|
|
71
|
-
res._body = body;
|
|
72
|
-
// Emit 'finish' asynchronously so that setHeader calls (which happen
|
|
73
|
-
// before json) are captured before the classifier runs.
|
|
74
|
-
Promise.resolve().then(() => res.emit('finish'));
|
|
75
|
-
return res;
|
|
76
|
-
},
|
|
77
|
-
send(body) {
|
|
78
|
-
res._body = body;
|
|
79
|
-
Promise.resolve().then(() => res.emit('finish'));
|
|
80
|
-
return res;
|
|
81
|
-
},
|
|
82
|
-
setHeader(name, value) {
|
|
83
|
-
setHeaderCalls.push({ name, value });
|
|
84
|
-
return res;
|
|
85
|
-
},
|
|
86
|
-
getHeader(name) {
|
|
87
|
-
const lower = name.toLowerCase();
|
|
88
|
-
const call = setHeaderCalls.find((c) => c.name.toLowerCase() === lower);
|
|
89
|
-
return call ? (Array.isArray(call.value) ? call.value[0] : call.value) : undefined;
|
|
90
|
-
},
|
|
91
|
-
on(event, cb) {
|
|
92
|
-
if (!listeners[event])
|
|
93
|
-
listeners[event] = [];
|
|
94
|
-
listeners[event].push(cb);
|
|
95
|
-
return res;
|
|
96
|
-
},
|
|
97
|
-
emit(event, ...args) {
|
|
98
|
-
for (const cb of listeners[event] || [])
|
|
99
|
-
cb(...args);
|
|
100
|
-
},
|
|
101
|
-
};
|
|
102
|
-
const req = { method, path, url: path, headers: {} };
|
|
103
|
-
return { req, res };
|
|
104
|
-
}
|
|
105
|
-
/** Create a `next` callback that acts as the downstream handler (sets 200) */
|
|
106
|
-
function okNext(_req, res) {
|
|
107
|
-
return (err) => {
|
|
108
|
-
if (!err)
|
|
109
|
-
res.status(200).json({ data: 'ok' });
|
|
110
|
-
};
|
|
111
|
-
}
|
|
112
|
-
function createMockHandler(scenarios) {
|
|
113
|
-
let idx = 0;
|
|
114
|
-
return async (req, res, next) => {
|
|
115
|
-
const s = scenarios[idx++ % scenarios.length];
|
|
116
|
-
switch (s.type) {
|
|
117
|
-
case 'challenge': {
|
|
118
|
-
// Simulates @x402/core's createHTTPResponse for a fresh challenge:
|
|
119
|
-
// status 402, PAYMENT-REQUIRED header with base64-encoded body,
|
|
120
|
-
// JSON body = {} (empty for API clients).
|
|
121
|
-
res.setHeader('PAYMENT-REQUIRED', challengeHeader({
|
|
122
|
-
amount: s.amount || '20000',
|
|
123
|
-
asset: s.asset || 'USDC',
|
|
124
|
-
}));
|
|
125
|
-
res.setHeader('Cache-Control', 'no-store');
|
|
126
|
-
res.status(402).json({});
|
|
127
|
-
break;
|
|
128
|
-
}
|
|
129
|
-
case 'paid':
|
|
130
|
-
next(); // downstream handler sets 200
|
|
131
|
-
break;
|
|
132
|
-
case 'verify_fail': {
|
|
133
|
-
// Simulates @x402/core's createHTTPResponse for a verify failure:
|
|
134
|
-
// status 402, PAYMENT-REQUIRED header with error != "Payment required",
|
|
135
|
-
// JSON body = {} (empty for API clients).
|
|
136
|
-
res.setHeader('PAYMENT-REQUIRED', verifyFailHeader());
|
|
137
|
-
res.setHeader('Cache-Control', 'no-store');
|
|
138
|
-
res.status(402).json({});
|
|
139
|
-
break;
|
|
140
|
-
}
|
|
141
|
-
case 'settle_fail': {
|
|
142
|
-
// Simulates @x402/core's buildSettlementFailureResponse:
|
|
143
|
-
// status 402, NO PAYMENT-REQUIRED header, PAYMENT-RESPONSE header,
|
|
144
|
-
// JSON body = {} (empty by default).
|
|
145
|
-
res.setHeader('PAYMENT-RESPONSE', encodePaymentRequiredHeader({ success: false }));
|
|
146
|
-
res.setHeader('Cache-Control', 'no-store');
|
|
147
|
-
res.status(402).json({});
|
|
148
|
-
break;
|
|
149
|
-
}
|
|
150
|
-
case 'rejected': {
|
|
151
|
-
// Simulates @x402/core's 403 from protected-request hook:
|
|
152
|
-
// status 403, JSON body = { error: reason }.
|
|
153
|
-
res.status(403).json({ error: s.reason || 'access denied' });
|
|
154
|
-
break;
|
|
155
|
-
}
|
|
156
|
-
}
|
|
157
|
-
};
|
|
158
|
-
}
|
|
159
|
-
// ─── Schema Validation ─────────────────────────────────────────
|
|
160
|
-
describe('mock schema validity', () => {
|
|
161
|
-
it('challenge PAYMENT-REQUIRED header decodes to valid @x402/core PaymentRequired schema', () => {
|
|
162
|
-
const header = challengeHeader();
|
|
163
|
-
const decoded = JSON.parse(Buffer.from(header, 'base64').toString('utf-8'));
|
|
164
|
-
const result = parsePaymentRequired(decoded);
|
|
165
|
-
expect(result.success).toBe(true);
|
|
166
|
-
});
|
|
167
|
-
it('verify-fail PAYMENT-REQUIRED header decodes to valid schema', () => {
|
|
168
|
-
const header = verifyFailHeader();
|
|
169
|
-
const decoded = JSON.parse(Buffer.from(header, 'base64').toString('utf-8'));
|
|
170
|
-
const result = parsePaymentRequired(decoded);
|
|
171
|
-
expect(result.success).toBe(true);
|
|
172
|
-
});
|
|
173
|
-
it('challenge header decodes with error = "Payment required"', () => {
|
|
174
|
-
const header = challengeHeader();
|
|
175
|
-
const decoded = JSON.parse(Buffer.from(header, 'base64').toString('utf-8'));
|
|
176
|
-
expect(decoded.error).toBe('Payment required');
|
|
177
|
-
});
|
|
178
|
-
it('verify-fail header decodes with error ≠ "Payment required"', () => {
|
|
179
|
-
const header = verifyFailHeader();
|
|
180
|
-
const decoded = JSON.parse(Buffer.from(header, 'base64').toString('utf-8'));
|
|
181
|
-
expect(decoded.error).toBe('payment verification failed');
|
|
182
|
-
});
|
|
183
|
-
it('challenge header has accepts[] with amount', () => {
|
|
184
|
-
const header = challengeHeader({ amount: '50000', asset: 'CETES' });
|
|
185
|
-
const decoded = JSON.parse(Buffer.from(header, 'base64').toString('utf-8'));
|
|
186
|
-
expect(decoded.accepts[0].amount).toBe('50000');
|
|
187
|
-
expect(decoded.accepts[0].asset).toBe('CETES');
|
|
188
|
-
});
|
|
189
|
-
});
|
|
190
|
-
// ─── Tests ─────────────────────────────────────────────────────
|
|
191
|
-
describe('x402Metrics', () => {
|
|
192
|
-
let metrics;
|
|
193
|
-
afterEach(() => {
|
|
194
|
-
metrics?.reset();
|
|
195
|
-
});
|
|
196
|
-
describe('basic wrapping', () => {
|
|
197
|
-
it('returns handler, metricsHandler, snapshot, and reset', () => {
|
|
198
|
-
metrics = (0, metrics_1.x402Metrics)(async (_req, _res, next) => next());
|
|
199
|
-
expect(typeof metrics.handler).toBe('function');
|
|
200
|
-
expect(typeof metrics.metricsHandler).toBe('function');
|
|
201
|
-
expect(typeof metrics.snapshot).toBe('function');
|
|
202
|
-
expect(typeof metrics.reset).toBe('function');
|
|
203
|
-
});
|
|
204
|
-
it('does not modify the inner middleware behavior', async () => {
|
|
205
|
-
const inner = jest.fn(async (_req, _res, next) => {
|
|
206
|
-
next();
|
|
207
|
-
});
|
|
208
|
-
metrics = (0, metrics_1.x402Metrics)(inner);
|
|
209
|
-
const { req, res } = createMockReqRes('GET', '/test');
|
|
210
|
-
const nextFn = okNext(req, res);
|
|
211
|
-
await metrics.handler(req, res, nextFn);
|
|
212
|
-
// Wait for async finish emission
|
|
213
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
214
|
-
expect(inner).toHaveBeenCalledTimes(1);
|
|
215
|
-
expect(inner).toHaveBeenCalledWith(req, res, nextFn);
|
|
216
|
-
expect(res.statusCode).toBe(200);
|
|
217
|
-
expect(res._body).toEqual({ data: 'ok' });
|
|
218
|
-
});
|
|
219
|
-
});
|
|
220
|
-
describe('challenge tracking', () => {
|
|
221
|
-
it('increments challengesIssued on402 with PAYMENT-REQUIRED header (error = "Payment required")', async () => {
|
|
222
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'challenge', amount: '20000' }]));
|
|
223
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
224
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
225
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
226
|
-
const snap = metrics.snapshot();
|
|
227
|
-
expect(snap.challengesIssued['GET /signals']).toBe(1);
|
|
228
|
-
expect(snap.verifyFail['GET /signals']).toBeUndefined();
|
|
229
|
-
});
|
|
230
|
-
it('counts multiple challenges for the same route', async () => {
|
|
231
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([
|
|
232
|
-
{ type: 'challenge' },
|
|
233
|
-
{ type: 'challenge' },
|
|
234
|
-
{ type: 'challenge' },
|
|
235
|
-
]));
|
|
236
|
-
for (let i = 0; i < 3; i++) {
|
|
237
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
238
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
239
|
-
}
|
|
240
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
241
|
-
expect(metrics.snapshot().challengesIssued['GET /signals']).toBe(3);
|
|
242
|
-
});
|
|
243
|
-
});
|
|
244
|
-
describe('402 classification (matches @x402/core schema)', () => {
|
|
245
|
-
it('classifies402 with PAYMENT-REQUIRED header (error = "Payment required") as challenge', async () => {
|
|
246
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'challenge' }]));
|
|
247
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
248
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
249
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
250
|
-
const snap = metrics.snapshot();
|
|
251
|
-
expect(snap.challengesIssued['GET /signals']).toBe(1);
|
|
252
|
-
expect(snap.verifyFail['GET /signals']).toBeUndefined();
|
|
253
|
-
});
|
|
254
|
-
it('classifies402 with PAYMENT-REQUIRED header (error ≠ "Payment required") as verify failure', async () => {
|
|
255
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'verify_fail' }]));
|
|
256
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
257
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
258
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
259
|
-
const snap = metrics.snapshot();
|
|
260
|
-
expect(snap.verifyFail['GET /signals']).toBe(1);
|
|
261
|
-
expect(snap.challengesIssued['GET /signals']).toBeUndefined();
|
|
262
|
-
});
|
|
263
|
-
it('classifies402 with PAYMENT-RESPONSE but no PAYMENT-REQUIRED as settlement failure', async () => {
|
|
264
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'settle_fail' }]));
|
|
265
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
266
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
267
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
268
|
-
const snap = metrics.snapshot();
|
|
269
|
-
expect(snap.settleFail['GET /signals']).toBe(1);
|
|
270
|
-
expect(snap.challengesIssued['GET /signals']).toBeUndefined();
|
|
271
|
-
expect(snap.verifyFail['GET /signals']).toBeUndefined();
|
|
272
|
-
});
|
|
273
|
-
});
|
|
274
|
-
describe('verify tracking', () => {
|
|
275
|
-
it('increments verifySuccess on 2xx responses', async () => {
|
|
276
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'paid' }, { type: 'paid' }]));
|
|
277
|
-
for (let i = 0; i < 2; i++) {
|
|
278
|
-
const { req, res } = createMockReqRes('GET', '/data');
|
|
279
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
280
|
-
}
|
|
281
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
282
|
-
const snap = metrics.snapshot();
|
|
283
|
-
expect(snap.verifySuccess['GET /data']).toBe(2);
|
|
284
|
-
});
|
|
285
|
-
it('increments verifyFail on402 with PAYMENT-REQUIRED header (verify error)', async () => {
|
|
286
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'verify_fail' }]));
|
|
287
|
-
const { req, res } = createMockReqRes('POST', '/pay');
|
|
288
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
289
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
290
|
-
expect(metrics.snapshot().verifyFail['POST /pay']).toBe(1);
|
|
291
|
-
});
|
|
292
|
-
});
|
|
293
|
-
describe('settle tracking', () => {
|
|
294
|
-
it('increments settleSuccess on 2xx responses', async () => {
|
|
295
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'paid' }]));
|
|
296
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
297
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
298
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
299
|
-
expect(metrics.snapshot().settleSuccess['GET /signals']).toBe(1);
|
|
300
|
-
});
|
|
301
|
-
it('increments settleFail on402 settlement failures (PAYMENT-RESPONSE without PAYMENT-REQUIRED)', async () => {
|
|
302
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'settle_fail' }]));
|
|
303
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
304
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
305
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
306
|
-
expect(metrics.snapshot().settleFail['GET /signals']).toBe(1);
|
|
307
|
-
});
|
|
308
|
-
it('counts5xx as infraErrors (FacilitatorResponseError from verify or settlement path)', async () => {
|
|
309
|
-
// 500 from sendInternalError
|
|
310
|
-
const inner500 = async (req, res, _next) => {
|
|
311
|
-
res.status(500).json({ error: 'facilitator down' });
|
|
312
|
-
};
|
|
313
|
-
metrics = (0, metrics_1.x402Metrics)(inner500);
|
|
314
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
315
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
316
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
317
|
-
expect(metrics.snapshot().infraErrors['GET /signals']).toBe(1);
|
|
318
|
-
expect(metrics.snapshot().settleFail['GET /signals']).toBeUndefined();
|
|
319
|
-
});
|
|
320
|
-
it('counts502 as infraErrors (FacilitatorResponseError)', async () => {
|
|
321
|
-
// 502 from sendFacilitatorError — happens on both verify and settlement paths
|
|
322
|
-
const inner502 = async (req, res, _next) => {
|
|
323
|
-
res.status(502).json({ error: 'facilitator rejected the API key' });
|
|
324
|
-
};
|
|
325
|
-
metrics = (0, metrics_1.x402Metrics)(inner502);
|
|
326
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
327
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
328
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
329
|
-
expect(metrics.snapshot().infraErrors['GET /signals']).toBe(1);
|
|
330
|
-
expect(metrics.snapshot().settleFail['GET /signals']).toBeUndefined();
|
|
331
|
-
});
|
|
332
|
-
});
|
|
333
|
-
describe('403 rejection tracking', () => {
|
|
334
|
-
it('counts403 rejections', async () => {
|
|
335
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'rejected', reason: 'rate limited' }]));
|
|
336
|
-
const { req, res } = createMockReqRes('GET', '/premium');
|
|
337
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
338
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
339
|
-
const snap = metrics.snapshot();
|
|
340
|
-
expect(snap.rejections['GET /premium']).toBe(1);
|
|
341
|
-
expect(snap.challengesIssued['GET /premium']).toBeUndefined();
|
|
342
|
-
expect(snap.verifyFail['GET /premium']).toBeUndefined();
|
|
343
|
-
});
|
|
344
|
-
it('counts multiple403 rejections for the same route', async () => {
|
|
345
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([
|
|
346
|
-
{ type: 'rejected' },
|
|
347
|
-
{ type: 'rejected' },
|
|
348
|
-
]));
|
|
349
|
-
for (let i = 0; i < 2; i++) {
|
|
350
|
-
const { req, res } = createMockReqRes('GET', '/premium');
|
|
351
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
352
|
-
}
|
|
353
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
354
|
-
expect(metrics.snapshot().rejections['GET /premium']).toBe(2);
|
|
355
|
-
});
|
|
356
|
-
});
|
|
357
|
-
describe('revenue tracking', () => {
|
|
358
|
-
it('tracks revenue from PAYMENT-REQUIRED header accepts[]', async () => {
|
|
359
|
-
// Sequence: challenge (20000) → paid → paid → challenge (50000) → paid
|
|
360
|
-
const handler = createMockHandler([
|
|
361
|
-
{ type: 'challenge', amount: '20000', asset: 'USDC' },
|
|
362
|
-
{ type: 'paid' },
|
|
363
|
-
{ type: 'paid' },
|
|
364
|
-
{ type: 'challenge', amount: '50000', asset: 'USDC' },
|
|
365
|
-
{ type: 'paid' },
|
|
366
|
-
]);
|
|
367
|
-
metrics = (0, metrics_1.x402Metrics)(handler);
|
|
368
|
-
// Request 1: challenge (price cached from header accepts[])
|
|
369
|
-
let { req, res } = createMockReqRes('GET', '/signals');
|
|
370
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
371
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
372
|
-
expect(metrics.snapshot().revenue).toEqual({});
|
|
373
|
-
// Request 2: paid → revenue += 20000
|
|
374
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
375
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
376
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
377
|
-
expect(metrics.snapshot().revenue['GET /signals']?.USDC).toBe(20000);
|
|
378
|
-
// Request 3: paid → revenue += 20000 (total: 40000)
|
|
379
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
380
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
381
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
382
|
-
expect(metrics.snapshot().revenue['GET /signals']?.USDC).toBe(40000);
|
|
383
|
-
// Request 4: challenge for premium (different route, 50000)
|
|
384
|
-
({ req, res } = createMockReqRes('GET', '/premium'));
|
|
385
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
386
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
387
|
-
expect(metrics.snapshot().revenue['GET /premium']).toBeUndefined();
|
|
388
|
-
// Request 5: paid for premium → revenue += 50000
|
|
389
|
-
({ req, res } = createMockReqRes('GET', '/premium'));
|
|
390
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
391
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
392
|
-
expect(metrics.snapshot().revenue['GET /premium']?.USDC).toBe(50000);
|
|
393
|
-
// Total for /signals should still be 40000
|
|
394
|
-
expect(metrics.snapshot().revenue['GET /signals']?.USDC).toBe(40000);
|
|
395
|
-
});
|
|
396
|
-
it('does not count revenue on failed verifications', async () => {
|
|
397
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([
|
|
398
|
-
{ type: 'challenge', amount: '20000' },
|
|
399
|
-
{ type: 'verify_fail' },
|
|
400
|
-
]));
|
|
401
|
-
let { req, res } = createMockReqRes('GET', '/signals');
|
|
402
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
403
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
404
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
405
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
406
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
407
|
-
expect(metrics.snapshot().revenue).toEqual({});
|
|
408
|
-
});
|
|
409
|
-
it('does not count revenue on settlement failures', async () => {
|
|
410
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([
|
|
411
|
-
{ type: 'challenge', amount: '20000' },
|
|
412
|
-
{ type: 'settle_fail' },
|
|
413
|
-
]));
|
|
414
|
-
let { req, res } = createMockReqRes('GET', '/signals');
|
|
415
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
416
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
417
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
418
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
419
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
420
|
-
expect(metrics.snapshot().revenue).toEqual({});
|
|
421
|
-
});
|
|
422
|
-
it('handles multiple assets per route', async () => {
|
|
423
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([
|
|
424
|
-
{ type: 'challenge', amount: '20000', asset: 'USDC' },
|
|
425
|
-
{ type: 'paid' },
|
|
426
|
-
{ type: 'challenge', amount: '5000', asset: 'CETES' },
|
|
427
|
-
{ type: 'paid' },
|
|
428
|
-
]));
|
|
429
|
-
let { req, res } = createMockReqRes('GET', '/signals');
|
|
430
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
431
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
432
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
433
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
434
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
435
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
436
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
437
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
438
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
439
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
440
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
441
|
-
const rev = metrics.snapshot().revenue['GET /signals'];
|
|
442
|
-
expect(rev?.USDC).toBe(20000);
|
|
443
|
-
expect(rev?.CETES).toBe(5000);
|
|
444
|
-
});
|
|
445
|
-
it('uses routes config when provided (more reliable than402 header)', async () => {
|
|
446
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'paid' }]), {
|
|
447
|
-
routes: {
|
|
448
|
-
'GET /signals': '$0.03',
|
|
449
|
-
},
|
|
450
|
-
});
|
|
451
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
452
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
453
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
454
|
-
// Revenue should be 0.03 from the routes config
|
|
455
|
-
expect(metrics.snapshot().revenue['GET /signals']?.USDC).toBe(0.03);
|
|
456
|
-
});
|
|
457
|
-
});
|
|
458
|
-
describe('latency histogram', () => {
|
|
459
|
-
it('records latency on successful settlements', async () => {
|
|
460
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'paid' }]), { buckets: [0.1, 0.5, 1] });
|
|
461
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
462
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
463
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
464
|
-
const snap = metrics.snapshot();
|
|
465
|
-
expect(snap.settlementLatency.counts['GET /signals']).toBe(1);
|
|
466
|
-
expect(snap.settlementLatency.sums['GET /signals']).toBeGreaterThanOrEqual(0);
|
|
467
|
-
});
|
|
468
|
-
it('does not record latency on non-2xx responses', async () => {
|
|
469
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'challenge' }]), { buckets: [0.1, 0.5, 1] });
|
|
470
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
471
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
472
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
473
|
-
const snap = metrics.snapshot();
|
|
474
|
-
expect(snap.settlementLatency.counts['GET /signals']).toBeUndefined();
|
|
475
|
-
});
|
|
476
|
-
});
|
|
477
|
-
describe('metricsHandler', () => {
|
|
478
|
-
it('returns valid Prometheus text exposition', async () => {
|
|
479
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([
|
|
480
|
-
{ type: 'challenge', amount: '20000' },
|
|
481
|
-
{ type: 'paid' },
|
|
482
|
-
]));
|
|
483
|
-
// Issue challenge
|
|
484
|
-
let { req, res } = createMockReqRes('GET', '/signals');
|
|
485
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
486
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
487
|
-
// Settle
|
|
488
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
489
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
490
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
491
|
-
// Get metrics
|
|
492
|
-
let metricsBody = '';
|
|
493
|
-
const mockMetricsRes = {
|
|
494
|
-
setHeader: jest.fn(),
|
|
495
|
-
send: jest.fn((body) => {
|
|
496
|
-
metricsBody = body;
|
|
497
|
-
}),
|
|
498
|
-
};
|
|
499
|
-
metrics.metricsHandler({}, mockMetricsRes);
|
|
500
|
-
expect(mockMetricsRes.setHeader).toHaveBeenCalledWith('Content-Type', 'text/plain; version=0.0.4; charset=utf-8');
|
|
501
|
-
expect(metricsBody).toContain('# HELP x402_challenges_total');
|
|
502
|
-
expect(metricsBody).toContain('# TYPE x402_challenges_total counter');
|
|
503
|
-
expect(metricsBody).toContain('x402_challenges_total{route="GET /signals"} 1');
|
|
504
|
-
expect(metricsBody).toContain('x402_verify_success_total{route="GET /signals"} 1');
|
|
505
|
-
expect(metricsBody).toContain('x402_settle_success_total{route="GET /signals"} 1');
|
|
506
|
-
expect(metricsBody).toContain('x402_revenue_total{route="GET /signals",asset="USDC"} 20000');
|
|
507
|
-
});
|
|
508
|
-
it('returns empty output when no requests have been made', () => {
|
|
509
|
-
metrics = (0, metrics_1.x402Metrics)(async (_req, _res, next) => next());
|
|
510
|
-
let metricsBody = '';
|
|
511
|
-
const mockMetricsRes = {
|
|
512
|
-
setHeader: jest.fn(),
|
|
513
|
-
send: jest.fn((body) => {
|
|
514
|
-
metricsBody = body;
|
|
515
|
-
}),
|
|
516
|
-
};
|
|
517
|
-
metrics.metricsHandler({}, mockMetricsRes);
|
|
518
|
-
// Should only have a trailing newline, no metric lines
|
|
519
|
-
expect(metricsBody.trim()).toBe('');
|
|
520
|
-
});
|
|
521
|
-
it('includes x402_rejections_total when403s have been counted', async () => {
|
|
522
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'rejected', reason: 'rate limited' }]));
|
|
523
|
-
const { req, res } = createMockReqRes('GET', '/premium');
|
|
524
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
525
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
526
|
-
let metricsBody = '';
|
|
527
|
-
const mockMetricsRes = {
|
|
528
|
-
setHeader: jest.fn(),
|
|
529
|
-
send: jest.fn((body) => {
|
|
530
|
-
metricsBody = body;
|
|
531
|
-
}),
|
|
532
|
-
};
|
|
533
|
-
metrics.metricsHandler({}, mockMetricsRes);
|
|
534
|
-
expect(metricsBody).toContain('# HELP x402_rejections_total');
|
|
535
|
-
expect(metricsBody).toContain('x402_rejections_total{route="GET /premium"} 1');
|
|
536
|
-
});
|
|
537
|
-
});
|
|
538
|
-
describe('reset', () => {
|
|
539
|
-
it('zeros all counters', async () => {
|
|
540
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([
|
|
541
|
-
{ type: 'challenge', amount: '20000' },
|
|
542
|
-
{ type: 'paid' },
|
|
543
|
-
]));
|
|
544
|
-
let { req, res } = createMockReqRes('GET', '/signals');
|
|
545
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
546
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
547
|
-
({ req, res } = createMockReqRes('GET', '/signals'));
|
|
548
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
549
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
550
|
-
expect(metrics.snapshot().challengesIssued['GET /signals']).toBe(1);
|
|
551
|
-
expect(metrics.snapshot().revenue['GET /signals']?.USDC).toBe(20000);
|
|
552
|
-
metrics.reset();
|
|
553
|
-
const snap = metrics.snapshot();
|
|
554
|
-
expect(snap.challengesIssued).toEqual({});
|
|
555
|
-
expect(snap.verifySuccess).toEqual({});
|
|
556
|
-
expect(snap.verifyFail).toEqual({});
|
|
557
|
-
expect(snap.settleSuccess).toEqual({});
|
|
558
|
-
expect(snap.settleFail).toEqual({});
|
|
559
|
-
expect(snap.infraErrors).toEqual({});
|
|
560
|
-
expect(snap.rejections).toEqual({});
|
|
561
|
-
expect(snap.revenue).toEqual({});
|
|
562
|
-
});
|
|
563
|
-
});
|
|
564
|
-
describe('header casing robustness', () => {
|
|
565
|
-
it('captures PAYMENT-REQUIRED header regardless of @x402/express casing', async () => {
|
|
566
|
-
// @x402/express passes the exact key "PAYMENT-REQUIRED" from @x402/core.
|
|
567
|
-
// Verify our case-insensitive interception works.
|
|
568
|
-
const inner = async (req, res, _next) => {
|
|
569
|
-
// Simulate exact @x402/express behavior:
|
|
570
|
-
// Object.entries(response.headers).forEach(([key, value]) => res.setHeader(key, value))
|
|
571
|
-
res.setHeader('PAYMENT-REQUIRED', challengeHeader({ amount: '30000' }));
|
|
572
|
-
res.setHeader('Cache-Control', 'no-store');
|
|
573
|
-
res.status(402).json({});
|
|
574
|
-
};
|
|
575
|
-
metrics = (0, metrics_1.x402Metrics)(inner);
|
|
576
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
577
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
578
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
579
|
-
const snap = metrics.snapshot();
|
|
580
|
-
expect(snap.challengesIssued['GET /signals']).toBe(1);
|
|
581
|
-
expect(snap.verifyFail['GET /signals']).toBeUndefined();
|
|
582
|
-
});
|
|
583
|
-
it('captures lowercase payment-required header variant', async () => {
|
|
584
|
-
// Some HTTP stacks may normalize header casing.
|
|
585
|
-
const inner = async (req, res, _next) => {
|
|
586
|
-
res.setHeader('payment-required', challengeHeader());
|
|
587
|
-
res.status(402).json({});
|
|
588
|
-
};
|
|
589
|
-
metrics = (0, metrics_1.x402Metrics)(inner);
|
|
590
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
591
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
592
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
593
|
-
expect(metrics.snapshot().challengesIssued['GET /signals']).toBe(1);
|
|
594
|
-
});
|
|
595
|
-
});
|
|
596
|
-
describe('PII exclusion', () => {
|
|
597
|
-
it('never includes payer addresses in metrics output', async () => {
|
|
598
|
-
metrics = (0, metrics_1.x402Metrics)(createMockHandler([{ type: 'challenge', amount: '20000' }]));
|
|
599
|
-
const { req, res } = createMockReqRes('GET', '/signals');
|
|
600
|
-
await metrics.handler(req, res, okNext(req, res));
|
|
601
|
-
await new Promise((r) => setTimeout(r, 10));
|
|
602
|
-
let metricsBody = '';
|
|
603
|
-
const mockMetricsRes = {
|
|
604
|
-
setHeader: jest.fn(),
|
|
605
|
-
send: jest.fn((body) => {
|
|
606
|
-
metricsBody = body;
|
|
607
|
-
}),
|
|
608
|
-
};
|
|
609
|
-
metrics.metricsHandler({}, mockMetricsRes);
|
|
610
|
-
// Payer addresses are G... Stellar addresses
|
|
611
|
-
expect(metricsBody).not.toMatch(/G[A-Z2-7]{55}/);
|
|
612
|
-
});
|
|
613
|
-
});
|
|
614
|
-
});
|
|
@@ -1,11 +0,0 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* Unit tests for the replay guard / rate limit checks that back
|
|
3
|
-
* X402ServeConfig['guard']. Pure functions against a fake in-memory store,
|
|
4
|
-
* no network or Express involved — the integration-level tests (guard
|
|
5
|
-
* wired through x402Serve() itself) live in x402serve-smoke.test.ts.
|
|
6
|
-
*
|
|
7
|
-
* These reproduce the exact scenarios a real production x402Serve() user
|
|
8
|
-
* (Edgadafi/remesa-liquidez) built their own version of this against, per
|
|
9
|
-
* https://github.com/nirium-protocol/nirium/issues/91.
|
|
10
|
-
*/
|
|
11
|
-
export {};
|