crypull 1.0.0

package/dist/index.mjs

@@ -0,0 +1,701 @@
+// src/providers/coingecko.ts
+var CoinGeckoProvider = class {
+  name = "CoinGecko";
+  baseUrl = "https://api.coingecko.com/api/v3";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/search?query=${query}`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.coins || []).slice(0, 10).map((coin) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  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`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (!data[id] || typeof data[id].usd === "undefined") return null;
+      return {
+        symbol: match ? match.symbol : id.toUpperCase(),
+        priceUsd: data[id].usd,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  async getTokenInfo(id) {
+    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`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.error) return null;
+      return {
+        name: data.name,
+        symbol: data.symbol.toUpperCase(),
+        description: data.description?.en,
+        priceUsd: data.market_data?.current_price?.usd || 0,
+        marketCap: data.market_data?.market_cap?.usd,
+        marketCapRank: data.market_cap_rank,
+        fdv: data.market_data?.fully_diluted_valuation?.usd,
+        circulatingSupply: data.market_data?.circulating_supply,
+        totalSupply: data.market_data?.total_supply,
+        maxSupply: data.market_data?.max_supply,
+        volume24h: data.market_data?.total_volume?.usd,
+        priceChange24h: data.market_data?.price_change_24h,
+        priceChangePercentage24h: data.market_data?.price_change_percentage_24h,
+        priceChangePercentage7d: data.market_data?.price_change_percentage_7d,
+        ath: data.market_data?.ath?.usd,
+        athDate: data.market_data?.ath_date?.usd,
+        atl: data.market_data?.atl?.usd,
+        atlDate: data.market_data?.atl_date?.usd,
+        links: {
+          website: data.links?.homepage?.[0],
+          twitter: data.links?.twitter_screen_name ? `https://twitter.com/${data.links.twitter_screen_name}` : 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")),
+          github: data.links?.repos_url?.github?.[0]
+        },
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/dexscreener.ts
+var DexScreenerProvider = class {
+  name = "DexScreener";
+  baseUrl = "https://api.dexscreener.com/latest/dex";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/search?q=${query}`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.pairs || []).slice(0, 10).map((pair) => ({
+        id: pair.baseToken.address,
+        name: pair.baseToken.name,
+        symbol: pair.baseToken.symbol.toUpperCase(),
+        network: pair.chainId,
+        source: this.name
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(address) {
+    const info = await this.getTokenInfo(address);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(address) {
+    try {
+      const res = await fetch(`${this.baseUrl}/tokens/${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) => ({
+        dexId: p.dexId,
+        url: p.url,
+        pairAddress: p.pairAddress,
+        baseTokenSymbol: p.baseToken.symbol,
+        quoteTokenSymbol: p.quoteToken.symbol,
+        priceUsd: parseFloat(p.priceUsd) || 0,
+        volume24h: p.volume?.h24,
+        liquidityUsd: p.liquidity?.usd
+      }));
+      return {
+        name: pair.baseToken.name,
+        symbol: pair.baseToken.symbol.toUpperCase(),
+        address: pair.baseToken.address,
+        network: pair.chainId,
+        priceUsd: parseFloat(pair.priceUsd) || 0,
+        fdv: pair.fdv,
+        volume24h: pair.volume?.h24,
+        liquidityUsd: pair.liquidity?.usd,
+        priceChangePercentage24h: pair.priceChange?.h24,
+        pairs: mappedPairs,
+        links: {
+          website: pair.info?.websites?.[0]?.url,
+          twitter: pair.info?.socials?.find((s) => s.type === "twitter")?.url,
+          telegram: pair.info?.socials?.find((s) => s.type === "telegram")?.url,
+          discord: pair.info?.socials?.find((s) => s.type === "discord")?.url
+        },
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/geckoterminal.ts
+var GeckoTerminalProvider = class {
+  name = "GeckoTerminal";
+  baseUrl = "https://api.geckoterminal.com/api/v2";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/search/pools?query=${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];
+        return {
+          id: pool.id,
+          // e.g. "eth_0x..."
+          name: attributes.name,
+          symbol: baseToken,
+          network: pool.relationships.network.data.id,
+          source: this.name
+        };
+      });
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(address, network = "eth") {
+    const info = await this.getTokenInfo(address, network);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(address, network = "eth") {
+    try {
+      const res = await fetch(`${this.baseUrl}/networks/${network}/tokens/${address}`);
+      if (!res.ok) return null;
+      const json = await res.json();
+      if (!json.data || !json.data.attributes) return null;
+      const attrs = json.data.attributes;
+      return {
+        name: attrs.name,
+        symbol: attrs.symbol.toUpperCase(),
+        address: attrs.address,
+        network,
+        priceUsd: parseFloat(attrs.price_usd) || 0,
+        fdv: parseFloat(attrs.fdv_usd),
+        volume24h: parseFloat(attrs.volume_usd?.h24 || 0),
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/binance.ts
+var BinanceProvider = class {
+  name = "Binance";
+  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,
+          source: this.name
+        }];
+      }
+      return [];
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(symbol) {
+    try {
+      let querySymbol = symbol.toUpperCase();
+      if (!querySymbol.endsWith("USDT") && !querySymbol.endsWith("BUSD") && !querySymbol.endsWith("BTC")) {
+        querySymbol += "USDT";
+      }
+      const res = await fetch(`${this.baseUrl}/ticker/price?symbol=${querySymbol}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      return {
+        symbol: symbol.toUpperCase(),
+        priceUsd: parseFloat(data.price) || 0,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    try {
+      let querySymbol = symbol.toUpperCase();
+      if (!querySymbol.endsWith("USDT") && !querySymbol.endsWith("BUSD") && !querySymbol.endsWith("BTC")) {
+        querySymbol += "USDT";
+      }
+      const res = await fetch(`${this.baseUrl}/ticker/24hr?symbol=${querySymbol}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      return {
+        name: symbol.toUpperCase(),
+        symbol: symbol.toUpperCase(),
+        priceUsd: parseFloat(data.lastPrice) || 0,
+        volume24h: parseFloat(data.quoteVolume) || 0,
+        // Quote volume in USDT roughly = USD volume
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/coinpaprika.ts
+var CoinpaprikaProvider = class {
+  name = "Coinpaprika";
+  baseUrl = "https://api.coinpaprika.com/v1";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/search?q=${query}&c=currencies&limit=10`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.currencies || []).map((coin) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(symbolOrId) {
+    const info = await this.getTokenInfo(symbolOrId);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(symbolOrId) {
+    try {
+      let id = symbolOrId.toLowerCase();
+      if (!id.includes("-")) {
+        const searchRes = await this.search(id);
+        const match = searchRes.find((s) => s.symbol.toLowerCase() === id || s.id === id);
+        if (match && match.id) {
+          id = match.id;
+        } else if (searchRes.length > 0 && searchRes[0].id) {
+          id = searchRes[0].id;
+        }
+      }
+      const res = await fetch(`${this.baseUrl}/tickers/${id}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      return {
+        name: data.name,
+        symbol: data.symbol.toUpperCase(),
+        description: data.description,
+        priceUsd: data.quotes?.USD?.price || 0,
+        marketCap: data.quotes?.USD?.market_cap,
+        marketCapRank: data.rank,
+        circulatingSupply: data.circulating_supply,
+        totalSupply: data.total_supply,
+        maxSupply: data.max_supply,
+        volume24h: data.quotes?.USD?.volume_24h,
+        priceChangePercentage24h: data.quotes?.USD?.percent_change_24h,
+        priceChangePercentage7d: data.quotes?.USD?.percent_change_7d,
+        ath: data.quotes?.USD?.ath_price,
+        athDate: data.quotes?.USD?.ath_date,
+        links: {
+          website: data.links?.website?.[0],
+          twitter: data.links?.twitter?.[0],
+          discord: data.links?.discord?.[0],
+          github: data.links?.source_code?.[0]
+        },
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/coincap.ts
+var CoinCapProvider = class {
+  name = "CoinCap";
+  baseUrl = "https://api.coincap.io/v2";
+  async search(query) {
+    try {
+      const res = await fetch(`${this.baseUrl}/assets?search=${query}&limit=10`);
+      if (!res.ok) return [];
+      const data = await res.json();
+      return (data.data || []).map((coin) => ({
+        id: coin.id,
+        name: coin.name,
+        symbol: coin.symbol.toUpperCase(),
+        source: this.name
+      }));
+    } catch (e) {
+      return [];
+    }
+  }
+  async getPrice(symbolOrId) {
+    const info = await this.getTokenInfo(symbolOrId);
+    if (!info) return null;
+    return {
+      symbol: info.symbol,
+      priceUsd: info.priceUsd,
+      source: this.name,
+      lastUpdated: info.lastUpdated
+    };
+  }
+  async getTokenInfo(symbolOrId) {
+    try {
+      let id = symbolOrId.toLowerCase();
+      const searchRes = await this.search(id);
+      const match = searchRes.find((s) => s.symbol.toLowerCase() === id || s.id === id);
+      if (match && match.id) {
+        id = match.id;
+      }
+      const res = await fetch(`${this.baseUrl}/assets/${id}`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      const asset = data.data;
+      if (!asset) return null;
+      return {
+        name: asset.name,
+        symbol: asset.symbol.toUpperCase(),
+        priceUsd: parseFloat(asset.priceUsd) || 0,
+        marketCap: parseFloat(asset.marketCapUsd),
+        volume24h: parseFloat(asset.volumeUsd24Hr),
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/providers/cryptocompare.ts
+var CryptoCompareProvider = class {
+  name = "CryptoCompare";
+  baseUrl = "https://min-api.cryptocompare.com/data";
+  async search(query) {
+    return [];
+  }
+  async getPrice(symbol) {
+    try {
+      const sym = symbol.toUpperCase();
+      const res = await fetch(`${this.baseUrl}/price?fsym=${sym}&tsyms=USD`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.Response === "Error" || !data.USD) return null;
+      return {
+        symbol: sym,
+        priceUsd: data.USD,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  async getTokenInfo(symbol) {
+    try {
+      const sym = symbol.toUpperCase();
+      const res = await fetch(`${this.baseUrl}/pricemultifull?fsyms=${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;
+      return {
+        name: sym,
+        // CryptoCompare doesn't give full name in this endpoint
+        symbol: sym,
+        priceUsd: raw.PRICE || 0,
+        marketCap: raw.MKTCAP,
+        volume24h: raw.TOTALVOLUME24HTO,
+        source: this.name,
+        lastUpdated: Date.now()
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+};
+
+// src/Crypull.ts
+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
+    ];
+  }
+  isAddress(query) {
+    return query.startsWith("0x") && query.length === 42 || query.length > 30;
+  }
+  /**
+   * Search for a token or coin across multiple 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 combined = [];
+    for (const res of results) {
+      if (res.status === "fulfilled" && res.value) {
+        combined.push(...res.value);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return combined.filter((item) => {
+      const key = `${item.symbol}`;
+      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')
+   */
+  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);
+        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);
+      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 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);
+        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);
+      if (res) return res;
+    }
+    return null;
+  }
+  /**
+   * 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;
+    }
+  }
+  /**
+   * 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 [];
+    }
+  }
+  /**
+   * 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 [];
+    }
+  }
+  /**
+   * Get fear and greed index
+   */
+  async sentiment() {
+    try {
+      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];
+      return {
+        value: parseInt(item.value),
+        classification: item.value_classification,
+        lastUpdated: parseInt(item.timestamp) * 1e3
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Get current ethereum gas prices (in Gwei)
+   */
+  async gas() {
+    try {
+      const res = await fetch(`https://api.etherscan.io/api?module=gastracker&action=gasoracle`);
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (data.status !== "1") return null;
+      return {
+        network: "Ethereum",
+        low: parseFloat(data.result.SafeGasPrice),
+        average: parseFloat(data.result.ProposeGasPrice),
+        high: parseFloat(data.result.FastGasPrice),
+        baseFee: parseFloat(data.result.suggestBaseFee)
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Get historical chart data for a coin
+   * @param query Coin symbol or 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;
+    }
+  }
+};
+
+// src/index.ts
+var crypull = new Crypull();
+
+export { BinanceProvider, CoinCapProvider, CoinGeckoProvider, CoinpaprikaProvider, CryptoCompareProvider, Crypull, DexScreenerProvider, GeckoTerminalProvider, crypull };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map