How I Built a Stablecoin Market Share Tracker That Saved My Crypto Startup

# This monstrosity crashed every morning at 9 AM
def predict_stablecoin_dominance(historical_data, sentiment_scores, moon_phase):
    # I actually included moon phase data. I'm not proud of this.
    model = build_overly_complex_lstm_model()
    predictions = model.predict(everything_and_the_kitchen_sink)
    return predictions  # Usually garbage

// Hard-earned wisdom: Always have backup data sources
class StablecoinDataCollector {
  constructor() {
    this.primarySource = new CoinGeckoAPI();
    this.backupSources = [
      new CoinMarketCapAPI(),
      new CryptoCompareAPI(),
      new DefiLlamaAPI()
    ];
    this.cache = new RedisCache({ ttl: 300 }); // 5-minute cache
  }

  async getMarketData(coinId) {
    const cacheKey = `market_data_${coinId}`;
    
    // Check cache first - this saved us from daily rate limits
    let data = await this.cache.get(cacheKey);
    if (data) return JSON.parse(data);

    // Try primary source
    try {
      data = await this.primarySource.getMarketData(coinId);
      await this.cache.set(cacheKey, JSON.stringify(data));
      return data;
    } catch (error) {
      console.log(`Primary source failed for ${coinId}, trying backup...`);
    }

    // Fallback to backup sources
    for (const source of this.backupSources) {
      try {
        data = await source.getMarketData(coinId);
        await this.cache.set(cacheKey, JSON.stringify(data));
        return data;
      } catch (error) {
        continue; // Try next source
      }
    }

    throw new Error(`All data sources failed for ${coinId}`);
  }
}

class MarketShareCalculator {
  constructor() {
    // List of stablecoins we track - learned this the hard way
    this.trackedCoins = [
      'tether', 'usd-coin', 'binance-usd', 'dai', 'frax',
      'terrausd', 'fei-usd', 'neutrino', 'magic-internet-money',
      'liquity-usd', 'true-usd', 'paxos-standard', 'gemini-dollar'
    ];
  }

  async calculateMarketShares() {
    const marketData = [];
    
    for (const coinId of this.trackedCoins) {
      try {
        const data = await this.dataCollector.getMarketData(coinId);
        
        // Skip obviously depegged coins - learned this during UST collapse
        if (this.isSignificantlyDepegged(data.current_price)) {
          console.log(`Skipping ${coinId} - severely depegged`);
          continue;
        }
        
        marketData.push({
          id: coinId,
          name: data.name,
          marketCap: data.market_cap,
          price: data.current_price,
          priceChange24h: data.price_change_percentage_24h
        });
      } catch (error) {
        console.error(`Failed to get data for ${coinId}:`, error.message);
      }
    }

    // Calculate total market cap and individual shares
    const totalMarketCap = marketData.reduce((sum, coin) => sum + coin.marketCap, 0);
    
    return marketData.map(coin => ({
      ...coin,
      marketShare: (coin.marketCap / totalMarketCap) * 100,
      marketShareChange: this.calculateShareChange(coin.id, coin.marketCap, totalMarketCap)
    })).sort((a, b) => b.marketShare - a.marketShare);
  }

  isSignificantlyDepegged(price) {
    // Consider anything below $0.95 or above $1.05 as depegged
    return price < 0.95 || price > 1.05;
  }
}

class MarketShareAlerts {
  constructor() {
    this.thresholds = {
      majorShift: 5.0,      // 5% market share change
      significantShift: 2.0, // 2% market share change
      priceAlert: 0.02       // 2% price deviation from $1
    };
  }

  async checkAlerts(currentData, previousData) {
    const alerts = [];

    for (const current of currentData) {
      const previous = previousData.find(p => p.id === current.id);
      if (!previous) continue;

      // Market share shift alerts
      const shareChange = Math.abs(current.marketShare - previous.marketShare);
      
      if (shareChange >= this.thresholds.majorShift) {
        alerts.push({
          type: 'MAJOR_MARKET_SHIFT',
          coin: current.name,
          message: `${current.name} market share ${current.marketShare > previous.marketShare ? 'gained' : 'lost'} ${shareChange.toFixed(2)}% in 24h`,
          severity: 'HIGH',
          currentShare: current.marketShare,
          previousShare: previous.marketShare
        });
      }

      // Depeg alerts - these saved us during the USDC crisis
      if (current.price < 0.98 || current.price > 1.02) {
        alerts.push({
          type: 'DEPEG_ALERT',
          coin: current.name,
          message: `${current.name} trading at $${current.price.toFixed(4)} - ${current.price < 1 ? 'below' : 'above'} peg`,
          severity: current.price < 0.95 || current.price > 1.05 ? 'HIGH' : 'MEDIUM',
          price: current.price
        });
      }
    }

    return alerts;
  }

  async sendAlerts(alerts) {
    // Send to Slack, Discord, email - whatever your team uses
    for (const alert of alerts) {
      if (alert.severity === 'HIGH') {
        await this.sendSlackAlert(alert);
        await this.sendEmailAlert(alert);
      } else {
        await this.sendSlackAlert(alert);
      }
    }
  }
}

// The component that displays market share changes
function MarketShareCard({ coin, previousShare }) {
  const changeInPoints = coin.marketShare - (previousShare || coin.marketShare);
  const isPositive = changeInPoints > 0;
  
  return (
    <div className={`market-share-card ${isPositive ? 'positive' : 'negative'}`}>
      <h3>{coin.name}</h3>
      <div className="share-display">
        <span className="current-share">{coin.marketShare.toFixed(1)}%</span>
        <span className={`change-indicator ${isPositive ? 'up' : 'down'}`}>
          {isPositive ? '+' : ''}{changeInPoints.toFixed(1)}pp
        </span>
      </div>
      <div className="market-cap">
        ${(coin.marketCap / 1e9).toFixed(1)}B market cap
      </div>
    </div>
  );
}

-- Simple but effective schema for tracking market share over time
CREATE TABLE stablecoin_snapshots (
    id SERIAL PRIMARY KEY,
    coin_id VARCHAR(50) NOT NULL,
    coin_name VARCHAR(100) NOT NULL,
    market_cap BIGINT NOT NULL,
    market_share DECIMAL(5,2) NOT NULL,
    price DECIMAL(10,6) NOT NULL,
    snapshot_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    
    INDEX idx_coin_time (coin_id, snapshot_time),
    INDEX idx_snapshot_time (snapshot_time)
);

-- Query to get 30-day market share trends
SELECT 
    coin_name,
    DATE(snapshot_time) as date,
    AVG(market_share) as avg_market_share
FROM stablecoin_snapshots 
WHERE snapshot_time >= NOW() - INTERVAL 30 DAY
GROUP BY coin_name, DATE(snapshot_time)
ORDER BY date ASC, avg_market_share DESC;

// Production-ready data pipeline
class StablecoinMonitor {
  constructor() {
    this.scheduler = new CronScheduler();
    this.dataCollector = new StablecoinDataCollector();
    this.calculator = new MarketShareCalculator();
    this.alertSystem = new MarketShareAlerts();
    this.database = new DatabaseManager();
  }

  async start() {
    // Collect data every 5 minutes
    this.scheduler.schedule('*/5 * * * *', async () => {
      try {
        const marketData = await this.calculator.calculateMarketShares();
        await this.database.saveSnapshot(marketData);
        
        // Check for alerts
        const previousData = await this.database.getPreviousSnapshot();
        const alerts = await this.alertSystem.checkAlerts(marketData, previousData);
        
        if (alerts.length > 0) {
          await this.alertSystem.sendAlerts(alerts);
        }
        
        console.log(`Updated market data for ${marketData.length} stablecoins`);
      } catch (error) {
        console.error('Market data update failed:', error);
        // Don't crash the whole system for one failed update
      }
    });

    console.log('Stablecoin monitor started successfully');
  }
}

// Start the monitoring system
const monitor = new StablecoinMonitor();
monitor.start();