@atlasauth/pca-acp 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,369 @@
+/**
+ * @atlasauth/pca-acp — Agentic Commerce Protocol (ACP) + x402 for PCA.
+ *
+ * ┌──────────────────────────────────────────────────────────────────────────────────────────────┐
+ * │  PCA GOVERNS. ACP mints the delegated one-time payment token. x402 (HTTP 402) is the pay rail.  │
+ * │  "Every payment mandate is a verifiable proof-carrying action."                                 │
+ * └──────────────────────────────────────────────────────────────────────────────────────────────┘
+ *
+ * ACP (the Agentic Commerce Protocol, OpenAI + Stripe, 2025) lets an agent complete a purchase inside a
+ * chat/agent surface. Its payment leg is the Delegated / Shared Payment Token: a one-time, scope-bound
+ * token the buyer's agent hands the merchant to pull a bounded amount for ONE checkout
+ * (session + merchant + amount + expiry). x402 (Coinbase's HTTP 402 "Payment Required" flow) is the
+ * other net-new rail: a resource server answers `402` with a payment challenge, the client pays, and
+ * the server settles.
+ *
+ * This module makes BOTH of those proof-carrying. A delegated payment token is minted FROM a PCActn and
+ * carries that proof's authority by reference (its digest); the PCA proof's capability caveats — the
+ * spend cap, the merchant/category allowlist, the human-present requirement — GATE issuance: a token is
+ * refused at mint when the requested amount / currency / merchant / category / modality exceeds what the
+ * proof authorizes. At settlement the token's session/merchant/amount/expiry binding is re-checked and
+ * the bound PCActn can be re-verified, failing closed on over-amount, wrong-merchant, expiry, or a proof
+ * that no longer matches.
+ *
+ * This is ACP + x402, NOT AP2. The AP2 Intent→Cart→Payment VDC chain is `@atlasauth/pca-ap2`; this
+ * package reuses that mandate vocabulary (MonetaryAmount / merchants / categories / human_present /
+ * PaymentMethod) for consistency but is a distinct, wire-compatible adapter, not a re-implementation.
+ *
+ * ────────────────────────────────────────────────────────────────────────────────────────────────
+ * HONEST CAVEAT — VERIFY BEFORE PRODUCTION WIRE USE
+ * ────────────────────────────────────────────────────────────────────────────────────────────────
+ * ACP and x402 are young and moving. The exact JSON field names of the Stripe Shared Payment Token and
+ * the Coinbase x402 `accepts` requirement object should be validated against their current specs before
+ * production. The AUTHORITY model here (mint-time caveat gating + settlement-time PCActn binding) is the
+ * stable, load-bearing contribution; the wire envelopes are structural and injectable.
+ */
+import { type Capability, type Caveat, type PCActn, type VerifyResult } from '@atlasauth/pca';
+import { type JWK, type KeyLike } from 'jose';
+/** The ACP delegated-payment-token shape this module emits (version pinned into the claims). */
+export declare const ACP_DELEGATED_TOKEN_VERSION: 1;
+/** The `typ` claim carried in a delegated payment token (identifies the envelope to a verifier). */
+export declare const ACP_DELEGATED_TOKEN_TYPE: "acp-delegated-payment";
+/** ISO-4217 currency + decimal value (use minor units in production to avoid float drift). */
+export interface MonetaryAmount {
+    currency: string;
+    value: number;
+}
+/** The payment instrument a delegated token authorizes. Mirrors the AP2 `PaymentMethod` shape. */
+export interface PaymentMethod {
+    /** e.g. `card`, `shared_payment_token`, `x402`, `crypto`. */
+    type: string;
+    display?: string;
+    /** Opaque token (e.g. a Stripe Shared Payment Token id); never a raw PAN. */
+    token?: string;
+}
+/** `{ type: 'max_amount', max, currency? }` — per-transaction spend ceiling (optionally currency-bound). */
+export declare const SPEND_CAP_CAVEAT: "max_amount";
+/** `{ type: 'merchant_allow', merchants: [...] }` — allowlisted merchant ids (absent ⇒ any merchant). */
+export declare const MERCHANT_ALLOW_CAVEAT: "merchant_allow";
+/** `{ type: 'merchant_category', categories: [...] }` — allowlisted MCC categories (absent ⇒ any). */
+export declare const MERCHANT_CATEGORY_CAVEAT: "merchant_category";
+/** `{ type: 'human_present', required: boolean }` — require a human-present modality for the charge. */
+export declare const HUMAN_PRESENT_CAVEAT: "human_present";
+export interface SpendCapCaveat extends Caveat {
+    type: typeof SPEND_CAP_CAVEAT;
+    max: number;
+    currency?: string;
+}
+export interface MerchantAllowCaveat extends Caveat {
+    type: typeof MERCHANT_ALLOW_CAVEAT;
+    merchants: string[];
+}
+export interface MerchantCategoryCaveat extends Caveat {
+    type: typeof MERCHANT_CATEGORY_CAVEAT;
+    categories: string[];
+}
+export interface HumanPresentCaveat extends Caveat {
+    type: typeof HUMAN_PRESENT_CAVEAT;
+    required: boolean;
+}
+/** Build a per-transaction spend-cap caveat `{ type: 'max_amount', max, currency? }`. */
+export declare function spendCapCaveat(max: number, currency?: string): SpendCapCaveat;
+/** Build a merchant-allowlist caveat `{ type: 'merchant_allow', merchants }`. */
+export declare function merchantAllowCaveat(merchants: string[]): MerchantAllowCaveat;
+/** Build a merchant-category (MCC) allowlist caveat `{ type: 'merchant_category', categories }`. */
+export declare function merchantCategoryCaveat(categories: string[]): MerchantCategoryCaveat;
+/** Build a human-present requirement caveat `{ type: 'human_present', required }`. */
+export declare function humanPresentCaveat(required?: boolean): HumanPresentCaveat;
+/** Thrown when a delegated payment token cannot be minted because the request exceeds the proof's authority. */
+export declare class AcpAuthorityError extends Error {
+    constructor(message: string);
+}
+/** The conjunction of all payment caveats on a proof's leaf capability. */
+export interface PaymentAuthority {
+    /** Tightest per-transaction spend cap, or undefined when unconstrained. */
+    maxAmount?: number;
+    /** Currency the spend cap is denominated in, or undefined when the cap is currency-agnostic. */
+    currency?: string;
+    /** Allowlisted merchant ids (intersection of every allowlist caveat), or `null` for "any merchant". */
+    merchants: string[] | null;
+    /** Allowlisted MCC categories (intersection), or `null` for "any category". */
+    categories: string[] | null;
+    /** True when any caveat requires the charge to be human-present. */
+    humanPresentRequired: boolean;
+}
+/**
+ * Collapse a leaf capability's cumulative caveat list into its effective payment authority. Payment
+ * caveats combine conjunctively (tightest cap, intersected allowlists, sticky human-present); a malformed
+ * PAYMENT caveat throws (fail closed); any non-payment caveat type is ignored. The order of caveats does
+ * not matter — the result is the same conjunction either way.
+ */
+export declare function extractPaymentAuthority(caveats: readonly Caveat[]): PaymentAuthority;
+/** A concrete purchase request, checked against a {@link PaymentAuthority}. */
+export interface PaymentRequest {
+    amount: number;
+    currency: string;
+    merchant: string;
+    /** The merchant's MCC category, when known (required only if the proof constrains categories). */
+    category?: string;
+    /** Whether a human is present/attesting for this charge (the ACP modality signal). */
+    humanPresent?: boolean;
+}
+/** The outcome of checking a purchase request against a proof's payment authority. */
+export interface AuthorityCheck {
+    ok: boolean;
+    reason?: string;
+}
+/**
+ * Check a concrete purchase request against the payment authority a PCActn carries. Pure and fail-closed:
+ * an over-cap amount, a currency the cap forbids, a merchant / category outside the allowlist, or a
+ * missing human-present signal the proof demands all return `{ ok: false }`.
+ */
+export declare function checkPaymentAuthority(authority: PaymentAuthority, request: PaymentRequest): AuthorityCheck;
+/** How a delegated payment token points back at the PCActn that authorized it (authority by reference). */
+export interface PcaAuthorityRef {
+    /** `pcactnDigest()` of the authorizing proof — the binding a verifier re-checks against the proof. */
+    digest: string;
+    /** The proof's audience (resource server / Atlas instance id). */
+    aud: string;
+    /** The proof's grant id. */
+    grant_ref: string;
+    /** The acting leaf capability holder (b64u public key). */
+    leaf_holder: string;
+    verb: string;
+    resource: string;
+    params_digest: string;
+}
+/** A key usable to sign/verify a delegated payment token. A plain JWK is imported; other forms pass through. */
+export type TokenKey = KeyLike | Uint8Array | JWK;
+/** The claims a delegated payment token carries (the JWS payload). One-time, scope-bound, proof-referenced. */
+export interface DelegatedPaymentClaims {
+    typ: typeof ACP_DELEGATED_TOKEN_TYPE;
+    ver: typeof ACP_DELEGATED_TOKEN_VERSION;
+    /** One-time id (a resource server tracks it to enforce single-use). */
+    jti: string;
+    /** The ACP checkout session this token is bound to. */
+    session: string;
+    /** The merchant this token may pay. */
+    merchant: string;
+    /** The maximum amount this token authorizes (minor-unit-safe decimal). */
+    amount: number;
+    currency: string;
+    /** Issued-at (epoch ms). */
+    iat: number;
+    /** Expiry (epoch ms). */
+    exp: number;
+    paymentMethod: PaymentMethod;
+    /** The ACP human-present modality signal for this charge. */
+    humanPresent: boolean;
+    /** The merchant category, when supplied at mint. */
+    category?: string;
+    /** Optional issuer id of the minting party (agent platform / facilitator). */
+    iss?: string;
+    /** The PCA authority this token carries by reference. */
+    pca: PcaAuthorityRef;
+}
+/** Options for {@link mintDelegatedPaymentToken}. */
+export interface MintOptions {
+    /** The amount to authorize (the token's ceiling for this one checkout). */
+    amount: number;
+    currency: string;
+    /** The merchant the token may pay. */
+    merchant: string;
+    /** The ACP checkout session id the token is bound to. */
+    session: string;
+    /** Token expiry (epoch ms). Must be in the future and not outlive the authorizing proof's `exp`. */
+    expiresAt: number;
+    paymentMethod: PaymentMethod;
+    /** The JWS signing key (the minting party's key). Required to produce the token. */
+    signingKey: TokenKey;
+    /** JWS algorithm (default `'EdDSA'`). */
+    alg?: string;
+    /** Merchant category (MCC), required only when the proof constrains categories. */
+    category?: string;
+    /** The human-present modality to stamp; also satisfies a `human_present` caveat when `true`. */
+    humanPresent?: boolean;
+    /** Issuer id to stamp into the claims. */
+    issuer?: string;
+    /** JWS `kid` header (set it when verifiers resolve the key from a JWKS). */
+    kid?: string;
+    /** Explicit one-time id. Default: a deterministic digest of the binding + proof digest. */
+    jti?: string;
+    /** Issued-at clock (epoch ms). Default `Date.now()`. */
+    now?: number;
+}
+/**
+ * Mint a one-time ACP delegated payment token (a JWS) FROM a PCActn. The token is bound to
+ * session + merchant + amount + currency + expiry and carries the proof's authority BY REFERENCE
+ * (`pca.digest`). The PCActn's capability caveats gate issuance: the request is checked against the
+ * proof's {@link PaymentAuthority} and the mint is REFUSED (throws {@link AcpAuthorityError}) when the
+ * amount / currency / merchant / category / modality exceeds it, or when the requested expiry is in the
+ * past or would outlive the proof. The token never re-exposes the proof's contents — only the digest.
+ */
+export declare function mintDelegatedPaymentToken(pcActn: PCActn, opts: MintOptions): Promise<string>;
+/** Options for {@link verifyDelegatedPaymentToken}. */
+export interface VerifyTokenOptions {
+    /** The expected merchant the token must authorize. */
+    expectedMerchant: string;
+    /** The amount the caller intends to settle. Fails closed when it exceeds the token's authorized amount. */
+    amount: number;
+    /** The JWS verification key. */
+    verifyKey: TokenKey;
+    /** JWS algorithm (default `'EdDSA'`). */
+    alg?: string;
+    /** Verification clock (epoch ms). Default `Date.now()`. */
+    now?: number;
+    /** The session the token must be bound to, when the caller wants it checked. */
+    expectedSession?: string;
+    /** Expected settlement currency, when the caller wants it checked. */
+    expectedCurrency?: string;
+    /**
+     * The authorizing PCActn. When supplied, its `pcactnDigest()` must equal the token's `pca.digest`
+     * (proof-binding). When `grant` is ALSO supplied, the proof is additionally re-verified end-to-end.
+     */
+    pcActn?: PCActn;
+    /** The grant to re-verify `pcActn` against (enables a full `verifyPCActnCore` pass). */
+    grant?: Capability;
+    /** This verifier's audience for the full `verifyPCActnCore` pass (see the core's fail-closed rule). */
+    audience?: string | null;
+}
+/** The outcome of verifying a delegated payment token. */
+export interface TokenVerification {
+    ok: boolean;
+    reason?: string;
+    /** The verified claims (present only on success, or when the JWS verified but a binding check failed). */
+    claims?: DelegatedPaymentClaims;
+    /** The full PCActn verify result, when a re-verify was requested. */
+    pcaResult?: VerifyResult;
+}
+/**
+ * Verify a delegated payment token at settlement. Checks the JWS signature, then the token binding:
+ * merchant must equal `expectedMerchant`, the amount being settled must not exceed the token's authorized
+ * amount, the token must not be expired, and (when asked) the session / currency must match. When a
+ * `pcActn` is supplied its digest must equal the token's `pca.digest`; with a `grant` it is re-verified
+ * end-to-end. Fails CLOSED on every mismatch.
+ */
+export declare function verifyDelegatedPaymentToken(token: string, opts: VerifyTokenOptions): Promise<TokenVerification>;
+/** A single x402 payment requirement (the server's `accepts` entry). Structural; check against the x402 spec. */
+export interface X402Requirement {
+    scheme: string;
+    network: string;
+    maxAmountRequired: string;
+    resource: string;
+    description: string;
+    payTo: string;
+    asset: string;
+    mimeType: string;
+}
+/** The HTTP 402 challenge a resource server returns to demand payment. */
+export interface X402Challenge {
+    status: 402;
+    headers: Record<string, string>;
+    body: {
+        x402Version: 1;
+        accepts: X402Requirement[];
+        error?: string;
+    };
+}
+/** Options for {@link x402Challenge}. */
+export interface X402ChallengeOptions {
+    amount: number;
+    currency?: string;
+    /** The settlement network (e.g. an x402 chain id). Default `base-sepolia`. */
+    network?: string;
+    /** Payee address / account. */
+    payTo?: string;
+    description?: string;
+    /** Payment scheme. Default `exact`. */
+    scheme?: string;
+    mimeType?: string;
+    /** An error reason to surface alongside the challenge (e.g. on a rejected prior attempt). */
+    error?: string;
+}
+/**
+ * Build the HTTP 402 `Payment Required` challenge for a protected resource — the server's `accepts`
+ * payment requirement plus the `402` status. Structural only; no network. (Field names follow the
+ * public x402 shape and should be validated against the x402 spec before production.)
+ */
+export declare function x402Challenge(resource: string, opts: X402ChallengeOptions): X402Challenge;
+/** The client's x402 payment payload (the decoded `X-PAYMENT`). Carries the delegated payment token. */
+export interface X402PaymentPayload {
+    x402Version?: number;
+    scheme?: string;
+    network?: string;
+    /** The ACP delegated payment token (a JWS) proving proof-carrying authority for this charge. */
+    token: string;
+    /** The merchant the client is paying (checked against the token). */
+    merchant?: string;
+    /** The amount the client intends to settle (checked against the token). */
+    amount?: number;
+    resource?: string;
+    [k: string]: unknown;
+}
+/** The outcome an injected x402 verifier returns. */
+export interface X402VerifyResult {
+    ok: boolean;
+    reason?: string;
+    /** The verified token claims, when the payment verified. */
+    claims?: DelegatedPaymentClaims;
+}
+/** An injectable function that verifies an x402 payment payload (fed a verified PCActn-bound token). */
+export type X402Verify = (payload: X402PaymentPayload) => X402VerifyResult | Promise<X402VerifyResult>;
+/** An injectable settlement step run once payment is verified (e.g. a facilitator call). No network here. */
+export type X402Settler = (payload: X402PaymentPayload, claims: DelegatedPaymentClaims) => unknown | Promise<unknown>;
+/** Options for {@link x402Settle} — the injected verify (required) and optional settlement step. */
+export interface X402SettleOptions {
+    verify: X402Verify;
+    /** Optional settlement step run only after `verify` passes; its return value becomes the `receipt`. */
+    settle?: X402Settler;
+}
+/** The outcome of an x402 settlement attempt. */
+export interface X402SettleResult {
+    settled: boolean;
+    status: number;
+    reason?: string;
+    claims?: DelegatedPaymentClaims;
+    receipt?: unknown;
+}
+/**
+ * Gate an x402 settlement on a verified, PCActn-bound payment. Runs the injected `verify` over the
+ * client's payment payload; on failure it REFUSES with a fresh `402` (fail closed), on success it
+ * optionally runs the injected `settle` step and returns the receipt. The verify/settle steps are
+ * injectable so this composes with {@link verifyDelegatedPaymentToken} (see {@link acpX402Verifier})
+ * without this module performing any network itself.
+ */
+export declare function x402Settle(payload: X402PaymentPayload, opts: X402SettleOptions): Promise<X402SettleResult>;
+/** Options for {@link acpX402Verifier}. */
+export interface AcpX402VerifierOptions {
+    /** The JWS verification key for the delegated payment token. */
+    verifyKey: TokenKey;
+    alg?: string;
+    now?: number;
+    /** Override the expected merchant (default: the payload's `merchant`). */
+    expectedMerchant?: string;
+    /** Override the settlement amount (default: the payload's `amount`). */
+    amount?: number;
+    expectedSession?: string;
+    expectedCurrency?: string;
+    /** The authorizing proof to re-check the token against (digest, and end-to-end with `grant`). */
+    pcActn?: PCActn;
+    grant?: Capability;
+    audience?: string | null;
+}
+/**
+ * Adapt {@link verifyDelegatedPaymentToken} into an {@link X402Verify} for {@link x402Settle}: it reads
+ * the delegated payment token (and, by default, the merchant + amount the client claims) from the x402
+ * payload and verifies the token's binding + bound proof. This is the glue that makes the
+ * 402 → pay-with-proof → settle flow proof-carrying end to end.
+ */
+export declare function acpX402Verifier(opts: AcpX402VerifierOptions): X402Verify;

package/dist/index.js

@@ -0,0 +1,478 @@
+"use strict";
+/**
+ * @atlasauth/pca-acp — Agentic Commerce Protocol (ACP) + x402 for PCA.
+ *
+ * ┌──────────────────────────────────────────────────────────────────────────────────────────────┐
+ * │  PCA GOVERNS. ACP mints the delegated one-time payment token. x402 (HTTP 402) is the pay rail.  │
+ * │  "Every payment mandate is a verifiable proof-carrying action."                                 │
+ * └──────────────────────────────────────────────────────────────────────────────────────────────┘
+ *
+ * ACP (the Agentic Commerce Protocol, OpenAI + Stripe, 2025) lets an agent complete a purchase inside a
+ * chat/agent surface. Its payment leg is the Delegated / Shared Payment Token: a one-time, scope-bound
+ * token the buyer's agent hands the merchant to pull a bounded amount for ONE checkout
+ * (session + merchant + amount + expiry). x402 (Coinbase's HTTP 402 "Payment Required" flow) is the
+ * other net-new rail: a resource server answers `402` with a payment challenge, the client pays, and
+ * the server settles.
+ *
+ * This module makes BOTH of those proof-carrying. A delegated payment token is minted FROM a PCActn and
+ * carries that proof's authority by reference (its digest); the PCA proof's capability caveats — the
+ * spend cap, the merchant/category allowlist, the human-present requirement — GATE issuance: a token is
+ * refused at mint when the requested amount / currency / merchant / category / modality exceeds what the
+ * proof authorizes. At settlement the token's session/merchant/amount/expiry binding is re-checked and
+ * the bound PCActn can be re-verified, failing closed on over-amount, wrong-merchant, expiry, or a proof
+ * that no longer matches.
+ *
+ * This is ACP + x402, NOT AP2. The AP2 Intent→Cart→Payment VDC chain is `@atlasauth/pca-ap2`; this
+ * package reuses that mandate vocabulary (MonetaryAmount / merchants / categories / human_present /
+ * PaymentMethod) for consistency but is a distinct, wire-compatible adapter, not a re-implementation.
+ *
+ * ────────────────────────────────────────────────────────────────────────────────────────────────
+ * HONEST CAVEAT — VERIFY BEFORE PRODUCTION WIRE USE
+ * ────────────────────────────────────────────────────────────────────────────────────────────────
+ * ACP and x402 are young and moving. The exact JSON field names of the Stripe Shared Payment Token and
+ * the Coinbase x402 `accepts` requirement object should be validated against their current specs before
+ * production. The AUTHORITY model here (mint-time caveat gating + settlement-time PCActn binding) is the
+ * stable, load-bearing contribution; the wire envelopes are structural and injectable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcpAuthorityError = exports.HUMAN_PRESENT_CAVEAT = exports.MERCHANT_CATEGORY_CAVEAT = exports.MERCHANT_ALLOW_CAVEAT = exports.SPEND_CAP_CAVEAT = exports.ACP_DELEGATED_TOKEN_TYPE = exports.ACP_DELEGATED_TOKEN_VERSION = void 0;
+exports.spendCapCaveat = spendCapCaveat;
+exports.merchantAllowCaveat = merchantAllowCaveat;
+exports.merchantCategoryCaveat = merchantCategoryCaveat;
+exports.humanPresentCaveat = humanPresentCaveat;
+exports.extractPaymentAuthority = extractPaymentAuthority;
+exports.checkPaymentAuthority = checkPaymentAuthority;
+exports.mintDelegatedPaymentToken = mintDelegatedPaymentToken;
+exports.verifyDelegatedPaymentToken = verifyDelegatedPaymentToken;
+exports.x402Challenge = x402Challenge;
+exports.x402Settle = x402Settle;
+exports.acpX402Verifier = acpX402Verifier;
+const pca_1 = require("@atlasauth/pca");
+const jose_1 = require("jose");
+// ===================================================================================================
+// Version + token type
+// ===================================================================================================
+/** The ACP delegated-payment-token shape this module emits (version pinned into the claims). */
+exports.ACP_DELEGATED_TOKEN_VERSION = 1;
+/** The `typ` claim carried in a delegated payment token (identifies the envelope to a verifier). */
+exports.ACP_DELEGATED_TOKEN_TYPE = 'acp-delegated-payment';
+// ===================================================================================================
+// Payment caveat vocabulary (what the PCA proof's capability chain carries to bound a purchase)
+// ===================================================================================================
+//
+// The PCA capability chain is attenuating and append-only (see @atlasauth/pca `capability.ts`): a child
+// hop can only ADD caveats, never drop or widen one. The leaf hop therefore carries the full cumulative
+// caveat list, and these payment caveats COMBINE CONJUNCTIVELY (the tightest spend cap wins; merchant /
+// category allowlists INTERSECT; any `human_present` requirement sticks). A malformed PAYMENT caveat
+// fails closed; caveats of any other type (ttl, scope, …) are ignored here.
+/** `{ type: 'max_amount', max, currency? }` — per-transaction spend ceiling (optionally currency-bound). */
+exports.SPEND_CAP_CAVEAT = 'max_amount';
+/** `{ type: 'merchant_allow', merchants: [...] }` — allowlisted merchant ids (absent ⇒ any merchant). */
+exports.MERCHANT_ALLOW_CAVEAT = 'merchant_allow';
+/** `{ type: 'merchant_category', categories: [...] }` — allowlisted MCC categories (absent ⇒ any). */
+exports.MERCHANT_CATEGORY_CAVEAT = 'merchant_category';
+/** `{ type: 'human_present', required: boolean }` — require a human-present modality for the charge. */
+exports.HUMAN_PRESENT_CAVEAT = 'human_present';
+/** Build a per-transaction spend-cap caveat `{ type: 'max_amount', max, currency? }`. */
+function spendCapCaveat(max, currency) {
+    return currency !== undefined ? { type: exports.SPEND_CAP_CAVEAT, max, currency } : { type: exports.SPEND_CAP_CAVEAT, max };
+}
+/** Build a merchant-allowlist caveat `{ type: 'merchant_allow', merchants }`. */
+function merchantAllowCaveat(merchants) {
+    return { type: exports.MERCHANT_ALLOW_CAVEAT, merchants: [...merchants] };
+}
+/** Build a merchant-category (MCC) allowlist caveat `{ type: 'merchant_category', categories }`. */
+function merchantCategoryCaveat(categories) {
+    return { type: exports.MERCHANT_CATEGORY_CAVEAT, categories: [...categories] };
+}
+/** Build a human-present requirement caveat `{ type: 'human_present', required }`. */
+function humanPresentCaveat(required = true) {
+    return { type: exports.HUMAN_PRESENT_CAVEAT, required };
+}
+// ===================================================================================================
+// Errors
+// ===================================================================================================
+/** Thrown when a delegated payment token cannot be minted because the request exceeds the proof's authority. */
+class AcpAuthorityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AcpAuthorityError';
+    }
+}
+exports.AcpAuthorityError = AcpAuthorityError;
+function asStringArray(v, label) {
+    if (!Array.isArray(v) || !v.every((x) => typeof x === 'string')) {
+        throw new AcpAuthorityError(`malformed ${label} caveat: expected a string[] (fail closed)`);
+    }
+    return v;
+}
+/**
+ * Collapse a leaf capability's cumulative caveat list into its effective payment authority. Payment
+ * caveats combine conjunctively (tightest cap, intersected allowlists, sticky human-present); a malformed
+ * PAYMENT caveat throws (fail closed); any non-payment caveat type is ignored. The order of caveats does
+ * not matter — the result is the same conjunction either way.
+ */
+function extractPaymentAuthority(caveats) {
+    let maxAmount;
+    let currency;
+    let merchants = null;
+    let categories = null;
+    let humanPresentRequired = false;
+    for (const c of caveats) {
+        switch (c.type) {
+            case exports.SPEND_CAP_CAVEAT: {
+                const max = c.max;
+                if (typeof max !== 'number' || !Number.isFinite(max) || max < 0) {
+                    throw new AcpAuthorityError('malformed max_amount caveat: max must be a finite number >= 0 (fail closed)');
+                }
+                maxAmount = maxAmount === undefined ? max : Math.min(maxAmount, max);
+                const cur = c.currency;
+                if (cur !== undefined) {
+                    if (typeof cur !== 'string' || cur.length === 0) {
+                        throw new AcpAuthorityError('malformed max_amount caveat: currency must be a non-empty string (fail closed)');
+                    }
+                    if (currency !== undefined && currency !== cur) {
+                        throw new AcpAuthorityError(`conflicting spend-cap currencies "${currency}" vs "${cur}" (fail closed)`);
+                    }
+                    currency = cur;
+                }
+                break;
+            }
+            case exports.MERCHANT_ALLOW_CAVEAT: {
+                const list = asStringArray(c.merchants, 'merchant_allow');
+                merchants = merchants === null ? [...new Set(list)] : merchants.filter((m) => list.includes(m));
+                break;
+            }
+            case exports.MERCHANT_CATEGORY_CAVEAT: {
+                const list = asStringArray(c.categories, 'merchant_category');
+                categories = categories === null ? [...new Set(list)] : categories.filter((m) => list.includes(m));
+                break;
+            }
+            case exports.HUMAN_PRESENT_CAVEAT: {
+                const req = c.required;
+                if (typeof req !== 'boolean') {
+                    throw new AcpAuthorityError('malformed human_present caveat: required must be a boolean (fail closed)');
+                }
+                humanPresentRequired = humanPresentRequired || req;
+                break;
+            }
+            default:
+                break; // non-payment caveat (ttl, scope, resource, …) — not this adapter's concern
+        }
+    }
+    return {
+        ...(maxAmount !== undefined ? { maxAmount } : {}),
+        ...(currency !== undefined ? { currency } : {}),
+        merchants,
+        categories,
+        humanPresentRequired,
+    };
+}
+/** The leaf (acting) capability of a proof's chain. */
+function leafCapability(pcActn) {
+    const chain = pcActn.cap_chain;
+    if (!Array.isArray(chain) || chain.length === 0) {
+        throw new AcpAuthorityError('PCActn carries no capability chain (fail closed)');
+    }
+    const leaf = chain[chain.length - 1];
+    if (leaf === undefined)
+        throw new AcpAuthorityError('PCActn capability chain has no leaf (fail closed)');
+    return leaf;
+}
+/**
+ * Check a concrete purchase request against the payment authority a PCActn carries. Pure and fail-closed:
+ * an over-cap amount, a currency the cap forbids, a merchant / category outside the allowlist, or a
+ * missing human-present signal the proof demands all return `{ ok: false }`.
+ */
+function checkPaymentAuthority(authority, request) {
+    if (typeof request.amount !== 'number' || !Number.isFinite(request.amount) || request.amount <= 0) {
+        return { ok: false, reason: 'amount must be a finite number > 0' };
+    }
+    if (typeof request.currency !== 'string' || request.currency.length === 0) {
+        return { ok: false, reason: 'currency must be a non-empty string' };
+    }
+    if (typeof request.merchant !== 'string' || request.merchant.length === 0) {
+        return { ok: false, reason: 'merchant must be a non-empty string' };
+    }
+    if (authority.currency !== undefined && authority.currency !== request.currency) {
+        return { ok: false, reason: `currency "${request.currency}" is not the authorized currency "${authority.currency}"` };
+    }
+    if (authority.maxAmount !== undefined && request.amount > authority.maxAmount) {
+        return { ok: false, reason: `amount ${request.amount} exceeds the authorized spend cap ${authority.maxAmount}` };
+    }
+    if (authority.merchants !== null && !authority.merchants.includes(request.merchant)) {
+        return { ok: false, reason: `merchant "${request.merchant}" is not in the authorized allowlist` };
+    }
+    if (authority.categories !== null) {
+        if (request.category === undefined) {
+            return { ok: false, reason: 'the proof constrains merchant categories but no category was supplied' };
+        }
+        if (!authority.categories.includes(request.category)) {
+            return { ok: false, reason: `category "${request.category}" is not in the authorized allowlist` };
+        }
+    }
+    if (authority.humanPresentRequired && request.humanPresent !== true) {
+        return { ok: false, reason: 'the proof requires a human-present charge but humanPresent was not asserted' };
+    }
+    return { ok: true };
+}
+function authorityRef(pcActn) {
+    const leaf = leafCapability(pcActn);
+    return {
+        digest: (0, pca_1.pcactnDigest)(pcActn),
+        aud: pcActn.aud,
+        grant_ref: pcActn.grant_ref,
+        leaf_holder: leaf.holder,
+        verb: pcActn.action.verb,
+        resource: pcActn.action.resource,
+        params_digest: pcActn.action.params_digest,
+    };
+}
+function isJwk(k) {
+    return typeof k === 'object' && k !== null && !(k instanceof Uint8Array) && 'kty' in k;
+}
+/**
+ * Mint a one-time ACP delegated payment token (a JWS) FROM a PCActn. The token is bound to
+ * session + merchant + amount + currency + expiry and carries the proof's authority BY REFERENCE
+ * (`pca.digest`). The PCActn's capability caveats gate issuance: the request is checked against the
+ * proof's {@link PaymentAuthority} and the mint is REFUSED (throws {@link AcpAuthorityError}) when the
+ * amount / currency / merchant / category / modality exceeds it, or when the requested expiry is in the
+ * past or would outlive the proof. The token never re-exposes the proof's contents — only the digest.
+ */
+async function mintDelegatedPaymentToken(pcActn, opts) {
+    const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+    // 1. Gate issuance on the proof's authority (fail closed on an over-authority request).
+    const authority = extractPaymentAuthority(leafCapability(pcActn).caveats);
+    const check = checkPaymentAuthority(authority, {
+        amount: opts.amount,
+        currency: opts.currency,
+        merchant: opts.merchant,
+        ...(opts.category !== undefined ? { category: opts.category } : {}),
+        ...(opts.humanPresent !== undefined ? { humanPresent: opts.humanPresent } : {}),
+    });
+    if (!check.ok)
+        throw new AcpAuthorityError(`refused: ${check.reason ?? 'request exceeds the proof authority'}`);
+    // 2. Expiry binding: the token must expire in the future and never outlive the proof that authorized it.
+    if (!Number.isFinite(opts.expiresAt))
+        throw new AcpAuthorityError('refused: expiresAt must be a finite epoch-ms timestamp');
+    if (opts.expiresAt <= now)
+        throw new AcpAuthorityError('refused: expiresAt is not in the future');
+    if (opts.expiresAt > pcActn.exp) {
+        throw new AcpAuthorityError(`refused: token expiry ${opts.expiresAt} would outlive the proof's exp ${pcActn.exp}`);
+    }
+    if (!opts.session)
+        throw new AcpAuthorityError('refused: a session id is required');
+    const pca = authorityRef(pcActn);
+    const jti = opts.jti ??
+        (0, pca_1.pcactnDigest)({
+            ...pcActn,
+            // Derive a stable one-time id from the proof digest + the token binding (not a real PCActn; just a hash seed).
+            nonce: `acp:${opts.session}:${opts.merchant}:${opts.amount}:${opts.currency}:${opts.expiresAt}:${pca.digest}`,
+        });
+    const claims = {
+        typ: exports.ACP_DELEGATED_TOKEN_TYPE,
+        ver: exports.ACP_DELEGATED_TOKEN_VERSION,
+        jti,
+        session: opts.session,
+        merchant: opts.merchant,
+        amount: opts.amount,
+        currency: opts.currency,
+        iat: now,
+        exp: opts.expiresAt,
+        paymentMethod: { ...opts.paymentMethod },
+        humanPresent: opts.humanPresent === true,
+        ...(opts.category !== undefined ? { category: opts.category } : {}),
+        ...(opts.issuer !== undefined ? { iss: opts.issuer } : {}),
+        pca,
+    };
+    const alg = opts.alg ?? 'EdDSA';
+    const key = isJwk(opts.signingKey) ? await (0, jose_1.importJWK)(opts.signingKey, alg) : opts.signingKey;
+    const protectedHeader = {
+        alg,
+        typ: exports.ACP_DELEGATED_TOKEN_TYPE,
+        ...(opts.kid !== undefined ? { kid: opts.kid } : {}),
+    };
+    return new jose_1.CompactSign((0, pca_1.utf8)(JSON.stringify(claims))).setProtectedHeader(protectedHeader).sign(key);
+}
+function isPaymentMethod(v) {
+    return v !== null && typeof v === 'object' && typeof v.type === 'string';
+}
+function parseClaims(bytes) {
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const c = parsed;
+    if (c.typ !== exports.ACP_DELEGATED_TOKEN_TYPE || c.ver !== exports.ACP_DELEGATED_TOKEN_VERSION)
+        return null;
+    if (typeof c.jti !== 'string' ||
+        typeof c.session !== 'string' ||
+        typeof c.merchant !== 'string' ||
+        typeof c.amount !== 'number' ||
+        typeof c.currency !== 'string' ||
+        typeof c.iat !== 'number' ||
+        typeof c.exp !== 'number' ||
+        typeof c.humanPresent !== 'boolean' ||
+        !isPaymentMethod(c.paymentMethod)) {
+        return null;
+    }
+    const pcaRaw = c.pca;
+    if (pcaRaw === null || typeof pcaRaw !== 'object' || Array.isArray(pcaRaw))
+        return null;
+    const p = pcaRaw;
+    if (typeof p.digest !== 'string' ||
+        typeof p.aud !== 'string' ||
+        typeof p.grant_ref !== 'string' ||
+        typeof p.leaf_holder !== 'string' ||
+        typeof p.verb !== 'string' ||
+        typeof p.resource !== 'string' ||
+        typeof p.params_digest !== 'string') {
+        return null;
+    }
+    // Shape validated field-by-field above; assemble the typed view.
+    return parsed;
+}
+/**
+ * Verify a delegated payment token at settlement. Checks the JWS signature, then the token binding:
+ * merchant must equal `expectedMerchant`, the amount being settled must not exceed the token's authorized
+ * amount, the token must not be expired, and (when asked) the session / currency must match. When a
+ * `pcActn` is supplied its digest must equal the token's `pca.digest`; with a `grant` it is re-verified
+ * end-to-end. Fails CLOSED on every mismatch.
+ */
+async function verifyDelegatedPaymentToken(token, opts) {
+    const alg = opts.alg ?? 'EdDSA';
+    const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+    // 1. JWS signature.
+    let claims;
+    try {
+        const key = isJwk(opts.verifyKey) ? await (0, jose_1.importJWK)(opts.verifyKey, alg) : opts.verifyKey;
+        const { payload } = await (0, jose_1.compactVerify)(token, key, { algorithms: [alg] });
+        claims = parseClaims(payload);
+    }
+    catch (e) {
+        return { ok: false, reason: `token signature did not verify: ${e.message}` };
+    }
+    if (claims === null)
+        return { ok: false, reason: 'token payload is not a well-formed delegated payment token' };
+    // 2. Binding checks (fail closed).
+    if (claims.merchant !== opts.expectedMerchant) {
+        return { ok: false, reason: `token merchant "${claims.merchant}" does not match expected "${opts.expectedMerchant}"`, claims };
+    }
+    if (typeof opts.amount !== 'number' || !Number.isFinite(opts.amount) || opts.amount <= 0) {
+        return { ok: false, reason: 'settlement amount must be a finite number > 0', claims };
+    }
+    if (opts.amount > claims.amount) {
+        return { ok: false, reason: `settlement amount ${opts.amount} exceeds the token's authorized amount ${claims.amount}`, claims };
+    }
+    if (now > claims.exp) {
+        return { ok: false, reason: 'the delegated payment token has expired', claims };
+    }
+    if (opts.expectedSession !== undefined && claims.session !== opts.expectedSession) {
+        return { ok: false, reason: `token session "${claims.session}" does not match expected "${opts.expectedSession}"`, claims };
+    }
+    if (opts.expectedCurrency !== undefined && claims.currency !== opts.expectedCurrency) {
+        return { ok: false, reason: `token currency "${claims.currency}" does not match expected "${opts.expectedCurrency}"`, claims };
+    }
+    // 3. Proof binding (optional): the token's digest must match the supplied PCActn.
+    if (opts.pcActn !== undefined) {
+        if ((0, pca_1.pcactnDigest)(opts.pcActn) !== claims.pca.digest) {
+            return { ok: false, reason: 'pcactn_digest mismatch: the supplied proof is not the one that minted this token', claims };
+        }
+        if (opts.grant !== undefined) {
+            const pcaResult = await (0, pca_1.verifyPCActnCore)(opts.pcActn, {
+                grant: opts.grant,
+                nowEpoch: now,
+                audience: opts.audience,
+            });
+            if (!pcaResult.allow) {
+                return { ok: false, reason: `bound proof failed to verify: ${pcaResult.reason ?? 'denied'}`, claims, pcaResult };
+            }
+            return { ok: true, claims, pcaResult };
+        }
+    }
+    return { ok: true, claims };
+}
+/**
+ * Build the HTTP 402 `Payment Required` challenge for a protected resource — the server's `accepts`
+ * payment requirement plus the `402` status. Structural only; no network. (Field names follow the
+ * public x402 shape and should be validated against the x402 spec before production.)
+ */
+function x402Challenge(resource, opts) {
+    const requirement = {
+        scheme: opts.scheme ?? 'exact',
+        network: opts.network ?? 'base-sepolia',
+        maxAmountRequired: String(opts.amount),
+        resource,
+        description: opts.description ?? `Payment required for ${resource}`,
+        payTo: opts.payTo ?? '',
+        asset: opts.currency ?? '',
+        mimeType: opts.mimeType ?? 'application/json',
+    };
+    return {
+        status: 402,
+        headers: { 'Content-Type': 'application/json' },
+        body: {
+            x402Version: 1,
+            accepts: [requirement],
+            ...(opts.error !== undefined ? { error: opts.error } : {}),
+        },
+    };
+}
+/**
+ * Gate an x402 settlement on a verified, PCActn-bound payment. Runs the injected `verify` over the
+ * client's payment payload; on failure it REFUSES with a fresh `402` (fail closed), on success it
+ * optionally runs the injected `settle` step and returns the receipt. The verify/settle steps are
+ * injectable so this composes with {@link verifyDelegatedPaymentToken} (see {@link acpX402Verifier})
+ * without this module performing any network itself.
+ */
+async function x402Settle(payload, opts) {
+    if (payload === null || typeof payload !== 'object' || typeof payload.token !== 'string') {
+        return { settled: false, status: 402, reason: 'x402 payment payload is missing a token' };
+    }
+    const v = await opts.verify(payload);
+    if (!v.ok) {
+        return { settled: false, status: 402, reason: v.reason ?? 'payment verification failed', ...(v.claims ? { claims: v.claims } : {}) };
+    }
+    if (v.claims === undefined) {
+        return { settled: false, status: 402, reason: 'verifier admitted the payment but returned no claims (fail closed)' };
+    }
+    const receipt = opts.settle ? await opts.settle(payload, v.claims) : undefined;
+    return { settled: true, status: 200, claims: v.claims, ...(receipt !== undefined ? { receipt } : {}) };
+}
+/**
+ * Adapt {@link verifyDelegatedPaymentToken} into an {@link X402Verify} for {@link x402Settle}: it reads
+ * the delegated payment token (and, by default, the merchant + amount the client claims) from the x402
+ * payload and verifies the token's binding + bound proof. This is the glue that makes the
+ * 402 → pay-with-proof → settle flow proof-carrying end to end.
+ */
+function acpX402Verifier(opts) {
+    return async (payload) => {
+        const merchant = opts.expectedMerchant ?? payload.merchant;
+        if (typeof merchant !== 'string' || merchant.length === 0) {
+            return { ok: false, reason: 'x402 payload has no merchant to check the token against' };
+        }
+        const amount = opts.amount ?? payload.amount;
+        if (typeof amount !== 'number') {
+            return { ok: false, reason: 'x402 payload has no amount to check the token against' };
+        }
+        const res = await verifyDelegatedPaymentToken(payload.token, {
+            expectedMerchant: merchant,
+            amount,
+            verifyKey: opts.verifyKey,
+            ...(opts.alg !== undefined ? { alg: opts.alg } : {}),
+            ...(opts.now !== undefined ? { now: opts.now } : {}),
+            ...(opts.expectedSession !== undefined ? { expectedSession: opts.expectedSession } : {}),
+            ...(opts.expectedCurrency !== undefined ? { expectedCurrency: opts.expectedCurrency } : {}),
+            ...(opts.pcActn !== undefined ? { pcActn: opts.pcActn } : {}),
+            ...(opts.grant !== undefined ? { grant: opts.grant } : {}),
+            ...(opts.audience !== undefined ? { audience: opts.audience } : {}),
+        });
+        return { ok: res.ok, ...(res.reason !== undefined ? { reason: res.reason } : {}), ...(res.claims ? { claims: res.claims } : {}) };
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "@atlasauth/pca-acp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Agentic Commerce (ACP) + x402 adapter for PCA: mint an ACP delegated one-time payment token (bound to session+merchant+amount+expiry) AS a PCA proof, and an x402/HTTP-402 facilitator hook that gates settlement on a verified PCActn.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "jose": "^5.9.6",
+    "@atlasauth/pca": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.4"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.