kassza 0.11.0 → 0.13.0

package/dist/payments/paypal.js

@@ -0,0 +1,337 @@
+import { i as encodeUtf8, n as bytesToBase64 } from "../binary-D0M9U2MD.js";
+import { r as roundMoney } from "../rounding-BLyHjjI5.js";
+import { a as readRawBody, d as normalizeCurrency, f as parseDecimalAmount, i as plainResponse, o as PaymentProviderError, r as parseJsonObject, s as WebhookVerificationError, t as respondToWebhook } from "../webhook-CrEGohbg.js";
+import { a as text, i as records, n as path, r as record, t as numeric } from "../json-DjnqnaJK.js";
+//#region src/payments/paypal.ts
+const PAYPAL_LIVE_API_URL = "https://api-m.paypal.com";
+const PAYPAL_SANDBOX_API_URL = "https://api-m.sandbox.paypal.com";
+const PAYPAL_METHOD = "PayPal";
+const PAYPAL_SHIPPING_ITEM_NAME = "Szállítási díj";
+const PAYPAL_HANDLING_ITEM_NAME = "Kezelési díj";
+const PAYPAL_INSURANCE_ITEM_NAME = "Biztosítás";
+const TOKEN_REFRESH_MARGIN_MS = 6e4;
+const AMOUNT_TOLERANCE = .005;
+const UNAUTHORIZED = 401;
+const TRANSMISSION_HEADERS = {
+	authAlgo: "paypal-auth-algo",
+	certUrl: "paypal-cert-url",
+	transmissionId: "paypal-transmission-id",
+	transmissionSig: "paypal-transmission-sig",
+	transmissionTime: "paypal-transmission-time"
+};
+function apiBase(options) {
+	return (options.apiUrl ?? (options.sandbox ? "https://api-m.sandbox.paypal.com" : "https://api-m.paypal.com")).replace(/\/+$/, "");
+}
+async function readJson(response, what) {
+	const json = record(await response.json().catch(() => void 0));
+	if (!response.ok || !json) {
+		const detail = text(json?.message) ?? text(json?.error_description) ?? text(json?.name);
+		throw new PaymentProviderError("paypal", `A PayPal ${what} nem sikerült (HTTP ${response.status})${detail ? `: ${detail}` : ""}.`, response.status);
+	}
+	return json;
+}
+function payPalApi(options) {
+	const clientId = options.clientId?.trim();
+	const clientSecret = options.clientSecret?.trim();
+	if (!clientId || !clientSecret) throw new TypeError("Add meg a PayPal REST alkalmazás clientId és clientSecret adatát.");
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	const base = apiBase(options);
+	const now = options.now ?? Date.now;
+	let cached;
+	async function fetchOrThrow(url, init, what) {
+		try {
+			return await fetchImpl(url, init);
+		} catch (error) {
+			throw new PaymentProviderError("paypal", `A PayPal ${what} nem sikerült.`, void 0, error);
+		}
+	}
+	async function token() {
+		if (cached && cached.expiresAt > now()) return cached.value;
+		const credentials = bytesToBase64(encodeUtf8(`${clientId}:${clientSecret}`));
+		const json = await readJson(await fetchOrThrow(`${base}/v1/oauth2/token`, {
+			method: "POST",
+			headers: {
+				authorization: `Basic ${credentials}`,
+				"content-type": "application/x-www-form-urlencoded",
+				accept: "application/json"
+			},
+			body: "grant_type=client_credentials"
+		}, "hozzáférési token kérése"), "hozzáférési token kérése");
+		const value = text(json.access_token);
+		if (!value) throw new PaymentProviderError("paypal", "A PayPal token válaszából hiányzik az access_token.");
+		const lifetimeMs = (numeric(json.expires_in) ?? 0) * 1e3;
+		cached = {
+			value,
+			expiresAt: now() + Math.max(0, lifetimeMs - TOKEN_REFRESH_MARGIN_MS)
+		};
+		return value;
+	}
+	async function send(method, pathname, body) {
+		const what = `${method} ${pathname} hívás`;
+		const attempt = async () => fetchOrThrow(`${base}${pathname}`, {
+			method,
+			headers: {
+				authorization: `Bearer ${await token()}`,
+				accept: "application/json",
+				...body === void 0 ? {} : { "content-type": "application/json" }
+			},
+			...body === void 0 ? {} : { body }
+		}, what);
+		let response = await attempt();
+		if (response.status === UNAUTHORIZED) {
+			cached = void 0;
+			response = await attempt();
+		}
+		return readJson(response, what);
+	}
+	return {
+		get: (pathname) => send("GET", pathname),
+		post: (pathname, body) => send("POST", pathname, body)
+	};
+}
+function payPalTransmission(headers) {
+	const authAlgo = headers.get(TRANSMISSION_HEADERS.authAlgo)?.trim();
+	const certUrl = headers.get(TRANSMISSION_HEADERS.certUrl)?.trim();
+	const transmissionId = headers.get(TRANSMISSION_HEADERS.transmissionId)?.trim();
+	const transmissionSig = headers.get(TRANSMISSION_HEADERS.transmissionSig)?.trim();
+	const transmissionTime = headers.get(TRANSMISSION_HEADERS.transmissionTime)?.trim();
+	if (!authAlgo || !certUrl || !transmissionId || !transmissionSig || !transmissionTime) return;
+	return {
+		authAlgo,
+		certUrl,
+		transmissionId,
+		transmissionSig,
+		transmissionTime
+	};
+}
+async function verifyPayPalWebhook(payload, headers, webhookId, api) {
+	const transmission = payPalTransmission(headers);
+	if (!transmission) throw new WebhookVerificationError("paypal", "missing_signature", "Hiányoznak a PayPal webhook PAYPAL-TRANSMISSION-* és PAYPAL-AUTH-ALGO fejlécei.");
+	parseJsonObject("paypal", payload);
+	const body = [
+		`{"auth_algo":${JSON.stringify(transmission.authAlgo)}`,
+		`"cert_url":${JSON.stringify(transmission.certUrl)}`,
+		`"transmission_id":${JSON.stringify(transmission.transmissionId)}`,
+		`"transmission_sig":${JSON.stringify(transmission.transmissionSig)}`,
+		`"transmission_time":${JSON.stringify(transmission.transmissionTime)}`,
+		`"webhook_id":${JSON.stringify(webhookId)}`,
+		`"webhook_event":${payload.trim()}}`
+	].join(",");
+	const result = await api.post("/v1/notifications/verify-webhook-signature", body);
+	if (text(result.verification_status) !== "SUCCESS") throw new WebhookVerificationError("paypal", "invalid_signature", "A PayPal szerint a webhook aláírása érvénytelen.");
+}
+function parsePayPalEvent(payload) {
+	const json = parseJsonObject("paypal", payload);
+	const id = text(json.id);
+	const eventType = text(json.event_type);
+	const resource = record(json.resource);
+	if (!id || !eventType || !resource) throw new WebhookVerificationError("paypal", "invalid_payload", "A PayPal eseményből hiányzik az id, az event_type vagy a resource.");
+	return {
+		id,
+		eventType,
+		resourceType: text(json.resource_type),
+		createTime: text(json.create_time),
+		resource,
+		raw: json
+	};
+}
+function moneyValue(value) {
+	const amount = text(record(value)?.value);
+	return amount === void 0 ? void 0 : parseDecimalAmount(amount);
+}
+function moneyOf(value) {
+	const amount = moneyValue(value);
+	const currency = text(record(value)?.currency_code);
+	if (amount === void 0 || !currency) return void 0;
+	return {
+		value: amount,
+		currency: normalizeCurrency(currency)
+	};
+}
+function payPalCaptureIdOfRefund(refund) {
+	const up = records(refund.links).find((link) => text(link.rel) === "up");
+	const href = text(up?.href);
+	if (!href) return void 0;
+	const match = /\/captures\/([^/?#]+)/.exec(href);
+	return match?.[1] ? decodeURIComponent(match[1]) : void 0;
+}
+function payPalOrderIdOfCapture(capture) {
+	return text(path(capture, "supplementary_data", "related_ids", "order_id"));
+}
+function addressOf(address) {
+	if (!address) return void 0;
+	return {
+		country: text(address.country_code),
+		zip: text(address.postal_code),
+		city: text(address.admin_area_2),
+		line1: text(address.address_line_1),
+		line2: text(address.address_line_2)
+	};
+}
+function personName(name, country) {
+	const full = text(name?.full_name);
+	if (full) return full;
+	const given = text(name?.given_name);
+	const surname = text(name?.surname);
+	const joined = (country === "HU" ? [surname, given] : [given, surname]).filter(Boolean).join(" ");
+	return joined === "" ? void 0 : joined;
+}
+function customerOf(order) {
+	if (!order) return void 0;
+	const payer = record(order.payer);
+	const shipping = record(records(order.purchase_units)[0]?.shipping);
+	const payerAddress = addressOf(record(payer?.address));
+	const shippingAddress = addressOf(record(shipping?.address));
+	const address = payerAddress?.line1 ? payerAddress : shippingAddress ?? payerAddress;
+	const name = personName(record(payer?.name), address?.country) ?? text(path(shipping, "name", "full_name"));
+	const email = text(payer?.email_address);
+	if (!name && !email && !address) return void 0;
+	return {
+		name,
+		email,
+		phone: text(path(payer, "phone", "phone_number", "national_number")),
+		address
+	};
+}
+function sameCurrency(values, currency) {
+	return values.every((value) => {
+		const code = text(record(value)?.currency_code);
+		return code === void 0 || normalizeCurrency(code) === currency;
+	});
+}
+function extraItem(value, name) {
+	const amount = moneyValue(value) ?? 0;
+	return amount > 0 ? [{
+		name,
+		quantity: 1,
+		totalGross: amount
+	}] : [];
+}
+function itemsOf(order, currency) {
+	const units = records(order?.purchase_units);
+	const unit = units[0];
+	if (!unit || units.length !== 1 || !currency) return void 0;
+	const breakdown = record(path(unit, "amount", "breakdown"));
+	const discount = (moneyValue(breakdown?.discount) ?? 0) + (moneyValue(breakdown?.shipping_discount) ?? 0);
+	const items = records(unit.items);
+	if (discount > 0 || items.length === 0) return void 0;
+	if ((moneyValue(breakdown?.tax_total) ?? 0) > 0 && !items.every((item) => record(item.tax))) return void 0;
+	if (!sameCurrency([
+		...items.flatMap((item) => [item.unit_amount, item.tax]),
+		breakdown?.shipping,
+		breakdown?.handling,
+		breakdown?.insurance
+	], currency)) return void 0;
+	return [
+		...items.map((item) => {
+			const quantity = numeric(item.quantity) ?? 1;
+			const unitGross = (moneyValue(item.unit_amount) ?? 0) + (moneyValue(item.tax) ?? 0);
+			return {
+				name: text(item.name) ?? "Tétel",
+				quantity,
+				totalGross: roundMoney(unitGross * quantity, 2),
+				sku: text(item.sku)
+			};
+		}),
+		...extraItem(breakdown?.shipping, PAYPAL_SHIPPING_ITEM_NAME),
+		...extraItem(breakdown?.handling, PAYPAL_HANDLING_ITEM_NAME),
+		...extraItem(breakdown?.insurance, PAYPAL_INSURANCE_ITEM_NAME)
+	];
+}
+function orderRefOf(resource, order) {
+	const unit = records(order?.purchase_units)[0];
+	return text(resource.custom_id) ?? text(resource.invoice_id) ?? text(unit?.custom_id) ?? text(unit?.invoice_id) ?? text(unit?.reference_id);
+}
+function fromCapture(event, kind, options) {
+	const capture = event.resource;
+	const id = text(capture.id);
+	if (!id) throw new PaymentProviderError("paypal", "A PayPal capture eseményből hiányzik az id.");
+	const amount = moneyOf(capture.amount);
+	const status = text(capture.status);
+	return {
+		provider: "paypal",
+		kind: kind === "paid" && status !== void 0 && status !== "COMPLETED" ? "other" : kind,
+		id,
+		eventId: event.id,
+		eventType: event.eventType,
+		orderRef: orderRefOf(capture, options.order),
+		amount,
+		paidAt: text(capture.create_time) ?? event.createTime,
+		method: options.method ?? "PayPal",
+		customer: customerOf(options.order),
+		items: kind === "paid" ? itemsOf(options.order, amount?.currency) : void 0,
+		raw: event.raw
+	};
+}
+function refundKind(refund, capture) {
+	if (text(refund.status) !== "COMPLETED") return "other";
+	const refunded = moneyValue(refund.amount);
+	const captured = moneyValue(capture?.amount);
+	if (refunded === void 0 || captured === void 0) return "partially-refunded";
+	return Math.abs(refunded - captured) <= AMOUNT_TOLERANCE ? "refunded" : "partially-refunded";
+}
+function fromRefund(event, options) {
+	const refund = event.resource;
+	const captureId = payPalCaptureIdOfRefund(refund);
+	if (!captureId) throw new PaymentProviderError("paypal", "A PayPal visszatérítésből nem olvasható ki az eredeti capture azonosítója.");
+	const capture = options.capture && text(options.capture.id) === captureId ? options.capture : void 0;
+	return {
+		provider: "paypal",
+		kind: refundKind(refund, capture),
+		id: captureId,
+		eventId: event.id,
+		eventType: event.eventType,
+		orderRef: orderRefOf(refund, void 0) ?? (capture ? orderRefOf(capture, void 0) : void 0),
+		amount: moneyOf(capture?.amount),
+		refundedAmount: moneyOf(path(refund, "seller_payable_breakdown", "total_refunded_amount")) ?? moneyOf(refund.amount),
+		paidAt: text(refund.create_time) ?? event.createTime,
+		method: options.method ?? "PayPal",
+		raw: event.raw
+	};
+}
+function payPalPaymentEvent(event, options = {}) {
+	switch (event.eventType) {
+		case "PAYMENT.CAPTURE.COMPLETED": return fromCapture(event, "paid", options);
+		case "PAYMENT.CAPTURE.DENIED":
+		case "PAYMENT.CAPTURE.DECLINED": return fromCapture(event, "failed", options);
+		case "PAYMENT.CAPTURE.PENDING": return fromCapture(event, "other", options);
+		case "PAYMENT.CAPTURE.REFUNDED": return fromRefund(event, options);
+		default: return;
+	}
+}
+async function loadExtras(event, api, options) {
+	if (event.eventType === "PAYMENT.CAPTURE.REFUNDED") {
+		const captureId = payPalCaptureIdOfRefund(event.resource);
+		if (!captureId) return {};
+		return { capture: await api.get(`/v2/payments/captures/${encodeURIComponent(captureId)}`) };
+	}
+	if (event.eventType !== "PAYMENT.CAPTURE.COMPLETED" || options.fetchOrder === false) return {};
+	const orderId = payPalOrderIdOfCapture(event.resource);
+	if (!orderId) return {};
+	return { order: await api.get(`/v2/checkout/orders/${encodeURIComponent(orderId)}`) };
+}
+function payPalWebhook(options) {
+	const webhookId = options.webhookId?.trim();
+	if (!webhookId) throw new TypeError("Add meg a PayPal webhook azonosítóját (webhookId).");
+	const api = payPalApi({
+		clientId: options.clientId,
+		clientSecret: options.clientSecret,
+		sandbox: options.sandbox,
+		apiUrl: options.apiUrl,
+		fetch: options.fetch
+	});
+	return (request) => respondToWebhook(options, async () => {
+		const payload = await readRawBody(request, "paypal", options.maxBodyBytes);
+		await verifyPayPalWebhook(payload, request.headers, webhookId, api);
+		const event = parsePayPalEvent(payload);
+		const extras = await loadExtras(event, api, options);
+		const payment = payPalPaymentEvent(event, {
+			method: options.method,
+			...extras
+		});
+		if (payment) await options.onPayment(payment);
+		return plainResponse(200, "OK");
+	});
+}
+//#endregion
+export { PAYPAL_HANDLING_ITEM_NAME, PAYPAL_INSURANCE_ITEM_NAME, PAYPAL_LIVE_API_URL, PAYPAL_METHOD, PAYPAL_SANDBOX_API_URL, PAYPAL_SHIPPING_ITEM_NAME, parsePayPalEvent, payPalApi, payPalCaptureIdOfRefund, payPalOrderIdOfCapture, payPalPaymentEvent, payPalTransmission, payPalWebhook, verifyPayPalWebhook };

package/dist/payments/revolut.cjs

@@ -0,0 +1,261 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_crypto = require("../crypto-Dpn4FHQ6.cjs");
+const require_webhook = require("../webhook-81giRMdQ.cjs");
+const require_json = require("../json-4y4E2xxS.cjs");
+//#region src/payments/revolut.ts
+const REVOLUT_LIVE_API_URL = "https://merchant.revolut.com";
+const REVOLUT_SANDBOX_API_URL = "https://sandbox-merchant.revolut.com";
+const REVOLUT_API_VERSION = "2026-08-17";
+const REVOLUT_DEFAULT_TOLERANCE_MS = 3e5;
+const REVOLUT_CARD_METHOD = "bankkártya";
+const REVOLUT_ACCOUNT_METHOD = "Revolut Pay";
+const REVOLUT_DIRECT_DEBIT_METHOD = "csoportos beszedés";
+const SIGNATURE_VERSION = "v1";
+const ORDER_EVENTS = /* @__PURE__ */ new Set(["ORDER_COMPLETED"]);
+const FAILED_EVENTS = /* @__PURE__ */ new Set([
+	"ORDER_CANCELLED",
+	"ORDER_FAILED",
+	"ORDER_PAYMENT_DECLINED",
+	"ORDER_PAYMENT_FAILED"
+]);
+const OTHER_EVENTS = /* @__PURE__ */ new Set(["ORDER_AUTHORISED"]);
+const SALE_ORDER_TYPES = /* @__PURE__ */ new Set(["payment", "payment_request"]);
+function secretsOf(secret) {
+	const list = (typeof secret === "string" ? [secret] : [...secret]).map((value) => value.trim());
+	if (list.length === 0 || list.some((value) => value === "")) throw new TypeError("Add meg a Revolut webhook aláíró titkát (wsk_...).");
+	return list;
+}
+function signaturesOf(header) {
+	return header.split(",").map((part) => part.trim()).filter((part) => part.startsWith(`${SIGNATURE_VERSION}=`));
+}
+async function verifyRevolutSignature(payload, signatureHeader, timestampHeader, secret, options = {}) {
+	const secrets = secretsOf(secret);
+	const signatures = signatureHeader ? signaturesOf(signatureHeader) : [];
+	const timestamp = timestampHeader?.trim();
+	if (signatures.length === 0 || !timestamp) throw new require_webhook.WebhookVerificationError("revolut", "missing_signature", "Hiányzik a Revolut-Signature vagy a Revolut-Request-Timestamp fejléc.");
+	if (!/^\d+$/.test(timestamp)) throw new require_webhook.WebhookVerificationError("revolut", "invalid_signature", "A Revolut-Request-Timestamp fejléc nem ezredmásodperces UNIX időbélyeg.");
+	const tolerance = options.toleranceMs ?? 3e5;
+	const now = options.now?.() ?? Date.now();
+	if (tolerance > 0 && Math.abs(now - Number(timestamp)) > tolerance) throw new require_webhook.WebhookVerificationError("revolut", "timestamp_out_of_range", `A Revolut esemény időbélyege több mint ${Math.round(tolerance / 1e3)} másodperccel eltér.`);
+	const message = `${SIGNATURE_VERSION}.${timestamp}.${payload}`;
+	for (const key of secrets) {
+		const expected = `${SIGNATURE_VERSION}=${await require_crypto.hmacHex("SHA-256", key, message)}`;
+		if (signatures.some((signature) => require_crypto.timingSafeEqual(signature, expected))) return;
+	}
+	throw new require_webhook.WebhookVerificationError("revolut", "invalid_signature", "A Revolut aláírás nem egyezik.");
+}
+function parseRevolutEvent(payload) {
+	const json = require_webhook.parseJsonObject("revolut", payload);
+	const event = require_json.text(json.event);
+	if (!event) throw new require_webhook.WebhookVerificationError("revolut", "invalid_payload", "A Revolut eseményből hiányzik az event mező.");
+	return {
+		event,
+		orderId: require_json.text(json.order_id),
+		merchantOrderRef: require_json.text(json.merchant_order_ext_ref),
+		raw: json
+	};
+}
+function apiBase(options) {
+	return (options.apiUrl ?? (options.sandbox ? "https://sandbox-merchant.revolut.com" : "https://merchant.revolut.com")).replace(/\/+$/, "");
+}
+async function fetchRevolutOrder(orderId, options) {
+	const fetchImpl = options.fetch ?? globalThis.fetch;
+	let response;
+	try {
+		response = await fetchImpl(`${apiBase(options)}/api/orders/${encodeURIComponent(orderId)}`, { headers: {
+			authorization: `Bearer ${options.apiKey}`,
+			"revolut-api-version": options.apiVersion ?? "2026-08-17",
+			accept: "application/json"
+		} });
+	} catch (error) {
+		throw new require_webhook.PaymentProviderError("revolut", "A Revolut rendelés lekérése nem sikerült.", void 0, error);
+	}
+	if (!response.ok) throw new require_webhook.PaymentProviderError("revolut", `A Revolut rendelés lekérése nem sikerült (HTTP ${response.status}).`, response.status);
+	const order = require_json.record(await response.json().catch(() => void 0));
+	if (!order || require_json.text(order.id) === void 0) throw new require_webhook.PaymentProviderError("revolut", "A Revolut rendelés válasza nem értelmezhető.");
+	return order;
+}
+function amountOf(order, key) {
+	const minor = require_json.numeric(order[key]);
+	const currency = require_json.text(order.currency);
+	if (minor === void 0 || !currency) return void 0;
+	return {
+		value: require_webhook.fromMinorUnits(minor, currency, "iso4217"),
+		currency: require_webhook.normalizeCurrency(currency)
+	};
+}
+function addressOf(address) {
+	if (!address) return void 0;
+	return {
+		country: require_json.text(address.country_code),
+		zip: require_json.text(address.postcode),
+		city: require_json.text(address.city),
+		line1: require_json.text(address.street_line_1),
+		line2: require_json.text(address.street_line_2)
+	};
+}
+function completedPayment(order) {
+	const payments = require_json.records(order.payments);
+	return payments.find((payment) => ["completed", "captured"].includes(require_json.text(payment.state) ?? "")) ?? payments.at(-1);
+}
+function customerOf(order) {
+	const customer = require_json.record(order.customer);
+	const payment = completedPayment(order);
+	const shipping = require_json.record(order.shipping);
+	const contact = require_json.record(shipping?.contact);
+	const address = addressOf(require_json.record(payment?.billing_address)) ?? addressOf(require_json.record(shipping?.address));
+	const name = require_json.text(customer?.full_name) ?? require_json.text(contact?.name);
+	const email = require_json.text(customer?.email) ?? require_json.text(contact?.email);
+	if (!name && !email && !address) return void 0;
+	return {
+		name,
+		email,
+		phone: require_json.text(customer?.phone) ?? require_json.text(contact?.phone),
+		address
+	};
+}
+function itemsOf(order) {
+	const currency = require_json.text(order.currency);
+	if (!currency) return void 0;
+	const items = require_json.records(order.line_items).map((item) => {
+		const total = require_json.numeric(item.total_amount);
+		if (total === void 0) throw new require_webhook.PaymentProviderError("revolut", "A Revolut tételből hiányzik a total_amount.");
+		return {
+			name: require_json.text(item.name) ?? "Tétel",
+			quantity: require_json.numeric(require_json.path(item, "quantity", "value")) ?? 1,
+			totalGross: require_webhook.fromMinorUnits(total, currency, "iso4217"),
+			unit: require_json.text(require_json.path(item, "quantity", "unit")),
+			sku: require_json.text(item.external_id)
+		};
+	});
+	return items.length > 0 ? items : void 0;
+}
+function methodOf(order, configured) {
+	if (configured) return configured;
+	const type = require_json.text(require_json.path(completedPayment(order), "payment_method", "type"));
+	if (type === "revolut_pay_account" || type === "revolut_pay") return REVOLUT_ACCOUNT_METHOD;
+	if (type === "sepa_direct_debit") return REVOLUT_DIRECT_DEBIT_METHOD;
+	return REVOLUT_CARD_METHOD;
+}
+function orderRefOf(order, event) {
+	return require_json.text(require_json.path(order, "merchant_order_data", "reference")) ?? event.merchantOrderRef;
+}
+function eventBase(event, kind, id, method) {
+	return {
+		provider: "revolut",
+		kind,
+		id,
+		eventId: `${event.event}:${event.orderId ?? id}`,
+		eventType: event.event,
+		method,
+		raw: event.raw
+	};
+}
+function fromSaleOrder(event, order, options) {
+	const id = require_json.text(order.id) ?? event.orderId ?? "";
+	assertCompleted(order);
+	return {
+		...eventBase(event, "paid", id, methodOf(order, options.method)),
+		orderRef: orderRefOf(order, event),
+		amount: amountOf(order, "amount"),
+		paidAt: require_json.text(order.updated_at),
+		customer: customerOf(order),
+		items: itemsOf(order)
+	};
+}
+function assertCompleted(order) {
+	const state = require_json.text(order.state);
+	if (state !== "completed") throw new require_webhook.PaymentProviderError("revolut", `A(z) ${require_json.text(order.id) ?? "?"} Revolut rendelés állapota ${state ?? "ismeretlen"}, nem completed; a webhook újraküldésekor újra megnézzük.`);
+}
+function refundKind(refund, original) {
+	const refundAmount = require_json.numeric(refund.amount);
+	const originalAmount = require_json.numeric(original.amount);
+	const refundedTotal = require_json.numeric(original.refunded_amount);
+	return refundAmount !== void 0 && refundAmount === originalAmount && refundedTotal === refundAmount ? "refunded" : "partially-refunded";
+}
+function fromRefundOrder(event, refund, options) {
+	const original = options.originalOrder;
+	const originalId = require_json.text(refund.related_order_id);
+	if (!original || !originalId || require_json.text(original.id) !== originalId) throw new require_webhook.PaymentProviderError("revolut", "A Revolut visszatérítéshez nem található az eredeti rendelés.");
+	assertCompleted(refund);
+	return {
+		...eventBase(event, refundKind(refund, original), originalId, methodOf(original, options.method)),
+		orderRef: orderRefOf(original, event),
+		amount: amountOf(original, "amount"),
+		refundedAmount: amountOf(original, "refunded_amount") ?? amountOf(refund, "amount"),
+		paidAt: require_json.text(refund.updated_at),
+		customer: customerOf(original)
+	};
+}
+function revolutPaymentEvent(event, options = {}) {
+	const orderId = event.orderId;
+	if (!orderId) return void 0;
+	if (FAILED_EVENTS.has(event.event)) return {
+		...eventBase(event, "failed", orderId, options.method ?? "bankkártya"),
+		orderRef: event.merchantOrderRef
+	};
+	if (OTHER_EVENTS.has(event.event)) return {
+		...eventBase(event, "other", orderId, options.method ?? "bankkártya"),
+		orderRef: event.merchantOrderRef
+	};
+	if (!ORDER_EVENTS.has(event.event)) return void 0;
+	const order = options.order;
+	if (!order || require_json.text(order.id) !== orderId) throw new require_webhook.PaymentProviderError("revolut", `A(z) ${event.event} eseményhez le kell kérni a(z) ${orderId} rendelést.`);
+	const type = require_json.text(order.type) ?? "payment";
+	if (type === "refund") return fromRefundOrder(event, order, options);
+	if (SALE_ORDER_TYPES.has(type)) return fromSaleOrder(event, order, options);
+	return {
+		...eventBase(event, "other", orderId, methodOf(order, options.method)),
+		orderRef: orderRefOf(order, event)
+	};
+}
+async function loadOrders(event, api) {
+	if (!event.orderId || !ORDER_EVENTS.has(event.event)) return {};
+	const order = await fetchRevolutOrder(event.orderId, api);
+	const relatedId = require_json.text(order.type) === "refund" ? require_json.text(order.related_order_id) : void 0;
+	if (!relatedId) return { order };
+	return {
+		order,
+		originalOrder: await fetchRevolutOrder(relatedId, api)
+	};
+}
+function revolutWebhook(options) {
+	secretsOf(options.secret);
+	const apiKey = options.apiKey?.trim();
+	if (!apiKey) throw new TypeError("Add meg a Revolut titkos API-kulcsot (apiKey): a webhook csak a rendelés azonosítóját küldi.");
+	const api = {
+		apiKey,
+		sandbox: options.sandbox,
+		apiUrl: options.apiUrl,
+		apiVersion: options.apiVersion,
+		fetch: options.fetch
+	};
+	return (request) => require_webhook.respondToWebhook(options, async () => {
+		const payload = await require_webhook.readRawBody(request, "revolut", options.maxBodyBytes);
+		await verifyRevolutSignature(payload, request.headers.get("revolut-signature"), request.headers.get("revolut-request-timestamp"), options.secret, {
+			toleranceMs: options.toleranceMs,
+			now: options.now
+		});
+		const event = parseRevolutEvent(payload);
+		const orders = await loadOrders(event, api);
+		const payment = revolutPaymentEvent(event, {
+			method: options.method,
+			...orders
+		});
+		if (payment) await options.onPayment(payment);
+		return new Response(null, { status: 204 });
+	});
+}
+//#endregion
+exports.REVOLUT_ACCOUNT_METHOD = REVOLUT_ACCOUNT_METHOD;
+exports.REVOLUT_API_VERSION = REVOLUT_API_VERSION;
+exports.REVOLUT_CARD_METHOD = REVOLUT_CARD_METHOD;
+exports.REVOLUT_DEFAULT_TOLERANCE_MS = REVOLUT_DEFAULT_TOLERANCE_MS;
+exports.REVOLUT_DIRECT_DEBIT_METHOD = REVOLUT_DIRECT_DEBIT_METHOD;
+exports.REVOLUT_LIVE_API_URL = REVOLUT_LIVE_API_URL;
+exports.REVOLUT_SANDBOX_API_URL = REVOLUT_SANDBOX_API_URL;
+exports.fetchRevolutOrder = fetchRevolutOrder;
+exports.parseRevolutEvent = parseRevolutEvent;
+exports.revolutPaymentEvent = revolutPaymentEvent;
+exports.revolutWebhook = revolutWebhook;
+exports.verifyRevolutSignature = verifyRevolutSignature;

package/dist/payments/revolut.d.cts

@@ -0,0 +1,48 @@
+import { i as PaymentEvent, l as PaymentWebhookBaseOptions } from "../types-BVeR7KyU.cjs";
+import { t as JsonRecord } from "../json-B70TwoX1.cjs";
+import { t as WebhookHandler } from "../webhook-CpMJuP6c.cjs";
+//#region src/payments/revolut.d.ts
+export declare const REVOLUT_LIVE_API_URL = "https://merchant.revolut.com";
+export declare const REVOLUT_SANDBOX_API_URL = "https://sandbox-merchant.revolut.com";
+export declare const REVOLUT_API_VERSION = "2026-08-17";
+export declare const REVOLUT_DEFAULT_TOLERANCE_MS = 3e5;
+export declare const REVOLUT_CARD_METHOD = "bankkártya";
+export declare const REVOLUT_ACCOUNT_METHOD = "Revolut Pay";
+export declare const REVOLUT_DIRECT_DEBIT_METHOD = "csoportos beszedés";
+export interface VerifyRevolutSignatureOptions {
+  readonly toleranceMs?: number | undefined;
+  readonly now?: (() => number) | undefined;
+}
+export declare function verifyRevolutSignature(payload: string, signatureHeader: string | null | undefined, timestampHeader: string | null | undefined, secret: string | readonly string[], options?: VerifyRevolutSignatureOptions): Promise<void>;
+export interface RevolutEvent {
+  readonly event: string;
+  readonly orderId?: string | undefined;
+  readonly merchantOrderRef?: string | undefined;
+  readonly raw: JsonRecord;
+}
+export declare function parseRevolutEvent(payload: string): RevolutEvent;
+export interface RevolutApiOptions {
+  readonly apiKey: string;
+  readonly sandbox?: boolean | undefined;
+  readonly apiUrl?: string | undefined;
+  readonly apiVersion?: string | undefined;
+  readonly fetch?: typeof globalThis.fetch | undefined;
+}
+export declare function fetchRevolutOrder(orderId: string, options: RevolutApiOptions): Promise<JsonRecord>;
+export interface RevolutPaymentOptions {
+  readonly method?: string | undefined;
+  readonly order?: JsonRecord | undefined;
+  readonly originalOrder?: JsonRecord | undefined;
+}
+export declare function revolutPaymentEvent(event: RevolutEvent, options?: RevolutPaymentOptions): PaymentEvent | undefined;
+export interface RevolutWebhookOptions extends PaymentWebhookBaseOptions {
+  readonly secret: string | readonly string[];
+  readonly apiKey: string;
+  readonly sandbox?: boolean | undefined;
+  readonly apiUrl?: string | undefined;
+  readonly apiVersion?: string | undefined;
+  readonly toleranceMs?: number | undefined;
+  readonly now?: (() => number) | undefined;
+}
+export declare function revolutWebhook(options: RevolutWebhookOptions): WebhookHandler;
+//#endregion