@provex/utils 1.0.16 → 1.2.4

package/dist/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');
+        });
+    });
+});