@provex/utils 1.0.16

package/dist/src/conversionRates.js

@@ -0,0 +1,219 @@
+import { SUPPORTED_CURRENCIES } from './currencies.js';
+import { verifierGetsKey } from './payment.js';
+/**
+ * Process deposit currency added events into organized conversion rates
+ */
+export function processConversionRates(options) {
+    const { events, sortOrder = 'asc', includeHistorical = false, chainId, } = options;
+    const ratesMap = new Map();
+    // Sort events by orderId
+    const sortedEvents = [...events].sort((a, b) => sortOrder === 'desc'
+        ? b.orderId.localeCompare(a.orderId)
+        : a.orderId.localeCompare(b.orderId));
+    for (const event of sortedEvents) {
+        if (!event.currentDepositConversionRateUpdated)
+            continue;
+        const providerKey = verifierGetsKey(chainId, event.verifier);
+        const currency = event.currency;
+        // Get or create provider rates map
+        const providerRates = ratesMap.get(providerKey) ?? new Map();
+        // Get or create currency rates array
+        const currencyRates = providerRates.get(currency) ?? [];
+        const rateInfo = {
+            currency,
+            depositConversionRateUpdatedId: event.currentDepositConversionRateUpdatedId,
+            value: event.currentDepositConversionRateUpdated.value ?? '',
+            verifier: event.verifier,
+            orderId: event.orderId,
+            depositId: event.depositId,
+            transaction: {
+                hash: event.transaction.hash,
+                block: {
+                    timestamp: event.transaction.block.timestamp
+                }
+            },
+        };
+        if (includeHistorical) {
+            // Add all rates chronologically
+            currencyRates.push(rateInfo);
+        }
+        else {
+            // Only keep the latest rate (first in desc order, last in asc order)
+            if (currencyRates.length === 0) {
+                currencyRates.push(rateInfo);
+            }
+            else if (sortOrder === 'asc') {
+                // Replace with newer rate
+                currencyRates[0] = rateInfo;
+            }
+            // For desc order with includeHistorical=false, we only add the first (most recent) rate
+        }
+        providerRates.set(currency, currencyRates);
+        ratesMap.set(providerKey, providerRates);
+    }
+    return ratesMap;
+}
+/**
+ * Get conversion rate for a specific currency and verifier combination
+ */
+export function getConversionRate(options) {
+    const { events, currency, verifier, chainId, includeHistory = false, fallbackRate } = options;
+    // Process rates to get organized data
+    const providerRates = processConversionRates({
+        events,
+        includeHistorical: includeHistory,
+        chainId,
+    });
+    const providerKey = verifierGetsKey(chainId, verifier);
+    const rates = providerRates.get(providerKey)?.get(currency);
+    if (rates && rates.length > 0) {
+        return includeHistory ? rates : rates[0];
+    }
+    // Check fallback rate if provided
+    if (fallbackRate &&
+        fallbackRate.currency === currency &&
+        fallbackRate.verifier === verifier) {
+        return {
+            depositConversionRateUpdatedId: '0',
+            currency: fallbackRate.currency,
+            value: fallbackRate.value,
+            verifier: fallbackRate.verifier,
+            depositId: '0',
+            orderId: '0', // Indicate this is a fallback/original rate
+            transaction: {
+                hash: '0',
+                block: {
+                    timestamp: '0'
+                }
+            }
+        };
+    }
+    return null;
+}
+/**
+ * Extract unique currencies from processed provider rates
+ */
+export function extractCurrencies(options) {
+    const { providerRates, providersOnly, currenciesOnly } = options;
+    const currencySet = new Set();
+    for (const [providerKey, currencyMap] of providerRates.entries()) {
+        // Filter by providers if specified
+        if (providersOnly && !providersOnly.includes(providerKey)) {
+            continue;
+        }
+        for (const [currency] of currencyMap.entries()) {
+            // Filter by currencies if specified
+            if (currenciesOnly && !currenciesOnly.includes(currency)) {
+                continue;
+            }
+            currencySet.add(currency);
+        }
+    }
+    return Array.from(currencySet);
+}
+/**
+ * Get the latest conversion rate across all providers for a currency
+ */
+export function getLatestRateForCurrency(options) {
+    const { providerRates, currency, preferredProvider } = options;
+    let latestRate = null;
+    let latestTimestamp = BigInt(0);
+    // Check preferred provider first
+    if (preferredProvider) {
+        const providerRate = providerRates.get(preferredProvider)?.get(currency);
+        if (providerRate && providerRate.transaction.block.timestamp) {
+            const tsmp = BigInt(providerRate.transaction.block.timestamp);
+            if (tsmp > latestTimestamp) {
+                latestRate = providerRate;
+                latestTimestamp = tsmp;
+            }
+        }
+    }
+    // Check all other providers
+    for (const [providerKey, currencyMap] of providerRates.entries()) {
+        if (providerKey === preferredProvider)
+            continue; // Already checked
+        const rate = currencyMap.get(currency);
+        if (rate && rate.transaction.block.timestamp) {
+            const tsmp = BigInt(rate.transaction.block.timestamp);
+            if (tsmp > latestTimestamp) {
+                latestRate = rate;
+                latestTimestamp = tsmp;
+            }
+        }
+    }
+    return latestRate;
+}
+/**
+ * Get the primary conversion rate from processed provider rates
+ * Returns the first available rate, prioritizing by provider order
+ */
+export function getPrimaryConversionRate(providerRates) {
+    for (const [, currencyMap] of providerRates) {
+        const usd = currencyMap.get(SUPPORTED_CURRENCIES.USD.contractId);
+        if (usd) {
+            return usd;
+        }
+    }
+    for (const [, currencyMap] of providerRates) {
+        for (const [, rate] of currencyMap.entries()) {
+            return rate;
+        }
+    }
+    return null;
+}
+/**
+ * Get primary conversion rate for a specific currency across all providers
+ */
+export function getPrimaryRateForCurrency(providerRates, currency) {
+    for (const [, currencyMap] of providerRates) {
+        const rates = currencyMap.get(currency);
+        if (rates) {
+            return rates;
+        }
+    }
+    return null;
+}
+/**
+ * Get the primary verifier (payment provider) from conversion rates
+ */
+export function getPrimaryVerifier(providerRates) {
+    const primaryRate = getPrimaryConversionRate(providerRates);
+    return primaryRate?.verifier || null;
+}
+/**
+ * Get the primary currency from conversion rates
+ */
+export function getPrimaryCurrency(providerRates) {
+    const primaryRate = getPrimaryConversionRate(providerRates);
+    return primaryRate?.currency || null;
+}
+/**
+ * Convert token input to currency
+ */
+export const convertTokenInputToCurrency = ({ token, amountOutInt, rate }) => {
+    const oneCent = 10n ** BigInt(token.decimals - 2);
+    const oneEther = 10n ** 18n;
+    const amountInInt = amountOutInt * BigInt(rate) / oneEther;
+    const remainder = amountInInt % oneCent;
+    const negativeSpace = oneCent - remainder;
+    const finalAmountInInt = amountInInt + (negativeSpace === oneCent ? 0n : negativeSpace);
+    return finalAmountInInt;
+};
+/**
+ * Convert currency amount to token amount out (inverse of convertTokenInputToCurrency)
+ * This accounts for the cent-rounding applied in the original function
+ */
+export const convertCurrencyToTokenOutput = ({ token, currency, currencyAmountInt, rate, }) => {
+    const smallestUnit = 10n ** BigInt(token.decimals - currency.decimals);
+    const oneEther = 10n ** 18n;
+    // First, we need to find the original amount before cent-rounding was applied
+    // The original function rounds up to the nearest cent, so we need to find
+    // the maximum token amount that would result in this currency amount after rounding
+    // Start with the direct inverse calculation
+    // console.log('currencyAmountInt', currencyAmountInt, smallestUnit, converter, rate)
+    let tokenAmountOut = (currencyAmountInt * smallestUnit * oneEther) / rate;
+    const remainder = tokenAmountOut % smallestUnit;
+    const finalTokenAmountOut = (tokenAmountOut - remainder);
+    return finalTokenAmountOut;
+};

package/dist/src/currencies.d.ts

@@ -0,0 +1,144 @@
+import { type Hex } from 'viem';
+import { type FormatRateDisplayOptions } from './units.js';
+/**
+ * Relevant info for a currency
+ */
+export interface CurrencyInfo {
+    ticker: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    contractId: Hex;
+    flag: string;
+}
+/**
+ * Country info from the countries.json file
+ */
+export interface CountryInfo {
+    code: string;
+    name: string;
+    country: string;
+    countryCode: string;
+    flag?: string;
+}
+/**
+ * Convert a ticker to a contract ID
+ * @param ticker - The ticker to convert
+ * @returns The contract ID
+ */
+export declare const tickerToContractId: (ticker: string) => Hex;
+/**
+ * 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
+ */
+export declare class Currency implements CurrencyInfo {
+    readonly ticker: string;
+    readonly symbol: string;
+    readonly name: string;
+    readonly decimals: number;
+    readonly contractId: Hex;
+    readonly flag: string;
+    constructor(code: string, symbol: string, name: string, decimals: number, flag?: string);
+    /**
+     * Generate a contract ID for the currency
+     * @returns The contract ID
+     */
+    private generateContractId;
+    /**
+     * Parse an amount to a bigint
+     * @param amount - The amount to parse
+     * @returns The amount as a bigint
+     */
+    parseAmount(amount: string): bigint | null;
+    /**
+     * Format an amount to a string
+     * @param amount - The amount to format
+     * @returns The amount as a string
+     */
+    formatAmount(amount: bigint | null, options?: Partial<FormatRateDisplayOptions>): string | null;
+    /**
+     * Convert to plain object for compatibility
+     * @returns The currency info
+     */
+    toJSON(): CurrencyInfo;
+}
+/**
+ * Generate contract ID for a currency code (standalone function for backward compatibility)
+ * @param currencyCode - The currency code
+ */
+export declare function generateCurrencyId(currencyCode: string): string;
+export declare const SUPPORTED_CURRENCIES: {
+    readonly USD: Currency;
+    readonly EUR: Currency;
+    readonly GBP: Currency;
+    readonly AUD: Currency;
+    readonly CAD: Currency;
+    readonly NZD: Currency;
+    readonly CHF: Currency;
+    readonly SEK: Currency;
+    readonly NOK: Currency;
+    readonly DKK: Currency;
+    readonly PLN: Currency;
+    readonly CZK: Currency;
+    readonly ARS: Currency;
+    readonly CNY: Currency;
+    readonly MXN: Currency;
+    readonly JPY: Currency;
+    readonly THB: Currency;
+    readonly RUB: Currency;
+    readonly AED: Currency;
+    readonly ZAR: Currency;
+    readonly HKD: Currency;
+    readonly SGD: Currency;
+    readonly SAR: Currency;
+    readonly ILS: Currency;
+    readonly IDR: Currency;
+    readonly MYR: Currency;
+    readonly PHP: Currency;
+    readonly VND: Currency;
+    readonly KRW: Currency;
+    readonly INR: Currency;
+    readonly BRL: Currency;
+    readonly KES: Currency;
+    readonly TRY: Currency;
+    readonly UGX: Currency;
+    readonly RON: Currency;
+    readonly HUF: Currency;
+};
+/** Supported currency code */
+export type SupportedCurrencyCode = keyof typeof SUPPORTED_CURRENCIES;
+export declare const currencyById: Map<`0x${string}`, Currency>;
+/**
+ * Get the currency info for a currency code
+ * @param currencyCode - The currency code
+ * @returns The currency info
+ */
+export declare function getCurrencyInfo(currencyCode: string): CurrencyInfo | null;
+/**
+ * Get the currency info for a contract ID
+ * @param contractId - The contract ID
+ * @returns The currency info
+ */
+export declare function getCurrencyByContractId(contractId: string): Currency | null;
+/**
+ * Format a currency amount
+ * @param amount - The amount to format
+ * @param currencyCode - The currency code
+ * @returns The formatted currency amount
+ */
+export declare function formatCurrencyAmount(amount: string | number, currencyCode: string): string;
+/**
+ * Get all supported currencies
+ * @returns All supported currencies
+ */
+export declare function getAllSupportedCurrencies(): CurrencyInfo[];
+/**
+ * Check if a currency is supported
+ * @param currencyCode - The currency code
+ * @returns True if the currency is supported, false otherwise
+ */
+export declare function isSupportedCurrency(currencyCode: string): boolean;

package/dist/src/currencies.js

@@ -0,0 +1,234 @@
+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
+const USD_FLAG_DATA_URL = `data:image/svg+xml;base64,${btoa(USD_FLAG_SVG)}`;
+const EUR_FLAG_DATA_URL = `data:image/svg+xml;base64,${btoa(EUR_FLAG_SVG)}`;
+const countries = countriesData;
+/**
+ * Convert a ticker to a contract ID
+ * @param ticker - The ticker to convert
+ * @returns The contract ID
+ */
+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
+ */
+export class Currency {
+    ticker;
+    symbol;
+    name;
+    decimals;
+    contractId;
+    flag;
+    constructor(code, symbol, name, decimals, flag) {
+        this.ticker = code.toUpperCase();
+        this.symbol = symbol;
+        this.name = name;
+        this.decimals = decimals;
+        this.flag = flag || ''; // figure out a fallback flag
+        this.contractId = this.generateContractId();
+    }
+    /**
+     * Generate a contract ID for the currency
+     * @returns The contract ID
+     */
+    generateContractId() {
+        return tickerToContractId(this.ticker);
+    }
+    /**
+     * Parse an amount to a bigint
+     * @param amount - The amount to parse
+     * @returns The amount as a bigint
+     */
+    parseAmount(amount) {
+        try {
+            return parseUnits(amount, { decimals: this.decimals });
+        }
+        catch (error) {
+            console.error('Error parsing amount: %o', amount, error);
+            return null;
+        }
+    }
+    /**
+     * Format an amount to a string
+     * @param amount - The amount to format
+     * @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);
+            return null;
+        }
+    }
+    /**
+     * Convert to plain object for compatibility
+     * @returns The currency info
+     */
+    toJSON() {
+        return {
+            ticker: this.ticker,
+            symbol: this.symbol,
+            name: this.name,
+            decimals: this.decimals,
+            contractId: this.contractId,
+            flag: this.flag,
+        };
+    }
+}
+/**
+ * Generate contract ID for a currency code (standalone function for backward compatibility)
+ * @param currencyCode - The currency code
+ */
+export function generateCurrencyId(currencyCode) {
+    const bytes = toBytes(currencyCode.toUpperCase());
+    return keccak256(bytes);
+}
+/**
+ * Get the flag for a country
+ * @param countryCode - The country code
+ * @returns The flag image path
+ */
+const flagFromCountries = (countryCode) => {
+    const country = countries.find((country) => country.code === countryCode);
+    return country?.flag || '';
+};
+// Supported fiat currencies with local flag files for major ones
+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),
+    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')),
+    NZD: new Currency('NZD', 'NZ$', 'New Zealand Dollar', 2, flagFromCountries('NZD')),
+    CHF: new Currency('CHF', 'CHF', 'Swiss Franc', 2, flagFromCountries('CHF')),
+    SEK: new Currency('SEK', 'kr', 'Swedish Krona', 2, flagFromCountries('SEK')),
+    NOK: new Currency('NOK', 'kr', 'Norwegian Krone', 2, flagFromCountries('NOK')),
+    DKK: new Currency('DKK', 'kr', 'Danish Krone', 2, flagFromCountries('DKK')),
+    PLN: new Currency('PLN', 'zł', 'Polish Złoty', 2, flagFromCountries('PLN')),
+    CZK: new Currency('CZK', 'Kč', 'Czech Koruna', 2, flagFromCountries('CZK')),
+    ARS: new Currency('ARS', 'ARS', 'Argentine Peso', 2, flagFromCountries('ARS')),
+    CNY: new Currency('CNY', '¥', 'Chinese Yuan', 2, flagFromCountries('CNY')),
+    MXN: new Currency('MXN', 'MX$', 'Mexican Peso', 2, flagFromCountries('MXN')),
+    JPY: new Currency('JPY', '¥', 'Japanese Yen', 0, flagFromCountries('JPY')),
+    THB: new Currency('THB', '฿', 'Thai Baht', 2, flagFromCountries('THB')),
+    RUB: new Currency('RUB', '₽', 'Russian Ruble', 2, flagFromCountries('RUB')),
+    AED: new Currency('AED', 'AED', 'United Arab Emirates Dirham', 2, flagFromCountries('AED')),
+    ZAR: new Currency('ZAR', 'R', 'South African Rand', 2, flagFromCountries('ZAR')),
+    HKD: new Currency('HKD', 'HK$', 'Hong Kong Dollar', 2, flagFromCountries('HKD')),
+    SGD: new Currency('SGD', 'S$', 'Singapore Dollar', 2, flagFromCountries('SGD')),
+    SAR: new Currency('SAR', 'SAR', 'Saudi Riyal', 2, flagFromCountries('SAR')),
+    ILS: new Currency('ILS', '₪', 'Israeli New Shekel', 2, flagFromCountries('ILS')),
+    IDR: new Currency('IDR', 'Rp', 'Indonesian Rupiah', 2, flagFromCountries('IDR')),
+    MYR: new Currency('MYR', 'RM', 'Malaysian Ringgit', 2, flagFromCountries('MYR')),
+    PHP: new Currency('PHP', '₱', 'Philippine Peso', 2, flagFromCountries('PHP')),
+    VND: new Currency('VND', '₫', 'Vietnamese Dong', 0, flagFromCountries('VND')),
+    KRW: new Currency('KRW', '₩', 'South Korean Won', 0, flagFromCountries('KRW')),
+    INR: new Currency('INR', '₹', 'Indian Rupee', 2, flagFromCountries('INR')),
+    BRL: new Currency('BRL', 'R$', 'Brazilian Real', 2, flagFromCountries('BRL')),
+    KES: new Currency('KES', 'KES', 'Kenyan Shilling', 2, flagFromCountries('KES')),
+    TRY: new Currency('TRY', '₺', 'Turkish Lira', 2, flagFromCountries('TRY')),
+    UGX: new Currency('UGX', 'USh', 'Ugandan Shilling', 0, flagFromCountries('UGX')),
+    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 */
+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}`);
+    }
+});
+export const currencyById = new Map(entries.map(([, currency]) => {
+    return [currency.contractId, currency];
+}));
+/**
+ * Get the currency info for a currency code
+ * @param currencyCode - The currency code
+ * @returns The currency info
+ */
+export function getCurrencyInfo(currencyCode) {
+    const currency = SUPPORTED_CURRENCIES[currencyCode.toUpperCase()];
+    return currency ? currency.toJSON() : null;
+}
+/**
+ * Get the currency info for a contract ID
+ * @param contractId - The contract ID
+ * @returns The currency info
+ */
+export function getCurrencyByContractId(contractId) {
+    if (!isHash(contractId)) {
+        throw new Error('Invalid contract ID');
+    }
+    const currency = currencyById.get(contractId);
+    return currency ? currency : null;
+}
+/**
+ * Format currency amount safely without Number() constructor, preserving decimal places
+ * @param value - The value to format
+ * @param decimals - The number of decimals
+ * @returns The formatted currency amount
+ */
+function formatCurrencyToFixedDecimals(value, decimals) {
+    const stringValue = value.toString();
+    const [integerPart, fractionalPart = ''] = stringValue.split('.');
+    if (decimals === 0) {
+        return integerPart;
+    }
+    // Pad or truncate fractional part to desired decimals
+    const paddedFractional = fractionalPart.padEnd(decimals, '0').slice(0, decimals);
+    // For currency formatting, always preserve trailing zeros
+    return `${integerPart}.${paddedFractional}`;
+}
+/**
+ * Format a currency amount
+ * @param amount - The amount to format
+ * @param currencyCode - The currency code
+ * @returns The formatted currency amount
+ */
+export function formatCurrencyAmount(amount, currencyCode) {
+    const currencyInfo = getCurrencyInfo(currencyCode);
+    if (!currencyInfo) {
+        return `${amount} ${currencyCode}`;
+    }
+    // Use currency-specific formatting that preserves decimal places
+    const formatted = formatCurrencyToFixedDecimals(amount, currencyInfo.decimals);
+    // Add thousands separators for better readability
+    const formattedWithSeparators = addThousandsSeparator(formatted);
+    return `${currencyInfo.symbol}${formattedWithSeparators}`;
+}
+/**
+ * Get all supported currencies
+ * @returns All supported currencies
+ */
+export function getAllSupportedCurrencies() {
+    return entries.map(([, currency]) => currency.toJSON());
+}
+/**
+ * Check if a currency is supported
+ * @param currencyCode - The currency code
+ * @returns True if the currency is supported, false otherwise
+ */
+export function isSupportedCurrency(currencyCode) {
+    return currencyCode.toUpperCase() in SUPPORTED_CURRENCIES;
+}