@catena/sdk 0.0.0-bootstrap.0 → 0.1.0

package/dist/mpp.mjs

@@ -0,0 +1,564 @@
+import { T as paymentCredentialFromIntentData, n as IntentSubmitError, t as ApiError } from "./client-CHZMO00P.mjs";
+import { a as assertNever, i as isReplayableFetchRequest, n as reportSettlementHint, r as fetchRetryHeaders, t as EVM_TRANSACTION_HASH_PATTERN } from "./settlement-report-CT3EbtLL.mjs";
+import { Credential, Method, PaymentRequest, Receipt, z } from "mppx";
+import { Mppx } from "mppx/client";
+import { isAddress } from "viem";
+//#region src/lib/mpp-resource-url.ts
+const MPP_MAX_RESOURCE_URL_LENGTH = 2048;
+var MppResourceUrlError = class extends Error {
+	name = "MppResourceUrlError";
+};
+function canonicalizeMppResourceUrl(input) {
+	if (input.length > MPP_MAX_RESOURCE_URL_LENGTH) throw new MppResourceUrlError("MPP resource URL is too long");
+	if (Array.from(input).some((character) => {
+		const code = character.charCodeAt(0);
+		return character === "\\" || code <= 32 || code === 127;
+	})) throw new MppResourceUrlError("MPP resource URL is invalid");
+	const components = input.match(/^([A-Za-z][A-Za-z0-9+.-]*):\/\/([^/?#]*)([^?#]*)(\?[^#]*)?(?:#.*)?$/);
+	if (!components) throw new MppResourceUrlError("MPP resource URL must be absolute");
+	let parsed;
+	try {
+		parsed = new URL(input);
+	} catch {
+		throw new MppResourceUrlError("MPP resource URL is invalid");
+	}
+	if (parsed.username || parsed.password) throw new MppResourceUrlError("MPP resource URL must not contain credentials");
+	const protocol = parsed.protocol.toLowerCase();
+	if (protocol !== "https:" && !(protocol === "http:" && isLoopbackHostname(parsed.hostname))) throw new MppResourceUrlError("MPP resource URL must use HTTPS or loopback HTTP");
+	const rawPath = components[3] || "/";
+	const rawQuery = components[4] || "";
+	const canonical = `${protocol}//${parsed.hostname.toLowerCase()}${parsed.port ? `:${parsed.port}` : ""}${rawPath}${rawQuery}`;
+	if (canonical.length > MPP_MAX_RESOURCE_URL_LENGTH) throw new MppResourceUrlError("MPP resource URL is too long");
+	return canonical;
+}
+function isLoopbackHostname(hostname) {
+	const normalized = hostname.toLowerCase();
+	if (normalized === "localhost" || normalized === "[::1]") return true;
+	const octets = normalized.split(".");
+	return octets.length === 4 && octets[0] === "127" && octets.every((octet) => /^\d{1,3}$/.test(octet) && Number(octet) <= 255);
+}
+//#endregion
+//#region src/mpp.ts
+const BASE_USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+const BASE_SEPOLIA_USDC = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+const MAX_REQUEST_LENGTH = 16384;
+const MAX_CHALLENGE_BYTES = 32768;
+const MIN_REMAINING_MS = 5e3;
+const MAX_VALIDITY_MS = 36e5;
+const BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+const ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/;
+const AMOUNT_PATTERN = /^(?:0|[1-9]\d*)$/;
+const RFC3339_UTC_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
+const RFC9530_DIGEST_PATTERN = /^sha-256=:([A-Za-z0-9+/]{43}=):$/;
+const MPPX_0_9_DIGEST_PATTERN = /^sha-256=([A-Za-z0-9+/]{43}=)$/;
+const MAX_CANDIDATE_CHALLENGES = 5;
+const FALLBACK_ERROR_CODES = new Set([
+	"mpp_challenge_not_payable",
+	"mpp_network_mismatch",
+	"mpp_counterparty_rail_not_found"
+]);
+const COUNTERPARTY_RAIL_NOT_FOUND_CODE = "mpp_counterparty_rail_not_found";
+const NETWORK_MISMATCH_CODE = "mpp_network_mismatch";
+const authorizationPayloadSchema = z.object({
+	type: z.literal("authorization"),
+	from: z.string(),
+	to: z.string(),
+	value: z.string(),
+	validAfter: z.string(),
+	validBefore: z.string(),
+	nonce: z.string(),
+	signature: z.string()
+});
+const commonRequestFields = {
+	amount: z.string(),
+	currency: z.string(),
+	description: z.optional(z.string()),
+	externalId: z.optional(z.string()),
+	recipient: z.string()
+};
+const evmRequestSchema = z.object({
+	...commonRequestFields,
+	methodDetails: z.object({
+		chainId: z.number(),
+		credentialTypes: z.array(z.literal("authorization")),
+		decimals: z.literal(6),
+		permit2Address: z.optional(z.string()),
+		splits: z.optional(z.never())
+	})
+});
+const usdcRequestSchema = z.object({
+	...commonRequestFields,
+	methodDetails: z.object({
+		type: z.literal("evm"),
+		evm: z.object({
+			chainId: z.number(),
+			credentialTypes: z.optional(z.array(z.literal("authorization"))),
+			decimals: z.literal(6),
+			permit2Address: z.optional(z.string()),
+			splits: z.optional(z.never())
+		})
+	})
+});
+const evmCharge = Method.from({
+	name: "evm",
+	intent: "charge",
+	schema: {
+		credential: { payload: authorizationPayloadSchema },
+		request: evmRequestSchema
+	}
+});
+const usdcCharge = Method.from({
+	name: "usdc",
+	intent: "charge",
+	schema: {
+		credential: { payload: authorizationPayloadSchema },
+		request: usdcRequestSchema
+	}
+});
+var MppPaymentError = class extends Error {
+	intentId;
+	status;
+	reasons;
+	expiresAt;
+	constructor(message, details) {
+		super(message);
+		this.name = "MppPaymentError";
+		this.intentId = details.intentId;
+		this.status = details.status;
+		this.reasons = details.reasons;
+		this.expiresAt = details.expiresAt;
+	}
+};
+var MppFetchPaymentError = class extends Error {
+	intentId;
+	reasons;
+	constructor(message, details = {}) {
+		super(message, details.cause === void 0 ? void 0 : { cause: details.cause });
+		this.name = "MppFetchPaymentError";
+		this.intentId = details.intentId;
+		this.reasons = details.reasons ?? [];
+	}
+};
+var MppNetworkMismatchError = class extends MppFetchPaymentError {
+	accountId;
+	requiredNetworks;
+	constructor(accountId, requiredNetworks, reasons) {
+		super(`Account ${accountId} cannot pay on the MPP challenge's required network${requiredNetworks.length === 1 ? "" : "s"}: ${requiredNetworks.join(", ")}`, { reasons });
+		this.name = "MppNetworkMismatchError";
+		this.accountId = accountId;
+		this.requiredNetworks = requiredNetworks;
+	}
+};
+var MppCounterpartyNotFoundError = class extends MppFetchPaymentError {
+	recipient;
+	network;
+	constructor(recipient, network, reasons) {
+		super(`No saved Catena counterparty rail can pay ${recipient} on ${network}`, { reasons });
+		this.name = "MppCounterpartyNotFoundError";
+		this.recipient = recipient;
+		this.network = network;
+	}
+};
+var MppApprovalPendingError = class extends MppFetchPaymentError {
+	expiresAt;
+	constructor(intentId, reasons, expiresAt) {
+		super(`The MPP payment is awaiting human approval (intent ${intentId}); retry the request after approval`, {
+			intentId,
+			reasons
+		});
+		this.name = "MppApprovalPendingError";
+		this.expiresAt = expiresAt;
+	}
+};
+var MppPaymentDeclinedError = class extends MppFetchPaymentError {
+	status;
+	constructor(intentId, status, reasons) {
+		super(`Catena ${status} the MPP payment (intent ${intentId})`, {
+			intentId,
+			reasons
+		});
+		this.name = "MppPaymentDeclinedError";
+		this.status = status;
+	}
+};
+var MppSubmitInterruptedError = class extends MppFetchPaymentError {
+	method;
+	atomicAmount;
+	network;
+	recipient;
+	resourceUrl;
+	constructor(intentId, terms, resourceUrl, cause) {
+		super(`The MPP payment could not be confirmed (intent ${intentId}); reconcile it with getIntent("${intentId}") before paying again`, {
+			intentId,
+			cause
+		});
+		this.name = "MppSubmitInterruptedError";
+		this.method = terms.method;
+		this.atomicAmount = terms.atomicAmount;
+		this.network = terms.network;
+		this.recipient = terms.recipient;
+		this.resourceUrl = resourceUrl;
+	}
+};
+var MppRetryFailedError = class extends MppFetchPaymentError {
+	receipt;
+	constructor(receipt, cause) {
+		super(`The MPP payment completed (intent ${receipt.intentId}) but the post-payment continuation failed; inspect getIntent("${receipt.intentId}") before retrying manually`, {
+			intentId: receipt.intentId,
+			cause
+		});
+		this.name = "MppRetryFailedError";
+		this.receipt = receipt;
+	}
+};
+function charge(parameters) {
+	const createCredential = async ({ challenge }) => {
+		return (await submitCatenaMppPayment(parameters, prepareCatenaMppPayment(challenge, parameters.maxAtomicAmount))).credential;
+	};
+	return [Method.toClient(evmCharge, {
+		canHandleChallenge: ({ challenge }) => supportedChallenge("evm", challenge, parameters.maxAtomicAmount) !== void 0,
+		createCredential
+	}), Method.toClient(usdcCharge, {
+		canHandleChallenge: ({ challenge }) => supportedChallenge("usdc", challenge, parameters.maxAtomicAmount) !== void 0,
+		createCredential
+	})];
+}
+const catena = Object.assign((parameters) => charge(parameters), { charge });
+function wrapFetchWithMppPayment(client, options) {
+	const baseFetch = (options.baseFetch ?? globalThis.fetch).bind(globalThis);
+	const parameters = {
+		client,
+		accountId: options.accountId,
+		...options.maxAtomicAmount !== void 0 && { maxAtomicAmount: options.maxAtomicAmount }
+	};
+	const mppx = Mppx.create({
+		methods: catena(parameters),
+		fetch: baseFetch,
+		polyfill: false
+	});
+	return async (input, init) => {
+		const response = await baseFetch(input, init);
+		if (response.status !== 402 || !response.headers.has("WWW-Authenticate")) return response;
+		let challenges;
+		try {
+			challenges = await mppx.transport.getChallenges(response, init);
+		} catch {
+			return response;
+		}
+		if (challenges.length === 0) return response;
+		if (!isReplayableFetchRequest(input, init)) throw new MppFetchPaymentError("The request body cannot be replayed after MPP payment; buffer it as a string, URLSearchParams, Blob, ArrayBuffer, or typed array");
+		const resourceUrl = paymentResourceUrl(input, response);
+		const { payment, prepared } = await paySupportedMppChallenge(mppx, response, challenges, init, parameters, resourceUrl);
+		const receipt = {
+			intentId: payment.intentId,
+			...payment.terms,
+			resourceUrl
+		};
+		await preserveMppPaymentReceipt(receipt, async () => {
+			await options.onPayment?.(receipt);
+		});
+		const headers = fetchRetryHeaders(input, init);
+		const paidInit = prepared.setCredential({
+			...init,
+			headers
+		}, payment.credential);
+		const paidResponse = await preserveMppPaymentReceipt(receipt, () => baseFetch(input, paidInit));
+		if (paidResponse.status === 402) throw new MppRetryFailedError(receipt, new Error("The paid MPP retry still requires payment"));
+		reportMppSettlement(client, receipt.intentId, paidResponse);
+		return paidResponse;
+	};
+}
+async function paySupportedMppChallenge(mppx, response, challenges, request, parameters, resourceUrl) {
+	let candidateIndexes;
+	const skips = [];
+	for (let attempt = 0; attempt < MAX_CANDIDATE_CHALLENGES; attempt += 1) {
+		const selection = { missing: false };
+		let prepared;
+		try {
+			prepared = await mppx.preparePayment(response, {
+				request,
+				orderChallenges: (candidates) => {
+					candidateIndexes ??= candidates.slice(0, MAX_CANDIDATE_CHALLENGES).map((candidate) => candidate.index);
+					const candidateIndex = candidateIndexes[attempt];
+					const candidate = candidates.find((current) => current.index === candidateIndex);
+					selection.missing = candidate === void 0;
+					return candidate === void 0 ? [] : [candidate];
+				}
+			});
+		} catch (cause) {
+			const currentCandidateIndexes = candidateIndexes ?? [];
+			if (currentCandidateIndexes.length === 0) {
+				if (challenges.some((challenge) => exceedsMaximumAtomicAmount(challenge, parameters.maxAtomicAmount))) throw new MppFetchPaymentError("Every supported charge in the MPP challenge costs more than the caller's maximum amount", { cause });
+				throw new MppFetchPaymentError("The MPP challenge offers no Catena-supported native USDC charge", { cause });
+			}
+			if (selection.missing && skips.length > 0) {
+				if (attempt + 1 < currentCandidateIndexes.length) continue;
+				break;
+			}
+			throw new MppFetchPaymentError("The selected MPP challenge could not be prepared", { cause });
+		}
+		const selected = prepareCatenaMppPayment(prepared.challenge, parameters.maxAtomicAmount);
+		try {
+			return {
+				payment: await submitCatenaMppPayment(parameters, selected, resourceUrl),
+				prepared
+			};
+		} catch (error) {
+			if (error instanceof ApiError && error.code !== void 0 && FALLBACK_ERROR_CODES.has(error.code)) skips.push({
+				error,
+				terms: selected.terms
+			});
+			else throw managedMppPaymentError(error, selected.terms, resourceUrl);
+		}
+		if (attempt + 1 >= (candidateIndexes?.length ?? 0)) break;
+	}
+	throw terminalMppCandidateError(parameters.accountId, skips);
+}
+function managedMppPaymentError(error, terms, resourceUrl) {
+	if (error instanceof IntentSubmitError && error.outcome === "unknown") return new MppSubmitInterruptedError(error.intentId, terms, resourceUrl, error);
+	if (!(error instanceof MppPaymentError)) return error;
+	switch (error.status) {
+		case "pending": return new MppApprovalPendingError(error.intentId, error.reasons, error.expiresAt);
+		case "blocked":
+		case "failed": return new MppPaymentDeclinedError(error.intentId, error.status, error.reasons);
+		case "processing":
+		case "completed": return new MppFetchPaymentError(error.message, {
+			intentId: error.intentId,
+			reasons: error.reasons,
+			cause: error
+		});
+	}
+	return assertNever(error.status);
+}
+function terminalMppCandidateError(accountId, skips) {
+	const counterpartySkips = skips.filter((skip) => skip.error.code === COUNTERPARTY_RAIL_NOT_FOUND_CODE);
+	const mismatchSkips = skips.filter((skip) => skip.error.code === NETWORK_MISMATCH_CODE);
+	const otherSkips = skips.filter((skip) => skip.error.code !== COUNTERPARTY_RAIL_NOT_FOUND_CODE && skip.error.code !== NETWORK_MISMATCH_CODE);
+	const reasons = [...new Set([
+		...counterpartySkips,
+		...mismatchSkips,
+		...otherSkips
+	].map((skip) => skip.error.message))];
+	const unsaved = counterpartySkips.find((skip) => skip.error.status === 404);
+	if (unsaved) return new MppCounterpartyNotFoundError(unsaved.terms.recipient, unsaved.terms.network, reasons);
+	if (mismatchSkips.length > 0 && counterpartySkips.length === 0) return new MppNetworkMismatchError(accountId, [...new Set(mismatchSkips.map((skip) => skip.terms.network))], reasons);
+	return new MppFetchPaymentError("No supported candidate in the MPP challenge is payable from this account", { reasons });
+}
+function paymentResourceUrl(input, response) {
+	let requested;
+	try {
+		requested = typeof input === "string" ? absoluteOrBrowserUrl(input) : input instanceof URL ? input : new URL(input.url);
+	} catch (cause) {
+		throw new MppFetchPaymentError("The MPP resource request URL must be absolute", { cause });
+	}
+	let finalUrl;
+	try {
+		finalUrl = new URL(response.url || requested.href);
+	} catch (cause) {
+		throw new MppFetchPaymentError("The final MPP resource URL is invalid", { cause });
+	}
+	if (finalUrl.origin !== requested.origin) throw new MppFetchPaymentError(`Refusing to pay after a cross-origin redirect from ${requested.origin} to ${finalUrl.origin}`);
+	try {
+		return canonicalizeMppResourceUrl(response.url || requested.href);
+	} catch (cause) {
+		throw new MppFetchPaymentError("The final MPP resource URL cannot be bound to a payment intent", { cause });
+	}
+}
+function absoluteOrBrowserUrl(input) {
+	try {
+		return new URL(input);
+	} catch {
+		return new URL(input, globalThis.location.href);
+	}
+}
+async function preserveMppPaymentReceipt(receipt, operation) {
+	try {
+		return await operation();
+	} catch (cause) {
+		throw new MppRetryFailedError(receipt, cause);
+	}
+}
+function reportMppSettlement(client, intentId, response) {
+	try {
+		const receipt = Receipt.fromResponse(response);
+		if (!EVM_TRANSACTION_HASH_PATTERN.test(receipt.reference)) return;
+		reportSettlementHint(client, intentId, receipt.reference);
+	} catch {
+		return;
+	}
+}
+function prepareCatenaMppPayment(challenge, maxAtomicAmount) {
+	const method = challenge.method;
+	if (method !== "evm" && method !== "usdc") throw new Error(`Unsupported Catena MPP challenge ${challenge.method}/${challenge.intent}`);
+	const supported = supportedChallenge(method, challenge, maxAtomicAmount);
+	if (supported === void 0) throw new Error("Catena MPP charge challenge failed validation");
+	return {
+		challenge: {
+			id: challenge.id,
+			realm: challenge.realm,
+			method,
+			intent: "charge",
+			request: supported.request,
+			...challenge.description !== void 0 && { description: challenge.description },
+			...challenge.digest !== void 0 && { digest: challenge.digest },
+			expires: supported.expires,
+			...supported.header !== void 0 && { header: supported.header },
+			...challenge.opaque !== void 0 && { opaque: challenge.opaque }
+		},
+		terms: supported.terms
+	};
+}
+async function submitCatenaMppPayment(parameters, prepared, resourceUrl) {
+	const result = await parameters.client.submitIntent({ action: {
+		type: "mpp",
+		accountId: parameters.accountId,
+		challenge: prepared.challenge,
+		...resourceUrl !== void 0 && { resource: { url: resourceUrl } }
+	} });
+	return {
+		...prepared,
+		credential: credentialFromResult(result, prepared.challenge),
+		intentId: result.id
+	};
+}
+function supportedChallenge(method, challenge, maxAtomicAmount) {
+	if (challenge.method !== method || challenge.intent !== "charge") return;
+	const envelope = supportedEnvelope(challenge);
+	if (envelope === void 0) return;
+	const terms = method === "evm" ? supportedEvmRequest(challenge.request, maxAtomicAmount) : supportedUsdcRequest(challenge.request, maxAtomicAmount);
+	return terms === void 0 ? void 0 : {
+		...envelope,
+		terms
+	};
+}
+function exceedsMaximumAtomicAmount(challenge, maxAtomicAmount) {
+	if (maxAtomicAmount === void 0 || challenge.method !== "evm" && challenge.method !== "usdc") return false;
+	const supported = supportedChallenge(challenge.method, challenge, void 0);
+	return supported !== void 0 && BigInt(supported.terms.atomicAmount) > maxAtomicAmount;
+}
+function hasSupportedCommonRequest(request, maxAtomicAmount) {
+	return isCanonicalPositiveAmount(request.amount) && (maxAtomicAmount === void 0 || BigInt(request.amount) <= maxAtomicAmount) && isAddress$1(request.currency) && isAddress$1(request.recipient) && (request.description === void 0 || isCanonicalizableText(request.description, 1024)) && (request.externalId === void 0 || isCanonicalizableText(request.externalId, 256));
+}
+function isCanonicalizableText(value, maximumLength) {
+	if (value.length > maximumLength) return false;
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint !== void 0 && codePoint >= 55296 && codePoint <= 57343) return false;
+	}
+	return true;
+}
+function supportedEvmRequest(request, maxAtomicAmount) {
+	const result = evmRequestSchema.safeParse(request);
+	if (!result.success || !hasSupportedCommonRequest(result.data, maxAtomicAmount)) return;
+	const { amount, currency, methodDetails, recipient } = result.data;
+	const network = nativeUsdcNetwork(methodDetails.chainId, currency);
+	return isSupportedMethodDetails(methodDetails) && methodDetails.credentialTypes.length === 1 && network !== void 0 ? {
+		method: "evm",
+		atomicAmount: amount,
+		network,
+		recipient
+	} : void 0;
+}
+function supportedUsdcRequest(request, maxAtomicAmount) {
+	const result = usdcRequestSchema.safeParse(request);
+	if (!result.success || !hasSupportedCommonRequest(result.data, maxAtomicAmount)) return;
+	const { amount, currency, methodDetails, recipient } = result.data;
+	const details = methodDetails.evm;
+	const network = nativeUsdcNetwork(details.chainId, currency);
+	return isSupportedMethodDetails(details) && (details.credentialTypes === void 0 || details.credentialTypes.length === 1) && network !== void 0 ? {
+		method: "usdc",
+		atomicAmount: amount,
+		network,
+		recipient
+	} : void 0;
+}
+function isSupportedMethodDetails(details) {
+	return Number.isSafeInteger(details.chainId) && details.chainId >= 1 && (details.permit2Address === void 0 || isAddress$1(details.permit2Address));
+}
+function nativeUsdcNetwork(chainId, currency) {
+	if (chainId === 8453) return currency.toLowerCase() === BASE_USDC.toLowerCase() ? "eip155:8453" : void 0;
+	if (chainId === 84532) return currency.toLowerCase() === BASE_SEPOLIA_USDC.toLowerCase() ? "eip155:84532" : void 0;
+}
+function supportedEnvelope(challenge) {
+	if (!hasSupportedChallengeStrings(challenge)) return;
+	const expiresAt = Date.parse(challenge.expires);
+	const remaining = expiresAt - Date.now();
+	if (!Number.isFinite(expiresAt) || remaining < MIN_REMAINING_MS || remaining > MAX_VALIDITY_MS) return;
+	const request = PaymentRequest.serialize(challenge.request);
+	const serializedBytes = new TextEncoder().encode(JSON.stringify({
+		...challenge,
+		request
+	})).byteLength;
+	return request.length > 0 && request.length <= MAX_REQUEST_LENGTH && serializedBytes <= MAX_CHALLENGE_BYTES ? {
+		request,
+		expires: challenge.expires,
+		header: challenge.header
+	} : void 0;
+}
+function hasSupportedChallengeStrings(challenge) {
+	return !(challenge.id.length < 1 || challenge.id.length > 256 || challenge.realm.length < 1 || challenge.realm.length > 256 || challenge.expires === void 0 || !RFC3339_UTC_PATTERN.test(challenge.expires) || challenge.description !== void 0 && challenge.description.length > 1024 || challenge.header !== void 0 && challenge.header !== "Payment-Authorization" || challenge.opaque !== void 0 && (challenge.opaque.length > 8192 || !BASE64URL_PATTERN.test(challenge.opaque)) || challenge.digest !== void 0 && !isSupportedDigest(challenge.digest));
+}
+function isSupportedDigest(value) {
+	if (value.length > 128) return false;
+	const match = RFC9530_DIGEST_PATTERN.exec(value) ?? MPPX_0_9_DIGEST_PATTERN.exec(value);
+	if (!match) return false;
+	try {
+		const decoded = atob(match[1]);
+		return decoded.length === 32 && btoa(decoded) === match[1];
+	} catch {
+		return false;
+	}
+}
+function isCanonicalPositiveAmount(value) {
+	return value.length <= 78 && AMOUNT_PATTERN.test(value) && BigInt(value) > 0n;
+}
+function isAddress$1(value) {
+	return ADDRESS_PATTERN.test(value) && isAddress(value);
+}
+function credentialFromResult(result, selectedChallenge) {
+	switch (result.status) {
+		case "completed": {
+			const credential = paymentCredentialFromIntentData(result.data, "mpp");
+			if (credential === void 0) throw paymentError(`Catena MPP payment ${result.id} completed without an MPP credential`, result);
+			if (!isCredentialForChallenge(credential, selectedChallenge)) throw paymentError(`Catena MPP payment ${result.id} completed with a credential that does not match the selected challenge; reconcile with client.getIntent("${result.id}") before another payment attempt`, result);
+			return credential;
+		}
+		case "pending": throw paymentError(`Catena MPP payment ${result.id} is pending${formatReasons(result.reasons)}`, result);
+		case "processing": throw paymentError(`Catena MPP payment ${result.id} is processing; if it was approved, re-run the paid request so a fresh challenge can consume the grant (polling never advances an approved payment); otherwise poll client.getIntent("${result.id}"), because an executing payment completes on its own`, result);
+		case "blocked": throw paymentError(`Catena MPP payment ${result.id} was blocked${formatReasons(result.reasons)}`, result);
+		case "failed": throw paymentError(`Catena MPP payment ${result.id} failed${formatReasons(result.reasons)}`, result);
+	}
+	return assertNever(result.status);
+}
+function isCredentialForChallenge(value, expected) {
+	if (value.trim().length === 0 || value.includes("\r") || value.includes("\n")) return false;
+	let credential;
+	try {
+		credential = Credential.deserialize(value);
+	} catch {
+		return false;
+	}
+	const challenge = credential.challenge;
+	if (challenge.id !== expected.id || challenge.realm !== expected.realm || challenge.method !== expected.method || challenge.intent !== expected.intent || challenge.description !== expected.description || challenge.digest !== expected.digest || challenge.expires !== expected.expires || challenge.header !== expected.header || challenge.opaque !== expected.opaque || PaymentRequest.serialize(challenge.request) !== expected.request) return false;
+	const payload = authorizationPayloadSchema.safeParse(credential.payload);
+	const request = expected.method === "evm" ? evmRequestSchema.safeParse(challenge.request) : usdcRequestSchema.safeParse(challenge.request);
+	if (!payload.success || !request.success) return false;
+	const recipient = request.data.recipient;
+	return isAddress$1(payload.data.from) && isAddress$1(payload.data.to) && payload.data.to.toLowerCase() === recipient.toLowerCase() && payload.data.value === request.data.amount && isCanonicalAtomicValue(payload.data.validAfter) && isCanonicalAtomicValue(payload.data.validBefore) && BigInt(payload.data.validBefore) > BigInt(payload.data.validAfter) && /^0x[0-9a-fA-F]{64}$/.test(payload.data.nonce) && /^0x[0-9a-fA-F]{130}$/.test(payload.data.signature);
+}
+function isCanonicalAtomicValue(value) {
+	return value.length <= 78 && AMOUNT_PATTERN.test(value);
+}
+function paymentError(message, result) {
+	return new MppPaymentError(message, {
+		intentId: result.id,
+		status: result.status,
+		reasons: result.reasons,
+		expiresAt: result.expiresAt
+	});
+}
+function formatReasons(reasons) {
+	return reasons.length > 0 ? `: ${reasons.join("; ")}` : "";
+}
+//#endregion
+export { MppApprovalPendingError, MppCounterpartyNotFoundError, MppFetchPaymentError, MppNetworkMismatchError, MppPaymentDeclinedError, MppPaymentError, MppRetryFailedError, MppSubmitInterruptedError, catena, wrapFetchWithMppPayment };

package/dist/settlement-report-CT3EbtLL.mjs

@@ -0,0 +1,36 @@
+//#region src/lib/assert-never.ts
+function assertNever(value) {
+	throw new Error(`Unhandled case: ${String(value)}`);
+}
+//#endregion
+//#region src/lib/fetch-replay.ts
+function isReplayableFetchRequest(input, init) {
+	if (init?.body !== void 0 && init.body !== null) {
+		if (typeof init.body !== "string" && !(init.body instanceof URLSearchParams) && !(init.body instanceof Blob) && !(init.body instanceof ArrayBuffer) && !ArrayBuffer.isView(init.body)) return false;
+	}
+	if (typeof Request !== "undefined" && input instanceof Request) return input.body === null && !input.bodyUsed;
+	return true;
+}
+function fetchRetryHeaders(input, init) {
+	const headers = new Headers(typeof Request !== "undefined" && input instanceof Request ? input.headers : void 0);
+	new Headers(init?.headers).forEach((value, key) => {
+		headers.set(key, value);
+	});
+	return headers;
+}
+//#endregion
+//#region src/lib/settlement-report.ts
+const EVM_TRANSACTION_HASH_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+async function reportSettlementHint(client, intentId, txHash, receipt) {
+	try {
+		await client.reportSettlement({
+			intentId,
+			txHash,
+			...receipt !== void 0 && { receipt }
+		});
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { assertNever as a, isReplayableFetchRequest as i, reportSettlementHint as n, fetchRetryHeaders as r, EVM_TRANSACTION_HASH_PATTERN as t };