@cygnus-wealth/asset-valuator 0.1.0 → 0.2.0

package/dist/asset-valuator.js

@@ -1,9 +1,9 @@
-import { CoinGeckoProvider } from './providers/coingecko.js';
+import { DecentralizedAggregator } from './providers/decentralized-aggregator.js';
 export class AssetValuator {
     constructor(provider) {
         this.cache = new Map();
         this.cacheTimeout = 60000; // 1 minute
-        this.provider = provider || new CoinGeckoProvider();
+        this.provider = provider || new DecentralizedAggregator();
     }
     getCacheKey(base, quote) {
         return `${base.toUpperCase()}_${quote.toUpperCase()}`;

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 export { AssetValuator } from './asset-valuator.js';
 export { CoinGeckoProvider } from './providers/coingecko.js';
+export { CoinPaprikaProvider } from './providers/coinpaprika.js';
+export { DecentralizedAggregator } from './providers/decentralized-aggregator.js';
+export { RateLimiter } from './utils/rate-limiter.js';
+export { EdgeCache } from './utils/edge-cache.js';
 export { DataModelConverter } from './converters/data-model-converter.js';
 export type { PriceData, AssetPrice, PriceProvider, SupportedCurrency, ConversionOptions } from './types.js';

package/dist/index.js

@@ -1,3 +1,7 @@
 export { AssetValuator } from './asset-valuator.js';
 export { CoinGeckoProvider } from './providers/coingecko.js';
+export { CoinPaprikaProvider } from './providers/coinpaprika.js';
+export { DecentralizedAggregator } from './providers/decentralized-aggregator.js';
+export { RateLimiter } from './utils/rate-limiter.js';
+export { EdgeCache } from './utils/edge-cache.js';
 export { DataModelConverter } from './converters/data-model-converter.js';

package/dist/providers/coingecko.d.ts

@@ -1,6 +1,7 @@
 import { PriceData, PriceProvider } from '../types.js';
 export declare class CoinGeckoProvider implements PriceProvider {
     private baseUrl;
+    private stablecoins;
     private symbolToIdMap;
     private getCoingeckoId;
     fetchPrice(symbol: string, currency?: string): Promise<PriceData>;

package/dist/providers/coingecko.js

@@ -2,10 +2,12 @@ import axios from 'axios';
 export class CoinGeckoProvider {
     constructor() {
         this.baseUrl = 'https://api.coingecko.com/api/v3';
+        this.stablecoins = new Set(['USDC', 'USDT', 'DAI']);
         this.symbolToIdMap = new Map([
             ['BTC', 'bitcoin'],
             ['ETH', 'ethereum'],
             ['USDT', 'tether'],
+            ['USDC', 'usd-coin'],
             ['BNB', 'binancecoin'],
             ['SOL', 'solana'],
             ['XRP', 'ripple'],
@@ -18,6 +20,15 @@ export class CoinGeckoProvider {
             ['UNI', 'uniswap'],
             ['ATOM', 'cosmos'],
             ['LTC', 'litecoin'],
+            ['DAI', 'dai'],
+            ['WBTC', 'wrapped-bitcoin'],
+            ['AAVE', 'aave'],
+            ['COMP', 'compound-governance-token'],
+            ['CRV', 'curve-dao-token'],
+            ['MKR', 'maker'],
+            ['SNX', 'synthetix-network-token'],
+            ['SUSHI', 'sushi'],
+            ['YFI', 'yearn-finance'],
         ]);
     }
     getCoingeckoId(symbol) {
@@ -44,6 +55,14 @@ export class CoinGeckoProvider {
             };
         }
         catch (error) {
+            // For stablecoins, return 1 USD if we can't fetch the price
+            if (this.stablecoins.has(symbol.toUpperCase()) && currency.toLowerCase() === 'usd') {
+                return {
+                    symbol: symbol.toUpperCase(),
+                    price: 1,
+                    timestamp: new Date()
+                };
+            }
             if (axios.isAxiosError(error)) {
                 throw new Error(`Failed to fetch price: ${error.message}`);
             }
@@ -72,10 +91,38 @@ export class CoinGeckoProvider {
                         timestamp
                     });
                 }
+                else if (this.stablecoins.has(symbol.toUpperCase()) && currency.toLowerCase() === 'usd') {
+                    // For stablecoins, return 1 USD if price is not found
+                    results.push({
+                        symbol: symbol.toUpperCase(),
+                        price: 1,
+                        timestamp
+                    });
+                }
             }
             return results;
         }
         catch (error) {
+            // If the entire request fails, check if any symbols are stablecoins
+            const results = [];
+            const timestamp = new Date();
+            for (const symbol of symbols) {
+                if (this.stablecoins.has(symbol.toUpperCase()) && currency.toLowerCase() === 'usd') {
+                    results.push({
+                        symbol: symbol.toUpperCase(),
+                        price: 1,
+                        timestamp
+                    });
+                }
+            }
+            // If we have stablecoin results, return them; otherwise throw the error
+            if (results.length > 0) {
+                // For non-stablecoins, we still need to throw an error
+                if (results.length < symbols.length) {
+                    console.warn(`Failed to fetch prices for some assets: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                }
+                return results;
+            }
             if (axios.isAxiosError(error)) {
                 throw new Error(`Failed to fetch prices: ${error.message}`);
             }

package/dist/providers/coinpaprika.d.ts

@@ -0,0 +1,8 @@
+import { PriceData, PriceProvider } from '../types.js';
+export declare class CoinPaprikaProvider implements PriceProvider {
+    private baseUrl;
+    private symbolToIdMap;
+    private getCoinPaprikaId;
+    fetchPrice(symbol: string, currency?: string): Promise<PriceData>;
+    fetchMultiplePrices(symbols: string[], currency?: string): Promise<PriceData[]>;
+}

package/dist/providers/coinpaprika.js

@@ -0,0 +1,64 @@
+import axios from 'axios';
+export class CoinPaprikaProvider {
+    constructor() {
+        this.baseUrl = 'https://api.coinpaprika.com/v1';
+        this.symbolToIdMap = new Map([
+            ['BTC', 'btc-bitcoin'],
+            ['ETH', 'eth-ethereum'],
+            ['USDT', 'usdt-tether'],
+            ['USDC', 'usdc-usd-coin'],
+            ['BNB', 'bnb-binance-coin'],
+            ['SOL', 'sol-solana'],
+            ['XRP', 'xrp-xrp'],
+            ['ADA', 'ada-cardano'],
+            ['DOGE', 'doge-dogecoin'],
+            ['AVAX', 'avax-avalanche'],
+            ['DOT', 'dot-polkadot'],
+            ['MATIC', 'matic-polygon'],
+            ['LINK', 'link-chainlink'],
+            ['UNI', 'uni-uniswap'],
+            ['ATOM', 'atom-cosmos'],
+            ['LTC', 'ltc-litecoin'],
+            ['DAI', 'dai-dai'],
+        ]);
+    }
+    getCoinPaprikaId(symbol) {
+        return this.symbolToIdMap.get(symbol.toUpperCase()) || `${symbol.toLowerCase()}-${symbol.toLowerCase()}`;
+    }
+    async fetchPrice(symbol, currency = 'usd') {
+        const id = this.getCoinPaprikaId(symbol);
+        const url = `${this.baseUrl}/tickers/${id}`;
+        try {
+            const response = await axios.get(url);
+            const data = response.data;
+            if (!data || !data.quotes || !data.quotes.USD) {
+                throw new Error(`Price not found for ${symbol}`);
+            }
+            // CoinPaprika only provides USD prices in free tier
+            const priceInUSD = data.quotes.USD.price;
+            let price = priceInUSD;
+            if (currency.toLowerCase() !== 'usd') {
+                // For other currencies, we'd need to convert
+                // This is a limitation of the free API
+                throw new Error(`CoinPaprika free tier only supports USD prices`);
+            }
+            return {
+                symbol: symbol.toUpperCase(),
+                price,
+                timestamp: new Date()
+            };
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                throw new Error(`Failed to fetch price from CoinPaprika: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    async fetchMultiplePrices(symbols, currency = 'usd') {
+        // CoinPaprika requires individual requests for each coin
+        const promises = symbols.map(symbol => this.fetchPrice(symbol, currency).catch(() => null));
+        const results = await Promise.all(promises);
+        return results.filter((result) => result !== null);
+    }
+}

package/dist/providers/decentralized-aggregator.d.ts

@@ -0,0 +1,30 @@
+import { PriceData, PriceProvider } from '../types.js';
+export interface AggregatorOptions {
+    providers?: PriceProvider[];
+    cacheOptions?: {
+        storage?: 'memory' | 'localStorage' | 'indexedDB';
+        ttl?: number;
+    };
+    rateLimitOptions?: {
+        maxRequests?: number;
+        windowMs?: number;
+    };
+    consensusThreshold?: number;
+}
+export declare class DecentralizedAggregator implements PriceProvider {
+    private providers;
+    private rateLimiter;
+    private cache;
+    private consensusThreshold;
+    constructor(options?: AggregatorOptions);
+    private selectBestStorage;
+    fetchPrice(symbol: string, currency?: string): Promise<PriceData>;
+    fetchMultiplePrices(symbols: string[], currency?: string): Promise<PriceData[]>;
+    private fetchFromProviders;
+    private calculateConsensusPrice;
+    private groupBySymbol;
+    addProvider(provider: PriceProvider): void;
+    removeProvider(index: number): void;
+    clearCache(): Promise<void>;
+    resetRateLimiter(): void;
+}

package/dist/providers/decentralized-aggregator.js

@@ -0,0 +1,174 @@
+import { CoinGeckoProvider } from './coingecko.js';
+import { CoinPaprikaProvider } from './coinpaprika.js';
+import { RateLimiter } from '../utils/rate-limiter.js';
+import { EdgeCache } from '../utils/edge-cache.js';
+import { hasIndexedDB, hasLocalStorage } from '../utils/browser-detect.js';
+export class DecentralizedAggregator {
+    constructor(options = {}) {
+        // Default providers
+        this.providers = options.providers || [
+            new CoinGeckoProvider(),
+            new CoinPaprikaProvider(),
+        ];
+        // Rate limiter with conservative defaults for edge devices
+        this.rateLimiter = new RateLimiter({
+            maxRequests: options.rateLimitOptions?.maxRequests || 5,
+            windowMs: options.rateLimitOptions?.windowMs || 60000, // 1 minute
+            retryAfterMs: 2000,
+            maxRetries: 3
+        });
+        // Edge cache with automatic storage selection
+        this.cache = new EdgeCache({
+            storage: options.cacheOptions?.storage || this.selectBestStorage(),
+            defaultTTL: options.cacheOptions?.ttl || 60000, // 60 seconds
+            maxSize: 500
+        });
+        this.consensusThreshold = options.consensusThreshold || 0.5;
+    }
+    selectBestStorage() {
+        if (hasIndexedDB()) {
+            return 'indexedDB';
+        }
+        else if (hasLocalStorage()) {
+            return 'localStorage';
+        }
+        return 'memory';
+    }
+    async fetchPrice(symbol, currency = 'usd') {
+        const cacheKey = `${symbol}-${currency}`;
+        // Check cache first
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        // Use rate limiter to fetch from providers
+        return this.rateLimiter.execute(cacheKey, async () => {
+            const results = await this.fetchFromProviders(symbol, currency);
+            if (results.length === 0) {
+                throw new Error(`No price data available for ${symbol}`);
+            }
+            // Calculate consensus price
+            const consensusPrice = this.calculateConsensusPrice(results);
+            const priceData = {
+                symbol: symbol.toUpperCase(),
+                price: consensusPrice,
+                timestamp: new Date()
+            };
+            // Cache the result
+            await this.cache.set(cacheKey, priceData);
+            return priceData;
+        });
+    }
+    async fetchMultiplePrices(symbols, currency = 'usd') {
+        // Check cache for all symbols
+        const results = [];
+        const uncachedSymbols = [];
+        for (const symbol of symbols) {
+            const cached = await this.cache.get(`${symbol}-${currency}`);
+            if (cached) {
+                results.push(cached);
+            }
+            else {
+                uncachedSymbols.push(symbol);
+            }
+        }
+        // Fetch uncached symbols
+        if (uncachedSymbols.length > 0) {
+            const batchKey = `batch-${uncachedSymbols.join(',')}-${currency}`;
+            const fetchedPrices = await this.rateLimiter.execute(batchKey, async () => {
+                const allResults = [];
+                // Try each provider
+                for (const provider of this.providers) {
+                    try {
+                        const providerResults = await provider.fetchMultiplePrices(uncachedSymbols, currency);
+                        allResults.push(...providerResults);
+                    }
+                    catch (error) {
+                        console.warn(`Provider failed:`, error);
+                    }
+                }
+                // Group by symbol and calculate consensus
+                const grouped = this.groupBySymbol(allResults);
+                const consensusPrices = [];
+                for (const [symbol, prices] of grouped.entries()) {
+                    if (prices.length > 0) {
+                        const consensusPrice = this.calculateConsensusPrice(prices);
+                        const priceData = {
+                            symbol,
+                            price: consensusPrice,
+                            timestamp: new Date()
+                        };
+                        consensusPrices.push(priceData);
+                        // Cache individual results
+                        await this.cache.set(`${symbol}-${currency}`, priceData);
+                    }
+                }
+                return consensusPrices;
+            });
+            results.push(...fetchedPrices);
+        }
+        return results;
+    }
+    async fetchFromProviders(symbol, currency) {
+        const results = [];
+        // Try each provider sequentially with fallback
+        for (const provider of this.providers) {
+            try {
+                const price = await provider.fetchPrice(symbol, currency);
+                results.push(price);
+                // If we have enough providers for consensus, we can stop
+                if (results.length >= Math.ceil(this.providers.length * this.consensusThreshold)) {
+                    break;
+                }
+            }
+            catch (error) {
+                console.warn(`Provider failed for ${symbol}:`, error);
+                // Continue to next provider
+            }
+        }
+        return results;
+    }
+    calculateConsensusPrice(prices) {
+        if (prices.length === 0) {
+            throw new Error('No prices available for consensus');
+        }
+        if (prices.length === 1) {
+            return prices[0].price;
+        }
+        // Sort prices
+        const sortedPrices = prices.map(p => p.price).sort((a, b) => a - b);
+        // Remove outliers (prices that deviate more than 10% from median)
+        const median = sortedPrices[Math.floor(sortedPrices.length / 2)];
+        const filtered = sortedPrices.filter(price => Math.abs(price - median) / median <= 0.1);
+        // If too many outliers, use median
+        if (filtered.length < prices.length * this.consensusThreshold) {
+            return median;
+        }
+        // Calculate average of filtered prices
+        return filtered.reduce((sum, price) => sum + price, 0) / filtered.length;
+    }
+    groupBySymbol(prices) {
+        const grouped = new Map();
+        for (const price of prices) {
+            const symbol = price.symbol.toUpperCase();
+            if (!grouped.has(symbol)) {
+                grouped.set(symbol, []);
+            }
+            grouped.get(symbol).push(price);
+        }
+        return grouped;
+    }
+    // Utility methods for managing the aggregator
+    addProvider(provider) {
+        this.providers.push(provider);
+    }
+    removeProvider(index) {
+        this.providers.splice(index, 1);
+    }
+    async clearCache() {
+        await this.cache.clear();
+    }
+    resetRateLimiter() {
+        this.rateLimiter.reset();
+    }
+}

package/dist/utils/browser-detect.d.ts

@@ -0,0 +1,9 @@
+declare global {
+    interface Window {
+        indexedDB: any;
+        localStorage: Storage;
+    }
+}
+export declare function isBrowser(): boolean;
+export declare function hasIndexedDB(): boolean;
+export declare function hasLocalStorage(): boolean;

package/dist/utils/browser-detect.js

@@ -0,0 +1,18 @@
+export function isBrowser() {
+    return typeof globalThis !== 'undefined' &&
+        typeof globalThis.window !== 'undefined' &&
+        typeof globalThis.window.document !== 'undefined';
+}
+export function hasIndexedDB() {
+    return isBrowser() && 'indexedDB' in globalThis.window;
+}
+export function hasLocalStorage() {
+    try {
+        return isBrowser() &&
+            'localStorage' in globalThis.window &&
+            globalThis.window.localStorage !== null;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/edge-cache.d.ts

@@ -0,0 +1,24 @@
+export interface CacheEntry<T> {
+    data: T;
+    timestamp: number;
+    ttl: number;
+}
+export interface EdgeCacheOptions {
+    defaultTTL?: number;
+    maxSize?: number;
+    storage?: 'memory' | 'localStorage' | 'indexedDB';
+}
+export declare class EdgeCache {
+    private memoryCache;
+    private options;
+    private dbName;
+    private storeName;
+    private db;
+    constructor(options?: EdgeCacheOptions);
+    private initIndexedDB;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, data: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+    private evictOldest;
+}

package/dist/utils/edge-cache.js

@@ -0,0 +1,212 @@
+import { hasIndexedDB, hasLocalStorage } from './browser-detect.js';
+export class EdgeCache {
+    constructor(options = {}) {
+        this.memoryCache = new Map();
+        this.dbName = 'asset-valuator-cache';
+        this.storeName = 'prices';
+        this.db = null;
+        this.options = {
+            defaultTTL: options.defaultTTL || 60000, // 60 seconds
+            maxSize: options.maxSize || 1000,
+            storage: options.storage || 'memory'
+        };
+        if (this.options.storage === 'indexedDB' && hasIndexedDB()) {
+            this.initIndexedDB();
+        }
+    }
+    async initIndexedDB() {
+        try {
+            const request = globalThis.window.indexedDB.open(this.dbName, 1);
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    db.createObjectStore(this.storeName, { keyPath: 'key' });
+                }
+            };
+            this.db = await new Promise((resolve, reject) => {
+                request.onsuccess = () => resolve(request.result);
+                request.onerror = () => reject(request.error);
+            });
+        }
+        catch (error) {
+            console.warn('IndexedDB initialization failed, falling back to memory cache', error);
+            this.options.storage = 'memory';
+        }
+    }
+    async get(key) {
+        const now = Date.now();
+        switch (this.options.storage) {
+            case 'localStorage':
+                if (hasLocalStorage()) {
+                    try {
+                        const stored = localStorage.getItem(`cache_${key}`);
+                        if (stored) {
+                            const entry = JSON.parse(stored);
+                            if (now - entry.timestamp < entry.ttl) {
+                                return entry.data;
+                            }
+                            localStorage.removeItem(`cache_${key}`);
+                        }
+                    }
+                    catch (error) {
+                        console.warn('localStorage read failed', error);
+                    }
+                }
+                break;
+            case 'indexedDB':
+                if (this.db) {
+                    try {
+                        const transaction = this.db.transaction([this.storeName], 'readonly');
+                        const store = transaction.objectStore(this.storeName);
+                        const request = store.get(key);
+                        const result = await new Promise((resolve, reject) => {
+                            request.onsuccess = () => resolve(request.result);
+                            request.onerror = () => reject(request.error);
+                        });
+                        if (result && now - result.timestamp < result.ttl) {
+                            return result.data;
+                        }
+                        // Clean up expired entry
+                        if (result) {
+                            this.delete(key);
+                        }
+                    }
+                    catch (error) {
+                        console.warn('IndexedDB read failed', error);
+                    }
+                }
+                break;
+            default: // memory
+                const entry = this.memoryCache.get(key);
+                if (entry && now - entry.timestamp < entry.ttl) {
+                    return entry.data;
+                }
+                if (entry) {
+                    this.memoryCache.delete(key);
+                }
+        }
+        return null;
+    }
+    async set(key, data, ttl) {
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            ttl: ttl || this.options.defaultTTL
+        };
+        switch (this.options.storage) {
+            case 'localStorage':
+                if (hasLocalStorage()) {
+                    try {
+                        localStorage.setItem(`cache_${key}`, JSON.stringify(entry));
+                        // Enforce max size for localStorage
+                        if (localStorage.length > this.options.maxSize) {
+                            this.evictOldest();
+                        }
+                    }
+                    catch (error) {
+                        console.warn('localStorage write failed', error);
+                        // Fall back to memory cache
+                        this.memoryCache.set(key, entry);
+                    }
+                }
+                break;
+            case 'indexedDB':
+                if (this.db) {
+                    try {
+                        const transaction = this.db.transaction([this.storeName], 'readwrite');
+                        const store = transaction.objectStore(this.storeName);
+                        await new Promise((resolve, reject) => {
+                            const request = store.put({ key, ...entry });
+                            request.onsuccess = () => resolve();
+                            request.onerror = () => reject(request.error);
+                        });
+                    }
+                    catch (error) {
+                        console.warn('IndexedDB write failed', error);
+                        // Fall back to memory cache
+                        this.memoryCache.set(key, entry);
+                    }
+                }
+                break;
+            default: // memory
+                this.memoryCache.set(key, entry);
+                // Enforce max size for memory cache
+                if (this.memoryCache.size > this.options.maxSize) {
+                    const firstKey = this.memoryCache.keys().next().value;
+                    this.memoryCache.delete(firstKey);
+                }
+        }
+    }
+    async delete(key) {
+        switch (this.options.storage) {
+            case 'localStorage':
+                if (hasLocalStorage()) {
+                    localStorage.removeItem(`cache_${key}`);
+                }
+                break;
+            case 'indexedDB':
+                if (this.db) {
+                    try {
+                        const transaction = this.db.transaction([this.storeName], 'readwrite');
+                        const store = transaction.objectStore(this.storeName);
+                        store.delete(key);
+                    }
+                    catch (error) {
+                        console.warn('IndexedDB delete failed', error);
+                    }
+                }
+                break;
+            default:
+                this.memoryCache.delete(key);
+        }
+    }
+    async clear() {
+        switch (this.options.storage) {
+            case 'localStorage':
+                if (hasLocalStorage()) {
+                    const keys = Object.keys(localStorage);
+                    keys.forEach(key => {
+                        if (key.startsWith('cache_')) {
+                            localStorage.removeItem(key);
+                        }
+                    });
+                }
+                break;
+            case 'indexedDB':
+                if (this.db) {
+                    try {
+                        const transaction = this.db.transaction([this.storeName], 'readwrite');
+                        const store = transaction.objectStore(this.storeName);
+                        store.clear();
+                    }
+                    catch (error) {
+                        console.warn('IndexedDB clear failed', error);
+                    }
+                }
+                break;
+            default:
+                this.memoryCache.clear();
+        }
+    }
+    evictOldest() {
+        if (hasLocalStorage()) {
+            const cacheKeys = Object.keys(localStorage)
+                .filter(key => key.startsWith('cache_'))
+                .map(key => {
+                try {
+                    const entry = JSON.parse(localStorage.getItem(key) || '{}');
+                    return { key, timestamp: entry.timestamp || 0 };
+                }
+                catch {
+                    return { key, timestamp: 0 };
+                }
+            })
+                .sort((a, b) => a.timestamp - b.timestamp);
+            // Remove oldest 10% of entries
+            const toRemove = Math.ceil(cacheKeys.length * 0.1);
+            cacheKeys.slice(0, toRemove).forEach(({ key }) => {
+                localStorage.removeItem(key);
+            });
+        }
+    }
+}

package/dist/utils/rate-limiter.d.ts

@@ -0,0 +1,16 @@
+export interface RateLimiterOptions {
+    maxRequests: number;
+    windowMs: number;
+    retryAfterMs?: number;
+    maxRetries?: number;
+}
+export declare class RateLimiter {
+    private options;
+    private requests;
+    private retryCount;
+    constructor(options: RateLimiterOptions);
+    execute<T>(key: string, fn: () => Promise<T>): Promise<T>;
+    private sleep;
+    private is429Error;
+    reset(): void;
+}

package/dist/utils/rate-limiter.js

@@ -0,0 +1,60 @@
+export class RateLimiter {
+    constructor(options) {
+        this.options = options;
+        this.requests = [];
+        this.retryCount = new Map();
+        this.options.retryAfterMs = options.retryAfterMs || 1000;
+        this.options.maxRetries = options.maxRetries || 3;
+    }
+    async execute(key, fn) {
+        const now = Date.now();
+        // Clean up old requests
+        this.requests = this.requests.filter(time => now - time < this.options.windowMs);
+        // Check if we're at the limit
+        if (this.requests.length >= this.options.maxRequests) {
+            const retries = this.retryCount.get(key) || 0;
+            if (retries >= this.options.maxRetries) {
+                this.retryCount.delete(key);
+                throw new Error('Rate limit exceeded. Please try again later.');
+            }
+            // Exponential backoff
+            const backoffMs = this.options.retryAfterMs * Math.pow(2, retries);
+            await this.sleep(backoffMs);
+            this.retryCount.set(key, retries + 1);
+            return this.execute(key, fn);
+        }
+        // Execute the function
+        this.requests.push(now);
+        this.retryCount.delete(key);
+        try {
+            return await fn();
+        }
+        catch (error) {
+            // If it's a 429 error, apply backoff
+            if (this.is429Error(error)) {
+                const retries = this.retryCount.get(key) || 0;
+                if (retries >= this.options.maxRetries) {
+                    this.retryCount.delete(key);
+                    throw error;
+                }
+                const backoffMs = this.options.retryAfterMs * Math.pow(2, retries);
+                await this.sleep(backoffMs);
+                this.retryCount.set(key, retries + 1);
+                return this.execute(key, fn);
+            }
+            throw error;
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    is429Error(error) {
+        return error?.response?.status === 429 ||
+            error?.code === 'ERR_RATE_LIMITED' ||
+            (error?.message && error.message.includes('429'));
+    }
+    reset() {
+        this.requests = [];
+        this.retryCount.clear();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cygnus-wealth/asset-valuator",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Asset valuation library for retrieving and converting cryptocurrency prices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,6 +40,7 @@
     "eslint": "^9.32.0",
     "jest": "^30.0.5",
     "ts-jest": "^29.4.0",
+    "tsx": "^4.7.0",
     "typescript": "^5.8.3"
   }
 }