crypull 1.0.2 → 1.1.0

package/dist/index.js

@@ -1,12 +1,25 @@
 'use strict';
 
+var fs = require('fs');
+var path4 = require('path');
+var url = require('url');
+var sha3 = require('@noble/hashes/sha3');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path4__default = /*#__PURE__*/_interopDefault(path4);
+
 // 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 +28,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 +95,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 +195,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 +211,7 @@ var DexScreenerProvider = class {
         network: pair.chainId,
         source: this.name
       }));
-    } catch (e) {
+    } catch {
       return [];
     }
   }
@@ -114,12 +227,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 +267,7 @@ var DexScreenerProvider = class {
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -158,26 +276,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 +313,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 +326,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 +434,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 +449,7 @@ var CoinpaprikaProvider = class {
         symbol: coin.symbol.toUpperCase(),
         source: this.name
       }));
-    } catch (e) {
+    } catch {
       return [];
     }
   }
@@ -310,19 +465,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 +501,7 @@ var CoinpaprikaProvider = class {
         source: this.name,
         lastUpdated: Date.now()
       };
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -356,10 +510,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 +525,7 @@ var CoinCapProvider = class {
         symbol: coin.symbol.toUpperCase(),
         source: this.name
       }));
-    } catch (e) {
+    } catch {
       return [];
     }
   }
@@ -384,13 +541,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 +557,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 +572,1462 @@ 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 (e) {
+    } 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 {
+      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;
+    }
+  }
+};
+var cached;
+function assetsDir() {
+  if (cached) return cached;
+  const here = path4__default.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href))));
+  const candidates = [
+    path4__default.default.resolve(here, "../assets"),
+    path4__default.default.resolve(here, "../../assets")
+  ];
+  for (const dir of candidates) {
+    if (fs.existsSync(path4__default.default.join(dir, "chains.json"))) {
+      cached = dir;
+      return dir;
+    }
+  }
+  throw new Error(
+    "crypull data files were not found. Icons and chain data ship in the package assets folder."
+  );
+}
+
+// src/chains.ts
+var ALIASES = {
+  ethereum: 1,
+  eth: 1,
+  mainnet: 1,
+  bsc: 56,
+  bnb: 56,
+  binance: 56,
+  "binance-smart-chain": 56,
+  polygon: 137,
+  matic: 137,
+  pol: 137,
+  arbitrum: 42161,
+  arb: 42161,
+  "arbitrum-one": 42161,
+  optimism: 10,
+  op: 10,
+  base: 8453,
+  avalanche: 43114,
+  avax: 43114,
+  fantom: 250,
+  ftm: 250,
+  gnosis: 100,
+  xdai: 100,
+  zksync: 324,
+  era: 324,
+  linea: 59144,
+  scroll: 534352,
+  blast: 81457,
+  mantle: 5e3,
+  celo: 42220,
+  moonbeam: 1284,
+  glmr: 1284,
+  cronos: 25,
+  cro: 25,
+  opbnb: 204,
+  metis: 1088,
+  taiko: 167e3,
+  sei: 1329,
+  sonic: 146,
+  unichain: 130,
+  worldchain: 480,
+  berachain: 80094,
+  bera: 80094,
+  abstract: 2741,
+  ink: 57073,
+  soneium: 1868,
+  mode: 34443,
+  rootstock: 30,
+  rsk: 30,
+  kava: 2222,
+  zkevm: 1101,
+  "polygon-zkevm": 1101,
+  manta: 169,
+  apechain: 33139,
+  sepolia: 11155111,
+  holesky: 17e3,
+  solana: "solana",
+  sol: "solana",
+  bitcoin: "bitcoin",
+  btc: "bitcoin",
+  tron: "tron",
+  trx: "tron",
+  ton: "ton",
+  toncoin: "ton",
+  sui: "sui",
+  aptos: "aptos",
+  apt: "aptos",
+  cosmos: "cosmos",
+  atom: "cosmos",
+  near: "near"
+};
+var cache;
+function loadChains() {
+  if (!cache) {
+    const file = path4__default.default.join(assetsDir(), "chains.json");
+    cache = JSON.parse(fs.readFileSync(file, "utf8"));
+  }
+  return cache;
+}
+function byChainId(chainId) {
+  return loadChains().find((chain) => chain.chainId === chainId) ?? null;
+}
+function rank(chain, query) {
+  let score = 0;
+  if (chain.featured) score += 100;
+  if (!chain.testnet) score += 40;
+  if (!chain.deprecated) score += 10;
+  if (chain.id === query) score += 30;
+  if (chain.shortName.toLowerCase() === query) score += 20;
+  if (chain.icon === query) score += 15;
+  return score;
+}
+function getChain(query) {
+  const chains = loadChains();
+  const text = String(query).trim().toLowerCase();
+  if (!text) return null;
+  if (typeof query === "number" || /^\d+$/.test(text)) {
+    return byChainId(Number(text));
+  }
+  if (text.startsWith("eip155:")) {
+    const id = Number(text.slice("eip155:".length));
+    return Number.isInteger(id) ? byChainId(id) : null;
+  }
+  const alias = ALIASES[text];
+  if (typeof alias === "number") {
+    const chain = byChainId(alias);
+    if (chain) return chain;
+  }
+  if (typeof alias === "string") {
+    const chain = chains.find((item) => item.id === alias);
+    if (chain) return chain;
+  }
+  const exact = chains.filter(
+    (chain) => chain.id === text || chain.shortName.toLowerCase() === text || chain.icon === text || chain.name.toLowerCase() === text
+  );
+  if (exact.length > 0) {
+    return exact.sort((a, b) => rank(b, text) - rank(a, text))[0];
+  }
+  if (text.length >= 4) {
+    const loose = chains.filter(
+      (chain) => chain.id.includes(text) || chain.shortName.toLowerCase().includes(text) || chain.name.toLowerCase().includes(text)
+    );
+    const pool = loose.filter((chain) => !chain.testnet);
+    const picked = pool.length === 1 ? pool : loose.length === 1 ? loose : [];
+    if (picked.length === 1) return picked[0];
+  }
+  return null;
+}
+function listChains(options = {}) {
+  return loadChains().filter((chain) => {
+    if (options.featured && !chain.featured) return false;
+    if (options.family && chain.family !== options.family) return false;
+    if (options.mainnet && chain.testnet) return false;
+    if (!options.includeDeprecated && chain.deprecated) return false;
+    return true;
+  }).sort((a, b) => Number(b.featured) - Number(a.featured) || (a.chainId ?? -1) - (b.chainId ?? -1));
+}
+function searchChains(query, limit = 20) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [];
+  return loadChains().filter(
+    (chain) => chain.id.includes(q) || chain.shortName.toLowerCase().includes(q) || chain.name.toLowerCase().includes(q) || chain.nativeCurrency.symbol.toLowerCase() === q
+  ).sort((a, b) => Number(b.featured) - Number(a.featured) || a.name.length - b.name.length).slice(0, limit);
+}
+function getRpcUrls(query) {
+  return getChain(query)?.rpc ?? [];
+}
+function explorerUrl(query, target, value) {
+  const chain = getChain(query);
+  const explorer = chain?.explorers[0];
+  if (!chain || !explorer) return null;
+  const pathName = target === "tx" ? explorer.txPath : target === "block" ? explorer.blockPath ?? "/block/" : target === "token" ? chain.family === "evm" ? "/token/" : explorer.addressPath : explorer.addressPath;
+  return `${explorer.url.replace(/\/$/, "")}${pathName}${value}`;
+}
+function toCaip2(query) {
+  const chain = getChain(query);
+  if (!chain) return null;
+  if (chain.family === "evm" && chain.chainId !== null) return `eip155:${chain.chainId}`;
+  if (chain.family === "solana") return "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+  if (chain.family === "bitcoin") return "bip122:000000000019d6689c085ae165831e93";
+  return null;
+}
+var NETWORK_KEYS = {
+  eth: "ethereum",
+  ethereum: "ethereum",
+  bsc: "binance-smart-chain",
+  bnb: "binance-smart-chain",
+  binance: "binance-smart-chain",
+  polygon: "polygon-pos",
+  matic: "polygon-pos",
+  pol: "polygon-pos",
+  arbitrum: "arbitrum-one",
+  arb: "arbitrum-one",
+  optimism: "optimistic-ethereum",
+  op: "optimistic-ethereum",
+  avalanche: "avalanche",
+  avax: "avalanche",
+  base: "base",
+  solana: "solana",
+  sol: "solana",
+  fantom: "fantom",
+  ftm: "fantom",
+  gnosis: "xdai",
+  linea: "linea",
+  scroll: "scroll",
+  zksync: "zksync",
+  blast: "blast",
+  mantle: "mantle",
+  celo: "celo",
+  cronos: "cronos",
+  tron: "tron",
+  trx: "tron"
+};
+var tokensCache;
+var networksCache;
+var walletsCache;
+var exchangesCache;
+var tokenBySymbol;
+var tokenById;
+function loadJson(name) {
+  const file = path4__default.default.join(assetsDir(), "metadata", name);
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+function listTokenMetadata() {
+  if (!tokensCache) tokensCache = loadJson("tokens.json");
+  return tokensCache;
+}
+function listNetworkMetadata() {
+  if (!networksCache) networksCache = loadJson("networks.json");
+  return networksCache;
+}
+function listWalletMetadata() {
+  if (!walletsCache) walletsCache = loadJson("wallets.json");
+  return walletsCache;
+}
+function listExchangeMetadata() {
+  if (!exchangesCache) exchangesCache = loadJson("exchanges.json");
+  return exchangesCache;
+}
+function tokenIndex() {
+  if (!tokenBySymbol || !tokenById) {
+    tokenBySymbol = /* @__PURE__ */ new Map();
+    tokenById = /* @__PURE__ */ new Map();
+    for (const token of listTokenMetadata()) {
+      tokenById.set(token.id.toLowerCase(), token);
+      const key = token.symbol.toLowerCase();
+      const current = tokenBySymbol.get(key);
+      const currentRank = current?.marketCapRank ?? Number.MAX_SAFE_INTEGER;
+      const nextRank = token.marketCapRank ?? Number.MAX_SAFE_INTEGER;
+      if (!current || nextRank < currentRank) tokenBySymbol.set(key, token);
+    }
+  }
+  return { bySymbol: tokenBySymbol, byId: tokenById };
+}
+function findToken(symbolOrId) {
+  const key = symbolOrId.trim().toLowerCase();
+  if (!key) return null;
+  const { bySymbol, byId } = tokenIndex();
+  return bySymbol.get(key) ?? byId.get(key) ?? null;
+}
+function searchTokens(query, limit = 20) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [];
+  return listTokenMetadata().filter((token) => token.symbol.toLowerCase().includes(q) || token.name.toLowerCase().includes(q) || token.id.includes(q)).sort((a, b) => (a.marketCapRank ?? Number.MAX_SAFE_INTEGER) - (b.marketCapRank ?? Number.MAX_SAFE_INTEGER)).slice(0, limit);
+}
+function findNetwork(idOrName) {
+  const key = idOrName.trim().toLowerCase();
+  if (!key) return null;
+  return listNetworkMetadata().find(
+    (network) => network.id.toLowerCase() === key || network.shortName?.toLowerCase() === key || network.name.toLowerCase() === key
+  ) ?? null;
+}
+function findWallet(idOrName) {
+  const key = idOrName.trim().toLowerCase();
+  if (!key) return null;
+  return listWalletMetadata().find(
+    (wallet) => wallet.id.toLowerCase() === key || wallet.name.toLowerCase() === key
+  ) ?? null;
+}
+function findExchange(idOrName) {
+  const key = idOrName.trim().toLowerCase();
+  if (!key) return null;
+  return listExchangeMetadata().find(
+    (exchange) => exchange.id.toLowerCase() === key || exchange.name.toLowerCase() === key
+  ) ?? null;
+}
+function getTokenAddress(symbolOrId, network) {
+  const token = findToken(symbolOrId);
+  if (!token) return null;
+  const normalized = network.trim().toLowerCase();
+  const key = NETWORK_KEYS[normalized] ?? normalized;
+  return token.addresses?.[key] ?? token.addresses?.[normalized] ?? null;
+}
+
+// src/icons.ts
+var listings = /* @__PURE__ */ new Map();
+function iconDir(kind, variant) {
+  if (kind === "crypto") return path4__default.default.join(assetsDir(), "icons", "crypto", variant);
+  const folder = kind === "token" ? "tokens" : `${kind}s`;
+  return path4__default.default.join(assetsDir(), "icons", "web3", folder, variant);
+}
+function readIcon(filePath, kind, id, variant) {
+  if (!fs.existsSync(filePath)) return null;
+  const svg = fs.readFileSync(filePath, "utf8");
+  return {
+    kind,
+    id,
+    variant,
+    svg,
+    dataUri: `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`,
+    filePath
+  };
+}
+function listIcons(kind, variant) {
+  const chosen = variant ?? (kind === "crypto" ? "color" : "branded");
+  const cacheKey = `${kind}:${chosen}`;
+  const cached2 = listings.get(cacheKey);
+  if (cached2) return cached2;
+  const dir = iconDir(kind, chosen);
+  if (!fs.existsSync(dir)) return [];
+  const names = fs.readdirSync(dir).filter((name) => name.endsWith(".svg")).map((name) => name.slice(0, -4)).sort((a, b) => a.localeCompare(b));
+  listings.set(cacheKey, names);
+  return names;
+}
+function getCryptoIcon(symbol, variant = "color") {
+  const id = symbol.trim().toLowerCase().replace(/\.svg$/i, "");
+  if (!id) return null;
+  return readIcon(path4__default.default.join(iconDir("crypto", variant), `${id}.svg`), "crypto", id, variant);
+}
+function getTokenIcon(symbol, variant = "branded") {
+  const token = findToken(symbol);
+  const fromMeta = token?.filePath?.split(":")[1];
+  const id = fromMeta || symbol.trim().toUpperCase().replace(/\.svg$/i, "");
+  if (!id) return null;
+  return readIcon(path4__default.default.join(iconDir("token", variant), `${id}.svg`), "token", id, variant);
+}
+function getNetworkIcon(id, variant = "branded") {
+  const network = findNetwork(id);
+  const fileId = network?.id || id.trim().toLowerCase().replace(/\.svg$/i, "");
+  if (!fileId) return null;
+  return readIcon(path4__default.default.join(iconDir("network", variant), `${fileId}.svg`), "network", fileId, variant);
+}
+function getWalletIcon(id, variant = "branded") {
+  const wallet = findWallet(id);
+  const fileId = wallet?.id || id.trim().toLowerCase().replace(/\.svg$/i, "");
+  if (!fileId) return null;
+  return readIcon(path4__default.default.join(iconDir("wallet", variant), `${fileId}.svg`), "wallet", fileId, variant);
+}
+function getExchangeIcon(id, variant = "branded") {
+  const exchange = findExchange(id);
+  const fileId = exchange?.id || id.trim().toLowerCase().replace(/\.svg$/i, "");
+  if (!fileId) return null;
+  return readIcon(path4__default.default.join(iconDir("exchange", variant), `${fileId}.svg`), "exchange", fileId, variant);
+}
+function prefersNetwork(query) {
+  return query.includes("-") || query.length > 8;
+}
+function getIcon(query, options) {
+  const q = query.trim();
+  if (!q) return null;
+  const variant = options?.variant;
+  const tokenVariant = variant === "mono" || variant === "black" || variant === "white" || variant === "icon" ? "mono" : variant === "background" ? "background" : "branded";
+  const cryptoVariant = variant === "black" || variant === "mono" ? "black" : variant === "white" ? "white" : variant === "icon" ? "icon" : "color";
+  if (prefersNetwork(q)) {
+    return getNetworkIcon(q, tokenVariant) ?? getWalletIcon(q, tokenVariant) ?? getExchangeIcon(q, tokenVariant) ?? getTokenIcon(q, tokenVariant) ?? getCryptoIcon(q, cryptoVariant);
+  }
+  return getTokenIcon(q, tokenVariant) ?? getCryptoIcon(q, cryptoVariant) ?? getNetworkIcon(q, tokenVariant) ?? getWalletIcon(q, tokenVariant) ?? getExchangeIcon(q, tokenVariant);
+}
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function isEvmAddress(value) {
+  return /^0x[a-fA-F0-9]{40}$/.test(value.trim());
+}
+function toChecksumAddress(address) {
+  const hex = address.trim().toLowerCase().replace(/^0x/, "");
+  if (!/^[0-9a-f]{40}$/.test(hex)) {
+    throw new Error("Invalid EVM address");
+  }
+  const hash = bytesToHex(sha3.keccak_256(new TextEncoder().encode(hex)));
+  let checksum = "0x";
+  for (let i = 0; i < hex.length; i++) {
+    checksum += parseInt(hash[i], 16) >= 8 ? hex[i].toUpperCase() : hex[i];
+  }
+  return checksum;
+}
+function isChecksumAddress(address) {
+  if (!isEvmAddress(address)) return false;
+  try {
+    return toChecksumAddress(address) === address.trim();
+  } catch {
+    return false;
+  }
+}
+var BASE58 = /^[1-9A-HJ-NP-Za-km-z]+$/;
+function detectAddress(value) {
+  const address = value.trim();
+  if (!address) return { kind: "unknown", address };
+  if (isEvmAddress(address)) return { kind: "evm", address };
+  if (/^T[1-9A-HJ-NP-Za-km-z]{33}$/.test(address)) {
+    return { kind: "tron", address };
+  }
+  if (/^bc1[ac-hj-np-z02-9]{11,71}$/i.test(address) || /^[13][1-9A-HJ-NP-Za-km-z]{24,33}$/.test(address)) {
+    return { kind: "bitcoin", address };
+  }
+  if (address.length >= 32 && address.length <= 44 && BASE58.test(address)) {
+    return { kind: "solana", address };
+  }
+  return { kind: "unknown", address };
+}
+function shortenAddress(value, chars = 4) {
+  const address = value.trim();
+  if (!Number.isInteger(chars) || chars < 1) {
+    throw new Error("chars must be a positive integer");
+  }
+  const head = chars + (address.startsWith("0x") || address.startsWith("0X") ? 2 : 0);
+  if (address.length <= head + chars + 1) return address;
+  return `${address.slice(0, head)}\u2026${address.slice(-chars)}`;
+}
+
+// src/units.ts
+function assertDecimals(decimals) {
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 78) {
+    throw new Error("decimals must be an integer between 0 and 78");
+  }
+}
+function parseUnits(value, decimals) {
+  assertDecimals(decimals);
+  const raw = typeof value === "number" ? String(value) : value.trim();
+  if (/e/i.test(raw)) {
+    throw new Error("Scientific notation is not supported. Pass a plain decimal string.");
+  }
+  if (!/^(?:\d+\.?\d*|\.\d+)$/.test(raw)) {
+    throw new Error(`Invalid numeric value "${raw}"`);
+  }
+  const [wholePart = "", fracPart = ""] = raw.split(".");
+  if (fracPart.length > decimals) {
+    throw new Error(`Value has more than ${decimals} decimal places`);
+  }
+  const whole = wholePart === "" ? "0" : wholePart;
+  const frac = fracPart.padEnd(decimals, "0");
+  const digits = `${whole}${frac}`.replace(/^0+/, "") || "0";
+  return BigInt(digits);
+}
+function formatUnits(value, decimals, maxFraction) {
+  assertDecimals(decimals);
+  const negative = typeof value === "bigint" ? value < 0n : String(value).trim().startsWith("-");
+  const abs = typeof value === "bigint" ? negative ? -value : value : BigInt(String(value).trim().replace(/^-/, ""));
+  if (maxFraction !== void 0 && (!Number.isInteger(maxFraction) || maxFraction < 0)) {
+    throw new Error("maxFraction must be a non-negative integer");
+  }
+  let scaled = abs;
+  let places = decimals;
+  if (maxFraction !== void 0 && maxFraction < decimals) {
+    const drop = 10n ** BigInt(decimals - maxFraction);
+    scaled = (abs + drop / 2n) / drop;
+    places = maxFraction;
+  }
+  if (scaled === 0n) return "0";
+  const base = 10n ** BigInt(places);
+  const whole = scaled / base;
+  let frac = (scaled % base).toString().padStart(places, "0");
+  frac = frac.replace(/0+$/, "");
+  const body = frac.length > 0 ? `${whole.toString()}.${frac}` : whole.toString();
+  return negative ? `-${body}` : body;
+}
+function parseEther(value) {
+  return parseUnits(value, 18);
+}
+function formatEther(value, maxFraction) {
+  return formatUnits(value, 18, maxFraction);
+}
+function parseGwei(value) {
+  return parseUnits(value, 9);
+}
+function formatGwei(value, maxFraction) {
+  return formatUnits(value, 9, maxFraction);
+}
+function toQuantity(value) {
+  const quantity = BigInt(value);
+  if (quantity < 0n) throw new Error("Hex quantity cannot be negative");
+  return `0x${quantity.toString(16)}`;
+}
+function fromQuantity(value) {
+  const hex = value.trim();
+  if (!/^0x[0-9a-fA-F]+$/.test(hex)) {
+    throw new Error(`Invalid hex quantity "${value}"`);
+  }
+  return BigInt(hex);
+}
+
+// src/rpc.ts
+var RpcError = class extends Error {
+  url;
+  constructor(message, url) {
+    super(message);
+    this.name = "RpcError";
+    this.url = url;
+  }
+};
+function requireChain(query) {
+  const chain = getChain(query);
+  if (!chain) throw new RpcError(`Unknown chain "${query}"`);
+  return chain;
+}
+async function jsonRpc(url, method, params = [], options) {
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+      signal: AbortSignal.timeout(options?.timeoutMs ?? 8e3)
+    });
+  } catch (error) {
+    throw new RpcError(error instanceof Error ? error.message : "RPC request failed", url);
+  }
+  if (!response.ok) throw new RpcError(`HTTP ${response.status}`, url);
+  const body = await response.json();
+  if (body.error) throw new RpcError(body.error.message || "RPC error", url);
+  return body.result;
+}
+async function jsonRpcFallback(urls, method, params = [], options) {
+  const list = urls.filter(Boolean).slice(0, options?.tries ?? 4);
+  if (list.length === 0) throw new RpcError("No RPC urls to try");
+  let last;
+  for (const url of list) {
+    try {
+      const result = await jsonRpc(url, method, params, options);
+      return { url, result };
+    } catch (error) {
+      last = error;
+    }
+  }
+  throw last instanceof Error ? last : new RpcError("All RPC urls failed");
+}
+async function evm(query, method, params = []) {
+  const chain = requireChain(query);
+  if (chain.family !== "evm") throw new RpcError(`${chain.name} is not an EVM chain`);
+  if (chain.rpc.length === 0) throw new RpcError(`${chain.name} has no RPC urls`);
+  const { result } = await jsonRpcFallback(chain.rpc, method, params);
+  return result;
+}
+async function getBlockNumber(query) {
+  const hex = await evm(query, "eth_blockNumber");
+  return Number(BigInt(hex));
+}
+async function getEvmBalance(query, address) {
+  const hex = await evm(query, "eth_getBalance", [address, "latest"]);
+  return BigInt(hex);
+}
+async function getTransactionCount(query, address) {
+  const hex = await evm(query, "eth_getTransactionCount", [address, "latest"]);
+  return Number(BigInt(hex));
+}
+async function getCode(query, address) {
+  return evm(query, "eth_getCode", [address, "latest"]);
+}
+async function getTransaction(query, hash) {
+  return evm(query, "eth_getTransactionByHash", [hash]);
+}
+async function getBlock(query, block = "latest") {
+  const tag = block === "latest" ? "latest" : toQuantity(block);
+  return evm(query, "eth_getBlockByNumber", [tag, false]);
+}
+async function ethCall(query, to, data) {
+  return evm(query, "eth_call", [{ to, data }, "latest"]);
+}
+async function getGasPrice(query) {
+  const hex = await evm(query, "eth_gasPrice");
+  return BigInt(hex);
+}
+function gwei(wei) {
+  if (wei === void 0) return void 0;
+  return Number(formatUnits(wei, 9));
+}
+async function getFeeEstimate(query) {
+  const gasPrice = await getGasPrice(query);
+  try {
+    const history = await evm(query, "eth_feeHistory", ["0x5", "latest", [10, 50, 90]]);
+    const baseFees = history.baseFeePerGas ?? [];
+    const baseFee = baseFees.length > 0 ? BigInt(baseFees[baseFees.length - 1]) : void 0;
+    const rewards = history.reward ?? [];
+    const priority = (index) => {
+      const values = rewards.map((row) => row?.[index] ? BigInt(row[index]) : 0n).filter((value) => value > 0n);
+      if (values.length === 0 || baseFee === void 0) return void 0;
+      const sum = values.reduce((total, value) => total + value, 0n);
+      return baseFee + sum / BigInt(values.length);
+    };
+    return {
+      gasPrice,
+      baseFee,
+      low: priority(0),
+      average: priority(1),
+      high: priority(2)
+    };
+  } catch {
+    return { gasPrice };
+  }
+}
+async function getChainGas(query) {
+  const chain = requireChain(query);
+  const fee = await getFeeEstimate(query);
+  const average = gwei(fee.average ?? fee.gasPrice) ?? 0;
+  return {
+    network: chain.name,
+    low: gwei(fee.low) ?? average,
+    average,
+    high: gwei(fee.high) ?? average,
+    baseFee: gwei(fee.baseFee)
+  };
+}
+async function bitcoinBalance(chain, address) {
+  let last;
+  for (const api of chain.api) {
+    try {
+      const response = await fetch(`${api.replace(/\/$/, "")}/address/${address}`, {
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (!response.ok) throw new RpcError(`HTTP ${response.status}`, api);
+      const data = await response.json();
+      const funded = BigInt(data.chain_stats?.funded_txo_sum ?? 0);
+      const spent = BigInt(data.chain_stats?.spent_txo_sum ?? 0);
+      return funded - spent;
+    } catch (error) {
+      last = error;
+    }
+  }
+  throw last instanceof Error ? last : new RpcError("Bitcoin API request failed");
+}
+function unsignedInteger(text, field) {
+  const match = text.match(new RegExp(`"${field}"\\s*:\\s*(\\d+)`));
+  return match ? match[1] : null;
+}
+async function solanaBalance(chain, address) {
+  let last;
+  for (const url of chain.rpc.slice(0, 4)) {
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "getBalance", params: [address] }),
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (!response.ok) throw new RpcError(`HTTP ${response.status}`, url);
+      const text = await response.text();
+      if (/"error"\s*:\s*(?!null)/.test(text)) {
+        const message = text.match(/"message"\s*:\s*"([^"]*)"/)?.[1] || "RPC error";
+        throw new RpcError(message, url);
+      }
+      const lamports = unsignedInteger(text, "value");
+      if (!lamports) throw new RpcError("Solana balance was missing", url);
+      return BigInt(lamports);
+    } catch (error) {
+      last = error;
+    }
+  }
+  throw last instanceof Error ? last : new RpcError("Solana RPC request failed");
+}
+async function tronBalance(chain, address) {
+  const api = chain.api[0];
+  if (!api) throw new RpcError("TRON API is not configured");
+  const response = await fetch(`${api.replace(/\/$/, "")}/wallet/getaccount`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ address, visible: true }),
+    signal: AbortSignal.timeout(8e3)
+  });
+  if (!response.ok) throw new RpcError(`HTTP ${response.status}`, api);
+  const text = await response.text();
+  if (/"Error"\s*:/.test(text)) throw new RpcError("TRON API request failed", api);
+  const sun = unsignedInteger(text, "balance");
+  return BigInt(sun ?? "0");
+}
+async function getNativeBalance(query, address) {
+  const chain = requireChain(query);
+  const owner = address.trim();
+  let raw;
+  if (chain.family === "evm") {
+    if (!isEvmAddress(owner)) throw new RpcError("Expected an EVM address");
+    raw = await getEvmBalance(query, owner);
+  } else if (chain.family === "solana") {
+    if (detectAddress(owner).kind !== "solana") throw new RpcError("Expected a Solana address");
+    raw = await solanaBalance(chain, owner);
+  } else if (chain.family === "bitcoin") {
+    if (detectAddress(owner).kind !== "bitcoin") throw new RpcError("Expected a Bitcoin address");
+    raw = await bitcoinBalance(chain, owner);
+  } else if (chain.family === "tron") {
+    if (detectAddress(owner).kind !== "tron") throw new RpcError("Expected a TRON address");
+    raw = await tronBalance(chain, owner);
+  } else {
+    throw new RpcError(
+      `No balance helper for ${chain.family}. Call jsonRpc() with ${chain.name} RPC urls from getRpcUrls().`
+    );
+  }
+  return {
+    chain,
+    address: owner,
+    raw,
+    formatted: formatUnits(raw, chain.nativeCurrency.decimals),
+    symbol: chain.nativeCurrency.symbol,
+    decimals: chain.nativeCurrency.decimals
+  };
+}
+async function probeRpcs(query, options) {
+  const chain = requireChain(query);
+  const urls = chain.rpc.slice(0, options?.limit ?? 4);
+  const method = chain.family === "evm" ? "eth_chainId" : chain.family === "solana" ? "getSlot" : null;
+  if (!method) {
+    return urls.map((url) => ({
+      url,
+      ok: false,
+      latencyMs: 0,
+      error: "Probe supports EVM and Solana RPC urls"
+    }));
+  }
+  return Promise.all(
+    urls.map(async (url) => {
+      const started = Date.now();
+      try {
+        const result = await jsonRpc(url, method, [], options);
+        return {
+          url,
+          ok: true,
+          latencyMs: Date.now() - started,
+          chainId: chain.family === "evm" ? Number(BigInt(String(result))) : void 0
+        };
+      } catch (error) {
+        return {
+          url,
+          ok: false,
+          latencyMs: Date.now() - started,
+          error: error instanceof Error ? error.message : "failed"
+        };
+      }
+    })
+  );
+}
+async function callChain(query, method, params = [], options) {
+  const urls = getRpcUrls(query);
+  if (urls.length === 0) throw new RpcError(`No RPC urls for "${query}"`);
+  const { result } = await jsonRpcFallback(urls, method, params, options);
+  return result;
+}
+
 // 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 +2036,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 +2079,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,52 +2092,222 @@ 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) {
+    const cg = this.coinGecko();
+    if (!cg) return null;
+    return cg.getChart(query.trim(), days);
+  }
+  /** Local SVG for a ticker, network, wallet, or exchange. */
+  icon(query, variant) {
+    return getIcon(query, variant ? { variant } : void 0);
+  }
+  /** Chain metadata, including public RPC URLs. */
+  chain(query) {
+    return getChain(query);
+  }
+  /** Public RPC URLs for a chain. */
+  rpcs(query) {
+    return getRpcUrls(query);
+  }
+  /** Latest block number for an EVM chain. */
+  async blockNumber(chain) {
     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 await getBlockNumber(chain);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Native balance. EVM, Solana, Bitcoin, and TRON have helpers.
+   * Returns the smallest unit in `raw` and a decimal string in `formatted`.
+   */
+  async balance(chain, address) {
+    try {
+      return await getNativeBalance(chain, address);
+    } catch {
+      return null;
+    }
+  }
+  /** Live gas estimate in gwei for an EVM chain, read from its RPC list. */
+  async chainGas(chain) {
+    try {
+      return await getChainGas(chain);
+    } catch {
+      return null;
+    }
+  }
+  /** JSON-RPC call against the chain's public RPC list, trying the next URL on failure. */
+  async rpc(chain, method, params = []) {
+    try {
+      return await callChain(chain, method, params);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Convert an amount between two symbols using USD prices.
+   * Pass `usd` as `to` for a fiat quote.
+   */
+  async convert(amount, from, to) {
+    if (!Number.isFinite(amount)) return null;
+    const target = to.trim().toLowerCase();
+    if (target === "usd" || target === "$") {
+      const quote2 = await this.price(from);
+      if (!quote2) return null;
       return {
-        prices,
-        timestamps,
-        minPrice: Math.min(...prices),
-        maxPrice: Math.max(...prices)
+        amount,
+        from: quote2.symbol,
+        to: "USD",
+        result: amount * quote2.priceUsd,
+        rate: quote2.priceUsd,
+        source: quote2.source
       };
-    } catch (e) {
-      return null;
     }
+    const [base, quote] = await Promise.all([this.price(from), this.price(to)]);
+    if (!base || !quote || quote.priceUsd === 0) return null;
+    const rate = base.priceUsd / quote.priceUsd;
+    return {
+      amount,
+      from: base.symbol,
+      to: quote.symbol,
+      result: amount * rate,
+      rate,
+      source: `${base.source}+${quote.source}`
+    };
   }
 };
 
+// src/format.ts
+function formatUsd(value, maximumFractionDigits = 2) {
+  if (!Number.isFinite(value)) return "$0";
+  const abs = Math.abs(value);
+  const digits = abs !== 0 && abs < 1 ? Math.min(8, maximumFractionDigits + 6) : maximumFractionDigits;
+  const formatted = abs.toLocaleString("en-US", {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: digits
+  });
+  return `${value < 0 ? "-" : ""}$${formatted}`;
+}
+function formatCompact(value) {
+  if (!Number.isFinite(value)) return "0";
+  const sign = value < 0 ? "-" : "";
+  const abs = Math.abs(value);
+  const units = [
+    { size: 1e12, suffix: "T" },
+    { size: 1e9, suffix: "B" },
+    { size: 1e6, suffix: "M" },
+    { size: 1e3, suffix: "K" }
+  ];
+  for (let i = 0; i < units.length; i++) {
+    const unit = units[i];
+    if (abs >= unit.size) {
+      const digitsFor = (scaled) => scaled >= 100 ? 0 : scaled >= 10 ? 1 : 2;
+      const trim = (scaled) => scaled.toFixed(digitsFor(scaled)).replace(/\.0+$/, "").replace(/(\.\d)0$/, "$1");
+      let text = trim(abs / unit.size);
+      if (Number(text) >= 1e3 && i > 0) {
+        text = trim(abs / units[i - 1].size);
+        return `${sign}${text}${units[i - 1].suffix}`;
+      }
+      return `${sign}${text}${unit.suffix}`;
+    }
+  }
+  if (abs >= 1) return `${sign}${abs.toFixed(2).replace(/\.?0+$/, "")}`;
+  if (abs === 0) return "0";
+  return `${sign}${abs.toFixed(4).replace(/0+$/, "").replace(/\.$/, "")}`;
+}
+function formatPercent(value, digits = 2) {
+  if (!Number.isFinite(value)) return "0%";
+  const sign = value > 0 ? "+" : "";
+  return `${sign}${value.toFixed(digits)}%`;
+}
+
 // src/index.ts
 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.RpcError = RpcError;
+exports.callChain = callChain;
 exports.crypull = crypull;
+exports.defaultDexNetwork = defaultDexNetwork;
+exports.detectAddress = detectAddress;
+exports.ethCall = ethCall;
+exports.explorerUrl = explorerUrl;
+exports.findExchange = findExchange;
+exports.findNetwork = findNetwork;
+exports.findToken = findToken;
+exports.findWallet = findWallet;
+exports.finiteOrUndefined = finiteOrUndefined;
+exports.formatCompact = formatCompact;
+exports.formatEther = formatEther;
+exports.formatGwei = formatGwei;
+exports.formatPercent = formatPercent;
+exports.formatUnits = formatUnits;
+exports.formatUsd = formatUsd;
+exports.fromBinancePair = fromBinancePair;
+exports.fromQuantity = fromQuantity;
+exports.getBlock = getBlock;
+exports.getBlockNumber = getBlockNumber;
+exports.getChain = getChain;
+exports.getChainGas = getChainGas;
+exports.getCode = getCode;
+exports.getCryptoIcon = getCryptoIcon;
+exports.getEvmBalance = getEvmBalance;
+exports.getExchangeIcon = getExchangeIcon;
+exports.getFeeEstimate = getFeeEstimate;
+exports.getGasPrice = getGasPrice;
+exports.getIcon = getIcon;
+exports.getNativeBalance = getNativeBalance;
+exports.getNetworkIcon = getNetworkIcon;
+exports.getRpcUrls = getRpcUrls;
+exports.getTokenAddress = getTokenAddress;
+exports.getTokenIcon = getTokenIcon;
+exports.getTransaction = getTransaction;
+exports.getTransactionCount = getTransactionCount;
+exports.getWalletIcon = getWalletIcon;
+exports.isChecksumAddress = isChecksumAddress;
+exports.isContractAddress = isContractAddress;
+exports.isEvmAddress = isEvmAddress;
+exports.jsonRpc = jsonRpc;
+exports.jsonRpcFallback = jsonRpcFallback;
+exports.listChains = listChains;
+exports.listExchangeMetadata = listExchangeMetadata;
+exports.listIcons = listIcons;
+exports.listNetworkMetadata = listNetworkMetadata;
+exports.listTokenMetadata = listTokenMetadata;
+exports.listWalletMetadata = listWalletMetadata;
+exports.parseEther = parseEther;
+exports.parseGwei = parseGwei;
+exports.parseUnits = parseUnits;
+exports.probeRpcs = probeRpcs;
+exports.searchChains = searchChains;
+exports.searchTokens = searchTokens;
+exports.shortenAddress = shortenAddress;
+exports.toBinancePair = toBinancePair;
+exports.toCaip2 = toCaip2;
+exports.toChecksumAddress = toChecksumAddress;
+exports.toQuantity = toQuantity;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map