@provex/utils 1.0.16 → 1.2.4

package/dist/conversionRates.test.js

@@ -0,0 +1,473 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { base } from 'viem/chains';
+import { processConversionRates, getConversionRate, extractCurrencies, getLatestRateForCurrency, getPrimaryConversionRate, getPrimaryRateForCurrency, getPrimaryVerifier, getPrimaryCurrency, convertTokenInputToCurrency, convertCurrencyToTokenOutput, } from './conversionRates.js';
+import { SUPPORTED_CURRENCIES } from './currencies.js';
+import { v2BaseContracts } from './contracts.js';
+describe('conversionRates', () => {
+    // Test data
+    const USD_CONTRACT_ID = SUPPORTED_CURRENCIES.USD.contractId;
+    const EUR_CONTRACT_ID = SUPPORTED_CURRENCIES.EUR.contractId;
+    // Use actual v2 verifier addresses from contracts
+    const VENMO_VERIFIER = v2BaseContracts.venmoReclaimVerifier[0];
+    const ZELLE_VERIFIER = v2BaseContracts.zelleBaseVerifier[0];
+    const createMockEvent = (overrides = {}) => ({
+        depositConversionRateUpdatedId: 'rate-1',
+        currency: USD_CONTRACT_ID,
+        verifier: VENMO_VERIFIER,
+        value: '1000000000000000000', // 1.0
+        orderId: '0x0001',
+        depositId: 'deposit-1',
+        transaction: {
+            hash: '0xhash1',
+            block: { timestamp: '1700000000' },
+        },
+        currentDepositConversionRateUpdatedId: 'rate-1',
+        currentDepositConversionRateUpdated: {
+            value: '1000000000000000000',
+        },
+        ...overrides,
+    });
+    const MOCK_TOKEN = {
+        address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+        decimals: 6,
+        symbol: 'USDC',
+        name: 'USD Coin',
+        chainId: base.id,
+    };
+    describe('processConversionRates', () => {
+        it('should process empty events array', () => {
+            const result = processConversionRates({
+                chainId: base.id,
+                events: [],
+            });
+            assert.equal(result.size, 0);
+        });
+        it('should process single event', () => {
+            const events = [createMockEvent()];
+            const result = processConversionRates({
+                chainId: base.id,
+                events,
+            });
+            assert.equal(result.size, 1);
+            const venmoRates = result.get('venmo');
+            assert.ok(venmoRates, 'Should have venmo rates');
+            const usdRates = venmoRates.get(USD_CONTRACT_ID);
+            assert.ok(usdRates, 'Should have USD rates');
+            assert.equal(usdRates.length, 1);
+        });
+        it('should skip events without currentDepositConversionRateUpdated', () => {
+            const events = [
+                createMockEvent({ currentDepositConversionRateUpdated: undefined }),
+            ];
+            const result = processConversionRates({
+                chainId: base.id,
+                events,
+            });
+            assert.equal(result.size, 0);
+        });
+        it('should sort events by orderId in ascending order by default', () => {
+            const events = [
+                createMockEvent({ orderId: '0x0002' }),
+                createMockEvent({ orderId: '0x0001' }),
+                createMockEvent({ orderId: '0x0003' }),
+            ];
+            const result = processConversionRates({
+                chainId: base.id,
+                events,
+                includeHistorical: true,
+            });
+            const venmoRates = result.get('venmo')?.get(USD_CONTRACT_ID);
+            assert.ok(venmoRates);
+            assert.equal(venmoRates[0].orderId, '0x0001');
+            assert.equal(venmoRates[1].orderId, '0x0002');
+            assert.equal(venmoRates[2].orderId, '0x0003');
+        });
+        it('should sort events in descending order when specified', () => {
+            const events = [
+                createMockEvent({ orderId: '0x0002' }),
+                createMockEvent({ orderId: '0x0001' }),
+                createMockEvent({ orderId: '0x0003' }),
+            ];
+            const result = processConversionRates({
+                chainId: base.id,
+                events,
+                sortOrder: 'desc',
+                includeHistorical: true,
+            });
+            const venmoRates = result.get('venmo')?.get(USD_CONTRACT_ID);
+            assert.ok(venmoRates);
+            assert.equal(venmoRates[0].orderId, '0x0003');
+        });
+        it('should keep only latest rate when includeHistorical is false', () => {
+            const events = [
+                createMockEvent({
+                    orderId: '0x0001',
+                    currentDepositConversionRateUpdated: { value: '1000000000000000000' },
+                }),
+                createMockEvent({
+                    orderId: '0x0002',
+                    currentDepositConversionRateUpdated: { value: '1050000000000000000' },
+                }),
+            ];
+            const result = processConversionRates({
+                chainId: base.id,
+                events,
+                includeHistorical: false,
+            });
+            const venmoRates = result.get('venmo')?.get(USD_CONTRACT_ID);
+            assert.ok(venmoRates);
+            assert.equal(venmoRates.length, 1);
+            // Should have the latest rate (sorted asc, so last one replaces)
+            assert.equal(venmoRates[0].value, '1050000000000000000');
+        });
+        it('should group rates by provider', () => {
+            const events = [
+                createMockEvent({ verifier: VENMO_VERIFIER }),
+                createMockEvent({ verifier: ZELLE_VERIFIER }),
+            ];
+            const result = processConversionRates({
+                chainId: base.id,
+                events,
+            });
+            assert.ok(result.get('venmo'), 'Should have venmo rates');
+            assert.ok(result.get('zelle'), 'Should have zelle rates');
+        });
+        it('should group rates by currency', () => {
+            const events = [
+                createMockEvent({ currency: USD_CONTRACT_ID }),
+                createMockEvent({ currency: EUR_CONTRACT_ID }),
+            ];
+            const result = processConversionRates({
+                chainId: base.id,
+                events,
+            });
+            const venmoRates = result.get('venmo');
+            assert.ok(venmoRates);
+            assert.ok(venmoRates.get(USD_CONTRACT_ID), 'Should have USD rates');
+            assert.ok(venmoRates.get(EUR_CONTRACT_ID), 'Should have EUR rates');
+        });
+    });
+    describe('getConversionRate', () => {
+        it('should return null for empty events', () => {
+            const result = getConversionRate({
+                events: [],
+                currency: USD_CONTRACT_ID,
+                verifier: VENMO_VERIFIER,
+                chainId: base.id,
+            });
+            assert.equal(result, null);
+        });
+        it('should return rate for matching currency and verifier', () => {
+            const events = [createMockEvent()];
+            const result = getConversionRate({
+                events,
+                currency: USD_CONTRACT_ID,
+                verifier: VENMO_VERIFIER,
+                chainId: base.id,
+            });
+            assert.ok(result, 'Should return a rate');
+            assert.ok(!Array.isArray(result), 'Should return single rate');
+            assert.equal(result.value, '1000000000000000000');
+        });
+        it('should return null for non-matching currency', () => {
+            const events = [createMockEvent({ currency: USD_CONTRACT_ID })];
+            const result = getConversionRate({
+                events,
+                currency: EUR_CONTRACT_ID,
+                verifier: VENMO_VERIFIER,
+                chainId: base.id,
+            });
+            assert.equal(result, null);
+        });
+        it('should return array when includeHistory is true', () => {
+            const events = [
+                createMockEvent({ orderId: '0x0001' }),
+                createMockEvent({ orderId: '0x0002' }),
+            ];
+            const result = getConversionRate({
+                events,
+                currency: USD_CONTRACT_ID,
+                verifier: VENMO_VERIFIER,
+                chainId: base.id,
+                includeHistory: true,
+            });
+            assert.ok(Array.isArray(result), 'Should return array');
+            assert.equal(result.length, 2);
+        });
+        it('should use fallback rate when no matching rate found', () => {
+            const fallbackRate = {
+                currency: USD_CONTRACT_ID,
+                value: '999000000000000000',
+                verifier: VENMO_VERIFIER,
+            };
+            const result = getConversionRate({
+                events: [],
+                currency: USD_CONTRACT_ID,
+                verifier: VENMO_VERIFIER,
+                chainId: base.id,
+                fallbackRate,
+            });
+            assert.ok(result, 'Should return fallback rate');
+            assert.ok(!Array.isArray(result));
+            assert.equal(result.value, '999000000000000000');
+        });
+        it('should not use fallback rate when currency does not match', () => {
+            const fallbackRate = {
+                currency: EUR_CONTRACT_ID,
+                value: '999000000000000000',
+                verifier: VENMO_VERIFIER,
+            };
+            const result = getConversionRate({
+                events: [],
+                currency: USD_CONTRACT_ID,
+                verifier: VENMO_VERIFIER,
+                chainId: base.id,
+                fallbackRate,
+            });
+            assert.equal(result, null);
+        });
+    });
+    describe('extractCurrencies', () => {
+        it('should extract currencies from provider rates', () => {
+            const providerRates = new Map([
+                [
+                    'venmo',
+                    new Map([
+                        [USD_CONTRACT_ID, [createMockEvent()]],
+                        [EUR_CONTRACT_ID, [createMockEvent({ currency: EUR_CONTRACT_ID })]],
+                    ]),
+                ],
+            ]);
+            const currencies = extractCurrencies({ providerRates });
+            assert.equal(currencies.length, 2);
+            assert.ok(currencies.includes(USD_CONTRACT_ID));
+            assert.ok(currencies.includes(EUR_CONTRACT_ID));
+        });
+        it('should filter by providers when specified', () => {
+            const providerRates = new Map([
+                ['venmo', new Map([[USD_CONTRACT_ID, [createMockEvent()]]])],
+                ['zelle', new Map([[EUR_CONTRACT_ID, [createMockEvent({ currency: EUR_CONTRACT_ID })]]])],
+            ]);
+            const currencies = extractCurrencies({
+                providerRates,
+                providersOnly: ['venmo'],
+            });
+            assert.equal(currencies.length, 1);
+            assert.ok(currencies.includes(USD_CONTRACT_ID));
+        });
+        it('should filter by currencies when specified', () => {
+            const providerRates = new Map([
+                [
+                    'venmo',
+                    new Map([
+                        [USD_CONTRACT_ID, [createMockEvent()]],
+                        [EUR_CONTRACT_ID, [createMockEvent({ currency: EUR_CONTRACT_ID })]],
+                    ]),
+                ],
+            ]);
+            const currencies = extractCurrencies({
+                providerRates,
+                currenciesOnly: [USD_CONTRACT_ID],
+            });
+            assert.equal(currencies.length, 1);
+            assert.ok(currencies.includes(USD_CONTRACT_ID));
+        });
+        it('should return empty array for empty provider rates', () => {
+            const currencies = extractCurrencies({ providerRates: new Map() });
+            assert.equal(currencies.length, 0);
+        });
+    });
+    describe('getLatestRateForCurrency', () => {
+        it('should return null for empty provider rates', () => {
+            const result = getLatestRateForCurrency({
+                providerRates: new Map(),
+                currency: USD_CONTRACT_ID,
+            });
+            assert.equal(result, null);
+        });
+        it('should return latest rate by timestamp', () => {
+            const oldRate = createMockEvent({
+                transaction: { hash: '0x1', block: { timestamp: '1700000000' } },
+            });
+            const newRate = createMockEvent({
+                transaction: { hash: '0x2', block: { timestamp: '1700001000' } },
+                verifier: ZELLE_VERIFIER,
+            });
+            const providerRates = new Map([
+                ['venmo', new Map([[USD_CONTRACT_ID, oldRate]])],
+                ['zelle', new Map([[USD_CONTRACT_ID, newRate]])],
+            ]);
+            const result = getLatestRateForCurrency({
+                providerRates,
+                currency: USD_CONTRACT_ID,
+            });
+            assert.ok(result);
+            assert.equal(result.transaction.block.timestamp, '1700001000');
+        });
+        it('should prefer specified provider when timestamps match', () => {
+            const rate = createMockEvent({
+                transaction: { hash: '0x1', block: { timestamp: '1700000000' } },
+            });
+            const providerRates = new Map([
+                ['venmo', new Map([[USD_CONTRACT_ID, rate]])],
+                ['zelle', new Map([[USD_CONTRACT_ID, { ...rate, verifier: ZELLE_VERIFIER }]])],
+            ]);
+            const result = getLatestRateForCurrency({
+                providerRates,
+                currency: USD_CONTRACT_ID,
+                preferredProvider: 'venmo',
+            });
+            assert.ok(result);
+            assert.equal(result.verifier, VENMO_VERIFIER);
+        });
+    });
+    describe('getPrimaryConversionRate', () => {
+        it('should return null for empty provider rates', () => {
+            const result = getPrimaryConversionRate(new Map());
+            assert.equal(result, null);
+        });
+        it('should prioritize USD over other currencies', () => {
+            const usdRate = createMockEvent({ currency: USD_CONTRACT_ID });
+            const eurRate = createMockEvent({ currency: EUR_CONTRACT_ID });
+            const providerRates = new Map([
+                ['venmo', new Map([[EUR_CONTRACT_ID, eurRate]])],
+                ['zelle', new Map([[USD_CONTRACT_ID, usdRate]])],
+            ]);
+            const result = getPrimaryConversionRate(providerRates);
+            assert.ok(result);
+            assert.equal(result.currency, USD_CONTRACT_ID);
+        });
+        it('should return first available rate if no USD', () => {
+            const eurRate = createMockEvent({ currency: EUR_CONTRACT_ID });
+            const providerRates = new Map([
+                ['venmo', new Map([[EUR_CONTRACT_ID, eurRate]])],
+            ]);
+            const result = getPrimaryConversionRate(providerRates);
+            assert.ok(result);
+            assert.equal(result.currency, EUR_CONTRACT_ID);
+        });
+    });
+    describe('getPrimaryRateForCurrency', () => {
+        it('should return rate for specified currency', () => {
+            const eurRate = createMockEvent({ currency: EUR_CONTRACT_ID });
+            const providerRates = new Map([
+                ['venmo', new Map([[EUR_CONTRACT_ID, eurRate]])],
+            ]);
+            const result = getPrimaryRateForCurrency(providerRates, EUR_CONTRACT_ID);
+            assert.ok(result);
+            assert.equal(result.currency, EUR_CONTRACT_ID);
+        });
+        it('should return null if currency not found', () => {
+            const usdRate = createMockEvent({ currency: USD_CONTRACT_ID });
+            const providerRates = new Map([
+                ['venmo', new Map([[USD_CONTRACT_ID, usdRate]])],
+            ]);
+            const result = getPrimaryRateForCurrency(providerRates, EUR_CONTRACT_ID);
+            assert.equal(result, null);
+        });
+    });
+    describe('getPrimaryVerifier', () => {
+        it('should return verifier from primary rate', () => {
+            const rate = createMockEvent({ verifier: VENMO_VERIFIER });
+            const providerRates = new Map([
+                ['venmo', new Map([[USD_CONTRACT_ID, rate]])],
+            ]);
+            const result = getPrimaryVerifier(providerRates);
+            assert.equal(result, VENMO_VERIFIER);
+        });
+        it('should return null for empty rates', () => {
+            const result = getPrimaryVerifier(new Map());
+            assert.equal(result, null);
+        });
+    });
+    describe('getPrimaryCurrency', () => {
+        it('should return currency from primary rate', () => {
+            const rate = createMockEvent({ currency: USD_CONTRACT_ID });
+            const providerRates = new Map([
+                ['venmo', new Map([[USD_CONTRACT_ID, rate]])],
+            ]);
+            const result = getPrimaryCurrency(providerRates);
+            assert.equal(result, USD_CONTRACT_ID);
+        });
+        it('should return null for empty rates', () => {
+            const result = getPrimaryCurrency(new Map());
+            assert.equal(result, null);
+        });
+    });
+    describe('convertTokenInputToCurrency', () => {
+        it('should convert token amount at 1:1 rate', () => {
+            const rate = 10n ** 18n; // 1.0 rate
+            const amountOutInt = 100000000n; // 100 USDC
+            const result = convertTokenInputToCurrency({
+                token: MOCK_TOKEN,
+                amountOutInt,
+                rate,
+            });
+            // At 1:1, 100 tokens should give ~100 fiat units
+            // Result is rounded up to nearest cent (10^4 for USDC with 6 decimals)
+            assert.equal(result, 100000000n);
+        });
+        it('should convert token amount at 1.05 rate', () => {
+            const rate = 1050000000000000000n; // 1.05 rate
+            const amountOutInt = 100000000n; // 100 USDC
+            const result = convertTokenInputToCurrency({
+                token: MOCK_TOKEN,
+                amountOutInt,
+                rate,
+            });
+            // 100 * 1.05 = 105, rounded up to nearest cent
+            assert.equal(result, 105000000n);
+        });
+        it('should round up to nearest cent', () => {
+            const rate = 10n ** 18n;
+            const amountOutInt = 100000001n; // 100.000001 USDC
+            const result = convertTokenInputToCurrency({
+                token: MOCK_TOKEN,
+                amountOutInt,
+                rate,
+            });
+            // Should round up from 100.000001 to 100.01 (nearest cent in 6 decimals)
+            assert.equal(result, 100010000n);
+        });
+    });
+    describe('convertCurrencyToTokenOutput', () => {
+        it('should convert fiat to tokens at 1:1 rate', () => {
+            const rate = 10n ** 18n;
+            const currencyAmountInt = 10000n; // $100.00 in cents
+            const result = convertCurrencyToTokenOutput({
+                token: MOCK_TOKEN,
+                currency: SUPPORTED_CURRENCIES.USD,
+                currencyAmountInt,
+                rate,
+            });
+            // At 1:1, $100 should give 100 USDC = 100_000000
+            assert.equal(result, 100000000n);
+        });
+        it('should convert fiat to tokens at 1.05 rate', () => {
+            const rate = 1050000000000000000n; // 1.05 rate
+            const currencyAmountInt = 10500n; // $105.00 in cents
+            const result = convertCurrencyToTokenOutput({
+                token: MOCK_TOKEN,
+                currency: SUPPORTED_CURRENCIES.USD,
+                currencyAmountInt,
+                rate,
+            });
+            // $105 at 1.05 rate should give 100 USDC
+            assert.equal(result, 100000000n);
+        });
+        it('should floor to smallest token unit', () => {
+            const rate = 10n ** 18n;
+            const currencyAmountInt = 10001n; // $100.01
+            const result = convertCurrencyToTokenOutput({
+                token: MOCK_TOKEN,
+                currency: SUPPORTED_CURRENCIES.USD,
+                currencyAmountInt,
+                rate,
+            });
+            // $100.01 at 1:1 = 100.01 USDC = 100_010000 base units
+            // Floored to smallest unit (10^4 for 6-2 decimal difference)
+            assert.equal(result, 100010000n);
+        });
+    });
+});