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 15 hours, 52 minutes ago History
policy.ts · 5.9 KB · 170 lines
1/**
2 * The policy engine.
3 *
4 * x402's whole value is that payment happens at machine speed. A wallet modal per
5 * $0.001 request destroys that. But auto-approval is also the entire attack surface:
6 * a hostile page can fire ten thousand 402 subresources in a loop, and because
7 * EIP-3009 is signature-based, our exposure is exactly what we agree to sign.
8 *
9 * So the signing policy IS the security boundary. Budgets are scoped by the pair
10 * (top-level origin the user is actually looking at) x (origin being paid), because
11 * a global cap alone lets one hostile tab spend the whole day's allowance, and a
12 * per-destination cap alone lets a hostile page fan out across a thousand domains
13 * it controls. We also cap payment *rate*, not just amount: draining $20 in 200
14 * separate $0.10 payments is still a drain.
15 */
16
17import { formatUsd } from "./assets.js";
18import type { Quote } from "./types.js";
19
20export interface PolicyLimits {
21 /** Anything at or below this is paid without asking. */
22 autoApproveUnderUsdMicro: bigint;
23 /** Hard ceiling per (topOrigin, destOrigin) pair per window. */
24 perPairPerWindowUsdMicro: bigint;
25 /** Hard ceiling across everything per window. Last line of defence. */
26 globalPerWindowUsdMicro: bigint;
27 windowMs: number;
28 /** Max payments per (topOrigin, destOrigin) per window, regardless of size. */
29 maxPaymentsPerPairPerWindow: number;
30 /** Clamp on server-chosen maxTimeoutSeconds. Bounds how long a signed
31 * authorization stays settleable, so a server can't bank it and settle later. */
32 maxAuthorizationLifetimeSeconds: number;
33 /** Networks we're willing to sign on. */
34 allowedNetworks: string[];
35 /** Schemes we implement. */
36 allowedSchemes: string[];
37}
38
39export const DEFAULT_LIMITS: PolicyLimits = {
40 autoApproveUnderUsdMicro: 50_000n, // $0.05
41 perPairPerWindowUsdMicro: 5_000_000n, // $5.00
42 globalPerWindowUsdMicro: 20_000_000n, // $20.00
43 windowMs: 24 * 60 * 60 * 1000,
44 maxPaymentsPerPairPerWindow: 500,
45 maxAuthorizationLifetimeSeconds: 120,
46 allowedNetworks: ["eip155:8453", "eip155:84532"],
47 allowedSchemes: ["exact"],
48};
49
50export type Verdict =
51 | { action: "allow"; reason: string }
52 | { action: "prompt"; reason: string }
53 | { action: "deny"; reason: string };
54
55interface Counter {
56 spentUsdMicro: bigint;
57 count: number;
58 windowStart: number;
59}
60
61export interface PolicyContext {
62 /** The page the user is actually looking at. Empty string for agent/CLI traffic. */
63 topOrigin: string;
64 /** The origin we'd be paying. */
65 destOrigin: string;
66}
67
68export class PolicyEngine {
69 private pairs = new Map<string, Counter>();
70 private global: Counter = { spentUsdMicro: 0n, count: 0, windowStart: 0 };
71 /** Origins the user has explicitly blessed, with a standing allowance. */
72 private grants = new Map<string, bigint>();
73
74 constructor(
75 public limits: PolicyLimits = DEFAULT_LIMITS,
76 private now: () => number = Date.now,
77 ) {}
78
79 private roll(c: Counter): Counter {
80 const t = this.now();
81 if (t - c.windowStart >= this.limits.windowMs) {
82 c.spentUsdMicro = 0n;
83 c.count = 0;
84 c.windowStart = t;
85 }
86 return c;
87 }
88
89 private pairCounter(ctx: PolicyContext): Counter {
90 const k = `${ctx.topOrigin}>${ctx.destOrigin}`;
91 let c = this.pairs.get(k);
92 if (!c) {
93 c = { spentUsdMicro: 0n, count: 0, windowStart: this.now() };
94 this.pairs.set(k, c);
95 }
96 return this.roll(c);
97 }
98
99 /** User explicitly authorises an origin up to `usdMicro` for this session. */
100 grant(destOrigin: string, usdMicro: bigint): void {
101 this.grants.set(destOrigin, (this.grants.get(destOrigin) ?? 0n) + usdMicro);
102 }
103
104 evaluate(quote: Quote, ctx: PolicyContext): Verdict {
105 const { requirements: r } = quote;
106 const L = this.limits;
107
108 if (!L.allowedSchemes.includes(r.scheme)) {
109 return { action: "deny", reason: `unsupported scheme "${r.scheme}"` };
110 }
111 if (!L.allowedNetworks.includes(r.network)) {
112 return { action: "deny", reason: `network "${r.network}" not allowed` };
113 }
114 if (quote.priceUsdMicro <= 0n) {
115 return { action: "deny", reason: "non-positive price" };
116 }
117
118 const pair = this.pairCounter(ctx);
119 const global = this.roll(this.global);
120
121 if (pair.count >= L.maxPaymentsPerPairPerWindow) {
122 return {
123 action: "deny",
124 reason: `payment rate cap hit for ${ctx.destOrigin} (${L.maxPaymentsPerPairPerWindow}/window)`,
125 };
126 }
127 if (global.spentUsdMicro + quote.priceUsdMicro > L.globalPerWindowUsdMicro) {
128 return {
129 action: "deny",
130 reason: `global budget exhausted (${formatUsd(global.spentUsdMicro)} of ${formatUsd(L.globalPerWindowUsdMicro)})`,
131 };
132 }
133 if (pair.spentUsdMicro + quote.priceUsdMicro > L.perPairPerWindowUsdMicro) {
134 return {
135 action: "prompt",
136 reason: `${ctx.destOrigin} would exceed its ${formatUsd(L.perPairPerWindowUsdMicro)} budget`,
137 };
138 }
139
140 const granted = this.grants.get(ctx.destOrigin) ?? 0n;
141 if (granted >= quote.priceUsdMicro) {
142 return { action: "allow", reason: `within standing grant for ${ctx.destOrigin}` };
143 }
144 if (quote.priceUsdMicro <= L.autoApproveUnderUsdMicro) {
145 return { action: "allow", reason: `${formatUsd(quote.priceUsdMicro)} under auto-approve threshold` };
146 }
147 return {
148 action: "prompt",
149 reason: `${formatUsd(quote.priceUsdMicro)} exceeds auto-approve threshold`,
150 };
151 }
152
153 /** Call only after a payment is actually signed and sent. */
154 record(quote: Quote, ctx: PolicyContext): void {
155 const pair = this.pairCounter(ctx);
156 const global = this.roll(this.global);
157 pair.spentUsdMicro += quote.priceUsdMicro;
158 pair.count += 1;
159 global.spentUsdMicro += quote.priceUsdMicro;
160 global.count += 1;
161 const g = this.grants.get(ctx.destOrigin);
162 if (g !== undefined) {
163 this.grants.set(ctx.destOrigin, g > quote.priceUsdMicro ? g - quote.priceUsdMicro : 0n);
164 }
165 }
166
167 spentUsdMicro(): bigint {
168 return this.roll(this.global).spentUsdMicro;
169 }
170}