crypull 1.0.0

package/src/cli.ts

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import pc from 'picocolors';
+import * as asciichart from 'asciichart';
+import { crypull } from './index.js';
+
+const program = new Command();
+
+program
+  .name('crypull')
+  .description('A human-friendly CLI to fetch crypto prices and info from multiple providers')
+  .version('1.0.0');
+
+program
+  .command('price <query>')
+  .description('Get the current price of a cryptocurrency (symbol or contract address)')
+  .action(async (query: string) => {
+    console.log(pc.cyan(`\nFetching price for ${pc.bold(query)}...`));
+    
+    const data = await crypull.price(query);
+    
+    if (!data) {
+      console.log(pc.red(`\n✖ Could not find price for "${query}".`));
+      return;
+    }
+
+    console.log(pc.green(`\n✔ Success! Found via ${pc.bold(data.source)}`));
+    console.log(pc.white(`----------------------------------------`));
+    console.log(`${pc.gray('Symbol:')}    ${pc.yellow(pc.bold(data.symbol))}`);
+    console.log(`${pc.gray('Price:')}     ${pc.green('$' + data.priceUsd.toLocaleString(undefined, { maximumFractionDigits: 6 }))}`);
+    console.log(`${pc.gray('Updated:')}   ${new Date(data.lastUpdated).toLocaleTimeString()}`);
+    console.log(pc.white(`----------------------------------------\n`));
+  });
+
+program
+  .command('info <query>')
+  .description('Get detailed info about a cryptocurrency (market cap, volume, FDV, etc.)')
+  .action(async (query: string) => {
+    console.log(pc.cyan(`\nFetching detailed info for ${pc.bold(query)}...`));
+    
+    const data = await crypull.info(query);
+    
+    if (!data) {
+      console.log(pc.red(`\n✖ Could not find info for "${query}".`));
+      return;
+    }
+
+    console.log(pc.green(`\n✔ Success! Found via ${pc.bold(data.source)}`));
+    console.log(pc.white(`----------------------------------------`));
+    console.log(`${pc.gray('Name:')}      ${pc.white(pc.bold(data.name))}`);
+    console.log(`${pc.gray('Symbol:')}    ${pc.yellow(pc.bold(data.symbol))}`);
+    console.log(`${pc.gray('Price:')}     ${pc.green('$' + data.priceUsd.toLocaleString(undefined, { maximumFractionDigits: 6 }))}`);
+    
+    if (data.marketCap) {
+      console.log(`${pc.gray('MarketCap:')} ${pc.white('$' + data.marketCap.toLocaleString())}`);
+    }
+    if (data.marketCapRank) {
+      console.log(`${pc.gray('Rank:')}      ${pc.magenta('#' + data.marketCapRank)}`);
+    }
+    if (data.fdv) {
+      console.log(`${pc.gray('FDV:')}       ${pc.white('$' + data.fdv.toLocaleString())}`);
+    }
+    if (data.circulatingSupply) {
+      console.log(`${pc.gray('Circ. Sup:')} ${pc.white(data.circulatingSupply.toLocaleString())}`);
+    }
+    if (data.totalSupply) {
+      console.log(`${pc.gray('Total Sup:')} ${pc.white(data.totalSupply.toLocaleString())}`);
+    }
+    if (data.maxSupply) {
+      console.log(`${pc.gray('Max Sup:')}   ${pc.white(data.maxSupply.toLocaleString())}`);
+    }
+    if (data.volume24h) {
+      console.log(`${pc.gray('24h Vol:')}   ${pc.white('$' + data.volume24h.toLocaleString())}`);
+    }
+    if (data.priceChangePercentage24h !== undefined) {
+      const pc24 = data.priceChangePercentage24h;
+      const color = pc24 >= 0 ? pc.green : pc.red;
+      console.log(`${pc.gray('24h %:')}     ${color(pc24.toFixed(2) + '%')}`);
+    }
+    if (data.liquidityUsd) {
+      console.log(`${pc.gray('Liquidity:')} ${pc.white('$' + data.liquidityUsd.toLocaleString())}`);
+    }
+    if (data.ath) {
+      console.log(`${pc.gray('ATH:')}       ${pc.green('$' + data.ath.toLocaleString())} ${data.athDate ? pc.gray(`(${new Date(data.athDate).toLocaleDateString()})`) : ''}`);
+    }
+    if (data.atl) {
+      console.log(`${pc.gray('ATL:')}       ${pc.red('$' + data.atl.toLocaleString())} ${data.atlDate ? pc.gray(`(${new Date(data.atlDate).toLocaleDateString()})`) : ''}`);
+    }
+    if (data.network) {
+      console.log(`${pc.gray('Network:')}   ${pc.magenta(data.network)}`);
+    }
+    if (data.address) {
+      console.log(`${pc.gray('Address:')}   ${pc.gray(data.address)}`);
+    }
+
+    if (data.links && Object.values(data.links).some(l => !!l)) {
+      console.log(pc.white(`\n--- Links ---`));
+      if (data.links.website) console.log(`${pc.gray('Website:')}   ${pc.blue(data.links.website)}`);
+      if (data.links.twitter) console.log(`${pc.gray('Twitter:')}   ${pc.blue(data.links.twitter)}`);
+      if (data.links.telegram) console.log(`${pc.gray('Telegram:')}  ${pc.blue(data.links.telegram)}`);
+      if (data.links.discord) console.log(`${pc.gray('Discord:')}   ${pc.blue(data.links.discord)}`);
+      if (data.links.github) console.log(`${pc.gray('GitHub:')}    ${pc.blue(data.links.github)}`);
+    }
+
+    if (data.description && data.description.length > 0) {
+      console.log(pc.white(`\n--- Description ---`));
+      // Truncate to 300 chars to not flood terminal
+      const desc = data.description.replace(/(<([^>]+)>)/gi, ""); // strip html
+      const truncated = desc.length > 300 ? desc.substring(0, 300) + '...' : desc;
+      console.log(pc.gray(truncated));
+    }
+
+    if (data.pairs && data.pairs.length > 0) {
+      console.log(pc.white(`\n--- Top Trading Pairs ---`));
+      data.pairs.slice(0, 5).forEach((p, i) => {
+        const title = `${p.baseTokenSymbol}/${p.quoteTokenSymbol}`;
+        const priceStr = p.priceUsd ? `$${p.priceUsd.toLocaleString(undefined, { maximumFractionDigits: 6 })}` : 'N/A';
+        const volStr = p.volume24h ? `$${p.volume24h.toLocaleString(undefined, { maximumFractionDigits: 0 })}` : 'N/A';
+        console.log(`${pc.blue(String(i + 1) + '.')} ${pc.yellow(title.padEnd(12, ' '))} | ${pc.green(priceStr.padEnd(12, ' '))} | Vol: ${pc.white(volStr)} | DEX: ${pc.magenta(p.dexId)}`);
+      });
+    }
+    
+    console.log(pc.white(`\n----------------------------------------`));
+    console.log(`${pc.gray('Updated:')}   ${new Date(data.lastUpdated).toLocaleTimeString()}`);
+    console.log(pc.white(`----------------------------------------\n`));
+  });
+
+program
+  .command('top')
+  .description('Show top 50 cryptocurrencies by market cap')
+  .action(async () => {
+    console.log(pc.cyan(`\nFetching top 50 cryptocurrencies...`));
+    
+    const results = await crypull.top();
+    
+    if (!results || results.length === 0) {
+      console.log(pc.red(`\n✖ Could not fetch top coins at this time.`));
+      return;
+    }
+
+    console.log(pc.green(`\n✔ Top 50 Cryptocurrencies:`));
+    console.log(pc.white(`----------------------------------------`));
+    
+    results.forEach((res, i) => {
+      const priceStr = res.priceUsd ? `$${res.priceUsd.toLocaleString(undefined, { maximumFractionDigits: 6 })}` : 'N/A';
+      const mcapStr = res.marketCap ? `$${res.marketCap.toLocaleString()}` : 'N/A';
+      
+      let changeStr = '';
+      if (res.priceChange24h !== undefined && res.priceChange24h !== null) {
+        const color = res.priceChange24h >= 0 ? pc.green : pc.red;
+        changeStr = color(`(${res.priceChange24h >= 0 ? '+' : ''}${res.priceChange24h.toFixed(2)}%)`);
+      }
+      
+      console.log(`${pc.blue(String(i + 1).padStart(2, ' '))}. ${pc.yellow(pc.bold(res.symbol.padEnd(8, ' ')))} | ${pc.green(priceStr.padEnd(12, ' '))} ${changeStr.padEnd(15, ' ')} | Mcap: ${pc.white(mcapStr)}`);
+    });
+    
+    console.log(pc.white(`----------------------------------------\n`));
+  });
+
+program
+  .command('search <query>')
+  .description('Search for tokens or coins across multiple providers')
+  .action(async (query: string) => {
+    console.log(pc.cyan(`\nSearching for ${pc.bold(query)}...`));
+    
+    const results = await crypull.search(query);
+    
+    if (!results || results.length === 0) {
+      console.log(pc.red(`\n✖ No results found for "${query}".`));
+      return;
+    }
+
+    console.log(pc.green(`\n✔ Found ${results.length} results:`));
+    console.log(pc.white(`----------------------------------------`));
+    
+    results.forEach((res, i) => {
+      console.log(`${pc.blue(String(i + 1).padStart(2, ' '))}. ${pc.yellow(pc.bold(res.symbol.padEnd(8, ' ')))} | ${pc.white(res.name)} ${pc.gray(`(via ${res.source})`)}`);
+      if (res.network) {
+        console.log(`    ${pc.gray('Network:')} ${pc.magenta(res.network)}`);
+      }
+      if (res.id && res.id.length > 20) {
+        console.log(`    ${pc.gray('Address:')} ${pc.gray(res.id)}`);
+      }
+    });
+    
+    console.log(pc.white(`----------------------------------------\n`));
+  });
+
+program
+  .command('trending')
+  .description('Show top 10 trending coins/tokens right now')
+  .action(async () => {
+    console.log(pc.cyan(`\nFetching top trending coins...`));
+    
+    const results = await crypull.trending();
+    
+    if (!results || results.length === 0) {
+      console.log(pc.red(`\n✖ Could not fetch trending data at this time.`));
+      return;
+    }
+
+    console.log(pc.green(`\n✔ Top 10 Trending Coins:`));
+    console.log(pc.white(`----------------------------------------`));
+    
+    results.forEach((res, i) => {
+      const priceStr = res.priceUsd ? `$${res.priceUsd.toLocaleString(undefined, { maximumFractionDigits: 6 })}` : 'N/A';
+      let changeStr = '';
+      if (res.priceChange24h !== undefined) {
+        const color = res.priceChange24h >= 0 ? pc.green : pc.red;
+        changeStr = color(`(${res.priceChange24h >= 0 ? '+' : ''}${res.priceChange24h.toFixed(2)}%)`);
+      }
+      const rankStr = res.marketCapRank ? pc.magenta(`#${res.marketCapRank}`) : '';
+      
+      console.log(`${pc.blue(String(i + 1).padStart(2, ' '))}. ${pc.yellow(pc.bold(res.symbol.padEnd(8, ' ')))} | ${pc.green(priceStr.padEnd(12, ' '))} ${changeStr.padEnd(15, ' ')} | ${rankStr}`);
+    });
+    
+    console.log(pc.white(`----------------------------------------\n`));
+  });
+
+program
+  .command('market')
+  .description('Show global cryptocurrency market overview')
+  .action(async () => {
+    console.log(pc.cyan(`\nFetching global market data...`));
+    
+    const data = await crypull.market();
+    
+    if (!data) {
+      console.log(pc.red(`\n✖ Could not fetch global market data at this time.`));
+      return;
+    }
+
+    console.log(pc.green(`\n✔ Global Market Overview:`));
+    console.log(pc.white(`----------------------------------------`));
+    console.log(`${pc.gray('Total Market Cap:')} ${pc.white('$' + data.totalMarketCapUsd.toLocaleString())}`);
+    console.log(`${pc.gray('24h Volume:')}       ${pc.white('$' + data.totalVolume24hUsd.toLocaleString())}`);
+    console.log(`${pc.gray('BTC Dominance:')}    ${pc.yellow(data.bitcoinDominancePercentage.toFixed(2) + '%')}`);
+    console.log(`${pc.gray('ETH Dominance:')}    ${pc.blue(data.ethereumDominancePercentage.toFixed(2) + '%')}`);
+    console.log(`${pc.gray('Active Coins:')}     ${pc.white(data.activeCryptocurrencies.toLocaleString())}`);
+    console.log(pc.white(`----------------------------------------`));
+    console.log(`${pc.gray('Updated:')}          ${new Date(data.lastUpdated).toLocaleTimeString()}`);
+    console.log(pc.white(`----------------------------------------\n`));
+  });
+
+program
+  .command('sentiment')
+  .description('Show current Crypto Fear & Greed Index')
+  .action(async () => {
+    console.log(pc.cyan(`\nFetching Fear & Greed Index...`));
+    
+    const data = await crypull.sentiment();
+    
+    if (!data) {
+      console.log(pc.red(`\n✖ Could not fetch sentiment data at this time.`));
+      return;
+    }
+
+    const value = data.value;
+    let color = pc.white;
+    if (value <= 25) color = pc.red;
+    else if (value <= 45) color = pc.yellow;
+    else if (value <= 55) color = pc.white;
+    else if (value <= 75) color = pc.green;
+    else color = pc.blue;
+
+    console.log(pc.green(`\n✔ Current Market Sentiment:`));
+    console.log(pc.white(`----------------------------------------`));
+    console.log(`${pc.gray('Score:')}          ${color(pc.bold(value.toString()) + ' / 100')}`);
+    console.log(`${pc.gray('Classification:')} ${color(pc.bold(data.classification))}`);
+    console.log(pc.white(`----------------------------------------\n`));
+  });
+
+program
+  .command('gas')
+  .description('Show current Ethereum network gas prices')
+  .action(async () => {
+    console.log(pc.cyan(`\nFetching network gas prices...`));
+    
+    const data = await crypull.gas();
+    
+    if (!data) {
+      console.log(pc.red(`\n✖ Could not fetch gas prices at this time.`));
+      return;
+    }
+
+    console.log(pc.green(`\n✔ ${data.network} Gas Tracker (Gwei):`));
+    console.log(pc.white(`----------------------------------------`));
+    console.log(`${pc.gray('Low (Safe):')}     ${pc.green(data.low + ' gwei')}`);
+    console.log(`${pc.gray('Average:')}        ${pc.yellow(data.average + ' gwei')}`);
+    console.log(`${pc.gray('High (Fast):')}    ${pc.red(data.high + ' gwei')}`);
+    if (data.baseFee) {
+      console.log(`${pc.gray('Base Fee:')}       ${pc.white(data.baseFee + ' gwei')}`);
+    }
+    console.log(pc.white(`----------------------------------------\n`));
+  });
+
+program
+  .command('chart <query>')
+  .description('Draw a terminal ASCII chart of historical prices')
+  .option('-d, --days <days>', 'Number of days to chart', '7')
+  .action(async (query: string, options) => {
+    const days = parseInt(options.days) || 7;
+    console.log(pc.cyan(`\nFetching ${days}-day chart data for ${pc.bold(query)}...`));
+    
+    const data = await crypull.chart(query, days);
+    
+    if (!data || !data.prices || data.prices.length === 0) {
+      console.log(pc.red(`\n✖ Could not fetch chart data for "${query}". Note: Charts may only be available for major coins.`));
+      return;
+    }
+
+    // Determine color based on price action
+    const firstPrice = data.prices[0];
+    const lastPrice = data.prices[data.prices.length - 1];
+    const isUp = lastPrice >= firstPrice;
+    
+    const chartConfig = {
+      colors: [isUp ? asciichart.lightgreen : asciichart.lightred],
+      height: 10
+    };
+
+    console.log(pc.green(`\n✔ ${days}-Day Chart for ${query.toUpperCase()}:`));
+    console.log(pc.gray(`Min: $${data.minPrice.toLocaleString(undefined, { maximumFractionDigits: 6 })} | Max: $${data.maxPrice.toLocaleString(undefined, { maximumFractionDigits: 6 })}`));
+    console.log(pc.white(`\n` + asciichart.plot(data.prices, chartConfig) + `\n`));
+  });
+
+program.parse(process.argv);

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from './types.js';
+export * from './Crypull.js';
+export * from './providers/coingecko.js';
+export * from './providers/dexscreener.js';
+export * from './providers/geckoterminal.js';
+export * from './providers/binance.js';
+export * from './providers/coinpaprika.js';
+export * from './providers/coincap.js';
+export * from './providers/cryptocompare.js';
+
+import { Crypull } from './Crypull.js';
+
+// Export a default instance for quick usage
+export const crypull = new Crypull();

package/src/providers/binance.ts

@@ -0,0 +1,74 @@
+import { ICryptoProvider, PriceData, SearchResult, TokenInfo } from '../types.js';
+
+export class BinanceProvider implements ICryptoProvider {
+  name = 'Binance';
+  private baseUrl = 'https://api.binance.com/api/v3';
+
+  async search(query: string): Promise<SearchResult[]> {
+    try {
+      // Binance doesn't have a direct "search" that returns symbols nicely for our format
+      // We can fetch exchangeInfo, but it's large. For speed, we return a mock match if they query
+      // or we just return an empty array and rely on other providers for search.
+      // But let's try a quick hack: if query is short, construct a symbol.
+      const symbol = query.toUpperCase();
+      const res = await fetch(`${this.baseUrl}/ticker/price?symbol=${symbol}USDT`);
+      if (res.ok) {
+        return [{
+          id: `${symbol}USDT`,
+          name: symbol,
+          symbol: symbol,
+          source: this.name
+        }];
+      }
+      return [];
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async getPrice(symbol: string): Promise<PriceData | null> {
+    try {
+      let querySymbol = symbol.toUpperCase();
+      if (!querySymbol.endsWith('USDT') && !querySymbol.endsWith('BUSD') && !querySymbol.endsWith('BTC')) {
+        querySymbol += 'USDT';
+      }
+
+      const res = await fetch(`${this.baseUrl}/ticker/price?symbol=${querySymbol}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+
+      return {
+        symbol: symbol.toUpperCase(),
+        priceUsd: parseFloat(data.price) || 0,
+        source: this.name,
+        lastUpdated: Date.now(),
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  async getTokenInfo(symbol: string): Promise<TokenInfo | null> {
+    try {
+      let querySymbol = symbol.toUpperCase();
+      if (!querySymbol.endsWith('USDT') && !querySymbol.endsWith('BUSD') && !querySymbol.endsWith('BTC')) {
+        querySymbol += 'USDT';
+      }
+
+      const res = await fetch(`${this.baseUrl}/ticker/24hr?symbol=${querySymbol}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+
+      return {
+        name: symbol.toUpperCase(),
+        symbol: symbol.toUpperCase(),
+        priceUsd: parseFloat(data.lastPrice) || 0,
+        volume24h: parseFloat(data.quoteVolume) || 0, // Quote volume in USDT roughly = USD volume
+        source: this.name,
+        lastUpdated: Date.now(),
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+}

package/src/providers/coincap.ts

@@ -0,0 +1,65 @@
+import { ICryptoProvider, PriceData, SearchResult, TokenInfo } from '../types.js';
+
+export class CoinCapProvider implements ICryptoProvider {
+  name = 'CoinCap';
+  private baseUrl = 'https://api.coincap.io/v2';
+
+  async search(query: string): Promise<SearchResult[]> {
+    try {
+      const res = await fetch(`${this.baseUrl}/assets?search=${query}&limit=10`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      
+      return (data.data || []).map((coin: any) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name,
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async getPrice(symbolOrId: string): Promise<PriceData | null> {
+    const info = await this.getTokenInfo(symbolOrId);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated,
+    };
+  }
+
+  async getTokenInfo(symbolOrId: string): Promise<TokenInfo | null> {
+    try {
+      let id = symbolOrId.toLowerCase();
+      
+      const searchRes = await this.search(id);
+      const match = searchRes.find(s => s.symbol.toLowerCase() === id || s.id === id);
+      if (match && match.id) {
+        id = match.id;
+      }
+
+      const res = await fetch(`${this.baseUrl}/assets/${id}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      const asset = data.data;
+
+      if (!asset) return null;
+
+      return {
+        name: asset.name,
+        symbol: asset.symbol.toUpperCase(),
+        priceUsd: parseFloat(asset.priceUsd) || 0,
+        marketCap: parseFloat(asset.marketCapUsd),
+        volume24h: parseFloat(asset.volumeUsd24Hr),
+        source: this.name,
+        lastUpdated: Date.now(),
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+}

package/src/providers/coingecko.ts

@@ -0,0 +1,92 @@
+import { ICryptoProvider, PriceData, SearchResult, TokenInfo } from '../types.js';
+
+export class CoinGeckoProvider implements ICryptoProvider {
+  name = 'CoinGecko';
+  private baseUrl = 'https://api.coingecko.com/api/v3';
+
+  async search(query: string): Promise<SearchResult[]> {
+    try {
+      const res = await fetch(`${this.baseUrl}/search?query=${query}`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.coins || []).slice(0, 10).map((coin: any) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name,
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async getPrice(symbolOrId: string): Promise<PriceData | null> {
+    try {
+      let id = symbolOrId.toLowerCase();
+      
+      const searchRes = await this.search(id);
+      const match = searchRes.find(s => s.symbol.toLowerCase() === id || s.id === id);
+      if (match && match.id) {
+        id = match.id;
+      }
+
+      const res = await fetch(`${this.baseUrl}/simple/price?ids=${id}&vs_currencies=usd`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      
+      if (!data[id] || typeof data[id].usd === 'undefined') return null;
+
+      return {
+        symbol: match ? match.symbol : id.toUpperCase(),
+        priceUsd: data[id].usd,
+        source: this.name,
+        lastUpdated: Date.now(),
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+
+  async getTokenInfo(id: string): Promise<TokenInfo | null> {
+    try {
+      // By default, assuming id is the coingecko internal ID (like "bitcoin")
+      const res = await fetch(`${this.baseUrl}/coins/${id.toLowerCase()}?localization=false&tickers=false&market_data=true&community_data=false&developer_data=false&sparkline=false`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      
+      if (data.error) return null;
+
+      return {
+        name: data.name,
+        symbol: data.symbol.toUpperCase(),
+        description: data.description?.en,
+        priceUsd: data.market_data?.current_price?.usd || 0,
+        marketCap: data.market_data?.market_cap?.usd,
+        marketCapRank: data.market_cap_rank,
+        fdv: data.market_data?.fully_diluted_valuation?.usd,
+        circulatingSupply: data.market_data?.circulating_supply,
+        totalSupply: data.market_data?.total_supply,
+        maxSupply: data.market_data?.max_supply,
+        volume24h: data.market_data?.total_volume?.usd,
+        priceChange24h: data.market_data?.price_change_24h,
+        priceChangePercentage24h: data.market_data?.price_change_percentage_24h,
+        priceChangePercentage7d: data.market_data?.price_change_percentage_7d,
+        ath: data.market_data?.ath?.usd,
+        athDate: data.market_data?.ath_date?.usd,
+        atl: data.market_data?.atl?.usd,
+        atlDate: data.market_data?.atl_date?.usd,
+        links: {
+          website: data.links?.homepage?.[0],
+          twitter: data.links?.twitter_screen_name ? `https://twitter.com/${data.links.twitter_screen_name}` : undefined,
+          telegram: data.links?.telegram_channel_identifier ? `https://t.me/${data.links.telegram_channel_identifier}` : undefined,
+          discord: data.links?.chat_url?.find((url: string) => url.includes('discord')),
+          github: data.links?.repos_url?.github?.[0],
+        },
+        source: this.name,
+        lastUpdated: Date.now(),
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+}

package/src/providers/coinpaprika.ts

@@ -0,0 +1,82 @@
+import { ICryptoProvider, PriceData, SearchResult, TokenInfo } from '../types.js';
+
+export class CoinpaprikaProvider implements ICryptoProvider {
+  name = 'Coinpaprika';
+  private baseUrl = 'https://api.coinpaprika.com/v1';
+
+  async search(query: string): Promise<SearchResult[]> {
+    try {
+      const res = await fetch(`${this.baseUrl}/search?q=${query}&c=currencies&limit=10`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      
+      return (data.currencies || []).map((coin: any) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name,
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async getPrice(symbolOrId: string): Promise<PriceData | null> {
+    const info = await this.getTokenInfo(symbolOrId);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated,
+    };
+  }
+
+  async getTokenInfo(symbolOrId: string): Promise<TokenInfo | null> {
+    try {
+      let id = symbolOrId.toLowerCase();
+      
+      // If it doesn't look like a coinpaprika id (e.g. btc-bitcoin), search for it
+      if (!id.includes('-')) {
+        const searchRes = await this.search(id);
+        const match = searchRes.find(s => s.symbol.toLowerCase() === id || s.id === id);
+        if (match && match.id) {
+          id = match.id;
+        } else if (searchRes.length > 0 && searchRes[0].id) {
+          id = searchRes[0].id;
+        }
+      }
+
+      const res = await fetch(`${this.baseUrl}/tickers/${id}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      
+      return {
+        name: data.name,
+        symbol: data.symbol.toUpperCase(),
+        description: data.description,
+        priceUsd: data.quotes?.USD?.price || 0,
+        marketCap: data.quotes?.USD?.market_cap,
+        marketCapRank: data.rank,
+        circulatingSupply: data.circulating_supply,
+        totalSupply: data.total_supply,
+        maxSupply: data.max_supply,
+        volume24h: data.quotes?.USD?.volume_24h,
+        priceChangePercentage24h: data.quotes?.USD?.percent_change_24h,
+        priceChangePercentage7d: data.quotes?.USD?.percent_change_7d,
+        ath: data.quotes?.USD?.ath_price,
+        athDate: data.quotes?.USD?.ath_date,
+        links: {
+          website: data.links?.website?.[0],
+          twitter: data.links?.twitter?.[0],
+          discord: data.links?.discord?.[0],
+          github: data.links?.source_code?.[0],
+        },
+        source: this.name,
+        lastUpdated: Date.now(),
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+}