crypull 1.0.0

package/src/providers/cryptocompare.ts

@@ -0,0 +1,56 @@
+import { ICryptoProvider, PriceData, SearchResult, TokenInfo } from '../types.js';
+
+export class CryptoCompareProvider implements ICryptoProvider {
+  name = 'CryptoCompare';
+  private baseUrl = 'https://min-api.cryptocompare.com/data';
+
+  async search(query: string): Promise<SearchResult[]> {
+    // CryptoCompare search is a bit heavy (fetches all coins), so we mock or skip for basic search
+    // Returning empty array and letting other providers handle search is better for perf.
+    return [];
+  }
+
+  async getPrice(symbol: string): Promise<PriceData | null> {
+    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: string): Promise<TokenInfo | null> {
+    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;
+    }
+  }
+}

package/src/providers/dexscreener.ts

@@ -0,0 +1,82 @@
+import { DexPairInfo, ICryptoProvider, PriceData, SearchResult, TokenInfo } from '../types.js';
+
+export class DexScreenerProvider implements ICryptoProvider {
+  name = 'DexScreener';
+  private baseUrl = 'https://api.dexscreener.com/latest/dex';
+
+  async search(query: string): Promise<SearchResult[]> {
+    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: any) => ({
+        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: string): Promise<PriceData | null> {
+    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: string): Promise<TokenInfo | null> {
+    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;
+
+      // The first pair is usually the most liquid one
+      const pair = data.pairs[0];
+      
+      // Map out all the pairs available on DEXs for this token
+      const mappedPairs: DexPairInfo[] = data.pairs.slice(0, 10).map((p: any) => ({
+        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: any) => s.type === 'twitter')?.url,
+          telegram: pair.info?.socials?.find((s: any) => s.type === 'telegram')?.url,
+          discord: pair.info?.socials?.find((s: any) => s.type === 'discord')?.url,
+        },
+        source: this.name,
+        lastUpdated: Date.now(),
+      };
+    } catch (e) {
+      return null;
+    }
+  }
+}

package/src/providers/geckoterminal.ts

@@ -0,0 +1,70 @@
+import { DexPairInfo, ICryptoProvider, PriceData, SearchResult, TokenInfo } from '../types.js';
+
+export class GeckoTerminalProvider implements ICryptoProvider {
+  name = 'GeckoTerminal';
+  private baseUrl = 'https://api.geckoterminal.com/api/v2';
+
+  async search(query: string): Promise<SearchResult[]> {
+    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: any) => {
+        const attributes = pool.attributes;
+        const baseToken = attributes.name.split(' / ')[0]; // Usually Base / Quote
+        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: string, network: string = 'eth'): Promise<PriceData | null> {
+    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: string, network: string = 'eth'): Promise<TokenInfo | null> {
+    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;
+
+      // Try to get pairs from pools list if geckoterminal provides it via another endpoint or included relationships
+      // For now, GeckoTerminal's token endpoint doesn't return rich pairs list natively without separate call.
+      // So we map what we can.
+      
+      return {
+        name: attrs.name,
+        symbol: attrs.symbol.toUpperCase(),
+        address: attrs.address,
+        network: 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;
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,130 @@
+// Base Types for unified response
+
+export interface PriceData {
+  symbol: string;
+  priceUsd: number;
+  source: string;
+  lastUpdated: number;
+}
+
+export interface TokenLinks {
+  website?: string;
+  twitter?: string;
+  telegram?: string;
+  discord?: string;
+  github?: string;
+  [key: string]: string | undefined;
+}
+
+export interface DexPairInfo {
+  dexId: string;
+  url: string;
+  pairAddress: string;
+  baseTokenSymbol: string;
+  quoteTokenSymbol: string;
+  priceUsd: number;
+  volume24h?: number;
+  liquidityUsd?: number;
+}
+
+export interface TrendingCoin {
+  id: string;
+  name: string;
+  symbol: string;
+  marketCapRank?: number;
+  priceUsd?: number;
+  priceChange24h?: number;
+  volume24h?: number;
+}
+
+export interface GlobalMarketData {
+  totalMarketCapUsd: number;
+  totalVolume24hUsd: number;
+  bitcoinDominancePercentage: number;
+  ethereumDominancePercentage: number;
+  activeCryptocurrencies: number;
+  lastUpdated: number;
+}
+
+export interface ChartData {
+  prices: number[];
+  timestamps: number[];
+  minPrice: number;
+  maxPrice: number;
+}
+
+export interface SentimentData {
+  value: number;       // 0 to 100
+  classification: string; // "Extreme Fear", "Fear", "Neutral", "Greed", "Extreme Greed"
+  lastUpdated: number;
+}
+
+export interface TopCoin {
+  id: string;
+  name: string;
+  symbol: string;
+  marketCapRank: number;
+  priceUsd: number;
+  marketCap: number;
+  volume24h: number;
+  priceChange24h: number;
+}
+
+export interface GasData {
+  network: string;
+  low: number;
+  average: number;
+  high: number;
+  baseFee?: number;
+}
+
+export interface TokenInfo {
+  name: string;
+  symbol: string;
+  address?: string;
+  network?: string;
+  description?: string;
+  priceUsd: number;
+  marketCap?: number;
+  marketCapRank?: number;
+  fdv?: number; // Fully Diluted Valuation
+  circulatingSupply?: number;
+  totalSupply?: number;
+  maxSupply?: number;
+  volume24h?: number;
+  liquidityUsd?: number;
+  
+  // Price Changes
+  priceChange24h?: number;
+  priceChangePercentage24h?: number;
+  priceChangePercentage7d?: number;
+  
+  // All Time High / Low
+  ath?: number;
+  athDate?: string;
+  atl?: number;
+  atlDate?: string;
+
+  links?: TokenLinks;
+
+  // Trading Pairs (mainly for DEX data)
+  pairs?: DexPairInfo[];
+  
+  source: string;
+  lastUpdated: number;
+}
+
+export interface SearchResult {
+  id?: string; // id or address
+  name: string;
+  symbol: string;
+  network?: string;
+  source: string;
+}
+
+export interface ICryptoProvider {
+  name: string;
+  getPrice(symbol: string): Promise<PriceData | null>;
+  getTokenInfo(address: string, network?: string): Promise<TokenInfo | null>;
+  search(query: string): Promise<SearchResult[]>;
+}

package/tests/index.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { Crypull } from '../src/Crypull.js';
+import { crypull } from '../src/index.js';
+
+describe('Crypull Aggregator', () => {
+  it('should export a default instance', () => {
+    expect(crypull).toBeDefined();
+    expect(crypull).toBeInstanceOf(Crypull);
+  });
+
+  it('should initialize successfully', () => {
+    const customCrypull = new Crypull();
+    expect(customCrypull).toBeDefined();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022", "DOM"],
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist"
+  },
+  "include": ["src/**/*", "examples/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts', 'src/cli.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  treeshake: true,
+});