@agentbadge/circle-payments 0.1.17 → 0.1.19
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 +77 -0
- package/dist/buyer/accepts.d.ts +33 -0
- package/dist/buyer/accepts.js +150 -0
- package/dist/buyer/caps.d.ts +27 -0
- package/dist/buyer/caps.js +67 -0
- package/dist/buyer/client.d.ts +66 -0
- package/dist/buyer/client.js +282 -0
- package/dist/buyer/guard.d.ts +9 -0
- package/dist/buyer/guard.js +1 -0
- package/dist/buyer/paginate.d.ts +6 -0
- package/dist/buyer/paginate.js +21 -0
- package/dist/buyer/risk-guard.d.ts +10 -0
- package/dist/buyer/risk-guard.js +47 -0
- package/dist/buyer/session.d.ts +18 -0
- package/dist/buyer/session.js +31 -0
- package/dist/chain/chain.d.ts +32 -0
- package/dist/chain/chain.js +44 -0
- package/dist/chain/index.d.ts +1 -0
- package/dist/chain/index.js +1 -0
- package/dist/chains.d.ts +8 -0
- package/dist/chains.js +28 -1
- package/dist/cli/pay.d.ts +7 -0
- package/dist/cli/pay.js +275 -0
- package/dist/gateway/deposit.d.ts +1 -1
- package/dist/gateway-probe.d.ts +1 -1
- package/dist/identity/erc8004.d.ts +18 -0
- package/dist/identity/erc8004.js +18 -1
- package/dist/identity/verify-passport.d.ts +1 -0
- package/dist/identity/verify-passport.js +1 -1
- package/dist/index.d.ts +12 -0
- package/dist/index.js +12 -0
- package/dist/middleware.d.ts +11 -0
- package/dist/middleware.js +40 -2
- package/dist/signer/arc-signer.d.ts +29 -0
- package/dist/signer/arc-signer.js +8 -0
- package/dist/signer/env-key.d.ts +20 -0
- package/dist/signer/env-key.js +58 -0
- package/dist/signer/protocol.d.ts +46 -0
- package/dist/signer/protocol.js +34 -0
- package/dist/signer/socket.d.ts +19 -0
- package/dist/signer/socket.js +139 -0
- package/package.json +5 -2
|
@@ -0,0 +1,282 @@
|
|
|
1
|
+
import { BatchEvmScheme } from "@circle-fin/x402-batching/client";
|
|
2
|
+
import { getChain } from "../chains.js";
|
|
3
|
+
import { decode402 } from "../identity/verify-passport.js";
|
|
4
|
+
import { signPayerChallenge } from "../payer-bind.js";
|
|
5
|
+
import { assertCaps, PaymentNotAcceptedError, } from "./caps.js";
|
|
6
|
+
import { validateAccepts } from "./accepts.js";
|
|
7
|
+
import { createSpendTracker } from "./session.js";
|
|
8
|
+
import { depositToGateway, gatewayBalance } from "../gateway/deposit.js";
|
|
9
|
+
export function viemSigner(client) {
|
|
10
|
+
const account = client.account;
|
|
11
|
+
const address = typeof account === "string" ? account : account?.address;
|
|
12
|
+
if (!address) {
|
|
13
|
+
throw new TypeError("viemSigner: wallet client has no account address");
|
|
14
|
+
}
|
|
15
|
+
return {
|
|
16
|
+
address,
|
|
17
|
+
signTypedData: client.signTypedData?.bind(client),
|
|
18
|
+
writeContract: client.writeContract?.bind(client),
|
|
19
|
+
signMessage: client.signMessage?.bind(client),
|
|
20
|
+
};
|
|
21
|
+
}
|
|
22
|
+
export class PaymentRefusedError extends Error {
|
|
23
|
+
field;
|
|
24
|
+
value;
|
|
25
|
+
constructor(field, value, reason) {
|
|
26
|
+
super(reason);
|
|
27
|
+
this.field = field;
|
|
28
|
+
this.value = value;
|
|
29
|
+
this.name = "PaymentRefusedError";
|
|
30
|
+
}
|
|
31
|
+
}
|
|
32
|
+
const TRANSFER_WITH_AUTHORIZATION_ABI = [
|
|
33
|
+
{
|
|
34
|
+
name: "transferWithAuthorization",
|
|
35
|
+
type: "function",
|
|
36
|
+
stateMutability: "nonpayable",
|
|
37
|
+
inputs: [
|
|
38
|
+
{ name: "from", type: "address" },
|
|
39
|
+
{ name: "to", type: "address" },
|
|
40
|
+
{ name: "value", type: "uint256" },
|
|
41
|
+
{ name: "validAfter", type: "uint256" },
|
|
42
|
+
{ name: "validBefore", type: "uint256" },
|
|
43
|
+
{ name: "nonce", type: "bytes32" },
|
|
44
|
+
{ name: "v", type: "uint8" },
|
|
45
|
+
{ name: "r", type: "bytes32" },
|
|
46
|
+
{ name: "s", type: "bytes32" },
|
|
47
|
+
],
|
|
48
|
+
outputs: [],
|
|
49
|
+
},
|
|
50
|
+
];
|
|
51
|
+
const b64encode = (o) => Buffer.from(JSON.stringify(o)).toString("base64");
|
|
52
|
+
function randomNonce() {
|
|
53
|
+
const bytes = new Uint8Array(32);
|
|
54
|
+
globalThis.crypto.getRandomValues(bytes);
|
|
55
|
+
return `0x${Buffer.from(bytes).toString("hex")}`;
|
|
56
|
+
}
|
|
57
|
+
async function signTransferAuth(signer, req) {
|
|
58
|
+
if (!signer.signTypedData) {
|
|
59
|
+
throw new PaymentRefusedError("signer", undefined, "signer lacks signTypedData — cannot sign EIP-3009 authorization");
|
|
60
|
+
}
|
|
61
|
+
const name = req.extra?.name;
|
|
62
|
+
const version = req.extra?.version;
|
|
63
|
+
if (typeof name !== "string" || typeof version !== "string") {
|
|
64
|
+
throw new PaymentRefusedError("extra.name", req.extra?.name, "requirements lack extra.name/extra.version for the EIP-712 domain — refusing to guess");
|
|
65
|
+
}
|
|
66
|
+
const chain = getChain(req.network);
|
|
67
|
+
if (!chain) {
|
|
68
|
+
throw new PaymentRefusedError("network", req.network, `unknown network ${req.network}`);
|
|
69
|
+
}
|
|
70
|
+
const nowSec = Math.floor(Date.now() / 1000);
|
|
71
|
+
const authorization = {
|
|
72
|
+
from: signer.address,
|
|
73
|
+
to: req.payTo,
|
|
74
|
+
value: req.amount,
|
|
75
|
+
validAfter: "0",
|
|
76
|
+
validBefore: String(nowSec + (req.maxTimeoutSeconds ?? 3600)),
|
|
77
|
+
nonce: randomNonce(),
|
|
78
|
+
};
|
|
79
|
+
const signature = await signer.signTypedData({
|
|
80
|
+
domain: {
|
|
81
|
+
name,
|
|
82
|
+
version,
|
|
83
|
+
chainId: chain.chainId,
|
|
84
|
+
verifyingContract: req.asset,
|
|
85
|
+
},
|
|
86
|
+
types: {
|
|
87
|
+
TransferWithAuthorization: [
|
|
88
|
+
{ name: "from", type: "address" },
|
|
89
|
+
{ name: "to", type: "address" },
|
|
90
|
+
{ name: "value", type: "uint256" },
|
|
91
|
+
{ name: "validAfter", type: "uint256" },
|
|
92
|
+
{ name: "validBefore", type: "uint256" },
|
|
93
|
+
{ name: "nonce", type: "bytes32" },
|
|
94
|
+
],
|
|
95
|
+
},
|
|
96
|
+
primaryType: "TransferWithAuthorization",
|
|
97
|
+
message: authorization,
|
|
98
|
+
});
|
|
99
|
+
return { signature, authorization };
|
|
100
|
+
}
|
|
101
|
+
function splitSig(sig) {
|
|
102
|
+
const r = `0x${sig.slice(2, 66)}`;
|
|
103
|
+
const s = `0x${sig.slice(66, 130)}`;
|
|
104
|
+
const v = Number.parseInt(sig.slice(130, 132), 16);
|
|
105
|
+
return { v, r, s };
|
|
106
|
+
}
|
|
107
|
+
async function broadcastTransferAuth(signer, req, signature, authorization) {
|
|
108
|
+
if (!signer.writeContract) {
|
|
109
|
+
throw new PaymentRefusedError("signer", undefined, "signer lacks writeContract — eip3009-client-broadcast requires on-chain broadcast");
|
|
110
|
+
}
|
|
111
|
+
const { v, r, s } = splitSig(signature);
|
|
112
|
+
return signer.writeContract({
|
|
113
|
+
address: req.asset,
|
|
114
|
+
abi: TRANSFER_WITH_AUTHORIZATION_ABI,
|
|
115
|
+
functionName: "transferWithAuthorization",
|
|
116
|
+
args: [
|
|
117
|
+
authorization.from,
|
|
118
|
+
authorization.to,
|
|
119
|
+
authorization.value,
|
|
120
|
+
authorization.validAfter,
|
|
121
|
+
authorization.validBefore,
|
|
122
|
+
authorization.nonce,
|
|
123
|
+
v,
|
|
124
|
+
r,
|
|
125
|
+
s,
|
|
126
|
+
],
|
|
127
|
+
});
|
|
128
|
+
}
|
|
129
|
+
async function buildPayment(signer, req) {
|
|
130
|
+
switch (req.scheme) {
|
|
131
|
+
case "exact": {
|
|
132
|
+
const { signature, authorization } = await signTransferAuth(signer, req);
|
|
133
|
+
return { payload: { signature, authorization }, committed: false };
|
|
134
|
+
}
|
|
135
|
+
case "gateway-batch": {
|
|
136
|
+
if (!signer.signTypedData) {
|
|
137
|
+
throw new PaymentRefusedError("signer", undefined, "signer lacks signTypedData — cannot sign gateway-batch authorization");
|
|
138
|
+
}
|
|
139
|
+
const scheme = new BatchEvmScheme({
|
|
140
|
+
address: signer.address,
|
|
141
|
+
signTypedData: signer.signTypedData.bind(signer),
|
|
142
|
+
});
|
|
143
|
+
const { payload } = await scheme.createPaymentPayload(2, req);
|
|
144
|
+
return {
|
|
145
|
+
payload: payload,
|
|
146
|
+
committed: false,
|
|
147
|
+
};
|
|
148
|
+
}
|
|
149
|
+
case "eip3009-client-broadcast": {
|
|
150
|
+
const { signature, authorization } = await signTransferAuth(signer, req);
|
|
151
|
+
const txHash = await broadcastTransferAuth(signer, req, signature, authorization);
|
|
152
|
+
return {
|
|
153
|
+
payload: { txHash, authorization, signature },
|
|
154
|
+
txHash,
|
|
155
|
+
committed: true,
|
|
156
|
+
};
|
|
157
|
+
}
|
|
158
|
+
default:
|
|
159
|
+
throw new PaymentRefusedError("scheme", req.scheme, `no signer path for scheme ${JSON.stringify(req.scheme)}`);
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
export function createPayingClient(opts) {
|
|
163
|
+
assertCaps(opts.caps);
|
|
164
|
+
if (!opts.signer?.address) {
|
|
165
|
+
throw new TypeError("createPayingClient: signer.address is required");
|
|
166
|
+
}
|
|
167
|
+
const caps = opts.caps;
|
|
168
|
+
const signer = opts.signer;
|
|
169
|
+
const fetchImpl = opts.fetch ?? fetch;
|
|
170
|
+
const tracker = createSpendTracker(caps, { onSpend: opts.onSpend });
|
|
171
|
+
const deposits = [];
|
|
172
|
+
const recordSpend = (req, resource) => tracker.record({
|
|
173
|
+
amountAtomic: req.amount,
|
|
174
|
+
network: req.network,
|
|
175
|
+
scheme: req.scheme,
|
|
176
|
+
resource,
|
|
177
|
+
});
|
|
178
|
+
async function ensureGatewayFunds(req) {
|
|
179
|
+
const g = opts.gateway;
|
|
180
|
+
if (!g?.autoDepositUsd)
|
|
181
|
+
return;
|
|
182
|
+
const chain = getChain(req.network);
|
|
183
|
+
if (!chain?.domain === undefined || !chain)
|
|
184
|
+
return;
|
|
185
|
+
const info = await gatewayBalance({
|
|
186
|
+
depositor: signer.address,
|
|
187
|
+
chain,
|
|
188
|
+
...(g.apiUrl ? { apiUrl: g.apiUrl } : {}),
|
|
189
|
+
fetchImpl,
|
|
190
|
+
});
|
|
191
|
+
if (!info)
|
|
192
|
+
return;
|
|
193
|
+
const need = BigInt(req.amount);
|
|
194
|
+
const available = BigInt(info.available ?? "0");
|
|
195
|
+
if (available >= need)
|
|
196
|
+
return;
|
|
197
|
+
if (!signer.writeContract) {
|
|
198
|
+
throw new PaymentRefusedError("signer", undefined, "gateway auto-deposit requires signer.writeContract");
|
|
199
|
+
}
|
|
200
|
+
const result = await depositToGateway({
|
|
201
|
+
wallet: {
|
|
202
|
+
account: signer.address,
|
|
203
|
+
writeContract: signer.writeContract.bind(signer),
|
|
204
|
+
},
|
|
205
|
+
chain,
|
|
206
|
+
amountUsd: g.autoDepositUsd,
|
|
207
|
+
});
|
|
208
|
+
deposits.push(result);
|
|
209
|
+
}
|
|
210
|
+
async function request(url, init = {}) {
|
|
211
|
+
const first = await fetchImpl(url, init);
|
|
212
|
+
if (first.status !== 402)
|
|
213
|
+
return first;
|
|
214
|
+
const header = first.headers.get("payment-required");
|
|
215
|
+
const body = header ?? (await first.clone().json().catch(() => undefined));
|
|
216
|
+
const pr = decode402(body);
|
|
217
|
+
const verdict = validateAccepts(pr, caps);
|
|
218
|
+
if (!verdict.ok) {
|
|
219
|
+
throw new PaymentRefusedError(verdict.field, verdict.value, verdict.reason);
|
|
220
|
+
}
|
|
221
|
+
const req = verdict.requirements;
|
|
222
|
+
if (opts.beforePayment) {
|
|
223
|
+
const targets = new Map();
|
|
224
|
+
if (opts.checkAllOffers !== false && pr) {
|
|
225
|
+
for (const a of pr.accepts ?? []) {
|
|
226
|
+
if (a?.payTo)
|
|
227
|
+
targets.set(`${a.payTo}:${a.network}`, { payTo: a.payTo, accept: a });
|
|
228
|
+
}
|
|
229
|
+
}
|
|
230
|
+
targets.set(`${req.payTo}:${req.network}`, { payTo: req.payTo, accept: req });
|
|
231
|
+
for (const { payTo, accept } of targets.values()) {
|
|
232
|
+
const decision = await opts.beforePayment(payTo, accept);
|
|
233
|
+
if (decision !== "allow") {
|
|
234
|
+
throw new PaymentRefusedError("payTo", payTo, decision.block);
|
|
235
|
+
}
|
|
236
|
+
}
|
|
237
|
+
}
|
|
238
|
+
tracker.tryReserve(req.amount);
|
|
239
|
+
if (req.scheme === "gateway-batch") {
|
|
240
|
+
await ensureGatewayFunds(req);
|
|
241
|
+
}
|
|
242
|
+
const signed = await buildPayment(signer, req);
|
|
243
|
+
if (signed.committed) {
|
|
244
|
+
recordSpend(req, url);
|
|
245
|
+
}
|
|
246
|
+
const headers = new Headers(init.headers);
|
|
247
|
+
headers.set("payment-signature", b64encode({ x402Version: 2, accepted: req, payload: signed.payload }));
|
|
248
|
+
if (req.extra?.payerBinding && signed.txHash && signer.signMessage) {
|
|
249
|
+
const timestamp = Math.floor(Date.now() / 1000);
|
|
250
|
+
const msgSigner = signer;
|
|
251
|
+
const sig = await signPayerChallenge(msgSigner, {
|
|
252
|
+
wallet: signer.address,
|
|
253
|
+
method: (init.method ?? "GET").toUpperCase(),
|
|
254
|
+
path: new URL(url).pathname,
|
|
255
|
+
payRef: signed.txHash,
|
|
256
|
+
timestamp,
|
|
257
|
+
});
|
|
258
|
+
headers.set("X-Wallet", signer.address);
|
|
259
|
+
headers.set("X-Sig", sig);
|
|
260
|
+
headers.set("X-Timestamp", String(timestamp));
|
|
261
|
+
}
|
|
262
|
+
const second = await fetchImpl(url, { ...init, headers });
|
|
263
|
+
if (second.status === 402) {
|
|
264
|
+
throw new PaymentNotAcceptedError(`server rejected payment for ${url} with a second 402`, "payment", signed.payload);
|
|
265
|
+
}
|
|
266
|
+
if (!signed.committed) {
|
|
267
|
+
recordSpend(req, url);
|
|
268
|
+
}
|
|
269
|
+
return second;
|
|
270
|
+
}
|
|
271
|
+
return {
|
|
272
|
+
request,
|
|
273
|
+
get: (url, init = {}) => request(url, { ...init, method: "GET" }),
|
|
274
|
+
post: (url, init = {}) => request(url, { ...init, method: "POST" }),
|
|
275
|
+
spent: () => tracker.spent(),
|
|
276
|
+
budget: () => tracker.budget(),
|
|
277
|
+
deposits: () => deposits,
|
|
278
|
+
tracker,
|
|
279
|
+
caps,
|
|
280
|
+
signer,
|
|
281
|
+
};
|
|
282
|
+
}
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
import type { PaymentRequirements } from "../chains.js";
|
|
2
|
+
export type Address = string;
|
|
3
|
+
export type GuardDecision = "allow" | {
|
|
4
|
+
block: string;
|
|
5
|
+
};
|
|
6
|
+
export type BeforePaymentFn = (payTo: Address, accept: PaymentRequirements) => Promise<GuardDecision>;
|
|
7
|
+
export interface GuardCheckOptions {
|
|
8
|
+
checkAllOffers?: boolean;
|
|
9
|
+
}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export {};
|
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
export async function paginateAll(fetchPage, opts = {}) {
|
|
2
|
+
const cursorField = opts.cursorField ?? "cursor";
|
|
3
|
+
const itemsField = opts.itemsField ?? "items";
|
|
4
|
+
const items = [];
|
|
5
|
+
let cursor;
|
|
6
|
+
let pages = 0;
|
|
7
|
+
do {
|
|
8
|
+
const res = await fetchPage(cursor);
|
|
9
|
+
if (!res.ok) {
|
|
10
|
+
throw new Error(`paginateAll: page fetch failed with status ${res.status}`);
|
|
11
|
+
}
|
|
12
|
+
const body = (await res.json());
|
|
13
|
+
const pageItems = body[itemsField];
|
|
14
|
+
if (Array.isArray(pageItems))
|
|
15
|
+
items.push(...pageItems);
|
|
16
|
+
const next = body[cursorField];
|
|
17
|
+
cursor = typeof next === "string" && next ? next : undefined;
|
|
18
|
+
pages++;
|
|
19
|
+
} while (cursor && (opts.maxPages === undefined || pages < opts.maxPages));
|
|
20
|
+
return items;
|
|
21
|
+
}
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
import type { BeforePaymentFn } from "./guard.js";
|
|
2
|
+
export interface RiskGuardOptions {
|
|
3
|
+
endpoint?: string;
|
|
4
|
+
minOrganicShare?: number;
|
|
5
|
+
allowNoData?: boolean;
|
|
6
|
+
onRiskError?: "allow" | "block";
|
|
7
|
+
timeoutMs?: number;
|
|
8
|
+
fetchImpl?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
|
|
9
|
+
}
|
|
10
|
+
export declare function createRiskGuard(opts?: RiskGuardOptions): BeforePaymentFn;
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
export function createRiskGuard(opts = {}) {
|
|
2
|
+
const endpoint = (opts.endpoint ?? "https://agentbadge.xyz/api/v1/risk").replace(/\/+$/, "");
|
|
3
|
+
const minOrganicShare = opts.minOrganicShare ?? 0.3;
|
|
4
|
+
const allowNoData = opts.allowNoData ?? true;
|
|
5
|
+
const onRiskError = opts.onRiskError ?? "allow";
|
|
6
|
+
const timeoutMs = opts.timeoutMs ?? 2_000;
|
|
7
|
+
const fetchImpl = opts.fetchImpl ?? fetch;
|
|
8
|
+
return async (payTo, accept) => {
|
|
9
|
+
const chain = accept.network?.match(/^eip155:(\d+)$/)?.[1];
|
|
10
|
+
const url = `${endpoint}/${payTo}${chain ? `?chain=${chain}` : ""}`;
|
|
11
|
+
let body = null;
|
|
12
|
+
try {
|
|
13
|
+
const res = await fetchImpl(url, {
|
|
14
|
+
signal: AbortSignal.timeout(timeoutMs),
|
|
15
|
+
headers: { accept: "application/json" },
|
|
16
|
+
});
|
|
17
|
+
if (res.ok) {
|
|
18
|
+
body = (await res.json().catch(() => null));
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
catch {
|
|
22
|
+
body = null;
|
|
23
|
+
}
|
|
24
|
+
if (body === null) {
|
|
25
|
+
return onRiskError === "allow"
|
|
26
|
+
? "allow"
|
|
27
|
+
: { block: "risk check failed (endpoint unreachable/error/429)" };
|
|
28
|
+
}
|
|
29
|
+
const reasons = (body.reasons ?? []).join("; ");
|
|
30
|
+
const suffix = reasons ? ` — ${reasons}` : "";
|
|
31
|
+
switch (body.verdict) {
|
|
32
|
+
case "pass":
|
|
33
|
+
case "caution":
|
|
34
|
+
if (body.verdict === "caution" && (body.organicShare ?? 0) < minOrganicShare) {
|
|
35
|
+
return { block: `organic share below ${minOrganicShare}${suffix}` };
|
|
36
|
+
}
|
|
37
|
+
return "allow";
|
|
38
|
+
case "no_data":
|
|
39
|
+
return allowNoData
|
|
40
|
+
? "allow"
|
|
41
|
+
: { block: "risk verdict no_data" };
|
|
42
|
+
case "block":
|
|
43
|
+
default:
|
|
44
|
+
return { block: `risk verdict ${body.verdict ?? "unknown"}${suffix}` };
|
|
45
|
+
}
|
|
46
|
+
};
|
|
47
|
+
}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import { type PaymentCaps } from "./caps.js";
|
|
2
|
+
export interface SpendEntry {
|
|
3
|
+
amountAtomic: string;
|
|
4
|
+
network?: string;
|
|
5
|
+
scheme?: string;
|
|
6
|
+
resource?: string;
|
|
7
|
+
}
|
|
8
|
+
export interface SpendTracker {
|
|
9
|
+
tryReserve(amountAtomic: string): void;
|
|
10
|
+
record(entry: SpendEntry): void;
|
|
11
|
+
spent(): string;
|
|
12
|
+
budget(): string;
|
|
13
|
+
reset(): void;
|
|
14
|
+
}
|
|
15
|
+
export interface SpendTrackerOptions {
|
|
16
|
+
onSpend?: (entry: SpendEntry) => void;
|
|
17
|
+
}
|
|
18
|
+
export declare function createSpendTracker(caps: PaymentCaps, opts?: SpendTrackerOptions): SpendTracker;
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
import { assertCaps, BudgetExhaustedError, CapExceededError, usdToAtomic, } from "./caps.js";
|
|
2
|
+
export function createSpendTracker(caps, opts = {}) {
|
|
3
|
+
assertCaps(caps);
|
|
4
|
+
const capAtomic = BigInt(usdToAtomic(caps.maxPaymentUsd));
|
|
5
|
+
const budgetAtomic = BigInt(usdToAtomic(caps.sessionBudgetUsd));
|
|
6
|
+
let spent = 0n;
|
|
7
|
+
return {
|
|
8
|
+
tryReserve(amountAtomic) {
|
|
9
|
+
const amount = BigInt(amountAtomic);
|
|
10
|
+
if (amount > capAtomic) {
|
|
11
|
+
throw new CapExceededError(capAtomic.toString(), amount.toString());
|
|
12
|
+
}
|
|
13
|
+
if (spent + amount > budgetAtomic) {
|
|
14
|
+
throw new BudgetExhaustedError(spent.toString(), budgetAtomic.toString(), amount.toString());
|
|
15
|
+
}
|
|
16
|
+
},
|
|
17
|
+
record(entry) {
|
|
18
|
+
spent += BigInt(entry.amountAtomic);
|
|
19
|
+
opts.onSpend?.(entry);
|
|
20
|
+
},
|
|
21
|
+
spent() {
|
|
22
|
+
return spent.toString();
|
|
23
|
+
},
|
|
24
|
+
budget() {
|
|
25
|
+
return budgetAtomic.toString();
|
|
26
|
+
},
|
|
27
|
+
reset() {
|
|
28
|
+
spent = 0n;
|
|
29
|
+
},
|
|
30
|
+
};
|
|
31
|
+
}
|
|
@@ -0,0 +1,32 @@
|
|
|
1
|
+
export type Hex = `0x${string}`;
|
|
2
|
+
export declare const GENESIS_HASH: Hex;
|
|
3
|
+
export interface ChainEntry {
|
|
4
|
+
seq: number;
|
|
5
|
+
domain: string;
|
|
6
|
+
verdictId: Hex;
|
|
7
|
+
prevHash: Hex;
|
|
8
|
+
entryHash: Hex;
|
|
9
|
+
artifactHash: Hex;
|
|
10
|
+
appendedAt: number;
|
|
11
|
+
}
|
|
12
|
+
export interface ChainHead {
|
|
13
|
+
domain: string;
|
|
14
|
+
headHash: Hex;
|
|
15
|
+
count: number;
|
|
16
|
+
lastFlushAt?: number;
|
|
17
|
+
anchor?: {
|
|
18
|
+
epochSeq: number;
|
|
19
|
+
txHash: Hex;
|
|
20
|
+
blockNumber: string;
|
|
21
|
+
};
|
|
22
|
+
}
|
|
23
|
+
export declare function computeEntryHash(prevHash: Hex, artifactHash: Hex): Hex;
|
|
24
|
+
export declare function appendEntry(domain: string, verdictId: Hex, artifactHash: Hex, entries: readonly ChainEntry[], appendedAt?: number): ChainEntry;
|
|
25
|
+
export interface ChainVerifyResult {
|
|
26
|
+
ok: boolean;
|
|
27
|
+
firstBrokenSeq: number | null;
|
|
28
|
+
headHash: Hex;
|
|
29
|
+
}
|
|
30
|
+
export declare function verifyChain(entries: readonly ChainEntry[]): ChainVerifyResult;
|
|
31
|
+
export declare function inclusionPath(entries: readonly ChainEntry[], seq: number): ChainEntry[];
|
|
32
|
+
export declare function chainHeadOf(domain: string, entries: readonly ChainEntry[]): ChainHead;
|
|
@@ -0,0 +1,44 @@
|
|
|
1
|
+
import { concatHex, keccak256 } from "viem";
|
|
2
|
+
export const GENESIS_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
|
|
3
|
+
export function computeEntryHash(prevHash, artifactHash) {
|
|
4
|
+
return keccak256(concatHex([prevHash, artifactHash]));
|
|
5
|
+
}
|
|
6
|
+
function headHashOf(entries) {
|
|
7
|
+
return entries.length === 0
|
|
8
|
+
? GENESIS_HASH
|
|
9
|
+
: entries[entries.length - 1].entryHash;
|
|
10
|
+
}
|
|
11
|
+
export function appendEntry(domain, verdictId, artifactHash, entries, appendedAt = Date.now()) {
|
|
12
|
+
const prevHash = headHashOf(entries);
|
|
13
|
+
return {
|
|
14
|
+
seq: entries.length,
|
|
15
|
+
domain,
|
|
16
|
+
verdictId,
|
|
17
|
+
prevHash,
|
|
18
|
+
entryHash: computeEntryHash(prevHash, artifactHash),
|
|
19
|
+
artifactHash,
|
|
20
|
+
appendedAt,
|
|
21
|
+
};
|
|
22
|
+
}
|
|
23
|
+
export function verifyChain(entries) {
|
|
24
|
+
let prevHash = GENESIS_HASH;
|
|
25
|
+
for (let i = 0; i < entries.length; i++) {
|
|
26
|
+
const e = entries[i];
|
|
27
|
+
const broken = e.seq !== i ||
|
|
28
|
+
e.prevHash !== prevHash ||
|
|
29
|
+
e.entryHash !== computeEntryHash(prevHash, e.artifactHash);
|
|
30
|
+
if (broken) {
|
|
31
|
+
return { ok: false, firstBrokenSeq: e.seq, headHash: prevHash };
|
|
32
|
+
}
|
|
33
|
+
prevHash = e.entryHash;
|
|
34
|
+
}
|
|
35
|
+
return { ok: true, firstBrokenSeq: null, headHash: prevHash };
|
|
36
|
+
}
|
|
37
|
+
export function inclusionPath(entries, seq) {
|
|
38
|
+
if (seq < 0 || seq >= entries.length)
|
|
39
|
+
return [];
|
|
40
|
+
return entries.slice(seq);
|
|
41
|
+
}
|
|
42
|
+
export function chainHeadOf(domain, entries) {
|
|
43
|
+
return { domain, headHash: headHashOf(entries), count: entries.length };
|
|
44
|
+
}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export * from "./chain.js";
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export * from "./chain.js";
|
package/dist/chains.d.ts
CHANGED
|
@@ -35,10 +35,18 @@ export declare const ARC_MAINNET_AGENTBADGE_CONTRACTS: {
|
|
|
35
35
|
readonly accessPassNFT: "0x68ca4d1a9ff24f86328f2fb3a30d81e503d367f5";
|
|
36
36
|
readonly marketplacePassNFT: "0xf8756ce4400c76f1c31b72216c391e1c46cc2c03";
|
|
37
37
|
};
|
|
38
|
+
export declare const CELO_MAINNET: SupportedChain;
|
|
39
|
+
export declare const CELO_SEPOLIA: SupportedChain;
|
|
40
|
+
export declare const CELO_ERC8004_CONTRACTS: {
|
|
41
|
+
readonly celo: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432";
|
|
42
|
+
readonly celoSepolia: "0x8004A818BFB912233c491871b3d84c89A494BD9e";
|
|
43
|
+
};
|
|
38
44
|
export declare const CHAINS: {
|
|
39
45
|
readonly [BASE_SEPOLIA.caip2]: SupportedChain;
|
|
40
46
|
readonly [ARC_TESTNET.caip2]: SupportedChain;
|
|
41
47
|
readonly [ARC_MAINNET.caip2]: SupportedChain;
|
|
48
|
+
readonly [CELO_MAINNET.caip2]: SupportedChain;
|
|
49
|
+
readonly [CELO_SEPOLIA.caip2]: SupportedChain;
|
|
42
50
|
};
|
|
43
51
|
export declare function getChain(id: string | number): SupportedChain | undefined;
|
|
44
52
|
export type PaymentSchemeId = "gateway-batch" | "exact" | "eip3009-client-broadcast";
|
package/dist/chains.js
CHANGED
|
@@ -17,7 +17,7 @@ export const ARC_TESTNET = {
|
|
|
17
17
|
name: "Arc Testnet",
|
|
18
18
|
usdc: "0x3600000000000000000000000000000000000000",
|
|
19
19
|
usdcDecimals: 6,
|
|
20
|
-
rpcUrl: "https://rpc.testnet.arc.
|
|
20
|
+
rpcUrl: "https://rpc.testnet.arc.io",
|
|
21
21
|
facilitatorUrl: "https://gateway-api-testnet.circle.com",
|
|
22
22
|
gatewayWallet: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
|
|
23
23
|
domain: 26,
|
|
@@ -56,10 +56,37 @@ export const ARC_MAINNET_AGENTBADGE_CONTRACTS = {
|
|
|
56
56
|
accessPassNFT: "0x68ca4d1a9ff24f86328f2fb3a30d81e503d367f5",
|
|
57
57
|
marketplacePassNFT: "0xf8756ce4400c76f1c31b72216c391e1c46cc2c03",
|
|
58
58
|
};
|
|
59
|
+
export const CELO_MAINNET = {
|
|
60
|
+
caip2: "eip155:42220",
|
|
61
|
+
chainId: 42220,
|
|
62
|
+
name: "Celo",
|
|
63
|
+
usdc: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C",
|
|
64
|
+
usdcDecimals: 6,
|
|
65
|
+
rpcUrl: process.env.CELO_RPC_URL ?? "https://forno.celo.org",
|
|
66
|
+
facilitatorUrl: "https://api.x402.celo.org",
|
|
67
|
+
explorerUrl: "https://celoscan.io",
|
|
68
|
+
};
|
|
69
|
+
export const CELO_SEPOLIA = {
|
|
70
|
+
caip2: "eip155:11142220",
|
|
71
|
+
chainId: 11142220,
|
|
72
|
+
name: "Celo Sepolia",
|
|
73
|
+
usdc: "0x01C5C0122039549AD1493B8220cABEdD739BC44E",
|
|
74
|
+
usdcDecimals: 6,
|
|
75
|
+
rpcUrl: process.env.CELO_SEPOLIA_RPC_URL ??
|
|
76
|
+
"https://forno.celo-sepolia.celo-testnet.org",
|
|
77
|
+
explorerUrl: "https://sepolia.celoscan.io",
|
|
78
|
+
faucetUrl: "https://faucet.celo.org/celo-sepolia",
|
|
79
|
+
};
|
|
80
|
+
export const CELO_ERC8004_CONTRACTS = {
|
|
81
|
+
celo: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
|
|
82
|
+
celoSepolia: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
|
|
83
|
+
};
|
|
59
84
|
export const CHAINS = {
|
|
60
85
|
[BASE_SEPOLIA.caip2]: BASE_SEPOLIA,
|
|
61
86
|
[ARC_TESTNET.caip2]: ARC_TESTNET,
|
|
62
87
|
[ARC_MAINNET.caip2]: ARC_MAINNET,
|
|
88
|
+
[CELO_MAINNET.caip2]: CELO_MAINNET,
|
|
89
|
+
[CELO_SEPOLIA.caip2]: CELO_SEPOLIA,
|
|
63
90
|
};
|
|
64
91
|
export function getChain(id) {
|
|
65
92
|
const key = typeof id === "number" ? `eip155:${id}` : id;
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
export interface CliIo {
|
|
3
|
+
stdout?: (s: string) => void;
|
|
4
|
+
stderr?: (s: string) => void;
|
|
5
|
+
fetchImpl?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
|
|
6
|
+
}
|
|
7
|
+
export declare function runPay(argv: string[], env?: NodeJS.ProcessEnv, io?: CliIo): Promise<number>;
|