@defdone/annon 0.0.0-stage → 0.1.0-alpha.1

package/dist/pay/pay.js

@@ -0,0 +1,297 @@
+import { usdc } from '../settle-near/codec.js';
+/**
+ * Paying for an Annon file on Base: the checks before the buyer's wallet is asked anything, then
+ * the EIP-3009 signature, checked and dry-run against USDC before it leaves the client.
+ *
+ * Every value the buyer signs comes from the Annon contract, never from the payment request: the
+ * request is only compared against it. The host can make the purchase fail, not misdirect it.
+ */
+import { sha256 } from '@noble/hashes/sha2.js';
+import { sameResource } from '../download/proof.js';
+import { inspect, inspectHeader, Pay2Error } from '../envelope/pay2.js';
+import { keyFromSecret } from '../keys/near-ckd.js';
+import { getConfig, getFile } from '../near/rpc.js';
+import { baseNonceV2, buildPurchaseMessage, purchaseId, } from '../settle-near/purchase.js';
+import { balanceOf, block, dryRun, fail, hasCode, head, PayError, paymentStatus, } from './base.js';
+import { digest, signer as recover, toHex, typedData, } from './eip3009.js';
+import { bounds, purchaseKey, randomHex, } from './purchase.js';
+import { ANNON_EXACT, BASE_NETWORK, PAYMENT_IDENTIFIER, paymentSignature, } from './x402.js';
+/** Bound the lifetime of an outstanding payment authorization. */
+export const MAX_VALIDITY_SECONDS = 180;
+/** How far the Base RPC's clock may be from ours. */
+export const MAX_CLOCK_SKEW_SECONDS = 60;
+const lower = (v) => (typeof v === 'string' ? v.toLowerCase() : undefined);
+const isAddress = (v) => typeof v === 'string' && /^0x[0-9a-fA-F]{40}$/.test(v);
+/**
+ * Profile section 7: the header (or, for a public body, the whole file) is the registered file,
+ * signed by its seller, with a key stanza for this contract. Before any signature.
+ */
+async function checkPay2(pay2, wholeFile, contractId, fileId, file) {
+    const listing = {
+        fileId,
+        cipherHash: file.cipherHash,
+        seller: file.seller,
+        ...(file.headerHash ? { publishedHeaderHash: file.headerHash } : {}),
+    };
+    let r;
+    try {
+        r = await (wholeFile ? inspect : inspectHeader)(pay2, listing, contractId);
+    }
+    catch (e) {
+        if (e instanceof Pay2Error)
+            return fail('file_invalid', `the PAY2 file failed its check: ${e.code}`);
+        throw e;
+    }
+    if (!r.usable)
+        fail('file_invalid', 'the PAY2 header has no key for this contract');
+    return r;
+}
+/** The registration, if the file can still be bought. */
+async function forSale(nearRpc, contractId, fileId) {
+    const file = await getFile(nearRpc, contractId, fileId);
+    if (!file)
+        return fail('unknown_file', 'the file is not registered on the Annon contract');
+    if (file.takenDown)
+        fail('taken_down', `the file was taken down (${file.takenDown})`);
+    if (file.salesStoppedAt !== null)
+        fail('sales_stopped', 'the seller stopped selling this file');
+    return file;
+}
+/** Every check that can refuse a purchase before the wallet is asked to sign. */
+export async function preflight(o) {
+    if (!/^0x[0-9a-f]{64}$/.test(o.fileId))
+        throw new TypeError('fileId must be 0x and 32 bytes of lowercase hex');
+    if (!isAddress(o.buyer))
+        throw new TypeError('buyer must be a 0x EVM address');
+    const buyer = o.buyer.toLowerCase();
+    // The payment request: only its own shape here; its values are compared with the contract below.
+    const pr = o.paymentRequired;
+    const named = pr?.resource?.url;
+    if (typeof named !== 'string' || !sameResource(named, o.url)) {
+        fail('bad_requirements', 'resource.url is not the URL that answered with this 402');
+    }
+    const offers = (Array.isArray(pr?.accepts) ? pr.accepts : []).filter((a) => a?.scheme === ANNON_EXACT && a?.network === BASE_NETWORK);
+    const [req] = offers;
+    if (offers.length !== 1 || !req)
+        return fail('network_mismatch', 'no single Annon offer on Base');
+    const extra = (req.extra ?? {});
+    // The extension is optional; when present it must name the file being bought.
+    const info = pr.extensions?.annon?.info;
+    if (info && (info.contract !== o.contractId || lower(info.fileId) !== o.fileId)) {
+        fail('file_mismatch', 'the payment request is for another Annon contract or file');
+    }
+    const timeout = req.maxTimeoutSeconds;
+    if (!Number.isSafeInteger(timeout) || timeout < 1) {
+        fail('bad_requirements', 'maxTimeoutSeconds must be a positive integer');
+    }
+    if (typeof req.amount !== 'string' || !/^\d{1,78}$/.test(req.amount)) {
+        fail('bad_requirements', 'amount must be a decimal string');
+    }
+    // The registration.
+    const file = await forSale(o.nearRpc, o.contractId, o.fileId);
+    if (file.moderator !== null && !(o.moderators ?? []).includes(file.moderator)) {
+        fail('unknown_moderator', `the file's moderator ${file.moderator} is not one you trust`);
+    }
+    const config = await getConfig(o.nearRpc, o.contractId);
+    if (file.terms.network !== config.network ||
+        file.terms.near.token !== config.nearUsdc ||
+        (file.terms.base && file.terms.base.usdc !== config.usdc))
+        fail('network_mismatch');
+    if (!(o.pay2 instanceof Uint8Array))
+        throw new TypeError('pay2 must be the PAY2 header bytes');
+    const checked = await checkPay2(o.pay2, info?.public === true, o.contractId, o.fileId, file);
+    if (!file.terms.base)
+        fail('method_mismatch', 'the file has no Base route');
+    const to = file.payTo;
+    // Facilitators take the EIP-712 domain from the offer, so it must be there and be USDC's.
+    if (lower(req.asset) !== config.usdc || extra.name !== 'USD Coin' || extra.version !== '2') {
+        fail('token_mismatch', 'the payment request is not for USDC on Base');
+    }
+    const method = extra.assetTransferMethod;
+    if (method !== undefined && method !== 'eip3009') {
+        fail('method_mismatch', `the offer is not a plain Annon transfer`);
+    }
+    // Extension v3 settles before serving and accepts only the commitment nonce.
+    const flow = extra.paymentFlow;
+    if (info?.version !== 3 || req.extra?.nonceVersion !== 2 || flow !== 'upfront') {
+        fail('method_mismatch', `unsupported payment flow ${String(extra.paymentFlow)}`);
+    }
+    // A split in the payment itself would take part of it away from the registered pay_to.
+    if (extra.splits !== undefined && !(Array.isArray(extra.splits) && extra.splits.length === 0)) {
+        fail('method_mismatch', 'the offer splits the payment; Annon pays the registered pay_to only');
+    }
+    if (lower(req.payTo) !== to) {
+        fail('recipient_mismatch', 'the payment request pays an address the registration does not');
+    }
+    if (BigInt(req.amount) !== file.price) {
+        fail('price_mismatch', 'the payment request asks a different price than the registration');
+    }
+    if (file.price > o.maxPrice)
+        fail('price_above_max', 'the price is above your limit');
+    // The buyer's wallet on Base.
+    const h = await head(o.baseRpc);
+    if (await hasCode(o.baseRpc, buyer, h.number)) {
+        fail('smart_wallet_unsupported', 'the wallet is a contract or delegated (EIP-7702); pay from a plain account');
+    }
+    if ((await balanceOf(o.baseRpc, config.usdc, buyer, h.number)) < file.price) {
+        fail('insufficient_balance', 'not enough USDC on Base');
+    }
+    return {
+        nearRpc: o.nearRpc,
+        baseRpc: o.baseRpc,
+        contractId: o.contractId,
+        fileId: o.fileId,
+        buyer,
+        seller: file.seller,
+        to,
+        usdc: config.usdc,
+        price: file.price,
+        validity: Math.min(timeout, MAX_VALIDITY_SECONDS),
+        file,
+        paymentRequired: pr,
+        offer: req,
+        header: checked.header,
+    };
+}
+/** The authorization an attempt signs. */
+const authorizationOf = (r, attempt = r.attempts[0]) => ({
+    from: r.terms.buyer,
+    to: r.terms.to,
+    value: BigInt(r.terms.price),
+    validAfter: 0n,
+    validBefore: BigInt(attempt.validBefore),
+    nonce: r.terms.nonce,
+});
+/**
+ * Asks the wallet to sign and returns the `PAYMENT-SIGNATURE` header. The purchase is recorded
+ * first (refused if this purchase_id already has a record); the signature is checked
+ * to be the buyer's, in the form USDC takes; the payload is recorded, and only then run against
+ * USDC and returned.
+ */
+export async function authorize(q, o) {
+    if (lower(o.wallet.address) !== q.buyer)
+        throw new TypeError('the wallet is not the buyer the quote was made for');
+    const p = o.purchase;
+    const id = purchaseId(p, { baseUsdc: q.usdc });
+    const message = buildPurchaseMessage(p, { baseUsdc: q.usdc });
+    if (p.route !== 'base-usdc' ||
+        p.contract !== q.contractId ||
+        p.file_id !== q.fileId ||
+        p.terms_hash !== q.file.termsHash ||
+        p.price !== q.price.toString() ||
+        p.asset !== q.usdc ||
+        toHex(keyFromSecret(o.buyerSecret).publicKeyBytes) !== p.buyer_key ||
+        BigInt(p.expires_at) <= BigInt(Math.floor(Date.now() / 1000)))
+        throw new TypeError('purchase does not match the checked quote/key');
+    // Both clocks are read, and checked against each other, before the registration: however long the
+    // reads below stall, and even if a clock is corrected meanwhile, the deadline stays within 180 s
+    // of a moment the file was still on sale (a stop must be checked again before settlement).
+    const h = await head(q.baseRpc);
+    const local = Math.floor(Date.now() / 1000);
+    if (Math.abs(h.timestamp - local) > MAX_CLOCK_SKEW_SECONDS) {
+        fail('transport', 'the Base RPC is not at the current time; its deadline would be wrong');
+    }
+    // The quote may be old: the file must still be for sale on the same terms.
+    const now = await forSale(q.nearRpc, q.contractId, q.fileId);
+    if (now.termsHash !== q.file.termsHash ||
+        now.price !== q.price ||
+        now.payTo !== q.file.payTo ||
+        now.moderator !== q.file.moderator ||
+        now.cipherHash !== q.file.cipherHash) {
+        fail('price_mismatch', 'the registration changed since the quote; check it again');
+    }
+    // Never sign without a checked header, even for a quote not made by `preflight`.
+    await checkPay2(q.header, false, q.contractId, q.fileId, now);
+    // The search for the payment starts at the finalized block: a reorg or a lying RPC can't put the
+    // payment below it.
+    const final = await block(q.baseRpc, 'finalized');
+    const start = Math.min(h.timestamp, local);
+    const created = {
+        schemaVersion: 2,
+        recoveryProved: false,
+        payment: {
+            route: 'base',
+            amountUsdc: usdc(q.price),
+            amountBaseUnits: q.price.toString(),
+            asset: { symbol: 'USDC', id: q.usdc },
+            network: BASE_NETWORK,
+        },
+        id,
+        purchase: p,
+        message,
+        buyerSecret: toHex(o.buyerSecret),
+        quote: null,
+        recovery: p.recovery,
+        checkedHeaderHash: toHex(sha256(q.header)),
+        revision: 0,
+        terms: {
+            network: BASE_NETWORK,
+            contractId: q.contractId,
+            fileId: q.fileId,
+            buyer: q.buyer,
+            seller: q.seller,
+            to: q.to,
+            usdc: q.usdc,
+            price: q.price.toString(),
+            buyerKey: p.buyer_key,
+            nonce: baseNonceV2(id),
+            headerHash: toHex(sha256(q.header)),
+            cipherHash: q.file.cipherHash,
+            moderator: q.file.moderator,
+        },
+        attempts: [
+            {
+                attemptId: randomHex(16),
+                ...(q.paymentRequired.extensions?.[PAYMENT_IDENTIFIER]
+                    ? { paymentId: `pay_${randomHex(16)}` }
+                    : {}),
+                preparedAt: start,
+                searchFromBlock: Math.min(final.number, h.number),
+                // The earliest reading: no clock and no stall can stretch the window.
+                validBefore: Math.min(start + q.validity, Number(p.expires_at)).toString(),
+                paymentRequired: q.paymentRequired,
+            },
+        ],
+    };
+    const key = purchaseKey(id);
+    if (!(await o.store.compareAndSet(key, null, created))) {
+        fail('purchase_open', 'this wallet has an open purchase of this file: follow its nextStep');
+    }
+    const attempt = created.attempts[0];
+    const a = authorizationOf(created);
+    const signature = await o.wallet.signTypedData(typedData(q.usdc, a));
+    if (typeof signature !== 'string' || recover(digest(q.usdc, a), signature) !== q.buyer) {
+        fail('bad_signature', 'the wallet did not return a plain signature from the buyer');
+    }
+    const header = paymentSignature(q.paymentRequired, q.offer, a, signature, p, attempt.paymentId);
+    // Recorded before any RPC sees it: a crash from here on can only resend this payload.
+    const purchase = {
+        ...created,
+        revision: 1,
+        attempts: [{ ...attempt, payload: header }],
+    };
+    if (!(await o.store.compareAndSet(key, created, purchase))) {
+        const e = new PayError('store_conflict', 'the purchase changed while the wallet signed');
+        e.purchase = created;
+        throw e;
+    }
+    try {
+        await dryRun(q.baseRpc, q.usdc, a, signature);
+    }
+    catch (e) {
+        // The RPC has seen a valid authorization: it can still land, so the purchase stays open.
+        if (e instanceof PayError)
+            e.purchase = purchase;
+        throw e;
+    }
+    return { header, purchase };
+}
+/** Where a recorded purchase stands on Base, over all its attempts. */
+export const status = (baseRpc, r) => paymentStatus(baseRpc, {
+    usdc: r.terms.usdc,
+    to: r.terms.to,
+    from: r.terms.buyer,
+    nonce: r.terms.nonce,
+    price: BigInt(r.terms.price),
+    ...bounds(r),
+});

package/dist/pay/purchase.d.ts

@@ -0,0 +1,103 @@
+import type { OneClickQuote } from '../oneclick/oneclick.js';
+import type { BuyRoute } from '../routes.js';
+import type { Identity } from '../settle-near/identity.js';
+import type { Purchase } from '../settle-near/purchase.js';
+/**
+ * A purchase on the buyer's side (x402-annon.md section 5): what is recorded before the wallet signs,
+ * and the signed payload recorded before anything else sees it. Records are addressed by purchase commitment; the original grant secret remains available after acceptance.
+ */
+import type { Versioned } from './store.js';
+import type { PaymentRequired } from './x402.js';
+/** What the purchase pays for; fixed when it is created. */
+interface PurchaseTerms {
+    network: string;
+    contractId: string;
+    fileId: string;
+    buyer: string;
+    seller: Identity;
+    /** The registered `pay_to`. */
+    to: string;
+    usdc: string;
+    price: string;
+    /** The one-time key the nonce commits to, 0x and 48 bytes. */
+    buyerKey: string;
+    /** base_nonce for the purchase commitment. */
+    nonce: string;
+    /** `SHA256` of the PAY2 header checked before signing (x402-annon.md section 7), 0x and lowercase. */
+    headerHash: string;
+    cipherHash: string;
+    moderator: string | null;
+}
+/** A saved Base payment authorization attempt. */
+export interface PaymentAttempt {
+    attemptId: string;
+    /** The `payment-identifier` id of its payload, when the server advertised the extension. */
+    paymentId?: string;
+    /** Unix seconds, before the wallet was asked. */
+    preparedAt: number;
+    /** The Base block its payment is searched from: finalized when it was prepared. */
+    searchFromBlock: number;
+    validBefore: string;
+    /** The 402 it answers. */
+    paymentRequired: PaymentRequired;
+    /**
+     * The `PAYMENT-SIGNATURE` header: a signed authorization anyone can submit until `validBefore`.
+     * Missing when the client stopped between the wallet and this record: then it may be signed.
+     */
+    payload?: string;
+}
+export interface SourceAsset {
+    chain: string;
+    asset: string;
+    symbol?: string;
+    decimals?: number;
+    contractAddress?: string;
+}
+export interface SourcePayment extends SourceAsset {
+    amount: string;
+    amountFormatted?: string;
+    depositBefore: string;
+}
+/** Public payment facts, without authorization payloads or deposit destinations. */
+export interface PaymentSummary {
+    amountUsdc: string;
+    amountBaseUnits: string;
+    asset: {
+        symbol: 'USDC';
+        id: string;
+    };
+    network: string;
+    route: BuyRoute;
+    source?: SourcePayment;
+}
+export interface PurchaseRecord extends Versioned {
+    schemaVersion: 2;
+    /** Durable ownership proof checkpoint. */
+    recoveryProved: boolean;
+    /** Source details are the reviewed 1Click quote. */
+    payment: PaymentSummary;
+    nearSubmission?: {
+        state: 'uncertain';
+        txHash: string;
+    };
+    paymentState?: 'expired' | 'canceled';
+    purchase: Purchase;
+    message: string;
+    buyerSecret: string;
+    quote: OneClickQuote | null;
+    recovery: Identity;
+    checkedHeaderHash: string;
+    terms: PurchaseTerms;
+    attempts: PaymentAttempt[];
+}
+/** Records are addressed by the commitment, independent of the paying wallet. */
+export declare const purchaseKey: (purchaseId: string) => string;
+/** What a search over every attempt covers: the earliest start, the latest deadline. */
+export declare function bounds(r: PurchaseRecord): {
+    block: number;
+    validBefore: bigint;
+};
+/** The recorded payload that can still settle by `now`, latest first; null if none can. */
+export declare function resendable(r: PurchaseRecord, now: number): string | null;
+export declare const randomHex: (bytes: number) => string;
+export {};

package/dist/pay/purchase.js

@@ -0,0 +1,20 @@
+/** Records are addressed by the commitment, independent of the paying wallet. */
+export const purchaseKey = (purchaseId) => `annon/purchase/${purchaseId}`;
+/** What a search over every attempt covers: the earliest start, the latest deadline. */
+export function bounds(r) {
+    if (!r.attempts.length)
+        throw new TypeError('a purchase record has at least one attempt');
+    return {
+        block: Math.min(...r.attempts.map((a) => a.searchFromBlock)),
+        validBefore: r.attempts.reduce((m, a) => (BigInt(a.validBefore) > m ? BigInt(a.validBefore) : m), 0n),
+    };
+}
+/** The recorded payload that can still settle by `now`, latest first; null if none can. */
+export function resendable(r, now) {
+    for (const a of [...r.attempts].reverse()) {
+        if (a.payload && BigInt(a.validBefore) > BigInt(now))
+            return a.payload;
+    }
+    return null;
+}
+export const randomHex = (bytes) => Array.from(crypto.getRandomValues(new Uint8Array(bytes)), (b) => b.toString(16).padStart(2, '0')).join('');

package/dist/pay/recover.d.ts

@@ -0,0 +1,31 @@
+import { type EvmLog } from './base.js';
+import { type PurchaseRecord } from './purchase.js';
+import type { Store } from './store.js';
+type NextStep = {
+    step: 'claim_key';
+    args: {
+        purchase_id: string;
+        grant: number;
+    };
+} | {
+    step: 'unlock';
+    args: {
+        purchase: string;
+        logs: EvmLog[];
+        header: string | null;
+    };
+} | {
+    step: 'resend';
+    header: string;
+} | {
+    step: 'wait';
+} | {
+    step: 'buy';
+};
+interface NextStepOptions {
+    nearRpc: string;
+    baseRpc: string;
+    store: Store<PurchaseRecord>;
+}
+export declare function nextStep(r: PurchaseRecord, o: NextStepOptions): Promise<NextStep>;
+export {};

package/dist/pay/recover.js

@@ -0,0 +1,34 @@
+/** Resume by purchase commitment; wallet addresses never establish entitlement. */
+import { getPurchase } from '../near/rpc.js';
+import { blockHeader, PayError } from './base.js';
+import { status } from './pay.js';
+import { purchaseKey, resendable } from './purchase.js';
+export async function nextStep(r, o) {
+    if (await getPurchase(o.nearRpc, r.purchase.contract, r.id))
+        return { step: 'claim_key', args: { purchase_id: r.id, grant: 0 } };
+    if (r.purchase.route === 'near-usdc')
+        return { step: 'wait' };
+    const s = await status(o.baseRpc, r);
+    if (s.state === 'pending') {
+        const header = resendable(r, Math.floor(Date.now() / 1000));
+        return header ? { step: 'resend', header } : { step: 'wait' };
+    }
+    if (s.state !== 'paid') {
+        if (r.paymentState !== s.state &&
+            !(await o.store.compareAndSet(purchaseKey(r.id), r, {
+                ...r,
+                revision: r.revision + 1,
+                paymentState: s.state,
+            })))
+            throw new PayError('store_conflict');
+        return { step: 'buy' };
+    }
+    return {
+        step: 'unlock',
+        args: {
+            purchase: r.message,
+            logs: s.logs,
+            header: await blockHeader(o.baseRpc, `0x${s.logs[0].block_hash}`),
+        },
+    };
+}

package/dist/pay/seller.d.ts

@@ -0,0 +1,130 @@
+/**
+ * The seller's side of `specs/x402-annon.md`: the 402 for an Annon file, built from its
+ * registration, and the check a server runs on `PAYMENT-SIGNATURE` before it settles. Settlement
+ * itself stays with the server's facilitator: any standard x402 one, through `forFacilitator`.
+ */
+import { type FileInfo } from '../near/rpc.js';
+import { type Purchase } from '../settle-near/purchase.js';
+import { type Offer, type PaymentRequired } from './x402.js';
+export interface OfferOptions {
+    nearRpc: string;
+    contractId: string;
+    fileId: string;
+    /**
+     * The PAY2 file (x402 `resource.url`): the paid request returns it, and buyers prove a purchase
+     * grant there to get it again (specs/download.md). https only.
+     */
+    url: string;
+    /** URL of the complete PAY2 header, public (x402-annon.md section 7): the client checks it first. */
+    header: string;
+    /** The seller publishes the body too: the client then checks the whole file before signing. */
+    public?: boolean;
+    /** At most this long for the buyer's authorization; the Annon client signs for at most 180. */
+    maxTimeoutSeconds?: number;
+    paymentMinValiditySeconds?: number;
+    /** The seller app's x402 builder code (`^[a-z0-9_]{1,32}$`), declared as `builder-code`. */
+    appCode?: string;
+    /** Describes the file for x402 discovery (`bazaar`, x402-annon.md section 11). */
+    discovery?: {
+        description?: string;
+        mimeType?: string;
+        serviceName?: string;
+        tags?: string[];
+        iconUrl?: string;
+    };
+}
+/**
+ * The `PaymentRequired` for a registration already read: the offer while sales are open, none once
+ * they are stopped: buyers still prove their purchase grant to download.
+ */
+export declare function paymentRequired(o: OfferOptions, file: FileInfo, usdc: string): PaymentRequired;
+/** A payment that may be settled, and what settlement needs. */
+export interface CheckedPayment {
+    purchase: Purchase;
+    purchaseId: string;
+    payer: string;
+    /** The buyer's one-time key: `unlock` needs it. */
+    buyerKey: string;
+    /** The nonce the buyer signed: `base_nonce(purchase_id)`. */
+    nonce: string;
+    validBefore: bigint;
+    /** The payload's `payment-identifier` id, if it has one. */
+    paymentId?: string;
+    offer: Offer;
+}
+type Payload = {
+    x402Version?: unknown;
+    accepted?: Offer;
+    payload?: {
+        signature?: unknown;
+        authorization?: Record<string, unknown>;
+    };
+    extensions?: Record<string, {
+        info?: Record<string, unknown>;
+    } & Record<string, unknown>>;
+};
+/**
+ * What a server runs before it settles: the registration read again now (a file stopped or taken
+ * down since the 402 is refused), then `checkPayment` against the offer it gives, with "now" taken
+ * from the earlier of this server's clock and Base's (USDC compares `validBefore` with Base time).
+ * New settlements require sales to be open and a short outstanding authorization window.
+ */
+export declare function verifyPayment(header: string, o: OfferOptions & {
+    baseRpc: string;
+}): Promise<CheckedPayment>;
+/** The base64 JSON of `PAYMENT-SIGNATURE`, as an x402 v2 payload. */
+export declare function readPayload(header: string): Payload;
+/**
+ * The purchase terms of a payload against the registration and the contract's configuration,
+ * without the seller's settings, the sale status or the deadline (x402-annon.md section 10, order of
+ * checks): what a retry of a payment already settling must still pass.
+ */
+export declare function checkTerms(header: string, t: {
+    contractId: string;
+    fileId: string;
+    usdc: string;
+    price: bigint;
+    payTo: string;
+    termsHash: string;
+}): CheckedPayment;
+/**
+ * @internal Use `verifyPayment`: this checks against a `PaymentRequired` that may be stale.
+ * Checks `PAYMENT-SIGNATURE` against the `PaymentRequired` this server sent (x402-annon.md section 3):
+ * the offer echoed unchanged, the `annon` extension echoed with a valid buyer key, an advertised
+ * `payment-identifier` echoed with a valid id, and the nonce the one that key gives. Run it before
+ * settling: a payment with any other nonce would move the buyer's money and never release the key.
+ * Throws `PayError` `bad_signature` or `bad_requirements`.
+ */
+export declare function checkPayment(header: string, pr: PaymentRequired, now?: number): CheckedPayment;
+/**
+ * A checked `annon-exact` payment as a standard x402 facilitator's `/verify` and `/settle` take it:
+ * the same signed authorization, every extension kept, with the scheme named `exact` in both the
+ * payload and the requirements (the official facilitator checks both). Run `verifyPayment` first.
+ */
+export declare function forFacilitator(header: string, offer: Offer): {
+    x402Version: 2;
+    paymentPayload: {
+        extensions?: {
+            [x: string]: unknown;
+        };
+        accepted: {
+            scheme: string;
+            network: string;
+            amount: string;
+            asset: string;
+            payTo: string;
+            maxTimeoutSeconds: number;
+            extra?: Record<string, unknown>;
+        };
+    };
+    paymentRequirements: {
+        scheme: string;
+        network: string;
+        amount: string;
+        asset: string;
+        payTo: string;
+        maxTimeoutSeconds: number;
+        extra?: Record<string, unknown>;
+    };
+};
+export {};