A desktop browser with x402 built in: when a page asks for payment, it pays in stablecoins and shows the content.

0 downloads

Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-browser.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-browser.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-browser.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 site icons (favicons) in tabs, address bar suggestions and the bookmarks panel 7249579 16 hours ago History
proxy.test.ts · 6.8 KB · 190 lines
1import { createServer as createHttp, type Server, request as httpRequest } from "node:http";
2import { createServer as createHttps } from "node:https";
3import { connect as tlsConnect } from "node:tls";
4import type { AddressInfo } from "node:net";
5import { afterAll, beforeAll, describe, expect, it } from "vitest";
6import { privateKeyToAccount } from "viem/accounts";
7import { PolicyEngine, Ledger, X402Engine } from "@dbbasic/x402-engine";
8import { X402Proxy } from "../src/server.js";
9import { CertificateAuthority } from "../src/ca.js";
10
11const NETWORK = "eip155:84532";
12const USDC = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
13const PAY_TO = "0x209693Bc6afc0C5328bA36FaF03C514EF312287C";
14const account = privateKeyToAccount(
15 "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d",
16);
17
18const b64 = (o: unknown) => Buffer.from(JSON.stringify(o)).toString("base64");
19
20/** A mock x402 origin: 402 with a PAYMENT-REQUIRED header, then 200 once paid. */
21function makeOrigin(handler: (req: unknown) => void, https = false, certHost = "localhost") {
22 const originCa = CertificateAuthority.ephemeral();
23 const listener = (req: import("node:http").IncomingMessage, res: import("node:http").ServerResponse) => {
24 handler(req);
25 if (!req.headers["payment-signature"]) {
26 const challenge = {
27 x402Version: 2,
28 accepts: [
29 {
30 scheme: "exact",
31 network: NETWORK,
32 amount: "10000",
33 asset: USDC,
34 payTo: PAY_TO,
35 maxTimeoutSeconds: 60,
36 extra: { name: "USDC", version: "2" },
37 },
38 ],
39 };
40 res.writeHead(402, { "PAYMENT-REQUIRED": b64(challenge), "content-type": "text/plain" });
41 res.end("payment required");
42 return;
43 }
44 res.writeHead(200, {
45 "PAYMENT-RESPONSE": b64({ success: true, transaction: "0xabc", network: NETWORK }),
46 "content-type": "text/plain",
47 });
48 res.end("PAID CONTENT");
49 };
50 if (https) {
51 const leaf = originCa.certFor(certHost);
52 return { server: createHttps({ cert: leaf.cert, key: leaf.key }, listener), ca: originCa };
53 }
54 return { server: createHttp(listener), ca: originCa };
55}
56
57function freshEngine(fetchImpl?: typeof fetch) {
58 return new X402Engine({
59 account,
60 policy: new PolicyEngine(),
61 ledger: new Ledger(),
62 fetchImpl,
63 });
64}
65
66// ---- HTTP forward-proxy path ----
67describe("proxy: plain HTTP", () => {
68 let origin: Server;
69 let originUrl: string;
70 let proxy: X402Proxy;
71 let proxyPort: number;
72 let hits = 0;
73
74 beforeAll(async () => {
75 const m = makeOrigin(() => hits++);
76 origin = m.server;
77 await new Promise<void>((r) => origin.listen(0, "127.0.0.1", r));
78 originUrl = `http://127.0.0.1:${(origin.address() as AddressInfo).port}`;
79
80 proxy = new X402Proxy({ engine: freshEngine(), ca: CertificateAuthority.ephemeral() });
81 ({ port: proxyPort } = await proxy.listen(0));
82 });
83
84 afterAll(async () => {
85 await proxy.close();
86 origin.close();
87 });
88
89 it("pays a 402 and returns the paid content through the proxy", async () => {
90 const body = await new Promise<string>((resolve, reject) => {
91 const req = httpRequest(
92 { host: "127.0.0.1", port: proxyPort, method: "GET", path: `${originUrl}/article` },
93 (res) => {
94 let data = "";
95 res.on("data", (c) => (data += c));
96 res.on("end", () => resolve(data));
97 },
98 );
99 req.on("error", reject);
100 req.end();
101 });
102
103 expect(body).toBe("PAID CONTENT");
104 expect(hits).toBe(2); // one 402, one paid retry
105 });
106});
107
108// ---- HTTPS MITM path (the real reason the proxy exists) ----
109describe("proxy: HTTPS via CONNECT + MITM", () => {
110 let origin: Server;
111 let originPort: number;
112 let proxy: X402Proxy;
113 let proxyPort: number;
114 let proxyCaPem: string;
115
116 beforeAll(async () => {
117 const m = makeOrigin(() => {}, true, "127.0.0.1");
118 origin = m.server;
119 await new Promise<void>((r) => origin.listen(0, "127.0.0.1", r));
120 originPort = (origin.address() as AddressInfo).port;
121
122 // The proxy's OUTBOUND fetch must trust the mock origin's self-signed cert.
123 // Scope the relaxation to this test process only.
124 const prev = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
125 process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
126 afterAll(() => {
127 if (prev === undefined) delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;
128 else process.env.NODE_TLS_REJECT_UNAUTHORIZED = prev;
129 });
130
131 const proxyCa = CertificateAuthority.ephemeral();
132 proxyCaPem = proxyCa.rootCertPem();
133 proxy = new X402Proxy({ engine: freshEngine(), ca: proxyCa });
134 ({ port: proxyPort } = await proxy.listen(0));
135 });
136
137 afterAll(async () => {
138 await proxy.close();
139 origin.close();
140 });
141
142 it("terminates TLS, pays the 402 inside the tunnel, returns paid content", async () => {
143 // Use 127.0.0.1 end to end: the origin binds IPv4-only, so resolving "localhost"
144 // (which prefers ::1) would hang the proxy's outbound fetch. The CA issues IP SANs.
145 const host = "127.0.0.1";
146 const target = `${host}:${originPort}`;
147
148 // 1. CONNECT to the proxy to open a tunnel.
149 const socket = await new Promise<import("node:stream").Duplex>((resolve, reject) => {
150 const req = httpRequest({ host: "127.0.0.1", port: proxyPort, method: "CONNECT", path: target });
151 req.on("connect", (res, sock) => {
152 if (res.statusCode !== 200) return reject(new Error(`CONNECT got ${res.statusCode}`));
153 resolve(sock);
154 });
155 req.on("error", reject);
156 req.end();
157 });
158
159 // 2. TLS to the proxy, trusting the proxy's root CA (as an installed CA would).
160 // SNI can't be an IP literal, so omit servername; chain trust via `ca` is still
161 // enforced, only the hostname match is skipped (fine for an IP-literal target).
162 const tls = tlsConnect({ socket, ca: [proxyCaPem], checkServerIdentity: () => undefined });
163 await new Promise<void>((resolve, reject) => {
164 tls.on("secureConnect", () => {
165 expect(tls.authorized).toBe(true); // proves the MITM leaf chains to our CA
166 resolve();
167 });
168 tls.on("error", reject);
169 setTimeout(() => reject(new Error("TLS handshake timeout")), 3000);
170 });
171
172 // 3. Speak plain HTTP inside the encrypted tunnel.
173 tls.write(`GET /premium HTTP/1.1\r\nHost: ${target}\r\nConnection: close\r\n\r\n`);
174 const raw = await new Promise<string>((resolve, reject) => {
175 let data = "";
176 const done = () => resolve(data);
177 tls.on("data", (c) => {
178 data += c.toString();
179 if (data.includes("PAID CONTENT")) done(); // full body arrived
180 });
181 tls.on("end", done);
182 tls.on("close", done);
183 tls.on("error", reject);
184 setTimeout(() => reject(new Error(`response timeout, got ${data.length}B: ${data.slice(0, 120)}`)), 3000);
185 });
186
187 expect(raw).toContain("200");
188 expect(raw).toContain("PAID CONTENT");
189 });
190});