crypull 1.0.2 → 1.0.3

package/dist/index.js

@@ -3,10 +3,13 @@
 // src/providers/coingecko.ts
 var CoinGeckoProvider = class {
   name = "CoinGecko";
+  addressBased = false;
   baseUrl = "https://api.coingecko.com/api/v3";
   async search(query) {
     try {
-      const res = await fetch(`${this.baseUrl}/search?query=${query}`);
+      const res = await fetch(
+        `${this.baseUrl}/search?query=${encodeURIComponent(query)}`
+      );
       if (!res.ok) return [];
       const data = await res.json();
       return (data.coins || []).slice(0, 10).map((coin) => ({
@@ -15,38 +18,53 @@ var CoinGeckoProvider = class {
         symbol: coin.symbol.toUpperCase(),
         source: this.name
       }));
-    } catch (e) {
+    } catch {
       return [];
     }
   }
+  /** Resolve a symbol or slug to a CoinGecko coin id. */
+  async resolveId(symbolOrId) {
+    const q = symbolOrId.toLowerCase().trim();
+    if (!q) return null;
+    const searchRes = await this.search(q);
+    const match = searchRes.find((s) => s.id === q) || searchRes.find((s) => s.symbol.toLowerCase() === q);
+    if (match?.id) {
+      return { id: match.id, symbol: match.symbol };
+    }
+    return { id: q, symbol: q.toUpperCase() };
+  }
   async getPrice(symbolOrId) {
     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`);
+      const resolved = await this.resolveId(symbolOrId);
+      if (!resolved) return null;
+      const res = await fetch(
+        `${this.baseUrl}/simple/price?ids=${encodeURIComponent(resolved.id)}&vs_currencies=usd`
+      );
       if (!res.ok) return null;
       const data = await res.json();
-      if (!data[id] || typeof data[id].usd === "undefined") return null;
+      if (!data[resolved.id] || typeof data[resolved.id].usd === "undefined") {
+        return null;
+      }
       return {
-        symbol: match ? match.symbol : id.toUpperCase(),
-        priceUsd: data[id].usd,
+        symbol: resolved.symbol,
+        priceUsd: data[resolved.id].usd,
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
-  async getTokenInfo(id) {
+  async getTokenInfo(symbolOrId) {
     try {
-      const res = await fetch(`${this.baseUrl}/coins/${id.toLowerCase()}?localization=false&tickers=false&market_data=true&community_data=false&developer_data=false&sparkline=false`);
+      const resolved = await this.resolveId(symbolOrId);
+      if (!resolved) return null;
+      const res = await fetch(
+        `${this.baseUrl}/coins/${encodeURIComponent(resolved.id)}?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;
+      if (data.error || !data.id) return null;
       return {
         name: data.name,
         symbol: data.symbol.toUpperCase(),
@@ -67,16 +85,98 @@ var CoinGeckoProvider = class {
         atl: data.market_data?.atl?.usd,
         atlDate: data.market_data?.atl_date?.usd,
         links: {
-          website: data.links?.homepage?.[0],
+          website: data.links?.homepage?.[0] || void 0,
           twitter: data.links?.twitter_screen_name ? `https://twitter.com/${data.links.twitter_screen_name}` : void 0,
           telegram: data.links?.telegram_channel_identifier ? `https://t.me/${data.links.telegram_channel_identifier}` : void 0,
-          discord: data.links?.chat_url?.find((url) => url.includes("discord")),
+          discord: data.links?.chat_url?.find(
+            (url) => url.includes("discord")
+          ),
           github: data.links?.repos_url?.github?.[0]
         },
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
+      return null;
+    }
+  }
+  async getGlobalMarket() {
+    try {
+      const res = await fetch(`${this.baseUrl}/global`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      const d = data.data;
+      if (!d) return null;
+      return {
+        totalMarketCapUsd: d.total_market_cap.usd,
+        totalVolume24hUsd: d.total_volume.usd,
+        bitcoinDominancePercentage: d.market_cap_percentage.btc,
+        ethereumDominancePercentage: d.market_cap_percentage.eth,
+        activeCryptocurrencies: d.active_cryptocurrencies,
+        lastUpdated: d.updated_at * 1e3
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getTrending() {
+    try {
+      const res = await fetch(`${this.baseUrl}/search/trending`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.coins || []).slice(0, 10).map((c) => ({
+        id: c.item.id,
+        name: c.item.name,
+        symbol: c.item.symbol.toUpperCase(),
+        marketCapRank: c.item.market_cap_rank,
+        priceUsd: c.item.data?.price,
+        priceChange24h: c.item.data?.price_change_percentage_24h?.usd,
+        volume24h: c.item.data?.total_volume
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getTop(limit = 50) {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=${limit}&page=1&sparkline=false`
+      );
+      if (!res.ok) return [];
+      const data = await res.json();
+      return data.map((c) => ({
+        id: c.id,
+        name: c.name,
+        symbol: c.symbol.toUpperCase(),
+        marketCapRank: c.market_cap_rank,
+        priceUsd: c.current_price,
+        marketCap: c.market_cap,
+        volume24h: c.total_volume,
+        priceChange24h: c.price_change_percentage_24h
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getChart(query, days = 7) {
+    try {
+      const resolved = await this.resolveId(query);
+      if (!resolved) return null;
+      const res = await fetch(
+        `${this.baseUrl}/coins/${encodeURIComponent(resolved.id)}/market_chart?vs_currency=usd&days=${days}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (!data.prices?.length) return null;
+      const prices = data.prices.map((p) => p[1]);
+      const timestamps = data.prices.map((p) => p[0]);
+      return {
+        prices,
+        timestamps,
+        minPrice: Math.min(...prices),
+        maxPrice: Math.max(...prices)
+      };
+    } catch {
       return null;
     }
   }
@@ -85,10 +185,13 @@ var CoinGeckoProvider = class {
 // src/providers/dexscreener.ts
 var DexScreenerProvider = class {
   name = "DexScreener";
+  addressBased = true;
   baseUrl = "https://api.dexscreener.com/latest/dex";
   async search(query) {
     try {
-      const res = await fetch(`${this.baseUrl}/search?q=${query}`);
+      const res = await fetch(
+        `${this.baseUrl}/search?q=${encodeURIComponent(query)}`
+      );
       if (!res.ok) return [];
       const data = await res.json();
       return (data.pairs || []).slice(0, 10).map((pair) => ({
@@ -98,7 +201,7 @@ var DexScreenerProvider = class {
         network: pair.chainId,
         source: this.name
       }));
-    } catch (e) {
+    } catch {
       return [];
     }
   }
@@ -114,12 +217,17 @@ var DexScreenerProvider = class {
   }
   async getTokenInfo(address) {
     try {
-      const res = await fetch(`${this.baseUrl}/tokens/${address}`);
+      const res = await fetch(
+        `${this.baseUrl}/tokens/${encodeURIComponent(address)}`
+      );
       if (!res.ok) return null;
       const data = await res.json();
-      if (!data.pairs || data.pairs.length === 0) return null;
-      const pair = data.pairs[0];
-      const mappedPairs = data.pairs.slice(0, 10).map((p) => ({
+      if (!data.pairs?.length) return null;
+      const sorted = [...data.pairs].sort(
+        (a, b) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0)
+      );
+      const pair = sorted[0];
+      const mappedPairs = sorted.slice(0, 10).map((p) => ({
         dexId: p.dexId,
         url: p.url,
         pairAddress: p.pairAddress,
@@ -149,7 +257,7 @@ var DexScreenerProvider = class {
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -158,26 +266,28 @@ var DexScreenerProvider = class {
 // src/providers/geckoterminal.ts
 var GeckoTerminalProvider = class {
   name = "GeckoTerminal";
+  addressBased = true;
   baseUrl = "https://api.geckoterminal.com/api/v2";
   async search(query) {
     try {
-      const res = await fetch(`${this.baseUrl}/search/pools?query=${query}`);
+      const res = await fetch(
+        `${this.baseUrl}/search/pools?query=${encodeURIComponent(query)}`
+      );
       if (!res.ok) return [];
       const data = await res.json();
       const pools = data.data || [];
       return pools.slice(0, 10).map((pool) => {
         const attributes = pool.attributes;
-        const baseToken = attributes.name.split(" / ")[0];
+        const baseToken = (attributes.name || "").split(" / ")[0] || attributes.name;
         return {
           id: pool.id,
-          // e.g. "eth_0x..."
           name: attributes.name,
-          symbol: baseToken,
-          network: pool.relationships.network.data.id,
+          symbol: typeof baseToken === "string" ? baseToken.toUpperCase() : String(baseToken),
+          network: pool.relationships?.network?.data?.id,
           source: this.name
         };
       });
-    } catch (e) {
+    } catch {
       return [];
     }
   }
@@ -193,10 +303,12 @@ var GeckoTerminalProvider = class {
   }
   async getTokenInfo(address, network = "eth") {
     try {
-      const res = await fetch(`${this.baseUrl}/networks/${network}/tokens/${address}`);
+      const res = await fetch(
+        `${this.baseUrl}/networks/${encodeURIComponent(network)}/tokens/${encodeURIComponent(address)}`
+      );
       if (!res.ok) return null;
       const json = await res.json();
-      if (!json.data || !json.data.attributes) return null;
+      if (!json.data?.attributes) return null;
       const attrs = json.data.attributes;
       return {
         name: attrs.name,
@@ -204,76 +316,106 @@ var GeckoTerminalProvider = class {
         address: attrs.address,
         network,
         priceUsd: parseFloat(attrs.price_usd) || 0,
-        fdv: parseFloat(attrs.fdv_usd),
-        volume24h: parseFloat(attrs.volume_usd?.h24 || 0),
+        fdv: parseFloat(attrs.fdv_usd) || void 0,
+        volume24h: parseFloat(attrs.volume_usd?.h24 || 0) || void 0,
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
 };
 
+// src/utils.ts
+function isContractAddress(query) {
+  const q = query.trim();
+  if (!q) return false;
+  if (/^0x[a-fA-F0-9]{40}$/.test(q)) return true;
+  if (q.length >= 32 && q.length <= 44 && !q.includes(" ") && /^[1-9A-HJ-NP-Za-km-z]+$/.test(q)) {
+    return true;
+  }
+  return false;
+}
+function toBinancePair(symbol) {
+  const upper = symbol.toUpperCase().trim();
+  if (!upper) return upper;
+  if (upper.endsWith("USDT") || upper.endsWith("BUSD")) return upper;
+  return `${upper}USDT`;
+}
+function fromBinancePair(pair) {
+  const upper = pair.toUpperCase();
+  if (upper.endsWith("USDT") && upper.length > 4) return upper.slice(0, -4);
+  if (upper.endsWith("BUSD") && upper.length > 4) return upper.slice(0, -4);
+  return upper;
+}
+function defaultDexNetwork(address) {
+  if (/^0x[a-fA-F0-9]{40}$/.test(address.trim())) return "eth";
+  return "solana";
+}
+function finiteOrUndefined(value) {
+  const n = typeof value === "number" ? value : parseFloat(String(value));
+  return Number.isFinite(n) ? n : void 0;
+}
+
 // src/providers/binance.ts
 var BinanceProvider = class {
   name = "Binance";
+  addressBased = false;
   baseUrl = "https://api.binance.com/api/v3";
   async search(query) {
     try {
-      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,
+      const pair = toBinancePair(query);
+      const res = await fetch(`${this.baseUrl}/ticker/price?symbol=${pair}`);
+      if (!res.ok) return [];
+      const base = fromBinancePair(pair);
+      return [
+        {
+          id: pair,
+          name: base,
+          symbol: base,
           source: this.name
-        }];
-      }
-      return [];
-    } catch (e) {
+        }
+      ];
+    } catch {
       return [];
     }
   }
   async getPrice(symbol) {
     try {
-      let querySymbol = symbol.toUpperCase();
-      if (!querySymbol.endsWith("USDT") && !querySymbol.endsWith("BUSD") && !querySymbol.endsWith("BTC")) {
-        querySymbol += "USDT";
-      }
+      const querySymbol = toBinancePair(symbol);
       const res = await fetch(`${this.baseUrl}/ticker/price?symbol=${querySymbol}`);
       if (!res.ok) return null;
       const data = await res.json();
+      if (!data.price) return null;
       return {
-        symbol: symbol.toUpperCase(),
+        symbol: fromBinancePair(querySymbol),
         priceUsd: parseFloat(data.price) || 0,
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
   async getTokenInfo(symbol) {
     try {
-      let querySymbol = symbol.toUpperCase();
-      if (!querySymbol.endsWith("USDT") && !querySymbol.endsWith("BUSD") && !querySymbol.endsWith("BTC")) {
-        querySymbol += "USDT";
-      }
+      const querySymbol = toBinancePair(symbol);
       const res = await fetch(`${this.baseUrl}/ticker/24hr?symbol=${querySymbol}`);
       if (!res.ok) return null;
       const data = await res.json();
+      if (!data.lastPrice) return null;
+      const base = fromBinancePair(querySymbol);
       return {
-        name: symbol.toUpperCase(),
-        symbol: symbol.toUpperCase(),
+        name: base,
+        symbol: base,
         priceUsd: parseFloat(data.lastPrice) || 0,
         volume24h: parseFloat(data.quoteVolume) || 0,
-        // Quote volume in USDT roughly = USD volume
+        priceChangePercentage24h: finiteOrUndefined(data.priceChangePercent),
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -282,10 +424,13 @@ var BinanceProvider = class {
 // src/providers/coinpaprika.ts
 var CoinpaprikaProvider = class {
   name = "Coinpaprika";
+  addressBased = false;
   baseUrl = "https://api.coinpaprika.com/v1";
   async search(query) {
     try {
-      const res = await fetch(`${this.baseUrl}/search?q=${query}&c=currencies&limit=10`);
+      const res = await fetch(
+        `${this.baseUrl}/search?q=${encodeURIComponent(query)}&c=currencies&limit=10`
+      );
       if (!res.ok) return [];
       const data = await res.json();
       return (data.currencies || []).map((coin) => ({
@@ -294,7 +439,7 @@ var CoinpaprikaProvider = class {
         symbol: coin.symbol.toUpperCase(),
         source: this.name
       }));
-    } catch (e) {
+    } catch {
       return [];
     }
   }
@@ -310,19 +455,18 @@ var CoinpaprikaProvider = class {
   }
   async getTokenInfo(symbolOrId) {
     try {
-      let id = symbolOrId.toLowerCase();
+      let id = symbolOrId.toLowerCase().trim();
+      if (!id) return null;
       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 match = searchRes.find((s) => s.symbol.toLowerCase() === id) || searchRes.find((s) => s.id === id);
+        if (!match?.id) return null;
+        id = match.id;
       }
-      const res = await fetch(`${this.baseUrl}/tickers/${id}`);
+      const res = await fetch(`${this.baseUrl}/tickers/${encodeURIComponent(id)}`);
       if (!res.ok) return null;
       const data = await res.json();
+      if (!data.symbol) return null;
       return {
         name: data.name,
         symbol: data.symbol.toUpperCase(),
@@ -347,7 +491,7 @@ var CoinpaprikaProvider = class {
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -356,10 +500,13 @@ var CoinpaprikaProvider = class {
 // src/providers/coincap.ts
 var CoinCapProvider = class {
   name = "CoinCap";
+  addressBased = false;
   baseUrl = "https://api.coincap.io/v2";
   async search(query) {
     try {
-      const res = await fetch(`${this.baseUrl}/assets?search=${query}&limit=10`);
+      const res = await fetch(
+        `${this.baseUrl}/assets?search=${encodeURIComponent(query)}&limit=10`
+      );
       if (!res.ok) return [];
       const data = await res.json();
       return (data.data || []).map((coin) => ({
@@ -368,7 +515,7 @@ var CoinCapProvider = class {
         symbol: coin.symbol.toUpperCase(),
         source: this.name
       }));
-    } catch (e) {
+    } catch {
       return [];
     }
   }
@@ -384,13 +531,14 @@ var CoinCapProvider = class {
   }
   async getTokenInfo(symbolOrId) {
     try {
-      let id = symbolOrId.toLowerCase();
+      let id = symbolOrId.toLowerCase().trim();
+      if (!id) return null;
       const searchRes = await this.search(id);
-      const match = searchRes.find((s) => s.symbol.toLowerCase() === id || s.id === id);
-      if (match && match.id) {
+      const match = searchRes.find((s) => s.symbol.toLowerCase() === id) || searchRes.find((s) => s.id === id);
+      if (match?.id) {
         id = match.id;
       }
-      const res = await fetch(`${this.baseUrl}/assets/${id}`);
+      const res = await fetch(`${this.baseUrl}/assets/${encodeURIComponent(id)}`);
       if (!res.ok) return null;
       const data = await res.json();
       const asset = data.data;
@@ -399,12 +547,13 @@ var CoinCapProvider = class {
         name: asset.name,
         symbol: asset.symbol.toUpperCase(),
         priceUsd: parseFloat(asset.priceUsd) || 0,
-        marketCap: parseFloat(asset.marketCapUsd),
-        volume24h: parseFloat(asset.volumeUsd24Hr),
+        marketCap: parseFloat(asset.marketCapUsd) || void 0,
+        volume24h: parseFloat(asset.volumeUsd24Hr) || void 0,
+        priceChangePercentage24h: parseFloat(asset.changePercent24Hr) || void 0,
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -413,151 +562,716 @@ var CoinCapProvider = class {
 // src/providers/cryptocompare.ts
 var CryptoCompareProvider = class {
   name = "CryptoCompare";
+  addressBased = false;
   baseUrl = "https://min-api.cryptocompare.com/data";
-  async search(query) {
+  // CryptoCompare coin list is heavy; search is handled by other providers.
+  async search(_query) {
     return [];
   }
   async getPrice(symbol) {
     try {
-      const sym = symbol.toUpperCase();
-      const res = await fetch(`${this.baseUrl}/price?fsym=${sym}&tsyms=USD`);
+      const sym = symbol.toUpperCase().trim();
+      if (!sym) return null;
+      const res = await fetch(
+        `${this.baseUrl}/price?fsym=${encodeURIComponent(sym)}&tsyms=USD`
+      );
       if (!res.ok) return null;
       const data = await res.json();
-      if (data.Response === "Error" || !data.USD) return null;
+      if (data.Response === "Error" || typeof data.USD !== "number") return null;
       return {
         symbol: sym,
         priceUsd: data.USD,
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
   async getTokenInfo(symbol) {
     try {
-      const sym = symbol.toUpperCase();
-      const res = await fetch(`${this.baseUrl}/pricemultifull?fsyms=${sym}&tsyms=USD`);
+      const sym = symbol.toUpperCase().trim();
+      if (!sym) return null;
+      const res = await fetch(
+        `${this.baseUrl}/pricemultifull?fsyms=${encodeURIComponent(sym)}&tsyms=USD`
+      );
       if (!res.ok) return null;
       const data = await res.json();
-      if (!data.RAW || !data.RAW[sym] || !data.RAW[sym].USD) return null;
-      const raw = data.RAW[sym].USD;
+      const raw = data.RAW?.[sym]?.USD;
+      if (!raw) return null;
       return {
         name: sym,
-        // CryptoCompare doesn't give full name in this endpoint
         symbol: sym,
         priceUsd: raw.PRICE || 0,
         marketCap: raw.MKTCAP,
         volume24h: raw.TOTALVOLUME24HTO,
+        priceChangePercentage24h: raw.CHANGEPCT24HOUR,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/providers/coinmarketcap.ts
+var CoinMarketCapProvider = class {
+  name = "CoinMarketCap";
+  addressBased = false;
+  baseUrl = "https://pro-api.coinmarketcap.com/public-api";
+  headers = {
+    Accept: "application/json",
+    "User-Agent": "crypull"
+  };
+  async search(query) {
+    try {
+      const q = query.trim();
+      if (!q) return [];
+      const res = await fetch(
+        `${this.baseUrl}/v1/cryptocurrency/map?symbol=${encodeURIComponent(q.toUpperCase())}`,
+        { headers: this.headers }
+      );
+      if (!res.ok) return [];
+      const data = await res.json();
+      const list = (data.data || []).filter((c) => c.is_active === 1).sort((a, b) => (a.rank || 999999) - (b.rank || 999999)).slice(0, 10);
+      return list.map((c) => ({
+        id: c.slug || String(c.id),
+        name: c.name,
+        symbol: c.symbol.toUpperCase(),
+        source: this.name
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getPrice(symbol) {
+    const info = await this.getTokenInfo(symbol);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(symbolOrSlug) {
+    try {
+      const q = symbolOrSlug.trim();
+      if (!q) return null;
+      let url = `${this.baseUrl}/v3/cryptocurrency/quotes/latest?symbol=${encodeURIComponent(q.toUpperCase())}`;
+      let res = await fetch(url, { headers: this.headers });
+      let data = res.ok ? await res.json() : null;
+      if (!data?.data?.length) {
+        url = `${this.baseUrl}/v3/cryptocurrency/quotes/latest?slug=${encodeURIComponent(q.toLowerCase())}`;
+        res = await fetch(url, { headers: this.headers });
+        if (!res.ok) return null;
+        data = await res.json();
+      }
+      const coin = data?.data?.[0];
+      if (!coin) return null;
+      const quote = Array.isArray(coin.quote) ? coin.quote.find((x) => x.symbol === "USD") || coin.quote[0] : coin.quote?.USD;
+      if (!quote || typeof quote.price !== "number") return null;
+      return {
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        priceUsd: quote.price,
+        marketCap: quote.market_cap,
+        marketCapRank: coin.cmc_rank,
+        fdv: quote.fully_diluted_market_cap,
+        circulatingSupply: coin.circulating_supply,
+        totalSupply: coin.total_supply,
+        maxSupply: coin.max_supply ?? void 0,
+        volume24h: quote.volume_24h,
+        priceChangePercentage24h: quote.percent_change_24h,
+        priceChangePercentage7d: quote.percent_change_7d,
+        source: this.name,
+        lastUpdated: quote.last_updated ? Date.parse(quote.last_updated) : Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/providers/coinlore.ts
+var CoinLoreProvider = class {
+  name = "CoinLore";
+  addressBased = false;
+  baseUrl = "https://api.coinlore.net/api";
+  /** Scan top tickers pages to resolve symbol → coin id. */
+  async findTicker(query) {
+    const q = query.toLowerCase().trim();
+    if (!q) return null;
+    for (let start = 0; start < 300; start += 100) {
+      const res = await fetch(
+        `${this.baseUrl}/tickers/?start=${start}&limit=100`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      const list = data.data || [];
+      if (!list.length) break;
+      const exact = list.find((c) => c.symbol?.toLowerCase() === q) || list.find((c) => c.nameid?.toLowerCase() === q) || list.find((c) => c.name?.toLowerCase() === q);
+      if (exact) return exact;
+    }
+    return null;
+  }
+  async search(query) {
+    try {
+      const q = query.toLowerCase().trim();
+      if (!q) return [];
+      const matches = [];
+      for (let start = 0; start < 200; start += 100) {
+        const res = await fetch(
+          `${this.baseUrl}/tickers/?start=${start}&limit=100`
+        );
+        if (!res.ok) break;
+        const data = await res.json();
+        const list = data.data || [];
+        if (!list.length) break;
+        for (const c of list) {
+          const sym = (c.symbol || "").toLowerCase();
+          const name = (c.name || "").toLowerCase();
+          const nameid = (c.nameid || "").toLowerCase();
+          if (sym.includes(q) || name.includes(q) || nameid.includes(q)) {
+            matches.push({
+              id: c.id,
+              name: c.name,
+              symbol: c.symbol.toUpperCase(),
+              source: this.name
+            });
+          }
+          if (matches.length >= 10) return matches;
+        }
+      }
+      return matches;
+    } catch {
+      return [];
+    }
+  }
+  async getPrice(symbol) {
+    const info = await this.getTokenInfo(symbol);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(symbolOrId) {
+    try {
+      const q = symbolOrId.trim();
+      if (!q) return null;
+      let ticker = null;
+      if (/^\d+$/.test(q)) {
+        const res = await fetch(`${this.baseUrl}/ticker/?id=${q}`);
+        if (res.ok) {
+          const data = await res.json();
+          ticker = Array.isArray(data) ? data[0] : null;
+        }
+      } else {
+        ticker = await this.findTicker(q);
+      }
+      if (!ticker) return null;
+      return {
+        name: ticker.name,
+        symbol: ticker.symbol.toUpperCase(),
+        priceUsd: parseFloat(ticker.price_usd) || 0,
+        marketCap: finiteOrUndefined(ticker.market_cap_usd),
+        marketCapRank: finiteOrUndefined(ticker.rank),
+        circulatingSupply: finiteOrUndefined(ticker.csupply),
+        totalSupply: finiteOrUndefined(ticker.tsupply),
+        maxSupply: finiteOrUndefined(ticker.msupply),
+        volume24h: finiteOrUndefined(ticker.volume24),
+        priceChangePercentage24h: finiteOrUndefined(ticker.percent_change_24h),
+        priceChangePercentage7d: finiteOrUndefined(ticker.percent_change_7d),
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/providers/coinbase.ts
+var CoinbaseProvider = class {
+  name = "Coinbase";
+  addressBased = false;
+  baseUrl = "https://api.coinbase.com/v2";
+  async search(query) {
+    try {
+      const sym = query.toUpperCase().trim();
+      if (!sym) return [];
+      const res = await fetch(`${this.baseUrl}/prices/${encodeURIComponent(sym)}-USD/spot`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      if (!data.data?.amount) return [];
+      return [
+        {
+          id: sym,
+          name: sym,
+          symbol: sym,
+          source: this.name
+        }
+      ];
+    } catch {
+      return [];
+    }
+  }
+  async getPrice(symbol) {
+    try {
+      const sym = symbol.toUpperCase().trim();
+      if (!sym) return null;
+      const res = await fetch(
+        `${this.baseUrl}/prices/${encodeURIComponent(sym)}-USD/spot`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      const amount = parseFloat(data.data?.amount);
+      if (!amount) return null;
+      return {
+        symbol: sym,
+        priceUsd: amount,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    const price = await this.getPrice(symbol);
+    if (!price) return null;
+    return {
+      name: price.symbol,
+      symbol: price.symbol,
+      priceUsd: price.priceUsd,
+      source: this.name,
+      lastUpdated: price.lastUpdated
+    };
+  }
+};
+
+// src/providers/kraken.ts
+var KrakenProvider = class {
+  name = "Kraken";
+  addressBased = false;
+  baseUrl = "https://api.kraken.com/0/public";
+  toPair(symbol) {
+    let base = symbol.toUpperCase().trim();
+    if (base.endsWith("USDT") && base.length > 4) {
+      base = base.slice(0, -4);
+    } else if (base.endsWith("USD") && base.length >= 6) {
+      base = base.slice(0, -3);
+    }
+    if (base === "BTC") base = "XBT";
+    return `${base}USD`;
+  }
+  fromPairKey(pairKey, fallback) {
+    const key = pairKey.toUpperCase();
+    if (key.includes("XBT")) return "BTC";
+    const base = fallback.toUpperCase().trim().replace(/USDT?$/, "");
+    return base === "XBT" ? "BTC" : base || key;
+  }
+  async search(query) {
+    const price = await this.getPrice(query);
+    if (!price) return [];
+    return [
+      {
+        id: price.symbol,
+        name: price.symbol,
+        symbol: price.symbol,
+        source: this.name
+      }
+    ];
+  }
+  async getPrice(symbol) {
+    try {
+      const pair = this.toPair(symbol);
+      const res = await fetch(
+        `${this.baseUrl}/Ticker?pair=${encodeURIComponent(pair)}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.error?.length || !data.result) return null;
+      const keys = Object.keys(data.result);
+      if (!keys.length) return null;
+      const ticker = data.result[keys[0]];
+      const last = parseFloat(ticker.c?.[0]);
+      if (!last) return null;
+      return {
+        symbol: this.fromPairKey(keys[0], symbol),
+        priceUsd: last,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    try {
+      const pair = this.toPair(symbol);
+      const res = await fetch(
+        `${this.baseUrl}/Ticker?pair=${encodeURIComponent(pair)}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.error?.length || !data.result) return null;
+      const keys = Object.keys(data.result);
+      if (!keys.length) return null;
+      const ticker = data.result[keys[0]];
+      const last = parseFloat(ticker.c?.[0]);
+      if (!last) return null;
+      const vol = parseFloat(ticker.v?.[1]);
+      const vwap = parseFloat(ticker.p?.[1]);
+      const sym = this.fromPairKey(keys[0], symbol);
+      return {
+        name: sym,
+        symbol: sym,
+        priceUsd: last,
+        volume24h: vol && vwap ? vol * vwap : void 0,
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/providers/kucoin.ts
+var KuCoinProvider = class {
+  name = "KuCoin";
+  addressBased = false;
+  baseUrl = "https://api.kucoin.com/api/v1";
+  toSymbol(symbol) {
+    const upper = symbol.toUpperCase().trim();
+    if (upper.includes("-")) return upper;
+    if (upper.endsWith("USDT") && upper.length > 4) {
+      return `${upper.slice(0, -4)}-USDT`;
+    }
+    return `${upper}-USDT`;
+  }
+  baseAsset(pair) {
+    return pair.split("-")[0] || pair;
+  }
+  async search(query) {
+    const price = await this.getPrice(query);
+    if (!price) return [];
+    return [
+      {
+        id: `${price.symbol}-USDT`,
+        name: price.symbol,
+        symbol: price.symbol,
+        source: this.name
+      }
+    ];
+  }
+  async getPrice(symbol) {
+    try {
+      const pair = this.toSymbol(symbol);
+      const res = await fetch(
+        `${this.baseUrl}/market/orderbook/level1?symbol=${encodeURIComponent(pair)}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.code !== "200000" || !data.data?.price) return null;
+      return {
+        symbol: this.baseAsset(pair),
+        priceUsd: parseFloat(data.data.price) || 0,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    try {
+      const pair = this.toSymbol(symbol);
+      const res = await fetch(
+        `${this.baseUrl}/market/stats?symbol=${encodeURIComponent(pair)}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.code !== "200000" || !data.data?.last) return null;
+      const d = data.data;
+      return {
+        name: this.baseAsset(pair),
+        symbol: this.baseAsset(pair),
+        priceUsd: parseFloat(d.last) || 0,
+        volume24h: finiteOrUndefined(d.volValue),
+        priceChangePercentage24h: (() => {
+          const rate = finiteOrUndefined(d.changeRate);
+          return rate === void 0 ? void 0 : rate * 100;
+        })(),
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/providers/bybit.ts
+var BybitProvider = class {
+  name = "Bybit";
+  addressBased = false;
+  baseUrl = "https://api.bybit.com/v5/market";
+  async search(query) {
+    const price = await this.getPrice(query);
+    if (!price) return [];
+    return [
+      {
+        id: toBinancePair(price.symbol),
+        name: price.symbol,
+        symbol: price.symbol,
+        source: this.name
+      }
+    ];
+  }
+  async getPrice(symbol) {
+    try {
+      const pair = toBinancePair(symbol);
+      const res = await fetch(
+        `${this.baseUrl}/tickers?category=spot&symbol=${encodeURIComponent(pair)}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      const item = data.result?.list?.[0];
+      if (!item?.lastPrice) return null;
+      return {
+        symbol: fromBinancePair(pair),
+        priceUsd: parseFloat(item.lastPrice) || 0,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    try {
+      const pair = toBinancePair(symbol);
+      const res = await fetch(
+        `${this.baseUrl}/tickers?category=spot&symbol=${encodeURIComponent(pair)}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      const item = data.result?.list?.[0];
+      if (!item?.lastPrice) return null;
+      const base = fromBinancePair(pair);
+      return {
+        name: base,
+        symbol: base,
+        priceUsd: parseFloat(item.lastPrice) || 0,
+        volume24h: finiteOrUndefined(item.turnover24h),
+        priceChangePercentage24h: (() => {
+          const pct = finiteOrUndefined(item.price24hPcnt);
+          return pct === void 0 ? void 0 : pct * 100;
+        })(),
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/providers/gateio.ts
+var GateIoProvider = class {
+  name = "Gate.io";
+  addressBased = false;
+  baseUrl = "https://api.gateio.ws/api/v4";
+  toPair(symbol) {
+    const upper = symbol.toUpperCase().trim();
+    if (upper.includes("_")) return upper;
+    if (upper.endsWith("USDT") && upper.length > 4) {
+      return `${upper.slice(0, -4)}_USDT`;
+    }
+    return `${upper}_USDT`;
+  }
+  baseAsset(pair) {
+    return pair.split("_")[0] || pair;
+  }
+  async search(query) {
+    const price = await this.getPrice(query);
+    if (!price) return [];
+    return [
+      {
+        id: this.toPair(price.symbol),
+        name: price.symbol,
+        symbol: price.symbol,
+        source: this.name
+      }
+    ];
+  }
+  async getPrice(symbol) {
+    try {
+      const pair = this.toPair(symbol);
+      const res = await fetch(
+        `${this.baseUrl}/spot/tickers?currency_pair=${encodeURIComponent(pair)}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      const item = Array.isArray(data) ? data[0] : null;
+      if (!item?.last) return null;
+      return {
+        symbol: this.baseAsset(pair),
+        priceUsd: parseFloat(item.last) || 0,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    try {
+      const pair = this.toPair(symbol);
+      const res = await fetch(
+        `${this.baseUrl}/spot/tickers?currency_pair=${encodeURIComponent(pair)}`
+      );
+      if (!res.ok) return null;
+      const data = await res.json();
+      const item = Array.isArray(data) ? data[0] : null;
+      if (!item?.last) return null;
+      const base = this.baseAsset(pair);
+      return {
+        name: base,
+        symbol: base,
+        priceUsd: parseFloat(item.last) || 0,
+        volume24h: finiteOrUndefined(item.quote_volume),
+        priceChangePercentage24h: finiteOrUndefined(item.change_percentage),
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch {
       return null;
     }
   }
 };
 
 // src/Crypull.ts
+function createDefaultProviders() {
+  return [
+    new BinanceProvider(),
+    new BybitProvider(),
+    new KuCoinProvider(),
+    new GateIoProvider(),
+    new CoinbaseProvider(),
+    new KrakenProvider(),
+    new CoinCapProvider(),
+    new CoinMarketCapProvider(),
+    new CoinGeckoProvider(),
+    new CoinpaprikaProvider(),
+    new CoinLoreProvider(),
+    new CryptoCompareProvider(),
+    new DexScreenerProvider(),
+    new GeckoTerminalProvider()
+  ];
+}
 var Crypull = class {
   providers;
-  // Standard free providers
-  coinGecko = new CoinGeckoProvider();
-  dexScreener = new DexScreenerProvider();
-  geckoTerminal = new GeckoTerminalProvider();
-  binance = new BinanceProvider();
-  coinpaprika = new CoinpaprikaProvider();
-  coincap = new CoinCapProvider();
-  cryptoCompare = new CryptoCompareProvider();
   constructor(options) {
-    this.providers = options?.providers || [
-      this.binance,
-      this.coinGecko,
-      this.coinpaprika,
-      this.coincap,
-      this.dexScreener,
-      this.geckoTerminal,
-      this.cryptoCompare
-    ];
+    this.providers = options?.providers?.length ? options.providers : createDefaultProviders();
+  }
+  symbolProviders() {
+    return this.providers.filter((p) => !p.addressBased);
+  }
+  addressProviders() {
+    return this.providers.filter((p) => p.addressBased);
   }
-  isAddress(query) {
-    return query.startsWith("0x") && query.length === 42 || query.length > 30;
+  coinGecko() {
+    return this.providers.find((p) => p instanceof CoinGeckoProvider);
   }
   /**
-   * Search for a token or coin across multiple providers in parallel
+   * Search for a token or coin across symbol + DEX providers in parallel.
    */
   async search(query) {
-    const promises = [
-      this.coinGecko.search(query),
-      this.dexScreener.search(query),
-      this.coinpaprika.search(query),
-      this.coincap.search(query)
-    ];
-    const results = await Promise.allSettled(promises);
+    const q = query.trim();
+    if (!q) return [];
+    const results = await Promise.allSettled(
+      this.providers.map((p) => p.search(q))
+    );
     const combined = [];
     for (const res of results) {
-      if (res.status === "fulfilled" && res.value) {
+      if (res.status === "fulfilled" && res.value.length) {
         combined.push(...res.value);
       }
     }
     const seen = /* @__PURE__ */ new Set();
     return combined.filter((item) => {
-      const key = `${item.symbol}`;
+      const key = item.id ? `${item.source}:${item.id}` : `${item.symbol}:${item.network ?? ""}:${item.source}`;
       if (seen.has(key)) return false;
       seen.add(key);
       return true;
     });
   }
   /**
-   * Get the current price of a cryptocurrency
-   * @param query Can be a symbol (e.g., 'BTC') or a contract address
-   * @param network Optional network for DEX addresses (e.g., 'eth', 'bsc')
+   * Get the current price of a cryptocurrency.
+   * @param query Symbol (e.g. 'BTC') or contract address
+   * @param network Optional network for DEX addresses (e.g. 'eth', 'bsc', 'solana')
    */
   async price(query, network) {
-    if (this.isAddress(query)) {
-      let res = await this.dexScreener.getPrice(query);
-      if (res) return res;
-      if (network) {
-        res = await this.geckoTerminal.getPrice(query, network);
+    const q = query.trim();
+    if (!q) return null;
+    if (isContractAddress(q)) {
+      for (const provider of this.addressProviders()) {
+        const net = network ?? (provider instanceof GeckoTerminalProvider ? defaultDexNetwork(q) : void 0);
+        const res = await provider.getPrice(q, net);
         if (res) return res;
       }
-    } else {
-      let res = await this.binance.getPrice(query);
-      if (res) return res;
-      res = await this.coincap.getPrice(query);
-      if (res) return res;
-      res = await this.coinGecko.getPrice(query);
-      if (res) return res;
-      res = await this.coinpaprika.getPrice(query);
-      if (res) return res;
-      res = await this.cryptoCompare.getPrice(query);
+      return null;
+    }
+    for (const provider of this.symbolProviders()) {
+      const res = await provider.getPrice(q);
       if (res) return res;
     }
     return null;
   }
   /**
    * Get detailed token info (market cap, volume, liquidity, etc.)
-   * @param query Can be a symbol (e.g., 'BTC') or a contract address
+   * @param query Symbol (e.g. 'BTC') or contract address
    * @param network Optional network for DEX addresses
    */
   async info(query, network) {
-    if (this.isAddress(query)) {
-      let res = await this.dexScreener.getTokenInfo(query);
-      if (res) return res;
-      if (network) {
-        res = await this.geckoTerminal.getTokenInfo(query, network);
+    const q = query.trim();
+    if (!q) return null;
+    if (isContractAddress(q)) {
+      for (const provider of this.addressProviders()) {
+        const net = network ?? (provider instanceof GeckoTerminalProvider ? defaultDexNetwork(q) : void 0);
+        const res = await provider.getTokenInfo(q, net);
         if (res) return res;
       }
-    } else {
-      let res = await this.coinGecko.getTokenInfo(query);
-      if (res) return res;
-      res = await this.coinpaprika.getTokenInfo(query);
-      if (res) return res;
-      res = await this.coincap.getTokenInfo(query);
-      if (res) return res;
-      res = await this.binance.getTokenInfo(query);
-      if (res) return res;
-      res = await this.cryptoCompare.getTokenInfo(query);
+      return null;
+    }
+    const preferred = [
+      "CoinGecko",
+      "CoinMarketCap",
+      "Coinpaprika",
+      "CoinLore",
+      "CoinCap",
+      "Binance",
+      "Bybit",
+      "KuCoin",
+      "Gate.io",
+      "Kraken",
+      "Coinbase",
+      "CryptoCompare"
+    ];
+    const providers = [...this.symbolProviders()].sort((a, b) => {
+      const ai = preferred.indexOf(a.name);
+      const bi = preferred.indexOf(b.name);
+      return (ai === -1 ? 99 : ai) - (bi === -1 ? 99 : bi);
+    });
+    for (const provider of providers) {
+      const res = await provider.getTokenInfo(q);
       if (res) return res;
     }
     return null;
@@ -566,81 +1280,41 @@ var Crypull = class {
    * Get global market data
    */
   async market() {
-    try {
-      const res = await fetch(`https://api.coingecko.com/api/v3/global`);
-      if (!res.ok) return null;
-      const data = await res.json();
-      const d = data.data;
-      return {
-        totalMarketCapUsd: d.total_market_cap.usd,
-        totalVolume24hUsd: d.total_volume.usd,
-        bitcoinDominancePercentage: d.market_cap_percentage.btc,
-        ethereumDominancePercentage: d.market_cap_percentage.eth,
-        activeCryptocurrencies: d.active_cryptocurrencies,
-        lastUpdated: d.updated_at * 1e3
-      };
-    } catch (e) {
-      return null;
-    }
+    const cg = this.coinGecko();
+    return cg ? cg.getGlobalMarket() : null;
   }
   /**
    * Get trending coins
    */
   async trending() {
-    try {
-      const res = await fetch(`https://api.coingecko.com/api/v3/search/trending`);
-      if (!res.ok) return [];
-      const data = await res.json();
-      return data.coins.slice(0, 10).map((c) => ({
-        id: c.item.id,
-        name: c.item.name,
-        symbol: c.item.symbol.toUpperCase(),
-        marketCapRank: c.item.market_cap_rank,
-        priceUsd: c.item.data?.price,
-        priceChange24h: c.item.data?.price_change_percentage_24h?.usd,
-        volume24h: c.item.data?.total_volume
-      }));
-    } catch (e) {
-      return [];
-    }
+    const cg = this.coinGecko();
+    if (cg) return cg.getTrending();
+    return [];
   }
   /**
    * Get top 50 coins by market cap
    */
   async top() {
-    try {
-      const res = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=50&page=1&sparkline=false`);
-      if (!res.ok) return [];
-      const data = await res.json();
-      return data.map((c) => ({
-        id: c.id,
-        name: c.name,
-        symbol: c.symbol.toUpperCase(),
-        marketCapRank: c.market_cap_rank,
-        priceUsd: c.current_price,
-        marketCap: c.market_cap,
-        volume24h: c.total_volume,
-        priceChange24h: c.price_change_percentage_24h
-      }));
-    } catch (e) {
-      return [];
-    }
+    const cg = this.coinGecko();
+    if (cg) return cg.getTop(50);
+    return [];
   }
   /**
    * Get fear and greed index
    */
   async sentiment() {
     try {
-      const res = await fetch(`https://api.alternative.me/fng/?limit=1`);
+      const res = await fetch("https://api.alternative.me/fng/?limit=1");
       if (!res.ok) return null;
       const data = await res.json();
-      const item = data.data[0];
+      const item = data.data?.[0];
+      if (!item) return null;
       return {
-        value: parseInt(item.value),
+        value: parseInt(item.value, 10),
         classification: item.value_classification,
-        lastUpdated: parseInt(item.timestamp) * 1e3
+        lastUpdated: parseInt(item.timestamp, 10) * 1e3
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -649,10 +1323,12 @@ var Crypull = class {
    */
   async gas() {
     try {
-      const res = await fetch(`https://api.etherscan.io/v2/api?chainid=1&module=gastracker&action=gasoracle`);
+      const res = await fetch(
+        "https://api.etherscan.io/v2/api?chainid=1&module=gastracker&action=gasoracle"
+      );
       if (!res.ok) return null;
       const data = await res.json();
-      if (data.status !== "1") return null;
+      if (data.status !== "1" || !data.result) return null;
       return {
         network: "Ethereum",
         low: parseFloat(data.result.SafeGasPrice),
@@ -660,38 +1336,19 @@ var Crypull = class {
         high: parseFloat(data.result.FastGasPrice),
         baseFee: parseFloat(data.result.suggestBaseFee)
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
   /**
    * Get historical chart data for a coin
-   * @param query Coin symbol or ID
+   * @param query Coin symbol or CoinGecko ID
    * @param days Number of days (e.g. 1, 7, 30)
    */
   async chart(query, days = 7) {
-    try {
-      let id = query.toLowerCase();
-      const searchRes = await this.coinGecko.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(`https://api.coingecko.com/api/v3/coins/${id}/market_chart?vs_currency=usd&days=${days}`);
-      if (!res.ok) return null;
-      const data = await res.json();
-      if (!data.prices || data.prices.length === 0) return null;
-      const prices = data.prices.map((p) => p[1]);
-      const timestamps = data.prices.map((p) => p[0]);
-      return {
-        prices,
-        timestamps,
-        minPrice: Math.min(...prices),
-        maxPrice: Math.max(...prices)
-      };
-    } catch (e) {
-      return null;
-    }
+    const cg = this.coinGecko();
+    if (!cg) return null;
+    return cg.getChart(query.trim(), days);
   }
 };
 
@@ -699,13 +1356,25 @@ var Crypull = class {
 var crypull = new Crypull();
 
 exports.BinanceProvider = BinanceProvider;
+exports.BybitProvider = BybitProvider;
 exports.CoinCapProvider = CoinCapProvider;
 exports.CoinGeckoProvider = CoinGeckoProvider;
+exports.CoinLoreProvider = CoinLoreProvider;
+exports.CoinMarketCapProvider = CoinMarketCapProvider;
+exports.CoinbaseProvider = CoinbaseProvider;
 exports.CoinpaprikaProvider = CoinpaprikaProvider;
 exports.CryptoCompareProvider = CryptoCompareProvider;
 exports.Crypull = Crypull;
 exports.DexScreenerProvider = DexScreenerProvider;
+exports.GateIoProvider = GateIoProvider;
 exports.GeckoTerminalProvider = GeckoTerminalProvider;
+exports.KrakenProvider = KrakenProvider;
+exports.KuCoinProvider = KuCoinProvider;
 exports.crypull = crypull;
+exports.defaultDexNetwork = defaultDexNetwork;
+exports.finiteOrUndefined = finiteOrUndefined;
+exports.fromBinancePair = fromBinancePair;
+exports.isContractAddress = isContractAddress;
+exports.toBinancePair = toBinancePair;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map