@amboras-dev/money 0.2.0 → 0.4.0

package/dist/{wire-sW0yzqth.js → wire-B4QU8O3W.js}

@@ -1,32 +1,9 @@
-import { $ as describeValue, C as medusaCurrencyCode, Q as MoneyError, X as mulDiv, c as toMajorDecimal, ct as normalizeDecimal, dt as roundToScale, ft as strictNumberDecimal, it as formatDecimal, k as storageExponent, lt as parseDecimal, mt as unitsWithin, n as fromMajor, o as readStored, pt as toDecimalText, rt as divRound, s as storedDecimal, t as boundedMoney, ut as pow10, y as findCurrency } from "./money-WhnGiI00.js";
-import { n as allocateUnits } from "./allocate-X7_jAtOj.js";
-import { t as hasOwnKey } from "./own-D7544D3k.js";
-import { n as isoMinorFactor } from "./iso-minor-CqkWDxHS.js";
-import { n as readNumberText } from "./number-text-DE-q4jO5.js";
-//#region src/wire/anet.ts
-const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-/**
-* The first `"<field>": <decimal>` (quoted or not) in a raw JSON body, verbatim: `JSON.parse`
-* would turn the gateway's `43.00` into `43`. The value is the whole JSON token, held to
-* `parseDecimal`'s `'plain'` grammar (`1e3` or `"43.10abc"` is not a decimal literal).
-* Undefined when absent; there is no lossy fallback.
-*/
-function jsonDecimalLiteral(rawBody, field) {
-	if (typeof rawBody !== "string" || typeof field !== "string") return void 0;
-	const tokens = rawBody.matchAll(new RegExp(`"${escapeRegExp(field)}"\\s*:\\s*("?)([^"\\s,}\\]]+)\\1`, "g"));
-	for (const [, , token] of tokens) if (parseDecimal(token, "plain")) return token;
-}
-const isPositiveLiteral = (text) => {
-	const value = parseDecimal(text.trim());
-	return value !== null && value.units > 0n;
-};
-function authorizeNetReversibleAmount(details) {
-	const settle = details.settleAmount ?? void 0;
-	if (settle !== void 0 && isPositiveLiteral(settle)) return settle;
-	return details.authAmount ?? settle;
-}
-//#endregion
-//#region src/data/psp.ts
+import { $ as describeValue, C as medusaCurrencyCode, Q as MoneyError, X as mulDiv, c as toMajorDecimal, ct as normalizeDecimal, dt as roundToScale, et as addDecimal, ft as strictNumberDecimal, it as formatDecimal, k as storageExponent, lt as parseDecimal, mt as unitsWithin, n as fromMajor, o as readStored, pt as toDecimalText, rt as divRound, s as storedDecimal, t as boundedMoney, tt as compareDecimal, ut as pow10, y as findCurrency } from "./money-BxbAw7BP.js";
+import { n as allocateUnits } from "./allocate-BBRfdaSC.js";
+import { t as hasOwnKey } from "./own-DHxqIYqL.js";
+import { n as isoMinorFactor } from "./iso-minor-odkY-e6I.js";
+import { n as readNumberText } from "./number-text-Bj-gZXiF.js";
+// src/data/psp.ts
 /** developer.paypal.com/reference/currency-codes ("Last updated: August 17, 2026"). */
 const PAYPAL_CURRENCY_DIGITS = {
 	0: [
@@ -519,15 +496,17 @@ const RAZORPAY_CURRENCY_EXPONENTS = {
 		"TND"
 	]
 };
-/** Paystack: "If we notice a fractional part during processing, we ignore the fractional part." */
-const PAYSTACK_CURRENCY_DIGITS = { 2: [
+/** paystack.com/docs/api/#supported-currency (retrieved 2026-10-07): every currency a Paystack account can charge. */
+const PAYSTACK_CURRENCIES = [
 	"GHS",
 	"KES",
 	"NGN",
 	"USD",
 	"XOF",
 	"ZAR"
-] };
+];
+/** Paystack: "If we notice a fractional part during processing, we ignore the fractional part." */
+const PAYSTACK_CURRENCY_DIGITS = { 2: PAYSTACK_CURRENCIES };
 /** Factor-1 overrides: ISO zero-decimal codes the PSP wants at two decimals (storage and wire agree). */
 const STRIPE_SENT_AS_TWO_DECIMAL = ["ISK", "UGX"];
 const ADYEN_SENT_AS_TWO_DECIMAL = ["ISK", "CLP"];
@@ -1000,6 +979,101 @@ const AUTHORIZE_NET_CURRENCIES = [
 	"PLN"
 ];
 const VND_ONLY = ["VND"];
+/**
+* The account countries a PSP onboards, for PSPs whose accounts each charge a per-country list.
+* Paystack: support.paystack.com/en/articles/2130690 "Enabling international payments for your
+* business" (retrieved 2026-10-26): "Côte d'Ivoire XOF", "Ghana GHS", "Kenya KES, USD", "Nigeria
+* NGN, USD", "South Africa ZAR", and "At the moment, only Kenya and Nigeria-based businesses have
+* the ability to accept payments for their business in USD and be paid out in USD". USD has to be
+* enabled on the account first (the article is how to enable it), and no Paystack API reports
+* whether it is, so USD is `optIn`, never in `currencies`.
+*/
+const PSP_ACCOUNT_COUNTRIES = { paystack: {
+	CI: { currencies: ["XOF"] },
+	GH: { currencies: ["GHS"] },
+	KE: {
+		currencies: ["KES"],
+		optIn: ["USD"]
+	},
+	NG: {
+		currencies: ["NGN"],
+		optIn: ["USD"]
+	},
+	ZA: { currencies: ["ZAR"] }
+} };
+/**
+* The currency every account of a multi-currency PSP charges without enabling anything; any other
+* needs the account's international or multi-currency add-on. The single-currency PSPs (MoMo,
+* VNPay, Payoo: `VND_ONLY`) are not restated here: their home currency is their one currency.
+* Razorpay: razorpay.com/docs/payments/international-payments (retrieved 2026-10-26) says "The final
+* settlement is done in the bank accounts of Indian businesses in INR", with international
+* payments activated under Account & Settings, and razorpay.com/docs/sg/payments/international-payments/faqs
+* (retrieved 2026-10-27): "The Settlement currency is INR (Indian rupees) for all transactions made
+* using Razorpay". This is the settlement currency only; it says nothing about where the account is
+* registered (Razorpay has no entry in `PSP_HOME_COUNTRY`). iyzico help centre (quoted in Medusa
+* `capabilities/iyzico.ts`, 2026-10-07; re-read 2026-10-26): "payments you take in foreign
+* currencies are exchanged into Turkish Liras", taking them needs the paid Multi Currency add-on.
+*/
+const PSP_HOME_CURRENCY = {
+	razorpay: "INR",
+	iyzico: "TRY"
+};
+/**
+* The one country every account of a PSP is registered in, for PSPs whose accounts are all
+* registered in a single country. Razorpay is left out: the same FAQ lists it as available in India,
+* Malaysia (Curlec), Singapore and the United States, so its accounts are not all registered in one
+* country, and a Singapore or US account must not read as IN. iyzico: consistent with orch `account-facts.ts`
+* `PROVIDER_CONSTANT_FACTS` (2026-10-26), which records TR, and with its Turkish-lira settlement
+* above. MoMo, VNPay, Payoo: domestic Vietnamese rails that take VND only (`VND_ONLY`), carried over
+* from the same `PROVIDER_CONSTANT_FACTS`.
+*/
+const PSP_HOME_COUNTRY = {
+	iyzico: "TR",
+	momo: "VN",
+	vnpay: "VN",
+	payoo: "VN"
+};
+/**
+* The currency of a saved-method verification charge when the caller has none, where the PSP
+* documents one. `only`: the PSP verifies in that currency alone, so any other is refused.
+* Razorpay: recurring payment orders take a currency where "currently, only INR is allowed"
+* (razorpay.com/docs/api/payments/recurring-payments/emandate/create-subsequent-payments, retrieved
+* 2026-10-26), so its verification is INR only. Mollie: docs.mollie.com/docs/multicurrency
+* (retrieved 2026-10-27) lists EUR as supported by "All payment methods except BACS, Blik, Swish
+* and Twint", so every card method takes EUR and a card verification can fall back to it. Adyen
+* and Paystack publish no such currency: Adyen's zero-amount verification takes whatever the
+* merchant account processes, and a Paystack account charges its own country's currency, so their
+* callers must pass one.
+*/
+const VERIFICATION_CURRENCY = {
+	razorpay: {
+		code: "INR",
+		only: true
+	},
+	mollie: {
+		code: "EUR",
+		only: false
+	}
+};
+/**
+* The PSPs whose wire amount Medusa computed in floating point before it adopted 0.2.0: major
+* units as `(stored / storageScale).toFixed(wireDigits)` on a double (Airwallex and Payoo then
+* `Number(...)` of that text). Source: Medusa `src/common/money/codec.ts` `majorStringCodec` /
+* `majorNumberCodec` and `psp-codecs.ts` (staging 785bd0420, 2026-10-27), and the same expression
+* in each provider's `amount.ts` before that codec existed (`03989fd4e^`). The stored amount was
+* `Number()` of Medusa's amount, unrounded. At an exact tie the double can sit just below it, so
+* USD 1072.5 went as `'10.72'` where 0.2.0 sends `'10.73'`; `sameWireAmount`'s
+* `acceptLegacyFloatRounding` reads that spelling. Payoo is listed because it used the same codec,
+* but its whole-dong rule leaves it no tie, so its float spelling is always the exact one.
+*/
+const PSP_LEGACY_FLOAT_TO_FIXED = [
+	"paypal",
+	"mollie",
+	"airwallex",
+	"iyzico",
+	"authorize-net",
+	"payoo"
+];
 /** orch `MINIMUM_AMOUNT_BY_CURRENCY`, majors. */
 const PSP_MINIMUM_MAJOR = { paystack: { USD: "2.00" } };
 /** RBI e-mandate AFA-free cap: INR 15,000 (razorpay-vault `15_000_00` paise, seam `1_500_000`). */
@@ -1014,8 +1088,29 @@ const PROVIDER_ONLY_CURRENCIES = { CNH: {
 	name: "Chinese Yuan (offshore)",
 	psps: ["adyen"]
 } };
-//#endregion
-//#region src/wire/currency.ts
+// src/wire/anet.ts
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* The first `"<field>": <decimal>` (quoted or not) in a raw JSON body, verbatim: `JSON.parse`
+* would turn the gateway's `43.00` into `43`. The value is the whole JSON token, held to
+* `parseDecimal`'s `'plain'` grammar (`1e3` or `"43.10abc"` is not a decimal literal).
+* Undefined when absent; there is no lossy fallback.
+*/
+function jsonDecimalLiteral(rawBody, field) {
+	if (typeof rawBody !== "string" || typeof field !== "string") return void 0;
+	const tokens = rawBody.matchAll(new RegExp(`"${escapeRegExp(field)}"\\s*:\\s*("?)([^"\\s,}\\]]+)\\1`, "g"));
+	for (const [, , token] of tokens) if (parseDecimal(token, "plain")) return token;
+}
+const isPositiveLiteral = (text) => {
+	const value = parseDecimal(text.trim());
+	return value !== null && value.units > 0n;
+};
+function authorizeNetReversibleAmount(details) {
+	const settle = details.settleAmount ?? void 0;
+	if (settle !== void 0 && isPositiveLiteral(settle)) return settle;
+	return details.authAmount ?? settle;
+}
+// src/wire/currency.ts
 /** The registry entry (any case, historic included) for `input`, else null. Never throws. */
 function wireCurrency(input) {
 	return findCurrency(input, { allowHistoric: true });
@@ -1070,8 +1165,17 @@ function wireStoredDecimal(m) {
 		stored: normalizeDecimal(parsed)
 	};
 }
-//#endregion
-//#region src/wire/descriptors.ts
+// src/wire/descriptors.ts
+function accountCountries(id) {
+	const table = PSP_ACCOUNT_COUNTRIES[id] ?? {};
+	return new Map(Object.keys(table).map((country) => {
+		const entry = {
+			currencies: new Set(table[country].currencies),
+			optIn: new Set(table[country].optIn ?? [])
+		};
+		return [country, Object.freeze(entry)];
+	}));
+}
 function digitTable(groups) {
 	const table = /* @__PURE__ */ new Map();
 	for (const digits of [
@@ -1113,7 +1217,12 @@ function describe(id, input) {
 		singleCurrency: input.singleCurrency ?? null,
 		unsupported: input.unsupported ?? genericUnsupported(input.tag),
 		facadeAccepts: input.facadeAccepts ?? scalesAnyCurrency,
-		inboundWholePositive: input.inboundWholePositive ?? false
+		inboundWholePositive: input.inboundWholePositive ?? false,
+		homeCurrency: PSP_HOME_CURRENCY[id] ?? input.singleCurrency ?? null,
+		homeCountry: PSP_HOME_COUNTRY[id] ?? null,
+		accountCountries: accountCountries(id),
+		verificationCurrency: VERIFICATION_CURRENCY[id] ?? null,
+		legacyFloatToFixed: PSP_LEGACY_FLOAT_TO_FIXED.includes(id)
 	});
 }
 const notTwoDecimalAtStripe = new Set(STRIPE_NOT_TWO_DECIMAL);
@@ -1266,8 +1375,7 @@ function pspDescriptor(psp) {
 	if (typeof psp === "string" && hasOwnKey(PSP_DESCRIPTORS, psp)) return PSP_DESCRIPTORS[psp];
 	throw new MoneyError("wire_unsupported", `Unknown payment provider: ${describeValue(psp)}`);
 }
-//#endregion
-//#region src/wire/marker.ts
+// src/wire/marker.ts
 const WIRE_SCALE_KEY = "amboras_wire_scale";
 const WIRE_SCALE_ISO_MINOR_V2 = "iso-minor-v2";
 const WIRE_SCALE_MARKER = Object.freeze({ [WIRE_SCALE_KEY]: WIRE_SCALE_ISO_MINOR_V2 });
@@ -1286,8 +1394,19 @@ function conventionKind(value) {
 	const kind = typeof value === "object" && value !== null ? value.kind : void 0;
 	return kind === "iso-minor-v2" || kind === "pre-cutover" ? kind : null;
 }
-//#endregion
-//#region src/wire/codec.ts
+const WIRE_ROUNDING_KEY = "amboras_wire_rounding";
+const WIRE_ROUNDING_EXACT = "exact";
+const WIRE_ROUNDING_MARKER = Object.freeze({ [WIRE_ROUNDING_KEY]: WIRE_ROUNDING_EXACT });
+/**
+* Whether a payment may be held at the PSP in Medusa's pre-0.2.0 float spelling: no record is a
+* non-null object whose `amboras_wire_rounding` is strictly `'exact'`. Pass the result as
+* `sameWireAmount`'s `acceptLegacyFloatRounding`, so only sessions created before the deploy get
+* the legacy spelling. Reads already fetched records only.
+*/
+function mayHoldLegacyFloatRounding(...records) {
+	return !records.some((r) => typeof r === "object" && r !== null && r["amboras_wire_rounding"] === "exact");
+}
+// src/wire/codec.ts
 const isBlank = (value) => value === null || value === void 0 || typeof value === "string" && value.trim() === "";
 const shownCode = (currency) => typeof currency === "string" ? currency.trim().toUpperCase() : describeValue(currency);
 function missingCurrency(d) {
@@ -1318,7 +1437,8 @@ function pspCurrencies(psp) {
 /**
 * `currency` as a CurrencyCode `psp` takes. Empty throws `currency_missing` (`[<Tag>] Cannot
 * scale an amount without a currency code; ...`); anything the PSP does not take throws
-* `wire_unsupported` with the provider's own message.
+* `wire_unsupported` with the provider's own message. Typed as the PSP's literal union where it
+* has a short fixed list (`assertPspCurrency('authorize-net', c)` is an `AuthorizeNetCurrency`).
 */
 function assertPspCurrency(psp, currency) {
 	const d = pspDescriptor(psp);
@@ -1349,6 +1469,28 @@ function pspDefaultCurrency(psp) {
 	const single = pspDescriptor(psp).singleCurrency;
 	return single === null ? null : single;
 }
+/**
+* The currency every account of `psp` charges without enabling anything (any other needs the
+* account's international or multi-currency add-on, or is never taken): Razorpay INR, iyzico TRY,
+* and for the single-currency PSPs their one currency (MoMo, VNPay and Payoo VND). Null for PSPs
+* whose accounts have no single home currency (Stripe, Adyen, PayPal, Mollie, Airwallex, Authorize.Net, and Paystack, whose home currency is the
+* account country's: `pspPresentment('paystack').accountCountries`). Unlike `pspDefaultCurrency`,
+* which is non-null only for the single-currency PSPs, a home currency does not mean the PSP takes
+* nothing else.
+*/
+function pspHomeCurrency(psp) {
+	const home = pspDescriptor(psp).homeCurrency;
+	return home === null ? null : home;
+}
+/**
+* The one country (ISO 3166 alpha-2) every account of `psp` is registered in, for PSPs whose
+* accounts are all registered in a single country: iyzico `'TR'`, MoMo, VNPay and Payoo `'VN'`. Null
+* for PSPs available in several countries: Razorpay (India, Malaysia, Singapore, the United States)
+* and Paystack (its country follows the account: `pspAccountCountryForCurrency`).
+*/
+function pspHomeCountry(psp) {
+	return pspDescriptor(psp).homeCountry;
+}
 function factorOf(d, info) {
 	if (d.sentAsTwoDecimal.has(info.code)) return 1n;
 	if (d.sentAsZeroDecimal.has(info.code)) return 100n;
@@ -1480,8 +1622,18 @@ function decodeChecked(d, wire, currency, convention, allowNegative, exact = fal
 	if (w.units < 0n && !allowNegative) throw new MoneyError("amount_invalid", `[${d.tag}] Negative wire amount: ${describeValue(wire)}`);
 	return decodeWith(d, w, info, kind, exact);
 }
-function decodeWire(psp, wire, currency, convention) {
-	return decodeChecked(pspDescriptor(psp), wire, currency, convention, true);
+function decodeOptions(d, options, extra) {
+	const notAnOptionsObject = options !== void 0 && (typeof options !== "object" || options === null || hasOwnKey(options, "kind"));
+	if (extra.length > 0 || notAnOptionsObject) {
+		const message = `[${d.tag}] decodeWire takes one options object ({ convention, allowNegative }) as its fourth argument.`;
+		throw new MoneyError("wire_refused", message);
+	}
+	return options ?? {};
+}
+function decodeWire(psp, wire, currency, options, ...extra) {
+	const d = pspDescriptor(psp);
+	const { convention, allowNegative } = decodeOptions(d, options, extra);
+	return decodeChecked(d, wire, currency, convention, allowNegative === true);
 }
 /**
 * `decodeWire` that never throws: undefined wherever it would throw (null, undefined, `''`,
@@ -1516,6 +1668,20 @@ function legacyIsoMajor(m) {
 	};
 	return formatDecimal(roundToScale(major, info.displayDigits, "half-up"));
 }
+/**
+* Internal: `m` as Medusa's pre-0.2.0 float codec spelled it for a `legacyFloatToFixed` PSP, at
+* the PSP's wire digits, or with `isoDigits` at the display digits (the pre-PSP-table spelling):
+* `(Number(amount) / storageScale).toFixed(digits)`, computed on a double on purpose, because
+* that is what the PSP holds for a payment created before 0.2.0 (USD 1072.5 is `'10.72'`).
+* Null for a PSP that never encoded in floating point.
+*/
+function legacyFloatMajor(psp, m, isoDigits) {
+	const d = pspDescriptor(psp);
+	if (!d.legacyFloatToFixed) return null;
+	const { info } = wireStoredDecimal(m);
+	const digits = isoDigits ? info.displayDigits : wireDigitsOf(d, info);
+	return (Number(m.amount) / info.storageScale).toFixed(digits);
+}
 /** Internal: one unit of the PSP's last wire digit as Money. */
 function wireUnit(psp, currency, convention) {
 	const d = pspDescriptor(psp);
@@ -1526,8 +1692,7 @@ function wireUnit(psp, currency, convention) {
 	}, info, d.gated ? requireConvention(d, convention) : null);
 	return boundedMoney(isoMinorFactor(info, wireDigitsOf(d, info)), info);
 }
-//#endregion
-//#region src/wire/breakdown.ts
+// src/wire/breakdown.ts
 /**
 * `total` and its `parts` (same currency, non-negative, adding up to `total`) as integer wire
 * amounts whose sum is exactly `encodeWire(psp, total)`: the wire total split by largest
@@ -1558,8 +1723,7 @@ function wireBreakdown(psp, total, parts, convention) {
 		parts: out
 	};
 }
-//#endregion
-//#region src/wire/compare.ts
+// src/wire/compare.ts
 /**
 * Whether a PSP-reported amount is `expected`, a Money or a FractionalMoney (Medusa's unrounded
 * session total). The expected wire is `encodeWire(psp, expected, { convention, allowZero: true })`
@@ -1574,7 +1738,10 @@ function sameWireAmount(psp, reported, expected, options = {}) {
 		const reportedInfo = wireCurrency(options.reportedCurrency);
 		if (reportedInfo === null || reportedInfo !== wireCurrency(expected.currency)) return false;
 	}
-	const targets = expectedTargets(psp, expected, convention, options.acceptLegacyIsoDigits === true);
+	const targets = expectedTargets(psp, expected, convention, {
+		isoDigits: options.acceptLegacyIsoDigits === true,
+		floatRounding: options.acceptLegacyFloatRounding === true
+	});
 	if (targets === null) return false;
 	const { target, legacy } = targets;
 	const decode = (value) => options.textOnly && typeof value !== "string" ? void 0 : tryDecodeWireExactly(psp, value, expected.currency, convention);
@@ -1586,10 +1753,14 @@ function sameWireAmount(psp, reported, expected, options = {}) {
 	}
 	const got = decode(reported);
 	if (got === void 0) return false;
-	return got.amount === target.amount || got.amount === legacy?.amount;
+	return got.amount === target.amount || legacy.some((m) => m.amount === got.amount);
 }
-/** What `expected` decodes to once sent (and in its legacy ISO-digit spelling), or null when it cannot be sent. */
-function expectedTargets(psp, expected, convention, acceptLegacy) {
+/**
+* What `expected` decodes to once sent, and to in each accepted legacy spelling (the exact
+* ISO-digit one; the pre-0.2.0 float one at the wire digits, and at the ISO digits too when both
+* are accepted), or null when it cannot be sent.
+*/
+function expectedTargets(psp, expected, convention, accept) {
 	try {
 		const d = pspDescriptor(psp);
 		const wire = encodeWire(psp, expected, {
@@ -1597,21 +1768,22 @@ function expectedTargets(psp, expected, convention, acceptLegacy) {
 			allowZero: true
 		});
 		const target = decodeAt(psp, wire, expected, convention);
-		if (!acceptLegacy || d.family === "iso-minor") return {
-			target,
-			legacy: void 0
-		};
-		const spelling = legacyIsoMajor(expected);
+		const spellings = [];
+		if (accept.isoDigits && d.family !== "iso-minor") spellings.push(legacyIsoMajor(expected));
+		if (accept.floatRounding) spellings.push(legacyFloatMajor(psp, expected, false));
+		if (accept.floatRounding && accept.isoDigits) spellings.push(legacyFloatMajor(psp, expected, true));
+		const legacy = [];
+		for (const spelling of spellings) if (spelling !== null && spelling !== String(wire)) legacy.push(decodeAt(psp, spelling, expected, convention));
 		return {
 			target,
-			legacy: spelling === String(wire) ? void 0 : decodeAt(psp, spelling, expected, convention)
+			legacy
 		};
 	} catch {
 		return null;
 	}
 }
 function decodeAt(psp, wire, expected, convention) {
-	return decodeWire(psp, wire, expected.currency, convention);
+	return decodeWire(psp, wire, expected.currency, { convention });
 }
 /**
 * One unit of the PSP's last wire digit, as Money: for ISO-minor PSPs `decodeWire(psp, 1)` (the
@@ -1625,8 +1797,7 @@ function oneWireUnit(psp, currency, convention) {
 function wireKeyPart(wire) {
 	return String(wire);
 }
-//#endregion
-//#region src/data/destinations.ts
+// src/data/destinations.ts
 const pixel = (currencyCase, unit = "major-number") => ({
 	unit,
 	currencyCase,
@@ -1689,8 +1860,7 @@ const DESTINATIONS = {
 		verified: true
 	}
 };
-//#endregion
-//#region src/wire/destinations.ts
+// src/wire/destinations.ts
 function descriptorOf(dest) {
 	if (typeof dest === "string" && hasOwnKey(DESTINATIONS, dest)) return DESTINATIONS[dest];
 	throw new MoneyError("wire_unsupported", `Unknown destination: ${describeValue(dest)}`);
@@ -1737,8 +1907,52 @@ function eventMoney(m) {
 		currency: medusaCurrencyCode(info.code)
 	};
 }
-//#endregion
-//#region src/wire/presentment.ts
+// src/wire/legacy-refund.ts
+const minus = (a, b) => addDecimal(a, {
+	units: -b.units,
+	scale: b.scale
+});
+/**
+* The PSP's remaining amount, to refund instead of `refund`, when the PSP holds the capture only
+* in Medusa's pre-0.2.0 float spelling (`legacyFloatToFixed` PSPs: USD 1072.5 captured as
+* `'10.72'`, where today's spelling is `'10.73'`) and `refund` is Medusa's whole remaining amount
+* (`captured - refunded`, exactly). Medusa's remaining then encodes one wire unit above what the
+* PSP still holds (after a `'0.72'` refund, Medusa's 1000.5 is `'10.01'` against the PSP's
+* `'10.00'`), and the PSP refuses it (NOT_ALLOWED), so the refund could never complete.
+* Returns `{ wire, money }` for the PSP's remaining (`'10.00'`, USD 1000), never more than it and
+* never more than one legacy rounding below what `refund` encodes to. Null (send `refund` as
+* is) for every other case: a PSP that never encoded in floating point, a capture that matches
+* today's spelling or no spelling, a partial refund, a refund that already fits, mixed
+* currencies, and any amount or PSP fact that cannot be read. Never throws.
+*/
+function legacyFloatRefundClamp(psp, input) {
+	try {
+		if (!pspDescriptor(psp).legacyFloatToFixed) return null;
+		const { captured, refunded, refund } = input;
+		const info = wireCurrency(captured.currency);
+		if (info === null || wireCurrency(refunded.currency) !== info || wireCurrency(refund.currency) !== info) return null;
+		const pspCaptured = tryDecodeWireExactly(psp, input.capturedWire, info.code, void 0);
+		const pspRefunded = tryDecodeWireExactly(psp, input.refundedWire, info.code, void 0);
+		if (pspCaptured === void 0 || pspRefunded === void 0) return null;
+		if (!(!sameWireAmount(psp, input.capturedWire, captured) && sameWireAmount(psp, input.capturedWire, captured, { acceptLegacyFloatRounding: true }))) return null;
+		const medusaRemaining = minus(wireStoredDecimal(captured).stored, wireStoredDecimal(refunded).stored);
+		if (compareDecimal(wireStoredDecimal(refund).stored, medusaRemaining) !== 0) return null;
+		const encode = encodeWire;
+		const decode = decodeWire;
+		const sent = decode(psp, encode(psp, refund, { label: "refund amount" }), info.code).amount;
+		const pspRemaining = pspCaptured.amount - pspRefunded.amount;
+		const legacyGap = decode(psp, encode(psp, captured), info.code).amount - pspCaptured.amount;
+		if (pspRemaining <= 0 || sent <= pspRemaining || sent - pspRemaining > legacyGap) return null;
+		const money = boundedMoney(BigInt(pspRemaining), info);
+		return {
+			wire: encode(psp, money, { label: "refund amount" }),
+			money
+		};
+	} catch {
+		return null;
+	}
+}
+// src/wire/presentment.ts
 /** Registry codes only, sorted: a provider-only code (Adyen CNH) or one the registry does not know is left out. */
 function knownCodes(codes) {
 	const known = [];
@@ -1759,33 +1973,75 @@ function pspPresentment(psp) {
 	const d = pspDescriptor(psp);
 	const requires = PRESENTMENT_REQUIRES_ACCOUNT_COUNTRY[d.id] ?? {};
 	const allowsOnly = PRESENTMENT_ACCOUNT_COUNTRY_ALLOWS_ONLY[d.id] ?? {};
+	const countries = new Map([...d.accountCountries].map(([country, entry]) => {
+		const lists = {
+			currencies: new Set(knownCodes(entry.currencies)),
+			optIn: new Set(knownCodes(entry.optIn))
+		};
+		return [country, Object.freeze(lists)];
+	}));
 	return Object.freeze({
 		currencies: new Set(knownCodes(d.presentmentCurrencies)),
 		currencyRequiresAccountCountry: new Map(knownCodes(Object.keys(requires)).map((code) => [code, new Set(requires[code])])),
-		accountCountryAllowsOnly: new Map(Object.keys(allowsOnly).map((country) => [country, new Set(knownCodes(allowsOnly[country]))]))
+		accountCountryAllowsOnly: new Map(Object.keys(allowsOnly).map((country) => [country, new Set(knownCodes(allowsOnly[country]))])),
+		accountCountries: countries,
+		optInCompanions: optInCompanionsOf(countries)
 	});
 }
 /**
+* Internal: per currency that names one account country, that country's opt-in currencies. A
+* currency two countries share names neither, so it gets no companion (no Paystack currency is
+* shared today; the tests hold the rule with a fixture).
+*/
+function optInCompanionsOf(countries) {
+	const companions = /* @__PURE__ */ new Map();
+	for (const entry of countries.values()) {
+		if (entry.optIn.size === 0) continue;
+		for (const code of entry.currencies) if (impliedCountry(countries, code) !== null) companions.set(code, new Set(entry.optIn));
+	}
+	return companions;
+}
+/** The one account country whose list (always or opt-in) holds `code`, else null. */
+function impliedCountry(countries, code) {
+	const holders = [...countries].filter(([, entry]) => entry.currencies.has(code) || entry.optIn.has(code));
+	return holders.length === 1 ? holders[0][0] : null;
+}
+/**
+* The account country a currency names for `psp`: the one country whose accounts present it
+* (Paystack NGN: `'NG'`, XOF: `'CI'`, the only XOF country Paystack onboards). Null when several
+* countries' accounts can present it (Paystack USD, on NG and KE accounts), when the PSP has no
+* per-country lists, or for an unknown code. Never throws for a bad code; an unknown PSP throws
+* `wire_unsupported`.
+*/
+function pspAccountCountryForCurrency(psp, currency) {
+	const d = pspDescriptor(psp);
+	const info = wireCurrency(currency);
+	return info === null ? null : impliedCountry(d.accountCountries, info.code);
+}
+/**
 * The currencies `psp` lets an account present (charge buyers in). Without `accountCountry`, the
-* union over every account country; with it (ISO 3166 alpha-2, any case), only what an account
-* registered there can charge: Stripe's three-decimal five need a UAE account, PayPal's BRL, CNY
-* and MYR an in-country one, Airwallex cards on a US account take its documented 76 and on an MX
-* account MXN only. Not `pspCurrencies`, which is what the codec scales and the facade lets
-* through (Stripe's adds every two-decimal ISO code it accepts on the wire).
+* union over every account country, opt-in currencies included; with it (ISO 3166 alpha-2, any
+* case), only what an account registered there can charge: Stripe's three-decimal five need a UAE
+* account, PayPal's BRL, CNY and MYR an in-country one, Airwallex cards on a US account take its
+* documented 76 and on an MX account MXN only, a Paystack account its country's currency (plus USD
+* on NG and KE with `includeOptIn`, and nothing for a country Paystack does not onboard). Not
+* `pspCurrencies`, which is what the codec scales and the facade lets through (Stripe's adds every
+* two-decimal ISO code it accepts on the wire).
 */
 function pspPresentmentCurrencies(psp, options = {}) {
 	const rules = pspPresentment(psp);
 	if (options.accountCountry === void 0) return rules.currencies;
 	const country = options.accountCountry.trim().toUpperCase();
 	const only = rules.accountCountryAllowsOnly.get(country);
+	const listed = rules.accountCountries.get(country);
 	const codes = [...rules.currencies].filter((code) => {
 		const required = rules.currencyRequiresAccountCountry.get(code);
-		return (required === void 0 || required.has(country)) && (only === void 0 || only.has(code));
+		const inCountryList = rules.accountCountries.size === 0 || listed !== void 0 && (listed.currencies.has(code) || options.includeOptIn === true && listed.optIn.has(code));
+		return (required === void 0 || required.has(country)) && (only === void 0 || only.has(code)) && inCountryList;
 	});
 	return new Set(codes);
 }
-//#endregion
-//#region src/wire/provider-amount.ts
+// src/wire/provider-amount.ts
 /**
 * A provider's major-unit amount (finite number, or text read by the separator engine, which
 * strips the currency's symbol and code) as Money, rounded once to the storage digits. Null on
@@ -1820,24 +2076,27 @@ function parseProviderAmount(value, currency, options = {}) {
 		return null;
 	}
 }
-//#endregion
-//#region src/wire/providers.ts
+// src/wire/providers.ts
 /** RBI e-mandate cap Razorpay token registrations carry as `max_amount`: INR 15,000 (1,500,000 paise = stored). */
 const RAZORPAY_AFA_FREE_CAP = Object.freeze(fromMajor(RAZORPAY_AFA_FREE_CAP_MAJOR, "INR"));
-/**
-* The symbolic charge a saved-card setup makes: Paystack one major unit, Razorpay one INR (any
-* other currency is `wire_unsupported`), Mollie one smallest wire unit (`'0.01'`, `'1'` for ISK
-* and JPY), Adyen zero. Vault charges are always new, so the iso-minor-v2 convention applies.
-*/
+const VERIFICATION_AMOUNTS = {
+	paystack: "one-major-unit",
+	razorpay: "one-major-unit",
+	mollie: "one-wire-unit",
+	adyen: "zero"
+};
+function verificationMoney(psp, code) {
+	const amount = VERIFICATION_AMOUNTS[psp];
+	if (amount === "one-major-unit") return fromMajor("1", code);
+	if (amount === "one-wire-unit") return wireUnit(psp, code);
+	return boundedMoney(0n, resolveWireCurrency(code));
+}
 function verificationCharge(psp, currency) {
-	const code = assertPspCurrency(psp, currency);
-	let charge;
-	if (psp === "paystack") charge = fromMajor("1", code);
-	else if (psp === "razorpay") {
-		if (code !== "INR") throw new MoneyError("wire_unsupported", `[Razorpay] Verification charges are made in INR only, not ${code}.`);
-		charge = fromMajor("1", code);
-	} else if (psp === "mollie") charge = wireUnit("mollie", code);
-	else charge = boundedMoney(0n, resolveWireCurrency(code));
+	const d = pspDescriptor(psp);
+	const documented = d.verificationCurrency;
+	const code = assertPspCurrency(psp, currency === void 0 ? documented?.code : currency);
+	if (documented?.only && code !== documented.code) throw new MoneyError("wire_unsupported", `[${d.tag}] Verification charges are made in ${documented.code} only, not ${code}.`);
+	const charge = verificationMoney(psp, code);
 	return {
 		wire: encodeWire(psp, charge, {
 			convention: ISO_MINOR_V2,
@@ -1857,8 +2116,7 @@ function iyzicoPrice(wire) {
 	const text = toDecimalText(parsed);
 	return text.includes(".") ? text : `${text}.0`;
 }
-//#endregion
-//#region src/wire/slot.ts
+// src/wire/slot.ts
 /** `m` for a slot context's `money` key. */
 function slotMoney(m) {
 	const { info } = storedDecimal(m);
@@ -1884,5 +2142,4 @@ function readSlotMoney(context) {
 	const money = context.money;
 	return (isRecord(money) ? read(money.amount, money.currency_code) : void 0) ?? read(context.total ?? context.price, context.currency_code, context.currency);
 }
-//#endregion
-export { WIRE_SCALE_KEY as A, pspSupportsCurrency as C, ISO_MINOR_V2 as D, wireFactor as E, jsonDecimalLiteral as F, conventionOf as M, PSP_IDS as N, PRE_CUTOVER as O, authorizeNetReversibleAmount as P, pspMinimumAmount as S, tryDecodeWire as T, assertPspCurrency as _, verificationCharge as a, pspCurrencies as b, pspPresentmentCurrencies as c, feedPrice as d, googleMicros as f, wireBreakdown as g, wireKeyPart as h, iyzicoPrice as i, WIRE_SCALE_MARKER as j, WIRE_SCALE_ISO_MINOR_V2 as k, destinationAmount as l, sameWireAmount as m, slotMoney as n, parseProviderAmount as o, oneWireUnit as p, RAZORPAY_AFA_FREE_CAP as r, pspPresentment as s, readSlotMoney as t, eventMoney as u, decodeWire as v, pspWireDigits as w, pspDefaultCurrency as x, encodeWire as y };
+export { wireFactor as A, mayHoldLegacyFloatRounding as B, pspDefaultCurrency as C, pspSupportsCurrency as D, pspMinimumAmount as E, WIRE_ROUNDING_MARKER as F, authorizeNetReversibleAmount as H, WIRE_SCALE_ISO_MINOR_V2 as I, WIRE_SCALE_KEY as L, PRE_CUTOVER as M, WIRE_ROUNDING_EXACT as N, pspWireDigits as O, WIRE_ROUNDING_KEY as P, WIRE_SCALE_MARKER as R, pspCurrencies as S, pspHomeCurrency as T, jsonDecimalLiteral as U, PSP_IDS as V, PAYSTACK_CURRENCIES as W, wireKeyPart as _, verificationCharge as a, decodeWire as b, pspPresentment as c, destinationAmount as d, eventMoney as f, sameWireAmount as g, oneWireUnit as h, iyzicoPrice as i, ISO_MINOR_V2 as j, tryDecodeWire as k, pspPresentmentCurrencies as l, googleMicros as m, slotMoney as n, parseProviderAmount as o, feedPrice as p, RAZORPAY_AFA_FREE_CAP as r, pspAccountCountryForCurrency as s, readSlotMoney as t, legacyFloatRefundClamp as u, wireBreakdown as v, pspHomeCountry as w, encodeWire as x, assertPspCurrency as y, conventionOf as z };