@agentbadge/circle-payments 0.1.18 → 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/chains.js +1 -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 +11 -0
- package/dist/index.js +11 -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
|
+
}
|
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,
|
|
@@ -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>;
|