@amboras-dev/money 0.1.0 → 0.3.0

package/dist/{wire-DQZ6fA3c.cjs → wire-u2tmHY0Y.cjs}

@@ -1,32 +1,9 @@
-const require_money = require("./money-D5-vlv0h.cjs");
-const require_allocate = require("./allocate-D7tm_t_o.cjs");
-const require_own = require("./own-oP9DXFWv.cjs");
-const require_iso_minor = require("./iso-minor--gQWI1f2.cjs");
-const require_number_text = require("./number-text-BpvN6NAo.cjs");
-//#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 (require_money.parseDecimal(token, "plain")) return token;
-}
-const isPositiveLiteral = (text) => {
-	const value = require_money.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
+const require_money = require("./money-DWBjuuEK.cjs");
+const require_allocate = require("./allocate-AusholrC.cjs");
+const require_own = require("./own-C5imDkyB.cjs");
+const require_iso_minor = require("./iso-minor-DyNjT9A1.cjs");
+const require_number_text = require("./number-text-CWuVwrlg.cjs");
+// 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"];
@@ -678,6 +657,118 @@ const STRIPE_PRESENTMENT_CURRENCIES = [
 	"ZAR",
 	"ZMW"
 ];
+/**
+* Presentment currencies only accounts registered in the named countries can charge.
+* Stripe: support.stripe.com/questions/which-payments-methods-and-products-are-available-in-the-uae
+* (retrieved 2026-10-07): "We also support charges in the following three-decimal currencies:
+* Bahraini dinar (BHD), Jordanian dinar (JOD), Kuwaiti dinar (KWD), Omani rial (OMR), Tunisian
+* dinar (TND)"; no other country's list on docs.stripe.com/currencies carries them.
+* PayPal: developer.paypal.com/reference/currency-codes (retrieved 2026-10-07) footnotes BRL, CNY
+* and MYR as supported "only for in-country PayPal accounts" (Medusa models the conservative
+* reading: an out-of-country account cannot charge them; unverified by a sandbox probe).
+*/
+const PRESENTMENT_REQUIRES_ACCOUNT_COUNTRY = {
+	stripe: {
+		BHD: ["AE"],
+		JOD: ["AE"],
+		KWD: ["AE"],
+		OMR: ["AE"],
+		TND: ["AE"]
+	},
+	paypal: {
+		BRL: ["BR"],
+		CNY: ["CN"],
+		MYR: ["MY"]
+	}
+};
+/**
+* Account countries whose card processing takes only the listed currencies.
+* Airwallex: airwallex.com/docs/payments/payment-methods/global/cards (retrieved 2026-10-26,
+* matching Medusa's 2026-10-07 copy): "Supported processing currencies can differ based on where
+* your business is registered and the card scheme." US and MX are listed below; AU, CA, SG, HK,
+* NZ, JP, MY, the EEA, CH, UK and IL take "Visa, MasterCard: All currencies".
+*/
+const PRESENTMENT_ACCOUNT_COUNTRY_ALLOWS_ONLY = { airwallex: {
+	US: [
+		"USD",
+		"EUR",
+		"GBP",
+		"AUD",
+		"SGD",
+		"JPY",
+		"CHF",
+		"NOK",
+		"DKK",
+		"CAD",
+		"NZD",
+		"HKD",
+		"KRW",
+		"PHP",
+		"MYR",
+		"TWD",
+		"VND",
+		"EGP",
+		"SAR",
+		"THB",
+		"MXN",
+		"TRY",
+		"INR",
+		"BRL",
+		"CNY",
+		"PKR",
+		"PLN",
+		"SEK",
+		"NGN",
+		"AED",
+		"IDR",
+		"BDT",
+		"ILS",
+		"ISK",
+		"MAD",
+		"ZAR",
+		"CZK",
+		"HUF",
+		"RON",
+		"CLP",
+		"QAR",
+		"COP",
+		"RUB",
+		"MWK",
+		"PEN",
+		"BGN",
+		"UAH",
+		"ARS",
+		"MOP",
+		"HRK",
+		"KZT",
+		"ALL",
+		"CRC",
+		"XOF",
+		"KES",
+		"UYU",
+		"LKR",
+		"BOB",
+		"PAB",
+		"GTQ",
+		"DOP",
+		"MMK",
+		"RSD",
+		"BZD",
+		"DZD",
+		"SHP",
+		"HNL",
+		"GEL",
+		"BAM",
+		"MKD",
+		"JMD",
+		"AWG",
+		"BBD",
+		"TTD",
+		"PYG",
+		"XAF"
+	],
+	MX: ["MXN"]
+} };
 /** Stripe's not-two-decimal set (capabilities/stripe-connect.ts:47), incl. the UAE-only five. */
 const STRIPE_NOT_TWO_DECIMAL = [
 	"BIF",
@@ -888,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`). */
@@ -902,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 (require_money.parseDecimal(token, "plain")) return token;
+}
+const isPositiveLiteral = (text) => {
+	const value = require_money.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 require_money.findCurrency(input, { allowHistoric: true });
@@ -933,8 +1140,42 @@ function wireStored(m) {
 		units: BigInt(m.amount)
 	};
 }
-//#endregion
-//#region src/wire/descriptors.ts
+const SAFE_LIMIT = BigInt(Number.MAX_SAFE_INTEGER);
+/**
+* A Money's or FractionalMoney's currency entry and its exact stored amount, normalized (scale 0
+* when whole, so a whole amount reads exactly as `wireStored` reads it). A number must be finite
+* and safe when whole, text plain decimal; the amount must round within the safe integers.
+*/
+function wireStoredDecimal(m) {
+	const info = resolveWireCurrency(m.currency);
+	const { amount } = m;
+	if (typeof amount === "string") {
+		const parsed = require_money.parseDecimal(amount, "plain");
+		if (parsed === null) throw new require_money.MoneyError("amount_invalid", `Stored amount must be plain decimal text, got ${require_money.describeValue(amount)}`);
+		if (!require_money.unitsWithin(require_money.roundToScale(parsed, 0, "up"), SAFE_LIMIT)) throw new require_money.MoneyError("amount_invalid", `Stored amount is beyond the safe integers: ${amount}`);
+		return {
+			info,
+			stored: require_money.normalizeDecimal(parsed)
+		};
+	}
+	const parsed = typeof amount === "number" ? require_money.strictNumberDecimal(amount) : null;
+	if (parsed === null) throw new require_money.MoneyError("amount_invalid", `Stored amount must be a safe integer, got ${require_money.describeValue(amount)}`);
+	return {
+		info,
+		stored: require_money.normalizeDecimal(parsed)
+	};
+}
+// 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 [
@@ -957,6 +1198,7 @@ const vndOnlyFacade = (code) => code === "VND";
 const NONE = /* @__PURE__ */ new Set();
 const NO_DIGITS = /* @__PURE__ */ new Map();
 function describe(id, input) {
+	const currencies = new Set(input.currencies);
 	return Object.freeze({
 		id,
 		tag: input.tag,
@@ -964,7 +1206,9 @@ function describe(id, input) {
 		gated: input.gated ?? false,
 		encodeGated: input.encodeGated ?? false,
 		preCutoverNeedsFactorOne: input.preCutoverNeedsFactorOne ?? false,
-		currencies: new Set(input.currencies),
+		roundsToStoredUnitFirst: input.roundsToStoredUnitFirst ?? false,
+		currencies,
+		presentmentCurrencies: input.presentmentCurrencies ? new Set(input.presentmentCurrencies) : currencies,
 		digits: input.digits ?? NO_DIGITS,
 		sentAsTwoDecimal: input.sentAsTwoDecimal ? new Set(input.sentAsTwoDecimal) : NONE,
 		sentAsZeroDecimal: input.sentAsZeroDecimal ? new Set(input.sentAsZeroDecimal) : NONE,
@@ -973,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);
@@ -996,7 +1245,9 @@ const PSP_DESCRIPTORS = Object.freeze({
 		family: "iso-minor",
 		gated: true,
 		encodeGated: true,
+		roundsToStoredUnitFirst: true,
 		currencies: STRIPE_SENDABLE,
+		presentmentCurrencies: STRIPE_PRESENTMENT_CURRENCIES,
 		sentAsTwoDecimal: STRIPE_SENT_AS_TWO_DECIMAL
 	}),
 	adyen: describe("adyen", {
@@ -1004,6 +1255,7 @@ const PSP_DESCRIPTORS = Object.freeze({
 		family: "iso-minor",
 		gated: true,
 		encodeGated: true,
+		roundsToStoredUnitFirst: true,
 		currencies: digitTable(ADYEN_CURRENCY_DIGITS).keys(),
 		digits: digitTable(ADYEN_CURRENCY_DIGITS),
 		sentAsTwoDecimal: ADYEN_SENT_AS_TWO_DECIMAL,
@@ -1123,8 +1375,7 @@ function pspDescriptor(psp) {
 	if (typeof psp === "string" && require_own.hasOwnKey(PSP_DESCRIPTORS, psp)) return PSP_DESCRIPTORS[psp];
 	throw new require_money.MoneyError("wire_unsupported", `Unknown payment provider: ${require_money.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 });
@@ -1143,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() : require_money.describeValue(currency);
 function missingCurrency(d) {
@@ -1175,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);
@@ -1206,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;
@@ -1258,32 +1543,39 @@ function requireConvention(d, convention) {
 }
 function encodeWire(psp, m, options = {}) {
 	const d = pspDescriptor(psp);
-	const { info, units } = wireStored(m);
-	const value = {
-		units,
-		scale: require_money.storageExponent(info)
-	};
+	const { info, stored: held } = wireStoredDecimal(m);
 	facadeCurrency(d, info.code);
 	const label = options.label ?? "amount";
-	const stored = value.units;
-	if (stored < 0n || stored === 0n && !options.allowZero) throw new require_money.MoneyError("wire_refused", `[${d.tag}] Invalid ${label}: ${m.amount}`);
+	const shown = require_money.formatDecimal(held);
+	const exponent = require_money.storageExponent(info);
+	const majorText = require_money.formatDecimal({
+		units: held.units,
+		scale: exponent + held.scale
+	});
+	if (held.units < 0n || held.units === 0n && !options.allowZero) throw new require_money.MoneyError("wire_refused", `[${d.tag}] Invalid ${label}: ${shown}`);
+	const stored = d.roundsToStoredUnitFirst ? require_money.roundToScale(held, 0, "half-up") : held;
+	const positive = held.units > 0n;
 	const factor = d.family === "iso-minor" ? factorOf(d, info) : 1n;
 	if (d.encodeGated && requireConvention(d, options.convention) === "pre-cutover") {
-		if (d.preCutoverNeedsFactorOne && require_money.divRound(stored, factor, "half-up") !== stored) throw new require_money.MoneyError("wire_refused", preCutoverRefusal(d.tag, info.code));
-		return m.amount;
+		if (!(stored.scale === 0 && (!d.preCutoverNeedsFactorOne || require_money.divRound(stored.units, factor, "half-up") === stored.units))) throw new require_money.MoneyError("wire_refused", preCutoverRefusal(d.tag, info.code));
+		if (stored.units === 0n && positive) throw subUnitRefusal(d, info, majorText, exponent, label);
+		return Number(stored.units);
 	}
-	if (d.wholeUnit?.applies(info) && stored % BigInt(info.storageScale) !== 0n) throw new require_money.MoneyError("wire_refused", d.wholeUnit.message(info, m.amount, label, require_money.formatDecimal(value)));
+	if (d.wholeUnit?.applies(info) && stored.units % (BigInt(info.storageScale) * require_money.pow10(stored.scale)) !== 0n) throw new require_money.MoneyError("wire_refused", d.wholeUnit.message(info, shown, label, majorText));
 	const digits = wireDigitsOf(d, info);
 	if (d.family === "iso-minor") {
-		const exact = require_money.divRound(stored, factor, "half-up");
-		if (exact === 0n && stored > 0n) throw subUnitRefusal(d, info, require_money.formatDecimal(value), digits, label);
+		const exact = require_money.divRound(stored.units, factor * require_money.pow10(stored.scale), "half-up");
+		if (exact === 0n && positive) throw subUnitRefusal(d, info, majorText, digits, label);
 		if (!d.threeDecimalStepOfTen || d.digits.get(info.code) !== 3) return Number(exact);
 		const stepped = exact - exact % 10n;
-		if (stepped === 0n && exact > 0n) throw new require_money.MoneyError("wire_refused", roundsToNothing(d.tag, info.code, require_money.formatDecimal(value)));
+		if (stepped === 0n && exact > 0n) throw new require_money.MoneyError("wire_refused", roundsToNothing(d.tag, info.code, majorText));
 		return Number(stepped);
 	}
-	const rounded = require_money.roundToScale(value, digits, "half-up");
-	if (rounded.units === 0n && stored > 0n) throw subUnitRefusal(d, info, require_money.formatDecimal(value), digits, label);
+	const rounded = require_money.roundToScale({
+		units: stored.units,
+		scale: exponent + stored.scale
+	}, digits, "half-up");
+	if (rounded.units === 0n && positive) throw subUnitRefusal(d, info, majorText, digits, label);
 	const text = require_money.formatDecimal(rounded);
 	return d.family === "major-number" ? Number(text) : text;
 }
@@ -1305,11 +1597,13 @@ function roundsToNothing(tag, code, major) {
 function wireDecimal(wire) {
 	return typeof wire === "number" ? require_money.strictNumberDecimal(wire) : require_money.parseDecimal(wire, "plain");
 }
-function decodeWith(d, w, info, kind) {
+/** `w` at storage scale, half-up; with `exact`, a wire naming a fraction of a storage unit throws `amount_invalid`. */
+function decodeWith(d, w, info, kind, exact = false) {
 	const scale = require_money.pow10(w.scale);
 	let multiplier;
 	if (d.family !== "iso-minor") multiplier = BigInt(info.storageScale);
 	else multiplier = kind === "pre-cutover" ? 1n : factorOf(d, info);
+	if (exact && w.units * multiplier % scale !== 0n) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] ${require_money.formatDecimal(w)} is not a whole ${info.code} storage amount`);
 	return require_money.boundedMoney(require_money.mulDiv(w.units, multiplier, scale, "half-up"), info);
 }
 /** VNPay: a positive whole safe integer, as Medusa's `vnpayWireAmountToStorage` reads one. */
@@ -1318,7 +1612,7 @@ function isWholePositive(w) {
 	return w.units > 0n && w.units % scale === 0n && w.units / scale <= BigInt(Number.MAX_SAFE_INTEGER);
 }
 /** Every inbound check: facade currency gate, convention, strict wire text, VNPay's "no amount", the sign. */
-function decodeChecked(d, wire, currency, convention, allowNegative) {
+function decodeChecked(d, wire, currency, convention, allowNegative, exact = false) {
 	if (isBlank(currency)) throw missingCurrency(d);
 	const info = facadeCurrency(d, currency);
 	const kind = d.gated ? requireConvention(d, convention) : null;
@@ -1326,10 +1620,20 @@ function decodeChecked(d, wire, currency, convention, allowNegative) {
 	if (!w) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] Not a wire amount: ${require_money.describeValue(wire)}`);
 	if (d.inboundWholePositive && !isWholePositive(w)) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] No amount: ${d.tag} amounts are positive whole numbers, got ${require_money.describeValue(wire)}`);
 	if (w.units < 0n && !allowNegative) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] Negative wire amount: ${require_money.describeValue(wire)}`);
-	return decodeWith(d, w, info, kind);
+	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 || require_own.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 require_money.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, `''`,
@@ -1344,13 +1648,39 @@ function tryDecodeWire(psp, wire, currency, options = {}) {
 		return;
 	}
 }
-/** Internal: the major-unit text of `m` at its display digits (the pre-PSP-table ISO spelling). */
+/**
+* Internal: `tryDecodeWire` (no negatives) that is also undefined for a wire naming a fraction of a
+* storage unit (Airwallex 43.004 is not USD 43.00): the comparators' reading of a reported amount.
+*/
+function tryDecodeWireExactly(psp, wire, currency, convention) {
+	try {
+		return decodeChecked(pspDescriptor(psp), wire, currency, convention, false, true);
+	} catch {
+		return;
+	}
+}
+/** Internal: the major-unit text of `m` at its display digits, half-up (the pre-PSP-table ISO spelling). */
 function legacyIsoMajor(m) {
-	const { info, units } = wireStored(m);
-	return require_money.formatDecimal(require_money.roundToScale({
-		units,
-		scale: require_money.storageExponent(info)
-	}, info.displayDigits, "half-up"));
+	const { info, stored } = wireStoredDecimal(m);
+	const major = {
+		units: stored.units,
+		scale: require_money.storageExponent(info) + stored.scale
+	};
+	return require_money.formatDecimal(require_money.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) {
@@ -1362,8 +1692,7 @@ function wireUnit(psp, currency, convention) {
 	}, info, d.gated ? requireConvention(d, convention) : null);
 	return require_money.boundedMoney(require_iso_minor.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
@@ -1394,13 +1723,14 @@ 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`. The expected wire is `encodeWire(psp, expected,
-* { convention, allowZero: true })` (a refusal means false); the reported one must decode
-* (`tryDecodeWire`: strict, never `''` or an exponent, no negatives) to the same stored amount,
-* so `'44.00'` matches a sent `'44'`. Never throws.
+* 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 })`
+* (a refusal means false); the reported one must decode exactly (strict like `tryDecodeWire`:
+* never `''` or an exponent, no negatives, and never a fraction of a storage unit) to the same
+* stored amount, so `'44.00'` matches a sent `'44'` and Airwallex `43.004` does not match `43`.
+* Never throws.
 */
 function sameWireAmount(psp, reported, expected, options = {}) {
 	const { convention } = options;
@@ -1408,10 +1738,13 @@ 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) => tryDecodeWire(psp, value, expected.currency, { convention });
+	const decode = (value) => options.textOnly && typeof value !== "string" ? void 0 : tryDecodeWireExactly(psp, value, expected.currency, convention);
 	if (options.policy === "requested-exact-collected-covers" && options.requested !== void 0 && options.requested !== null) {
 		const requested = decode(options.requested);
 		const collected = decode(reported);
@@ -1420,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, {
@@ -1431,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
@@ -1459,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,
@@ -1523,8 +1860,7 @@ const DESTINATIONS = {
 		verified: true
 	}
 };
-//#endregion
-//#region src/wire/destinations.ts
+// src/wire/destinations.ts
 function descriptorOf(dest) {
 	if (typeof dest === "string" && require_own.hasOwnKey(DESTINATIONS, dest)) return DESTINATIONS[dest];
 	throw new require_money.MoneyError("wire_unsupported", `Unknown destination: ${require_money.describeValue(dest)}`);
@@ -1571,8 +1907,141 @@ function eventMoney(m) {
 		currency: require_money.medusaCurrencyCode(info.code)
 	};
 }
-//#endregion
-//#region src/wire/provider-amount.ts
+// src/wire/legacy-refund.ts
+const minus = (a, b) => require_money.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 (require_money.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 = require_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 = [];
+	for (const code of codes) {
+		const info = wireCurrency(code);
+		if (info) known.push(info.code);
+	}
+	return known.sort();
+}
+/**
+* The PSP's presentment rules, as data: the union of currencies some account can charge, the
+* currencies that need an account in particular countries, and the account countries limited to
+* a list. For capability declarations that hold the rules themselves; `pspPresentmentCurrencies`
+* applies them to one account. Fresh collections on every call. An unknown PSP throws
+* `wire_unsupported`.
+*/
+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]))])),
+		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, 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);
+		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);
+}
+// 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
@@ -1607,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(require_money.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 require_money.fromMajor("1", code);
+	if (amount === "one-wire-unit") return wireUnit(psp, code);
+	return require_money.boundedMoney(0n, resolveWireCurrency(code));
+}
 function verificationCharge(psp, currency) {
-	const code = assertPspCurrency(psp, currency);
-	let charge;
-	if (psp === "paystack") charge = require_money.fromMajor("1", code);
-	else if (psp === "razorpay") {
-		if (code !== "INR") throw new require_money.MoneyError("wire_unsupported", `[Razorpay] Verification charges are made in INR only, not ${code}.`);
-		charge = require_money.fromMajor("1", code);
-	} else if (psp === "mollie") charge = wireUnit("mollie", code);
-	else charge = require_money.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 require_money.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,
@@ -1644,8 +2116,7 @@ function iyzicoPrice(wire) {
 	const text = require_money.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 } = require_money.storedDecimal(m);
@@ -1671,13 +2142,18 @@ 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
 Object.defineProperty(exports, "ISO_MINOR_V2", {
 	enumerable: true,
 	get: function() {
 		return ISO_MINOR_V2;
 	}
 });
+Object.defineProperty(exports, "PAYSTACK_CURRENCIES", {
+	enumerable: true,
+	get: function() {
+		return PAYSTACK_CURRENCIES;
+	}
+});
 Object.defineProperty(exports, "PRE_CUTOVER", {
 	enumerable: true,
 	get: function() {
@@ -1696,6 +2172,24 @@ Object.defineProperty(exports, "RAZORPAY_AFA_FREE_CAP", {
 		return RAZORPAY_AFA_FREE_CAP;
 	}
 });
+Object.defineProperty(exports, "WIRE_ROUNDING_EXACT", {
+	enumerable: true,
+	get: function() {
+		return WIRE_ROUNDING_EXACT;
+	}
+});
+Object.defineProperty(exports, "WIRE_ROUNDING_KEY", {
+	enumerable: true,
+	get: function() {
+		return WIRE_ROUNDING_KEY;
+	}
+});
+Object.defineProperty(exports, "WIRE_ROUNDING_MARKER", {
+	enumerable: true,
+	get: function() {
+		return WIRE_ROUNDING_MARKER;
+	}
+});
 Object.defineProperty(exports, "WIRE_SCALE_ISO_MINOR_V2", {
 	enumerable: true,
 	get: function() {
@@ -1780,6 +2274,18 @@ Object.defineProperty(exports, "jsonDecimalLiteral", {
 		return jsonDecimalLiteral;
 	}
 });
+Object.defineProperty(exports, "legacyFloatRefundClamp", {
+	enumerable: true,
+	get: function() {
+		return legacyFloatRefundClamp;
+	}
+});
+Object.defineProperty(exports, "mayHoldLegacyFloatRounding", {
+	enumerable: true,
+	get: function() {
+		return mayHoldLegacyFloatRounding;
+	}
+});
 Object.defineProperty(exports, "oneWireUnit", {
 	enumerable: true,
 	get: function() {
@@ -1792,6 +2298,12 @@ Object.defineProperty(exports, "parseProviderAmount", {
 		return parseProviderAmount;
 	}
 });
+Object.defineProperty(exports, "pspAccountCountryForCurrency", {
+	enumerable: true,
+	get: function() {
+		return pspAccountCountryForCurrency;
+	}
+});
 Object.defineProperty(exports, "pspCurrencies", {
 	enumerable: true,
 	get: function() {
@@ -1804,12 +2316,36 @@ Object.defineProperty(exports, "pspDefaultCurrency", {
 		return pspDefaultCurrency;
 	}
 });
+Object.defineProperty(exports, "pspHomeCountry", {
+	enumerable: true,
+	get: function() {
+		return pspHomeCountry;
+	}
+});
+Object.defineProperty(exports, "pspHomeCurrency", {
+	enumerable: true,
+	get: function() {
+		return pspHomeCurrency;
+	}
+});
 Object.defineProperty(exports, "pspMinimumAmount", {
 	enumerable: true,
 	get: function() {
 		return pspMinimumAmount;
 	}
 });
+Object.defineProperty(exports, "pspPresentment", {
+	enumerable: true,
+	get: function() {
+		return pspPresentment;
+	}
+});
+Object.defineProperty(exports, "pspPresentmentCurrencies", {
+	enumerable: true,
+	get: function() {
+		return pspPresentmentCurrencies;
+	}
+});
 Object.defineProperty(exports, "pspSupportsCurrency", {
 	enumerable: true,
 	get: function() {