@provex/utils 1.0.16 → 1.2.3

package/dist/src/currencies.js

@@ -1,9 +1,24 @@
+/**
+ * @fileoverview Fiat currency definitions and utilities for the Provex protocol.
+ *
+ * This module defines supported fiat currencies with their symbols, decimals,
+ * and contract IDs (keccak256 hashes used for on-chain identification).
+ *
+ * @remarks
+ * - Currency contract IDs are keccak256(currencyCode) used in smart contracts
+ * - Most currencies use 2 decimal places, but JPY/KRW/VND/UGX use 0
+ * - The Currency class provides parsing/formatting utilities for amounts
+ *
+ * @see {@link payment} for payment provider currency support
+ * @see {@link conversionRates} for exchange rate calculations
+ */
 import { isHash, keccak256, toBytes } from 'viem';
 import { addThousandsSeparator, formatUnits, parseUnits } from './units.js';
 import countriesData from './data/countries.json' with { type: 'json' };
 import { USD_FLAG_SVG, EUR_FLAG_SVG } from './flags.js';
-// Convert SVG strings to data URLs
+/** Pre-computed data URL for USD flag (custom square design) */
 const USD_FLAG_DATA_URL = `data:image/svg+xml;base64,${btoa(USD_FLAG_SVG)}`;
+/** Pre-computed data URL for EUR flag (custom square design) */
 const EUR_FLAG_DATA_URL = `data:image/svg+xml;base64,${btoa(EUR_FLAG_SVG)}`;
 const countries = countriesData;
 /**
@@ -15,12 +30,20 @@ export const tickerToContractId = (ticker) => {
     return keccak256(toBytes(ticker.toUpperCase()));
 };
 /**
- * Currency class that automatically generates contract ID
- * @param code - The currency code
- * @param symbol - The currency symbol
- * @param name - The currency name
- * @param decimals - The number of decimals
- * @param flag - The flag image path
+ * Currency class representing a fiat currency with parsing and formatting utilities.
+ *
+ * Each currency has:
+ * - A unique ticker (ISO 4217 code)
+ * - A display symbol
+ * - A contract ID (keccak256 hash for on-chain use)
+ * - Decimal precision for amount formatting
+ *
+ * @example
+ * ```ts
+ * const usd = SUPPORTED_CURRENCIES.USD
+ * const amount = usd.parseAmount('100.50')    // 10050n (2 decimals)
+ * const display = usd.formatAmount(10050n)   // '100.50'
+ * ```
  */
 export class Currency {
     ticker;
@@ -29,12 +52,24 @@ export class Currency {
     decimals;
     contractId;
     flag;
-    constructor(code, symbol, name, decimals, flag) {
+    zoom;
+    /**
+     * Create a new Currency instance.
+     *
+     * @param code - ISO 4217 currency code (converted to uppercase)
+     * @param symbol - Display symbol (e.g., '$')
+     * @param name - Full currency name
+     * @param decimals - Number of decimal places
+     * @param flag - Optional flag image URL
+     * @param zoom - Optional zoom level for flag display (default: 1.5)
+     */
+    constructor(code, symbol, name, decimals, flag, zoom) {
         this.ticker = code.toUpperCase();
         this.symbol = symbol;
         this.name = name;
         this.decimals = decimals;
-        this.flag = flag || ''; // figure out a fallback flag
+        this.flag = flag || '';
+        this.zoom = zoom ?? 1.5;
         this.contractId = this.generateContractId();
     }
     /**
@@ -64,21 +99,9 @@ export class Currency {
      * @returns The amount as a string
      */
     formatAmount(amount, options = {}) {
-        try {
-            if (amount === null) {
-                return null;
-            }
-            return formatUnits(amount, {
-                decimals: this.decimals,
-                truncateDecimals: 2,
-                padDecimals: 2,
-                ...options,
-            });
-        }
-        catch (err) {
-            console.error('Error formatting amount: %o', amount, err);
+        if (amount === null)
             return null;
-        }
+        return formatUnits(amount, { decimals: this.decimals, truncateDecimals: 2, padDecimals: 2, ...options });
     }
     /**
      * Convert to plain object for compatibility
@@ -92,6 +115,7 @@ export class Currency {
             decimals: this.decimals,
             contractId: this.contractId,
             flag: this.flag,
+            zoom: this.zoom,
         };
     }
 }
@@ -109,13 +133,35 @@ export function generateCurrencyId(currencyCode) {
  * @returns The flag image path
  */
 const flagFromCountries = (countryCode) => {
-    const country = countries.find((country) => country.code === countryCode);
-    return country?.flag || '';
+    return countries.find((country) => country.code === countryCode)?.flag ?? '';
 };
-// Supported fiat currencies with local flag files for major ones
+/**
+ * Registry of all supported fiat currencies.
+ *
+ * Each currency is a Currency instance with:
+ * - Correct decimal precision (0 for JPY/KRW/VND/UGX, 2 for others)
+ * - Unique contract ID (keccak256 hash)
+ * - Flag image for UI display
+ *
+ * @remarks
+ * Payment providers support different subsets of currencies.
+ * Use `getCurrenciesForProvider()` in payment.ts to get supported currencies
+ * for a specific payment method.
+ *
+ * @example
+ * ```ts
+ * // Get USD currency info
+ * const usd = SUPPORTED_CURRENCIES.USD
+ * console.log(usd.symbol)      // '$'
+ * console.log(usd.contractId)  // '0x...' (keccak256('USD'))
+ *
+ * // Parse user input
+ * const amount = usd.parseAmount('100.50')
+ * ```
+ */
 export const SUPPORTED_CURRENCIES = {
-    USD: new Currency('USD', '$', 'US Dollar', 2, USD_FLAG_DATA_URL),
-    EUR: new Currency('EUR', '€', 'Euro', 2, EUR_FLAG_DATA_URL),
+    USD: new Currency('USD', '$', 'US Dollar', 2, USD_FLAG_DATA_URL, 1),
+    EUR: new Currency('EUR', '€', 'Euro', 2, EUR_FLAG_DATA_URL, 1),
     GBP: new Currency('GBP', '£', 'British Pound', 2, flagFromCountries('GBP')),
     AUD: new Currency('AUD', 'A$', 'Australian Dollar', 2, flagFromCountries('AUD')),
     CAD: new Currency('CAD', 'C$', 'Canadian Dollar', 2, flagFromCountries('CAD')),
@@ -151,17 +197,33 @@ export const SUPPORTED_CURRENCIES = {
     RON: new Currency('RON', 'RON', 'Romanian Leu', 2, flagFromCountries('RON')),
     HUF: new Currency('HUF', 'Ft', 'Hungarian Forint', 2, flagFromCountries('HUF')),
 };
-/** Entries for the supported currencies */
+/** Sorted entries for consistent iteration order */
 const entries = Object.entries(SUPPORTED_CURRENCIES).sort(([a], [b]) => a.localeCompare(b));
-entries.forEach(([, currency]) => {
-    // console.log(currency.ticker, currency.contractId)
-    if (!currency.flag) {
-        console.error(`missing flag for ${currency.ticker}`);
-    }
-});
+/**
+ * Map from contract ID (keccak256 hash) to Currency instance.
+ * Used for O(1) lookup of currency info from on-chain data.
+ *
+ * @example
+ * ```ts
+ * const contractId = '0x...' // from blockchain event
+ * const currency = currencyById.get(contractId)
+ * if (currency) {
+ *   console.log(currency.ticker) // 'USD'
+ * }
+ * ```
+ */
 export const currencyById = new Map(entries.map(([, currency]) => {
     return [currency.contractId, currency];
 }));
+/**
+ * Get the currency name/ticker by contract ID
+ * @param contractId - The contract ID (keccak256 hash)
+ * @returns The currency ticker or the original contractId if not found
+ */
+export function getCurrencyNameByContractId(contractId) {
+    const currency = currencyById.get(contractId);
+    return currency?.ticker ?? contractId;
+}
 /**
  * Get the currency info for a currency code
  * @param currencyCode - The currency code
@@ -169,7 +231,7 @@ export const currencyById = new Map(entries.map(([, currency]) => {
  */
 export function getCurrencyInfo(currencyCode) {
     const currency = SUPPORTED_CURRENCIES[currencyCode.toUpperCase()];
-    return currency ? currency.toJSON() : null;
+    return currency?.toJSON() ?? null;
 }
 /**
  * Get the currency info for a contract ID
@@ -180,8 +242,7 @@ export function getCurrencyByContractId(contractId) {
     if (!isHash(contractId)) {
         throw new Error('Invalid contract ID');
     }
-    const currency = currencyById.get(contractId);
-    return currency ? currency : null;
+    return currencyById.get(contractId) ?? null;
 }
 /**
  * Format currency amount safely without Number() constructor, preserving decimal places
@@ -232,3 +293,23 @@ export function getAllSupportedCurrencies() {
 export function isSupportedCurrency(currencyCode) {
     return currencyCode.toUpperCase() in SUPPORTED_CURRENCIES;
 }
+/**
+ * Format the default conversion rate based on currency decimals.
+ * Returns "1" for zero-decimal currencies (JPY, KRW, VND, UGX),
+ * or "1.00" for standard 2-decimal currencies (USD, EUR, etc.).
+ *
+ * @param currency - The currency to format the default rate for
+ * @returns Formatted default rate string matching the currency's decimal precision
+ *
+ * @example
+ * ```ts
+ * formatDefaultRate(SUPPORTED_CURRENCIES.JPY) // "1" (0 decimals)
+ * formatDefaultRate(SUPPORTED_CURRENCIES.USD) // "1.00" (2 decimals)
+ * formatDefaultRate(SUPPORTED_CURRENCIES.EUR) // "1.00" (2 decimals)
+ * ```
+ */
+export function formatDefaultRate(currency) {
+    if (currency.decimals === 0)
+        return '1';
+    return `1.${'0'.repeat(currency.decimals)}`;
+}

package/dist/src/currencies.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/currencies.test.js

@@ -0,0 +1,343 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { SUPPORTED_CURRENCIES, getCurrencyInfo, getCurrencyByContractId, getCurrencyNameByContractId, getAllSupportedCurrencies, isSupportedCurrency, formatCurrencyAmount, tickerToContractId, generateCurrencyId, formatDefaultRate, Currency, } from './currencies.js';
+describe('currencies', () => {
+    describe('SUPPORTED_CURRENCIES', () => {
+        it('should have exactly 36 supported currencies', () => {
+            const count = Object.keys(SUPPORTED_CURRENCIES).length;
+            assert.equal(count, 36, `Expected 36 currencies, but found ${count}`);
+        });
+        it('should have USD as the first major currency', () => {
+            assert.ok(SUPPORTED_CURRENCIES.USD);
+            assert.equal(SUPPORTED_CURRENCIES.USD.ticker, 'USD');
+            assert.equal(SUPPORTED_CURRENCIES.USD.symbol, '$');
+            assert.equal(SUPPORTED_CURRENCIES.USD.decimals, 2);
+        });
+        it('should have EUR as a supported currency', () => {
+            assert.ok(SUPPORTED_CURRENCIES.EUR);
+            assert.equal(SUPPORTED_CURRENCIES.EUR.ticker, 'EUR');
+            assert.equal(SUPPORTED_CURRENCIES.EUR.symbol, '€');
+            assert.equal(SUPPORTED_CURRENCIES.EUR.decimals, 2);
+        });
+        it('should include zero-decimal currencies', () => {
+            assert.equal(SUPPORTED_CURRENCIES.JPY.decimals, 0);
+            assert.equal(SUPPORTED_CURRENCIES.KRW.decimals, 0);
+            assert.equal(SUPPORTED_CURRENCIES.VND.decimals, 0);
+            assert.equal(SUPPORTED_CURRENCIES.UGX.decimals, 0);
+        });
+        it('should have unique contract IDs for all currencies', () => {
+            const contractIds = new Set();
+            const currencies = Object.values(SUPPORTED_CURRENCIES);
+            for (const currency of currencies) {
+                assert.ok(!contractIds.has(currency.contractId), `Duplicate contract ID found for ${currency.ticker}`);
+                contractIds.add(currency.contractId);
+            }
+            assert.equal(contractIds.size, currencies.length);
+        });
+        it('should have flags for all currencies', () => {
+            const currencies = Object.values(SUPPORTED_CURRENCIES);
+            for (const currency of currencies) {
+                assert.ok(currency.flag, `Missing flag for ${currency.ticker}`);
+                assert.ok(currency.flag.length > 0, `Empty flag for ${currency.ticker}`);
+            }
+        });
+        it('should have valid ticker codes', () => {
+            const currencies = Object.values(SUPPORTED_CURRENCIES);
+            for (const currency of currencies) {
+                assert.ok(currency.ticker.length === 3, `Invalid ticker length for ${currency.ticker}`);
+                assert.equal(currency.ticker, currency.ticker.toUpperCase(), `Ticker should be uppercase: ${currency.ticker}`);
+            }
+        });
+    });
+    describe('getCurrencyInfo', () => {
+        it('should return currency info for valid currency code', () => {
+            const usd = getCurrencyInfo('USD');
+            assert.ok(usd);
+            assert.equal(usd.ticker, 'USD');
+            assert.equal(usd.symbol, '$');
+            assert.equal(usd.decimals, 2);
+        });
+        it('should be case-insensitive', () => {
+            const usdLower = getCurrencyInfo('usd');
+            const usdUpper = getCurrencyInfo('USD');
+            const usdMixed = getCurrencyInfo('UsD');
+            assert.deepEqual(usdLower, usdUpper);
+            assert.deepEqual(usdLower, usdMixed);
+        });
+        it('should return null for invalid currency code', () => {
+            const invalid = getCurrencyInfo('INVALID');
+            assert.equal(invalid, null);
+        });
+        it('should return null for empty string', () => {
+            const empty = getCurrencyInfo('');
+            assert.equal(empty, null);
+        });
+    });
+    describe('getCurrencyByContractId', () => {
+        it('should return currency for valid contract ID', () => {
+            const usdContractId = SUPPORTED_CURRENCIES.USD.contractId;
+            const currency = getCurrencyByContractId(usdContractId);
+            assert.ok(currency);
+            assert.equal(currency.ticker, 'USD');
+        });
+        it('should return null for invalid contract ID', () => {
+            const fakeHash = '0x' + '0'.repeat(64);
+            const currency = getCurrencyByContractId(fakeHash);
+            assert.equal(currency, null);
+        });
+        it('should throw for non-hash input', () => {
+            assert.throws(() => {
+                getCurrencyByContractId('not-a-hash');
+            }, /Invalid contract ID/);
+        });
+    });
+    describe('getCurrencyNameByContractId', () => {
+        it('should return ticker for valid contract ID', () => {
+            const usdContractId = SUPPORTED_CURRENCIES.USD.contractId;
+            const name = getCurrencyNameByContractId(usdContractId);
+            assert.equal(name, 'USD');
+        });
+        it('should return original contract ID for unknown ID', () => {
+            const fakeHash = '0x' + '1'.repeat(64);
+            const name = getCurrencyNameByContractId(fakeHash);
+            assert.equal(name, fakeHash);
+        });
+    });
+    describe('getAllSupportedCurrencies', () => {
+        it('should return all currencies', () => {
+            const all = getAllSupportedCurrencies();
+            assert.equal(all.length, 36);
+        });
+        it('should return CurrencyInfo objects', () => {
+            const all = getAllSupportedCurrencies();
+            const first = all[0];
+            assert.ok(first.ticker);
+            assert.ok(first.symbol);
+            assert.ok(first.name);
+            assert.ok(typeof first.decimals === 'number');
+            assert.ok(first.contractId);
+            assert.ok(first.flag);
+        });
+        it('should return sorted currencies', () => {
+            const all = getAllSupportedCurrencies();
+            const tickers = all.map(c => c.ticker);
+            const sorted = [...tickers].sort();
+            assert.deepEqual(tickers, sorted);
+        });
+    });
+    describe('isSupportedCurrency', () => {
+        it('should return true for supported currencies', () => {
+            assert.equal(isSupportedCurrency('USD'), true);
+            assert.equal(isSupportedCurrency('EUR'), true);
+            assert.equal(isSupportedCurrency('GBP'), true);
+        });
+        it('should be case-insensitive', () => {
+            assert.equal(isSupportedCurrency('usd'), true);
+            assert.equal(isSupportedCurrency('USD'), true);
+            assert.equal(isSupportedCurrency('UsD'), true);
+        });
+        it('should return false for unsupported currencies', () => {
+            assert.equal(isSupportedCurrency('INVALID'), false);
+            assert.equal(isSupportedCurrency(''), false);
+            assert.equal(isSupportedCurrency('XXX'), false);
+        });
+    });
+    describe('formatCurrencyAmount', () => {
+        it('should format USD amounts with 2 decimals', () => {
+            assert.equal(formatCurrencyAmount(100, 'USD'), '$100.00');
+            assert.equal(formatCurrencyAmount(1000, 'USD'), '$1,000.00');
+            assert.equal(formatCurrencyAmount(1234.56, 'USD'), '$1,234.56');
+        });
+        it('should format JPY amounts with 0 decimals', () => {
+            assert.equal(formatCurrencyAmount(100, 'JPY'), '¥100');
+            assert.equal(formatCurrencyAmount(1000, 'JPY'), '¥1,000');
+            assert.equal(formatCurrencyAmount(1234, 'JPY'), '¥1,234');
+        });
+        it('should format EUR amounts correctly', () => {
+            assert.equal(formatCurrencyAmount(100, 'EUR'), '€100.00');
+            assert.equal(formatCurrencyAmount(1234.56, 'EUR'), '€1,234.56');
+        });
+        it('should handle string inputs', () => {
+            assert.equal(formatCurrencyAmount('100', 'USD'), '$100.00');
+            assert.equal(formatCurrencyAmount('1234.56', 'USD'), '$1,234.56');
+        });
+        it('should handle unknown currencies', () => {
+            const result = formatCurrencyAmount(100, 'UNKNOWN');
+            assert.equal(result, '100 UNKNOWN');
+        });
+        it('should add thousands separators', () => {
+            assert.equal(formatCurrencyAmount(1000000, 'USD'), '$1,000,000.00');
+            assert.equal(formatCurrencyAmount(123456789, 'JPY'), '¥123,456,789');
+        });
+    });
+    describe('tickerToContractId', () => {
+        it('should generate consistent contract IDs', () => {
+            const id1 = tickerToContractId('USD');
+            const id2 = tickerToContractId('USD');
+            assert.equal(id1, id2);
+        });
+        it('should be case-insensitive', () => {
+            const idUpper = tickerToContractId('USD');
+            const idLower = tickerToContractId('usd');
+            const idMixed = tickerToContractId('UsD');
+            assert.equal(idUpper, idLower);
+            assert.equal(idUpper, idMixed);
+        });
+        it('should generate different IDs for different tickers', () => {
+            const usdId = tickerToContractId('USD');
+            const eurId = tickerToContractId('EUR');
+            const gbpId = tickerToContractId('GBP');
+            assert.notEqual(usdId, eurId);
+            assert.notEqual(usdId, gbpId);
+            assert.notEqual(eurId, gbpId);
+        });
+        it('should generate 32-byte hashes', () => {
+            const id = tickerToContractId('USD');
+            assert.equal(id.length, 66); // '0x' + 64 hex chars
+            assert.ok(id.startsWith('0x'));
+        });
+    });
+    describe('Currency class', () => {
+        it('should parse amounts correctly', () => {
+            const usd = SUPPORTED_CURRENCIES.USD;
+            const amount = usd.parseAmount('100.50');
+            assert.equal(amount, 10050n); // 100.50 with 2 decimals
+        });
+        it('should return null for invalid amounts', () => {
+            const usd = SUPPORTED_CURRENCIES.USD;
+            const amount = usd.parseAmount('invalid');
+            assert.equal(amount, null);
+        });
+        it('should format amounts correctly', () => {
+            const usd = SUPPORTED_CURRENCIES.USD;
+            const formatted = usd.formatAmount(10050n);
+            assert.equal(formatted, '100.50');
+        });
+        it('should handle null amounts', () => {
+            const usd = SUPPORTED_CURRENCIES.USD;
+            const formatted = usd.formatAmount(null);
+            assert.equal(formatted, null);
+        });
+        it('should format with custom options', () => {
+            const usd = SUPPORTED_CURRENCIES.USD;
+            const formatted = usd.formatAmount(10050n, { truncateDecimals: 0, padDecimals: 0 });
+            assert.ok(formatted, 'formatted should be truthy');
+            assert.ok(!formatted.includes('.'), `formatted should not include '.', but got: ${formatted}`);
+        });
+        it('should have default zoom of 1.5 when not specified', () => {
+            // GBP uses flagFromCountries and no explicit zoom
+            const gbp = SUPPORTED_CURRENCIES.GBP;
+            assert.equal(gbp.zoom, 1.5);
+        });
+        it('should use explicit zoom when specified', () => {
+            // USD has explicit zoom of 1
+            const usd = SUPPORTED_CURRENCIES.USD;
+            assert.equal(usd.zoom, 1);
+        });
+        it('should have flag from countries data', () => {
+            // GBP gets flag from countries.json
+            const gbp = SUPPORTED_CURRENCIES.GBP;
+            assert.ok(gbp.flag.length > 0);
+        });
+        it('should have explicit flag for USD/EUR', () => {
+            const usd = SUPPORTED_CURRENCIES.USD;
+            const eur = SUPPORTED_CURRENCIES.EUR;
+            assert.ok(usd.flag.startsWith('data:'));
+            assert.ok(eur.flag.startsWith('data:'));
+        });
+        it('should default flag to empty string when not provided', () => {
+            const currency = new Currency('TST', '$', 'Test', 2);
+            assert.equal(currency.flag, '');
+        });
+        it('should default zoom to 1.5 when not provided', () => {
+            const currency = new Currency('TST', '$', 'Test', 2);
+            assert.equal(currency.zoom, 1.5);
+        });
+        it('should use provided flag when specified', () => {
+            const currency = new Currency('TST', '$', 'Test', 2, 'custom-flag.png');
+            assert.equal(currency.flag, 'custom-flag.png');
+        });
+        it('should use provided zoom when specified', () => {
+            const currency = new Currency('TST', '$', 'Test', 2, '', 2.0);
+            assert.equal(currency.zoom, 2.0);
+        });
+        it('should use provided flag with default zoom', () => {
+            const currency = new Currency('TST', '$', 'Test', 2, 'flag.png');
+            assert.equal(currency.flag, 'flag.png');
+            assert.equal(currency.zoom, 1.5); // default
+        });
+        it('should handle empty string flag', () => {
+            const currency = new Currency('TST', '$', 'Test', 2, '');
+            assert.equal(currency.flag, '');
+            assert.equal(currency.zoom, 1.5);
+        });
+    });
+    describe('generateCurrencyId', () => {
+        it('should generate consistent IDs', () => {
+            const id1 = generateCurrencyId('USD');
+            const id2 = generateCurrencyId('USD');
+            assert.equal(id1, id2);
+        });
+        it('should be case insensitive', () => {
+            const upper = generateCurrencyId('USD');
+            const lower = generateCurrencyId('usd');
+            const mixed = generateCurrencyId('UsD');
+            assert.equal(upper, lower);
+            assert.equal(upper, mixed);
+        });
+        it('should generate different IDs for different currencies', () => {
+            const usd = generateCurrencyId('USD');
+            const eur = generateCurrencyId('EUR');
+            assert.notEqual(usd, eur);
+        });
+        it('should match tickerToContractId output', () => {
+            const fromGenerate = generateCurrencyId('USD');
+            const fromTicker = tickerToContractId('USD');
+            assert.equal(fromGenerate, fromTicker);
+        });
+    });
+    describe('formatDefaultRate', () => {
+        it('returns "1" for zero-decimal currencies (JPY)', () => {
+            const result = formatDefaultRate(SUPPORTED_CURRENCIES.JPY);
+            assert.equal(result, '1');
+        });
+        it('returns "1" for zero-decimal currencies (KRW)', () => {
+            const result = formatDefaultRate(SUPPORTED_CURRENCIES.KRW);
+            assert.equal(result, '1');
+        });
+        it('returns "1" for zero-decimal currencies (VND)', () => {
+            const result = formatDefaultRate(SUPPORTED_CURRENCIES.VND);
+            assert.equal(result, '1');
+        });
+        it('returns "1" for zero-decimal currencies (UGX)', () => {
+            const result = formatDefaultRate(SUPPORTED_CURRENCIES.UGX);
+            assert.equal(result, '1');
+        });
+        it('returns "1.00" for 2-decimal currencies (USD)', () => {
+            const result = formatDefaultRate(SUPPORTED_CURRENCIES.USD);
+            assert.equal(result, '1.00');
+        });
+        it('returns "1.00" for 2-decimal currencies (EUR)', () => {
+            const result = formatDefaultRate(SUPPORTED_CURRENCIES.EUR);
+            assert.equal(result, '1.00');
+        });
+        it('returns "1.00" for 2-decimal currencies (GBP)', () => {
+            const result = formatDefaultRate(SUPPORTED_CURRENCIES.GBP);
+            assert.equal(result, '1.00');
+        });
+        it('returns "1.00" for 2-decimal currencies (ARS)', () => {
+            const result = formatDefaultRate(SUPPORTED_CURRENCIES.ARS);
+            assert.equal(result, '1.00');
+        });
+        it('works with CurrencyInfo (toJSON output)', () => {
+            const currencyInfo = SUPPORTED_CURRENCIES.USD.toJSON();
+            const result = formatDefaultRate(currencyInfo);
+            assert.equal(result, '1.00');
+        });
+        it('handles custom Currency with different decimals', () => {
+            const customCurrency = new Currency('TST', '$', 'Test', 3);
+            const result = formatDefaultRate(customCurrency);
+            assert.equal(result, '1.000');
+        });
+    });
+});