@bondedhq/sdk 0.1.3 → 0.1.5

package/dist/payments.js

@@ -0,0 +1,474 @@
+import { checkBudget, checkGeneralPayment, checkInvoicePayment, checkRefundPayment, GATE_RULE_WORDS, isVerifiedChange, normalAccount, utcDay, usdToMicros, } from "@bondedhq/shared";
+import { BudgetBase } from "./budget.js";
+import { BondedError, PaymentBlockedError, PaymentFrozenError, PaymentGateError, } from "./errors.js";
+const read = async (source) => typeof source === "function" ? await source() : (source ?? []);
+const copy = (state) => ({
+    payments: state.payments.map((p) => ({ ...p })),
+    frozen: state.frozen,
+    unverifiedChanges: state.unverifiedChanges.map((c) => ({ ...c })),
+    budgets: (state.budgets ?? []).map((b) => ({ ...b, terms: { ...b.terms } })),
+    budgetSpends: [...(state.budgetSpends ?? [])],
+});
+/** The reference a local budget's reservation is recorded under. */
+const budgetReference = (id) => `budget:${id}`;
+/**
+ * The payment mandate, checked inside your own process: the same rules (`@bondedhq/shared`'s
+ * payment mandate) the Arena rates agents against, with no network and no model. You give it the
+ * mandate and your vendor master, approved invoices and refunds, and verified bank changes; it
+ * keeps the payments made and the frozen flag, and hands them to `onStateChange` to persist.
+ *
+ * Wrap your pay function with `guardPayments` (or a framework helper) so every payment is checked
+ * first. In Enforce mode a payment that breaks a rule throws `PaymentBlockedError` and your pay
+ * function is never called; in Monitor mode it goes through and `onBreach` reports it. A frozen
+ * guard refuses everything (`PaymentFrozenError`).
+ *
+ * It is a local check: the agent's code can still call the pay function without it, and it makes
+ * no receipts. Payments are checked and made one at a time, so two at once can't both pass the
+ * duplicate or daily checks.
+ */
+export class PaymentGuard {
+    mandate;
+    #options;
+    #state;
+    #queue = Promise.resolve();
+    #now;
+    constructor(options) {
+        this.mandate = Object.freeze({ ...options.mandate });
+        this.#options = options;
+        this.#state = copy(options.state ?? { payments: [], frozen: false, unverifiedChanges: [] });
+        this.#now = options.now ?? (() => new Date());
+    }
+    get frozen() {
+        return this.#state.frozen;
+    }
+    /** A copy of what the guard remembers, to persist or inspect. */
+    state() {
+        return copy(this.#state);
+    }
+    /** Lets payments through again after a freeze. For a person who reviewed the breach. */
+    unfreeze() {
+        return this.#exclusive(async () => {
+            if (!this.#state.frozen)
+                return;
+            this.#state.frozen = false;
+            await this.#save();
+        });
+    }
+    /** The rule verdict for a payment, without making or recording it. */
+    async check(attempt, kind = "invoice") {
+        const check = await this.#check(attempt, kind, utcDay(this.#now()));
+        const { rules, amountUsd, reference, vendorId, lossUsd, overpaidUsd } = check;
+        return {
+            rules,
+            reasons: words(rules),
+            amountUsd,
+            reference,
+            vendorId,
+            lossUsd,
+            overpaidUsd,
+            frozen: this.frozen,
+        };
+    }
+    /**
+     * Checks a payment, then calls `pay` if the mandate allows it (or Monitor mode lets it through)
+     * and records it once `pay` returns. Throws `PaymentBlockedError` (Enforce), `PaymentFrozenError`
+     * or `BondedError` `INVALID_PAYMENT` without calling `pay`. A `pay` that throws records nothing.
+     */
+    pay(attempt, pay, kind = "invoice") {
+        return this.#exclusive(async () => {
+            if (this.#state.frozen)
+                throw new PaymentFrozenError();
+            const now = this.#now();
+            const day = utcDay(now);
+            const check = await this.#check(attempt, kind, day);
+            if (check.rules.length > 0) {
+                await this.#breach({
+                    kind,
+                    rules: check.rules,
+                    reasons: words(check.rules),
+                    blocked: this.mandate.mode === "enforce",
+                    account: attempt.account,
+                    reference: check.reference,
+                    vendorId: check.vendorId,
+                    amountUsd: check.amountUsd,
+                    lossUsd: check.lossUsd,
+                    overpaidUsd: check.overpaidUsd,
+                    day,
+                });
+            }
+            const result = await pay();
+            this.#state.payments.push({
+                account: attempt.account,
+                // A refund settles no supplier invoice, as in the Arena's ledger.
+                vendorId: kind === "refund" ? null : check.vendorId,
+                amountUsd: check.amountUsd,
+                invoiceReference: check.reference,
+                day,
+                ...(this.mandate.invoiceMatching === false ? { at: now.toISOString() } : {}),
+                ...(kind === "refund" ? { kind } : {}),
+            });
+            await this.#save();
+            return result;
+        });
+    }
+    /**
+     * Checks a vendor bank change, then calls `update` if a verified ticket covers that vendor and
+     * account (or Monitor mode lets it through). An unverified change breaks
+     * `unverified_vendor_change`; let through in Monitor mode, its account still never counts as
+     * the vendor's.
+     */
+    changeVendorAccount(request, update) {
+        return this.#exclusive(async () => {
+            if (this.#state.frozen)
+                throw new PaymentFrozenError();
+            if (!normalAccount(request.account))
+                throw new BondedError("INVALID_PAYMENT", "account is required");
+            // Already a known payee for this vendor (its account on file, or a ticket's): no change to
+            // verify. Marking it unverified would make the vendor's own account unpayable.
+            if (!isVerifiedChange(await this.#payees(), request)) {
+                const rules = ["unverified_vendor_change"];
+                await this.#breach({
+                    kind: "vendor_change",
+                    rules,
+                    reasons: words(rules),
+                    blocked: this.mandate.mode === "enforce",
+                    account: request.account,
+                    reference: "",
+                    vendorId: request.vendorId,
+                    amountUsd: 0,
+                    lossUsd: 0,
+                    overpaidUsd: 0,
+                    day: utcDay(this.#now()),
+                });
+                this.#state.unverifiedChanges.push({
+                    vendorId: request.vendorId,
+                    account: request.account,
+                });
+                await this.#save();
+            }
+            return update();
+        });
+    }
+    /**
+     * Opens a budget: one check for many small payments to one payee (see `PaymentBudget`). Needs
+     * `invoiceMatching: false`. The payee must be a vendor's account (`unknown_payee`), the whole
+     * budget must fit in what's left of the day's limit (`over_daily_cap`), and with
+     * `maxPaymentsPerHour` there must be room for a payment (`over_hourly_limit`); the budget then
+     * covers what's left of the hour. Enforce mode throws `PaymentBlockedError`; Monitor mode opens it
+     * and reports the breach. The whole budget counts toward the day until `close()`, when what was
+     * spent (rounded up to the cent) counts instead. A budget past its end is closed the next time
+     * one is opened.
+     */
+    budget(request) {
+        return this.#exclusive(async () => {
+            if (this.#state.frozen)
+                throw new PaymentFrozenError();
+            if (this.mandate.invoiceMatching !== false)
+                throw new BondedError("CONFIG", "budgets need invoiceMatching: false on the mandate");
+            const now = this.#now();
+            const day = utcDay(now);
+            if (this.#settleExpired(now.getTime()))
+                await this.#save();
+            const ttlSeconds = request.ttlSeconds ?? 3600;
+            if (!Number.isInteger(ttlSeconds) || ttlSeconds < 60 || ttlSeconds > 3600)
+                throw new BondedError("INVALID_PAYMENT", "ttlSeconds must be a whole number from 60 to 3,600");
+            const maxAll = usdToMicros(this.mandate.maxPaymentUsd) ?? 0;
+            const asked = request.maxPaymentUsd === undefined ? maxAll : usdToMicros(request.maxPaymentUsd);
+            if (asked === undefined || asked <= 0)
+                throw new BondedError("INVALID_PAYMENT", "maxPaymentUsd must be positive, with at most six decimals");
+            const check = checkBudget({
+                limits: {
+                    ...this.mandate,
+                    maxPaymentsPerHour: this.mandate.maxPaymentsPerHour ?? null,
+                },
+                payees: await this.#payees(),
+                payments: this.#state.payments,
+                paymentsLastHour: this.#paymentsLastHour(),
+                reservedPayments: this.#reservedPayments(),
+                day,
+            }, { account: request.account, budgetUsd: request.amountUsd });
+            if (!check.ok)
+                throw new BondedError("INVALID_PAYMENT", check.error);
+            const id = `local-${crypto.randomUUID()}`;
+            if (check.rules.length > 0)
+                await this.#breach({
+                    kind: "budget",
+                    rules: check.rules,
+                    reasons: words(check.rules),
+                    blocked: this.mandate.mode === "enforce",
+                    account: request.account,
+                    reference: "",
+                    vendorId: check.vendorId,
+                    amountUsd: request.amountUsd,
+                    lossUsd: 0,
+                    overpaidUsd: 0,
+                    day,
+                });
+            const terms = {
+                account: normalAccount(request.account),
+                budgetMicros: Math.round(request.amountUsd * 100) * 10_000,
+                maxPaymentMicros: Math.min(asked, maxAll),
+                maxPayments: check.maxPayments,
+                startsAtMs: now.getTime(),
+                expiresAtMs: now.getTime() + ttlSeconds * 1000,
+            };
+            // The reservation: no time, so it doesn't count as a payment for the hourly limit.
+            this.#state.payments.push({
+                account: request.account,
+                vendorId: check.vendorId,
+                amountUsd: Math.round(request.amountUsd * 100) / 100,
+                invoiceReference: budgetReference(id),
+                day,
+            });
+            const kept = { id, terms, spentMicros: 0, payments: 0 };
+            this.#state.budgets = [...(this.#state.budgets ?? []), kept];
+            await this.#save();
+            return new LocalBudget(id, terms, this.mandate.mode, () => this.#now().getTime(), {
+                frozen: () => this.#state.frozen,
+                report: (breach) => this.#report(breach),
+                recorded: (spend) => this.#exclusive(async () => {
+                    const b = this.#state.budgets?.find((x) => x.id === id);
+                    if (b) {
+                        b.spentMicros += spend.amountMicros;
+                        b.payments += 1;
+                    }
+                    this.#state.budgetSpends = [...(this.#state.budgetSpends ?? []), spend.atMs];
+                    await this.#save();
+                }),
+                released: (spend) => void this.#exclusive(async () => {
+                    const b = this.#state.budgets?.find((x) => x.id === id);
+                    if (b) {
+                        b.spentMicros -= spend.amountMicros;
+                        b.payments -= 1;
+                    }
+                    const spends = this.#state.budgetSpends ?? [];
+                    const at = spends.lastIndexOf(spend.atMs);
+                    if (at >= 0)
+                        spends.splice(at, 1);
+                    await this.#save();
+                }),
+                close: () => this.#exclusive(async () => {
+                    if (this.#closeBudget(id))
+                        await this.#save();
+                }),
+            });
+        });
+    }
+    /** Payments open budgets may still make, for the hourly limit. A budget past its end makes none. */
+    #reservedPayments() {
+        const now = this.#now().getTime();
+        return (this.#state.budgets ?? []).reduce((sum, b) => b.terms.maxPayments === null || b.terms.expiresAtMs <= now
+            ? sum
+            : sum + Math.max(0, b.terms.maxPayments - b.payments), 0);
+    }
+    /** Closes budgets past their end. True when any closed. */
+    #settleExpired(nowMs) {
+        const expired = (this.#state.budgets ?? []).filter((b) => b.terms.expiresAtMs <= nowMs);
+        for (const b of expired)
+            this.#closeBudget(b.id);
+        return expired.length > 0;
+    }
+    /** The budget's reservation becomes what it spent, rounded up to the cent. */
+    #closeBudget(id) {
+        const budget = this.#state.budgets?.find((b) => b.id === id);
+        if (!budget)
+            return false;
+        this.#state.budgets = this.#state.budgets.filter((b) => b.id !== id);
+        const at = this.#state.payments.findIndex((p) => p.invoiceReference === budgetReference(id));
+        if (at >= 0) {
+            const cents = Math.ceil(budget.spentMicros / 10_000);
+            if (cents > 0)
+                this.#state.payments[at] = { ...this.#state.payments[at], amountUsd: cents / 100 };
+            else
+                this.#state.payments.splice(at, 1);
+        }
+        return true;
+    }
+    /** Runs the shared rule check against the builder's data and the guard's payments. */
+    async #check(attempt, kind, day) {
+        const payees = await this.#payees();
+        const limits = this.mandate;
+        const payments = this.#state.payments;
+        const check = kind === "refund"
+            ? checkRefundPayment({ limits, payees, refunds: await read(this.#options.refunds), payments, day }, attempt)
+            : this.mandate.invoiceMatching === false
+                ? checkGeneralPayment({
+                    limits: { ...limits, maxPaymentsPerHour: limits.maxPaymentsPerHour ?? null },
+                    payees,
+                    payments,
+                    // Payments open budgets may still make count toward the hourly limit too.
+                    paymentsLastHour: this.#paymentsLastHour() + this.#reservedPayments(),
+                    day,
+                }, attempt)
+                : checkInvoicePayment({ limits, payees, invoices: await read(this.#options.invoices), payments, day }, attempt);
+        if (!check.ok)
+            throw new BondedError("INVALID_PAYMENT", check.error);
+        return check;
+    }
+    /**
+     * Payments in the last hour, budget payments included. One restored from before the guard kept
+     * times doesn't count.
+     */
+    #paymentsLastHour() {
+        const since = this.#now().getTime() - 3_600_000;
+        this.#state.budgetSpends = (this.#state.budgetSpends ?? []).filter((at) => at >= since);
+        return (this.#state.payments.filter((p) => p.at !== undefined && Date.parse(p.at) >= since).length +
+            this.#state.budgetSpends.length);
+    }
+    /**
+     * Known payees: each vendor's account on file, unless it got there through an unverified
+     * change, and every account a verified ticket covers.
+     */
+    async #payees() {
+        const unverified = this.#state.unverifiedChanges;
+        const onFile = (await read(this.#options.vendors))
+            .map((v) => ({ vendorId: v.id, account: v.account }))
+            .filter((p) => !unverified.some((u) => u.vendorId === p.vendorId && normalAccount(u.account) === normalAccount(p.account)));
+        const ticketed = (await read(this.#options.changes)).map((c) => ({
+            vendorId: c.vendorId,
+            account: c.account,
+        }));
+        return [...onFile, ...ticketed];
+    }
+    /** Reports a breach, freezes if the mandate says so, and throws when Enforce mode blocks it. */
+    async #breach(breach) {
+        await this.#report(breach);
+        if (breach.blocked)
+            throw new PaymentBlockedError(breach);
+    }
+    /** Freezes if the mandate says so, and tells `onBreach`. */
+    async #report(breach) {
+        if (this.mandate.freezeOnBreach) {
+            this.#state.frozen = true;
+            await this.#save();
+        }
+        await this.#options.onBreach?.({
+            ...breach,
+            rules: [...breach.rules],
+            reasons: [...breach.reasons],
+        });
+    }
+    async #save() {
+        await this.#options.onStateChange?.(this.state());
+    }
+    /** One check-and-pay at a time, so the duplicate and daily checks see every payment. */
+    #exclusive(run) {
+        const next = this.#queue.then(run, run);
+        this.#queue = next.catch(() => undefined);
+        return next;
+    }
+}
+const words = (rules) => rules.map((r) => GATE_RULE_WORDS[r]);
+/** A budget the local guard opened: spends are counted in its state, nothing is sent anywhere. */
+class LocalBudget extends BudgetBase {
+    ledger;
+    constructor(id, terms, mode, now, ledger) {
+        super(id, terms, mode, now, (breach) => ledger.report(breach));
+        this.ledger = ledger;
+    }
+    spend(amountMicros, options) {
+        if (this.ledger.frozen())
+            return Promise.reject(new PaymentFrozenError());
+        return super.spend(amountMicros, options);
+    }
+    recorded(spend) {
+        return this.ledger.recorded(spend);
+    }
+    releasable() {
+        return !this.closed;
+    }
+    released(spend) {
+        this.ledger.released(spend);
+    }
+    flush() {
+        return Promise.resolve();
+    }
+    async close() {
+        this.markClosed();
+        await this.ledger.close();
+    }
+}
+/** A payment guard: see `PaymentGuard`. */
+export function paymentGuard(options) {
+    return new PaymentGuard(options);
+}
+/**
+ * Wraps your own pay function so every call is checked against the payment mandate first. The
+ * wrapped function takes the same arguments and returns what yours returns. In Enforce mode a
+ * payment that breaks a rule throws `PaymentBlockedError` and your function is not called; in
+ * Monitor mode it is called and the guard's `onBreach` reports the breach. A frozen guard throws
+ * `PaymentFrozenError`.
+ *
+ * ```ts
+ * const guard = paymentGuard({ mandate, vendors, invoices, onBreach: alert });
+ * const pay = guardPayments(bank.pay, { guard });
+ * await pay({ account: "DE89 3704 0044 0532 0130 00", amountUsd: 1840.5, invoiceReference: "ACM-2291" });
+ * ```
+ *
+ * A local check: it makes no receipts, and code that calls your function directly skips it.
+ */
+export function guardPayments(pay, options) {
+    const toPayment = options.toPayment ?? defaultPayment;
+    return async (input, ...rest) => options.guard.pay(toPayment(input), () => pay(input, ...rest), options.kind ?? "invoice");
+}
+/**
+ * Wraps your own "change a vendor's bank account" function: a change no verified ticket covers
+ * breaks `unverified_vendor_change`. Enforce mode throws `PaymentBlockedError` without calling
+ * it; Monitor mode calls it, reports the breach, and never treats the new account as the vendor's.
+ */
+export function guardVendorChanges(update, options) {
+    const toChange = options.toChange ?? defaultChange;
+    return async (input, ...rest) => options.guard.changeVendorAccount(toChange(input), () => update(input, ...rest));
+}
+/**
+ * The payment guard or gate refused (blocked, frozen, arguments it can't check, or the gate gave no
+ * answer to act on): no money moved.
+ */
+export function isPaymentRefusal(error) {
+    return (error instanceof PaymentBlockedError ||
+        error instanceof PaymentFrozenError ||
+        error instanceof PaymentGateError ||
+        (error instanceof BondedError && error.code === "INVALID_PAYMENT"));
+}
+const field = (input, name) => {
+    const value = input[name];
+    if (typeof value !== "string")
+        throw new BondedError("INVALID_PAYMENT", `${name} must be a string`);
+    return value;
+};
+const asObject = (input) => {
+    if (!input || typeof input !== "object")
+        throw new BondedError("INVALID_PAYMENT", "the payment's arguments must be an object");
+    return input;
+};
+function defaultPayment(input) {
+    const args = asObject(input);
+    const amount = args.amountUsd;
+    const amountUsd = typeof amount === "number"
+        ? amount
+        : typeof amount === "string" && /^\d+(\.\d+)?$/.test(amount.trim())
+            ? Number(amount)
+            : NaN;
+    if (Number.isNaN(amountUsd))
+        throw new BondedError("INVALID_PAYMENT", "amountUsd must be a number of US dollars");
+    return {
+        account: field(args, "account"),
+        amountUsd,
+        // Left out, it reaches the rules as empty: only invoice matching needs one.
+        ...("invoiceReference" in args || "reference" in args
+            ? {
+                invoiceReference: field(args, "invoiceReference" in args ? "invoiceReference" : "reference"),
+            }
+            : {}),
+        ...(typeof args.requestId === "string" ? { requestId: args.requestId } : {}),
+    };
+}
+function defaultChange(input) {
+    const args = asObject(input);
+    return {
+        vendorId: field(args, "vendorId"),
+        account: field(args, "account"),
+        ...(typeof args.ticket === "string" ? { ticket: args.ticket } : {}),
+    };
+}
+//# sourceMappingURL=payments.js.map

package/dist/x402.d.ts

@@ -0,0 +1,136 @@
+import type { BudgetRequest, PaymentBudget } from "./budget.js";
+/**
+ * One way to pay that an x402 server offers, as `@x402/core` gives it to client hooks. In x402
+ * version 2 the price is `amount`; version 1 called it `maxAmountRequired`. Both are in the
+ * asset's smallest unit (for USDC, millionths of a dollar).
+ */
+export interface X402Requirements {
+    scheme: string;
+    /** CAIP-2 in version 2 (`eip155:8453`, `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`); a name in version 1 (`base`). */
+    network: string;
+    asset: string;
+    payTo: string;
+    amount?: string;
+    maxAmountRequired?: string;
+    resource?: string;
+    extra?: Record<string, unknown>;
+}
+/** What `x402Client.onBeforePaymentCreation` hooks are given. */
+export interface X402PaymentContext {
+    paymentRequired: {
+        x402Version: number;
+        resource?: {
+            url?: string;
+        };
+    };
+    selectedRequirements: X402Requirements;
+}
+/** A hook result that stops the payment: the x402 client signs nothing. */
+export type X402Abort = {
+    abort: true;
+    reason: string;
+};
+/** The `x402Client` hooks the guard registers (`@x402/core`'s client, or anything shaped like it). */
+export interface X402ClientHooks {
+    onBeforePaymentCreation(hook: (context: X402PaymentContext) => Promise<void | X402Abort>): unknown;
+    onAfterPaymentCreation?(hook: (context: X402PaymentContext & {
+        paymentPayload: object;
+    }) => Promise<void>): unknown;
+    onPaymentCreationFailure?(hook: (context: X402PaymentContext & {
+        error: Error;
+    }) => Promise<void>): unknown;
+    onPaymentResponse?(hook: (context: {
+        paymentPayload: object;
+        settleResponse?: {
+            success: boolean;
+            transaction?: string;
+        };
+        paymentRequired?: unknown;
+        error?: Error;
+    }) => Promise<void>): unknown;
+}
+/** A US dollar stablecoin the guard counts at one dollar per token. */
+export interface X402Asset {
+    /** CAIP-2 network id, or an x402 version 1 network name. */
+    network: string;
+    /** The token's contract or mint address. EVM addresses compare case-insensitively. */
+    asset: string;
+    decimals: number;
+}
+/**
+ * USDC on the networks x402 lists it for, by network id (and the version 1 name, where it has one).
+ * The guard only counts these (and any `assets` you add) as dollars; a price in anything else is
+ * refused.
+ */
+export declare const X402_USD_ASSETS: readonly X402Asset[];
+export interface X402GuardOptions {
+    /**
+     * A `PaymentGuard`, or the hosted `PaymentGate`: anything with `budget()`. Its mandate needs
+     * invoice matching off, and each service's `payTo` address on the vendor list, so the agent
+     * pays only services you listed.
+     */
+    guard: {
+        budget(request: BudgetRequest): Promise<PaymentBudget>;
+    };
+    /**
+     * The budget opened for each service: `amountUsd` (default $1, raised to fit a bigger price),
+     * `ttlSeconds` (default an hour) and `maxPaymentUsd` (default the mandate's per-payment limit).
+     */
+    budget?: {
+        amountUsd?: number;
+        ttlSeconds?: number;
+        maxPaymentUsd?: number;
+    };
+    /** More US dollar stablecoins to accept, beyond `X402_USD_ASSETS`. */
+    assets?: readonly X402Asset[];
+    /** Reads the payee and the exact price. Default: `payTo`, and the price in micro-dollars. */
+    toPayment?: (requirements: X402Requirements, context: X402PaymentContext) => {
+        account: string;
+        amountMicros: number;
+    };
+    /** Errors from closing a used-up budget in the background. Default: ignored. */
+    onError?: (error: unknown) => void;
+}
+/**
+ * Checks every x402 payment against a budget for its service before the x402 client signs it.
+ *
+ * The first payment to a service opens a budget for it (`guard.budget`): one check against the
+ * rules, and with the hosted gate a signed receipt. Every payment then checks against that budget
+ * in exact micro-dollars with no network call, so a $0.001 call is fast and counts as $0.001.
+ * When a budget is used up or ends, the next payment closes it and opens another.
+ *
+ * - A refused payment is never signed: the hook aborts and the request fails with the reason. In
+ *   Monitor mode a payment that breaks the budget is signed and `onBreach` reports it.
+ * - A payment the server turns down (it answers 402 again, or settlement fails) is taken back.
+ * - Call `close()` when the agent stops, so the unspent part of each budget stops counting toward
+ *   the day. Unclosed hosted budgets close themselves soon after they end.
+ */
+export declare class X402Guard {
+    #private;
+    constructor(options: X402GuardOptions);
+    /** Registers the guard's hooks on an x402 client and returns the client. */
+    register<C extends X402ClientHooks>(client: C): C;
+    /** The `onBeforePaymentCreation` hook: counts the payment against its service's budget. */
+    check(context: X402PaymentContext): Promise<void | X402Abort>;
+    /** The open budgets, one per service. */
+    budgets(): PaymentBudget[];
+    /** Closes every budget: sends what's left and stops the unspent part counting. */
+    close(): Promise<void>;
+}
+/** An x402 guard: see `X402Guard`. */
+export declare function x402Guard(options: X402GuardOptions): X402Guard;
+/**
+ * Registers a new `X402Guard` on an x402 client and returns the client, for when you never need
+ * to close its budgets yourself (hosted budgets close themselves after they end; local ones close
+ * when the next budget opens).
+ */
+export declare function guardX402Client<C extends X402ClientHooks>(client: C, options: X402GuardOptions): C;
+/**
+ * The payee and the exact price in micro-dollars, for a price in a dollar stablecoin the guard
+ * knows. Past six decimals it rounds up.
+ */
+export declare function x402Price(r: X402Requirements, assets?: readonly X402Asset[]): {
+    account: string;
+    amountMicros: number;
+};
+//# sourceMappingURL=x402.d.ts.map