Integration Guide

Complete guide for integrating IllumindGame into your applications. Learn how to build prediction bots, portfolio trackers, and custom interfaces.

🚀 Quick Start Integration

1. Get API Credentials

// Register at: https://app.illumindgame.io/developers
// Get your API key from the developer dashboard

const config = {
  apiKey: 'ilg_live_abc123...',
  baseURL: 'https://api.illumindgame.io/v1',
  network: 'mainnet' // or 'testnet'
};

2. Install SDK

# JavaScript/Node.js
npm install @illumindgame/sdk

# Python
pip install illumind-sdk

# Go
go get github.com/illumindgame/go-sdk

3. Basic Setup

const { IllumindClient } = require('@illumindgame/sdk');

const client = new IllumindClient({
  apiKey: process.env.ILLUMIND_API_KEY,
  network: 'mainnet'
});

// Test connection
async function testConnection() {
  try {
    const currentRound = await client.rounds.getCurrent();
    console.log('Connected! Current round:', currentRound.roundId);
  } catch (error) {
    console.error('Connection failed:', error.message);
  }
}

🤖 Building a Trading Bot

Simple AI-Following Bot

class AIFollowBot {
  constructor(apiKey, walletPrivateKey) {
    this.client = new IllumindClient({ apiKey });
    this.wallet = new ethers.Wallet(walletPrivateKey);
    this.minConfidence = 75; // Only trade with 75%+ confidence
    this.maxStakePerRound = ethers.utils.parseEther("100"); // 100 ILLUMIND max
  }
  
  async start() {
    console.log('🤖 AI Follow Bot started...');
    
    // Check every minute for new rounds
    setInterval(async () => {
      await this.analyzeAndTrade();
    }, 60000);
    
    // Also listen for real-time updates
    this.client.ws.subscribe('rounds', this.onRoundUpdate.bind(this));
  }
  
  async analyzeAndTrade() {
    try {
      const [currentRound, aiAnalysis] = await Promise.all([
        this.client.rounds.getCurrent(),
        this.client.ai.getAnalysis()
      ]);
      
      // Check if we should make a prediction
      if (this.shouldTrade(currentRound, aiAnalysis)) {
        await this.makePrediction(currentRound, aiAnalysis);
      }
    } catch (error) {
      console.error('Trading error:', error);
    }
  }
  
  shouldTrade(round, analysis) {
    // Only trade if:
    // 1. High AI confidence
    // 2. Round just started (>4 minutes remaining)
    // 3. We haven't predicted yet
    return (
      analysis.confidence >= this.minConfidence &&
      round.timeRemaining > 240 &&
      !this.hasAlreadyPredicted(round.roundId)
    );
  }
  
  async makePrediction(round, analysis) {
    // Calculate stake based on confidence
    const baseStake = ethers.utils.parseEther("10"); // 10 ILLUMIND base
    const confidenceMultiplier = analysis.confidence / 100;
    const stakeAmount = baseStake.mul(Math.floor(confidenceMultiplier * 100)).div(100);
    
    const maxStake = this.maxStakePerRound;
    const finalStake = stakeAmount.gt(maxStake) ? maxStake : stakeAmount;
    
    console.log(`📊 Making prediction: ${analysis.direction} with ${ethers.utils.formatEther(finalStake)} ILLUMIND`);
    console.log(`🎯 AI Confidence: ${analysis.confidence}%`);
    
    try {
      const prediction = await this.client.predictions.create({
        roundId: round.roundId,
        direction: analysis.direction,
        amount: finalStake.toString(),
        signature: await this.signPrediction(round.roundId, analysis.direction, finalStake)
      });
      
      console.log('✅ Prediction successful:', prediction.predictionId);
      
      // Store prediction for tracking
      this.storePrediction(prediction);
      
    } catch (error) {
      console.error('❌ Prediction failed:', error.message);
    }
  }
  
  async signPrediction(roundId, direction, amount) {
    // Create message hash for signing
    const messageHash = ethers.utils.solidityKeccak256(
      ['uint256', 'bool', 'uint256', 'address'],
      [roundId, direction === 'UP', amount, this.wallet.address]
    );
    
    // Sign the message
    return await this.wallet.signMessage(ethers.utils.arrayify(messageHash));
  }
  
  onRoundUpdate(data) {
    console.log(`⏰ Round ${data.roundId}: ${data.timeRemaining}s remaining`);
    
    // If round ending soon, prepare for next round
    if (data.timeRemaining < 30) {
      setTimeout(() => this.analyzeAndTrade(), 30000);
    }
  }
  
  // Track predictions to avoid duplicates
  predictionHistory = new Set();
  
  hasAlreadyPredicted(roundId) {
    return this.predictionHistory.has(roundId);
  }
  
  storePrediction(prediction) {
    this.predictionHistory.add(prediction.roundId);
  }
}

// Usage
const bot = new AIFollowBot(
  process.env.ILLUMIND_API_KEY,
  process.env.WALLET_PRIVATE_KEY
);

bot.start();

Advanced Pattern Recognition Bot

class PatternBot {
  constructor(apiKey, walletPrivateKey) {
    this.client = new IllumindClient({ apiKey });
    this.wallet = new ethers.Wallet(walletPrivateKey);
    this.patterns = new Map();
    this.minPatternConfidence = 0.7;
  }
  
  async analyzePatterns() {
    // Get last 100 rounds
    const history = await this.client.rounds.getHistory({ limit: 100 });
    
    // Analyze winning patterns
    const patterns = this.extractPatterns(history.rounds);
    
    return this.findBestPattern(patterns);
  }
  
  extractPatterns(rounds) {
    const patterns = [];
    
    for (let i = 3; i < rounds.length; i++) {
      const sequence = rounds.slice(i-3, i).map(r => r.winner);
      const nextResult = rounds[i].winner;
      
      patterns.push({
        sequence: sequence.join(''),
        result: nextResult,
        aiConfidence: rounds[i].aiAnalysis?.confidence || 50
      });
    }
    
    return this.groupPatternsBySequence(patterns);
  }
  
  groupPatternsBySequence(patterns) {
    const grouped = new Map();
    
    patterns.forEach(pattern => {
      const key = pattern.sequence;
      if (!grouped.has(key)) {
        grouped.set(key, {
          sequence: key,
          upCount: 0,
          downCount: 0,
          totalConfidence: 0,
          samples: 0
        });
      }
      
      const group = grouped.get(key);
      group.samples++;
      group.totalConfidence += pattern.aiConfidence;
      
      if (pattern.result === 'UP') {
        group.upCount++;
      } else {
        group.downCount++;
      }
    });
    
    return Array.from(grouped.values()).map(group => ({
      ...group,
      upProbability: group.upCount / group.samples,
      downProbability: group.downCount / group.samples,
      avgConfidence: group.totalConfidence / group.samples,
      reliability: Math.max(group.upProbability, group.downProbability)
    }));
  }
  
  async makePredictionWithPattern() {
    const currentRound = await this.client.rounds.getCurrent();
    const recentHistory = await this.client.rounds.getHistory({ limit: 3 });
    
    const recentSequence = recentHistory.rounds
      .map(r => r.winner)
      .join('');
    
    const matchingPattern = this.patterns.get(recentSequence);
    
    if (matchingPattern && matchingPattern.reliability > this.minPatternConfidence) {
      const direction = matchingPattern.upProbability > matchingPattern.downProbability ? 'UP' : 'DOWN';
      const confidence = matchingPattern.reliability * 100;
      
      console.log(`📈 Pattern detected: ${recentSequence} → ${direction} (${confidence.toFixed(1)}% confidence)`);
      
      // Make prediction based on pattern
      await this.makePrediction(currentRound.roundId, direction, confidence);
    }
  }
}

📊 Portfolio Management Dashboard

Real-time Portfolio Tracker

class PortfolioManager {
  constructor(apiKey, userAddress) {
    this.client = new IllumindClient({ apiKey });
    this.userAddress = userAddress;
    this.portfolio = {
      totalValue: 0,
      todaysPnL: 0,
      accuracy: 0,
      activePositions: [],
      historicalPerformance: []
    };
  }
  
  async updatePortfolio() {
    try {
      const [userStats, predictions, currentRound] = await Promise.all([
        this.client.stats.getUser(this.userAddress),
        this.client.predictions.getUser(this.userAddress, { status: 'active' }),
        this.client.rounds.getCurrent()
      ]);
      
      this.portfolio = {
        totalValue: parseFloat(ethers.utils.formatEther(userStats.totalRewards)),
        netProfit: parseFloat(ethers.utils.formatEther(userStats.netProfit)),
        accuracy: userStats.accuracy,
        currentStreak: userStats.currentStreak,
        totalPredictions: userStats.totalPredictions,
        activePositions: this.calculateActivePositions(predictions.predictions, currentRound),
        rank: userStats.rank
      };
      
      this.emitPortfolioUpdate();
      
    } catch (error) {
      console.error('Portfolio update failed:', error);
    }
  }
  
  calculateActivePositions(predictions, currentRound) {
    return predictions.map(pred => {
      const timeRemaining = Math.max(0, currentRound.endTime - Date.now()) / 1000;
      const currentPrice = currentRound.currentPrice || currentRound.priceAtStart;
      const priceChange = currentPrice - currentRound.priceAtStart;
      
      const isWinning = (pred.direction === 'UP' && priceChange > 0) ||
                       (pred.direction === 'DOWN' && priceChange < 0);
      
      return {
        predictionId: pred.predictionId,
        roundId: pred.roundId,
        direction: pred.direction,
        amount: parseFloat(ethers.utils.formatEther(pred.amount)),
        timeRemaining,
        isWinning,
        estimatedReward: parseFloat(ethers.utils.formatEther(pred.expectedReward)),
        currentPnL: isWinning ? 
          parseFloat(ethers.utils.formatEther(pred.expectedReward)) - parseFloat(ethers.utils.formatEther(pred.amount)) :
          -parseFloat(ethers.utils.formatEther(pred.amount))
      };
    });
  }
  
  async getPerformanceAnalytics() {
    const predictions = await this.client.predictions.getUser(this.userAddress, { 
      status: 'all', 
      limit: 1000 
    });
    
    return {
      dailyAccuracy: this.calculateDailyAccuracy(predictions.predictions),
      bestTimeframes: this.findBestPerformingTimeframes(predictions.predictions),
      directionBias: this.analyzeDirectionBias(predictions.predictions),
      stakingStrategy: this.analyzeStakingPatterns(predictions.predictions)
    };
  }
  
  calculateDailyAccuracy(predictions) {
    const dailyStats = new Map();
    
    predictions.forEach(pred => {
      const date = new Date(pred.timestamp).toDateString();
      
      if (!dailyStats.has(date)) {
        dailyStats.set(date, { total: 0, successful: 0 });
      }
      
      const stats = dailyStats.get(date);
      stats.total++;
      
      if (pred.status === 'won') {
        stats.successful++;
      }
    });
    
    return Array.from(dailyStats.entries()).map(([date, stats]) => ({
      date,
      accuracy: (stats.successful / stats.total) * 100,
      totalPredictions: stats.total
    }));
  }
  
  // Subscribe to real-time updates
  startRealTimeTracking() {
    this.client.ws.subscribe('rounds', (data) => {
      // Update active positions with real-time data
      this.updateActivePositionsRealTime(data);
    });
    
    // Update portfolio every 30 seconds
    setInterval(() => {
      this.updatePortfolio();
    }, 30000);
  }
  
  emitPortfolioUpdate() {
    // Emit event for UI updates
    this.emit('portfolioUpdate', this.portfolio);
  }
}

🎨 Custom UI Components

React Prediction Widget

import React, { useState, useEffect } from 'react';
import { IllumindClient } from '@illumindgame/sdk';

const PredictionWidget = ({ apiKey, userAddress }) => {
  const [currentRound, setCurrentRound] = useState(null);
  const [aiAnalysis, setAiAnalysis] = useState(null);
  const [prediction, setPrediction] = useState(null);
  const [loading, setLoading] = useState(false);
  
  const client = new IllumindClient({ apiKey });
  
  useEffect(() => {
    loadData();
    
    // Subscribe to real-time updates
    client.ws.subscribe('rounds', (data) => {
      setCurrentRound(prev => ({ ...prev, ...data }));
    });
    
    client.ws.subscribe('ai_analysis', (data) => {
      setAiAnalysis(data);
    });
    
    return () => {
      client.ws.disconnect();
    };
  }, []);
  
  const loadData = async () => {
    try {
      const [round, analysis] = await Promise.all([
        client.rounds.getCurrent(),
        client.ai.getAnalysis()
      ]);
      
      setCurrentRound(round);
      setAiAnalysis(analysis);
    } catch (error) {
      console.error('Failed to load data:', error);
    }
  };
  
  const makePrediction = async (direction) => {
    setLoading(true);
    
    try {
      const amount = ethers.utils.parseEther("10").toString(); // 10 ILLUMIND
      
      const result = await client.predictions.create({
        roundId: currentRound.roundId,
        direction,
        amount,
        userAddress
      });
      
      setPrediction(result);
      
    } catch (error) {
      console.error('Prediction failed:', error);
      alert('Prediction failed: ' + error.message);
    } finally {
      setLoading(false);
    }
  };
  
  if (!currentRound || !aiAnalysis) {
    return <div className="loading">Loading...</div>;
  }
  
  return (
    <div className="prediction-widget">
      <div className="round-info">
        <h3>Round #{currentRound.roundId}</h3>
        <div className="timer">
          ⏱️ {Math.floor(currentRound.timeRemaining / 60)}:
          {(currentRound.timeRemaining % 60).toString().padStart(2, '0')}
        </div>
        <div className="price">
          💰 Starting Price: ${(currentRound.priceAtStart / 100).toFixed(2)}
        </div>
      </div>
      
      <div className="ai-analysis">
        <h4>🤖 AI Analysis</h4>
        <div className="confidence">
          Confidence: {aiAnalysis.confidence}%
        </div>
        <div className="direction">
          Prediction: {aiAnalysis.direction} 
          {aiAnalysis.direction === 'UP' ? '⬆️' : '⬇️'}
        </div>
        <div className="risk">
          Risk Level: {aiAnalysis.riskLevel}
        </div>
      </div>
      
      <div className="prediction-buttons">
        <button 
          className="btn-up"
          onClick={() => makePrediction('UP')}
          disabled={loading || prediction}
        >
          ⬆️ UP
        </button>
        <button 
          className="btn-down"
          onClick={() => makePrediction('DOWN')}
          disabled={loading || prediction}
        >
          ⬇️ DOWN
        </button>
      </div>
      
      {prediction && (
        <div className="prediction-success">
          ✅ Prediction submitted! 
          <br />
          Expected reward: {ethers.utils.formatEther(prediction.expectedReward)} ILLUMIND
        </div>
      )}
      
      <div className="pool-info">
        <div>
          ⬆️ UP Pool: {ethers.utils.formatEther(currentRound.totalUpAmount)} ILLUMIND
        </div>
        <div>
          ⬇️ DOWN Pool: {ethers.utils.formatEther(currentRound.totalDownAmount)} ILLUMIND
        </div>
      </div>
    </div>
  );
};

export default PredictionWidget;

Vue.js Dashboard Component

<template>
  <div class="illumind-dashboard">
    <div class="stats-grid">
      <div class="stat-card">
        <h3>Portfolio Value</h3>
        <div class="value">{{ formatToken(portfolio.totalValue) }} ILLUMIND</div>
        <div class="change" :class="{ positive: portfolio.todaysPnL > 0 }">
          {{ portfolio.todaysPnL > 0 ? '+' : '' }}{{ formatToken(portfolio.todaysPnL) }}
        </div>
      </div>
      
      <div class="stat-card">
        <h3>Accuracy</h3>
        <div class="value">{{ portfolio.accuracy.toFixed(1) }}%</div>
        <div class="subtitle">{{ portfolio.totalPredictions }} predictions</div>
      </div>
      
      <div class="stat-card">
        <h3>Current Streak</h3>
        <div class="value">{{ portfolio.currentStreak }}</div>
        <div class="subtitle">consecutive wins</div>
      </div>
    </div>
    
    <div class="active-positions">
      <h3>Active Positions</h3>
      <div class="positions-list">
        <div 
          v-for="position in portfolio.activePositions" 
          :key="position.predictionId"
          class="position-card"
          :class="{ winning: position.isWinning }"
        >
          <div class="position-header">
            <span class="direction">{{ position.direction }}</span>
            <span class="amount">{{ formatToken(position.amount) }} ILLUMIND</span>
          </div>
          <div class="position-status">
            <span class="pnl" :class="{ positive: position.currentPnL > 0 }">
              {{ position.currentPnL > 0 ? '+' : '' }}{{ formatToken(position.currentPnL) }}
            </span>
            <span class="timer">{{ formatTime(position.timeRemaining) }}</span>
          </div>
        </div>
      </div>
    </div>
  </div>
</template>

<script>
import { IllumindClient } from '@illumindgame/sdk';

export default {
  name: 'IllumindDashboard',
  props: {
    apiKey: String,
    userAddress: String
  },
  data() {
    return {
      client: null,
      portfolio: {
        totalValue: 0,
        todaysPnL: 0,
        accuracy: 0,
        currentStreak: 0,
        totalPredictions: 0,
        activePositions: []
      }
    };
  },
  async mounted() {
    this.client = new IllumindClient({ 
      apiKey: this.apiKey 
    });
    
    await this.loadPortfolio();
    this.startRealTimeUpdates();
  },
  methods: {
    async loadPortfolio() {
      try {
        const stats = await this.client.stats.getUser(this.userAddress);
        
        this.portfolio = {
          totalValue: parseFloat(stats.totalRewards) / 1e18,
          netProfit: parseFloat(stats.netProfit) / 1e18,
          accuracy: stats.accuracy,
          currentStreak: stats.currentStreak,
          totalPredictions: stats.totalPredictions,
          activePositions: await this.loadActivePositions()
        };
      } catch (error) {
        console.error('Failed to load portfolio:', error);
      }
    },
    
    async loadActivePositions() {
      const predictions = await this.client.predictions.getUser(this.userAddress, {
        status: 'active'
      });
      
      return predictions.predictions.map(pred => ({
        predictionId: pred.predictionId,
        direction: pred.direction,
        amount: parseFloat(pred.amount) / 1e18,
        currentPnL: pred.status === 'won' ? 
          (parseFloat(pred.reward) - parseFloat(pred.amount)) / 1e18 : 
          -parseFloat(pred.amount) / 1e18,
        timeRemaining: pred.timeRemaining,
        isWinning: pred.status === 'won'
      }));
    },
    
    startRealTimeUpdates() {
      // Update every 30 seconds
      setInterval(() => {
        this.loadPortfolio();
      }, 30000);
      
      // WebSocket updates
      this.client.ws.subscribe('rounds', (data) => {
        // Update active positions
        this.updateActivePositions(data);
      });
    },
    
    formatToken(amount) {
      return new Intl.NumberFormat('en-US', {
        minimumFractionDigits: 2,
        maximumFractionDigits: 2
      }).format(amount);
    },
    
    formatTime(seconds) {
      const minutes = Math.floor(seconds / 60);
      const secs = seconds % 60;
      return `${minutes}:${secs.toString().padStart(2, '0')}`;
    }
  }
};
</script>

🔧 Advanced Integration Patterns

Event-Driven Architecture

class EventDrivenIllumind {
  constructor(apiKey) {
    this.client = new IllumindClient({ apiKey });
    this.eventHandlers = new Map();
    this.setupEventListeners();
  }
  
  setupEventListeners() {
    // Round events
    this.client.ws.subscribe('round_started', this.handleRoundStarted.bind(this));
    this.client.ws.subscribe('round_ended', this.handleRoundEnded.bind(this));
    
    // Prediction events  
    this.client.ws.subscribe('prediction_made', this.handlePredictionMade.bind(this));
    this.client.ws.subscribe('reward_claimed', this.handleRewardClaimed.bind(this));
    
    // AI events
    this.client.ws.subscribe('ai_update', this.handleAIUpdate.bind(this));
  }
  
  handleRoundStarted(data) {
    this.emit('round:started', data);
    
    // Auto-trigger analysis for new round
    setTimeout(() => {
      this.analyzeNewRound(data.roundId);
    }, 1000);
  }
  
  handleRoundEnded(data) {
    this.emit('round:ended', data);
    
    // Process results and update statistics
    this.processRoundResults(data);
  }
  
  async analyzeNewRound(roundId) {
    const analysis = await this.client.ai.getAnalysis();
    
    this.emit('analysis:ready', {
      roundId,
      analysis,
      timestamp: Date.now()
    });
  }
  
  // Event emitter pattern
  on(event, handler) {
    if (!this.eventHandlers.has(event)) {
      this.eventHandlers.set(event, []);
    }
    this.eventHandlers.get(event).push(handler);
  }
  
  emit(event, data) {
    const handlers = this.eventHandlers.get(event) || [];
    handlers.forEach(handler => handler(data));
  }
}

// Usage
const illumind = new EventDrivenIllumind(process.env.ILLUMIND_API_KEY);

illumind.on('round:started', (data) => {
  console.log('New round started:', data.roundId);
});

illumind.on('analysis:ready', (data) => {
  console.log('AI analysis ready:', data.analysis);
  
  // Make trading decision
  if (data.analysis.confidence > 80) {
    makeAutoPrediction(data.roundId, data.analysis.direction);
  }
});

Microservices Integration

// Prediction Service
class PredictionService {
  constructor(apiKey) {
    this.client = new IllumindClient({ apiKey });
  }
  
  async processWebhook(req, res) {
    const { type, data } = req.body;
    
    switch (type) {
      case 'round.started':
        await this.handleNewRound(data);
        break;
      case 'prediction.successful':
        await this.handleSuccessfulPrediction(data);
        break;
      case 'ai.analysis.updated':
        await this.handleAIUpdate(data);
        break;
    }
    
    res.status(200).json({ received: true });
  }
  
  async handleNewRound(roundData) {
    // Notify all registered bots
    await this.notificationService.sendToSubscribers('new-round', roundData);
    
    // Store round data
    await this.database.rounds.create(roundData);
    
    // Trigger analysis
    await this.analysisService.analyzeRound(roundData.roundId);
  }
}

// Analysis Service
class AnalysisService {
  async analyzeRound(roundId) {
    const [aiAnalysis, historicalData, marketData] = await Promise.all([
      this.client.ai.getAnalysis(),
      this.getHistoricalPatterns(),
      this.getMarketData()
    ]);
    
    const combinedAnalysis = this.combineAnalyses({
      ai: aiAnalysis,
      historical: historicalData,
      market: marketData
    });
    
    // Publish analysis
    await this.publishAnalysis(roundId, combinedAnalysis);
  }
  
  combineAnalyses(data) {
    // Custom algorithm to combine multiple analysis sources
    const weights = {
      ai: 0.4,
      historical: 0.3,
      market: 0.3
    };
    
    return {
      direction: this.calculateWeightedDirection(data, weights),
      confidence: this.calculateCombinedConfidence(data, weights),
      factors: this.extractKeyFactors(data)
    };
  }
}

📱 Mobile App Integration

React Native Component

import React, { useState, useEffect } from 'react';
import { View, Text, TouchableOpacity, Alert } from 'react-native';
import { IllumindClient } from '@illumindgame/sdk-react-native';

const MobilePredictionScreen = () => {
  const [client] = useState(() => new IllumindClient({
    apiKey: 'your-api-key'
  }));
  
  const [currentRound, setCurrentRound] = useState(null);
  const [userStats, setUserStats] = useState(null);
  
  useEffect(() => {
    loadData();
    
    // Real-time updates
    client.ws.subscribe('rounds', setCurrentRound);
    
    return () => client.ws.disconnect();
  }, []);
  
  const loadData = async () => {
    try {
      const [round, stats] = await Promise.all([
        client.rounds.getCurrent(),
        client.stats.getUser(userAddress)
      ]);
      
      setCurrentRound(round);
      setUserStats(stats);
    } catch (error) {
      Alert.alert('Error', 'Failed to load data');
    }
  };
  
  const makePrediction = async (direction) => {
    try {
      await client.predictions.create({
        roundId: currentRound.roundId,
        direction,
        amount: '1000000000000000000000' // 1000 ILLUMIND
      });
      
      Alert.alert('Success', 'Prediction submitted!');
    } catch (error) {
      Alert.alert('Error', error.message);
    }
  };
  
  return (
    <View style={styles.container}>
      <View style={styles.roundInfo}>
        <Text style={styles.roundTitle}>Round #{currentRound?.roundId}</Text>
        <Text style={styles.timer}>
          ⏱️ {Math.floor(currentRound?.timeRemaining / 60)}:
          {(currentRound?.timeRemaining % 60).toString().padStart(2, '0')}
        </Text>
      </View>
      
      <View style={styles.predictionButtons}>
        <TouchableOpacity 
          style={[styles.button, styles.upButton]}
          onPress={() => makePrediction('UP')}
        >
          <Text style={styles.buttonText}>⬆️ UP</Text>
        </TouchableOpacity>
        
        <TouchableOpacity 
          style={[styles.button, styles.downButton]}
          onPress={() => makePrediction('DOWN')}
        >
          <Text style={styles.buttonText}>⬇️ DOWN</Text>
        </TouchableOpacity>
      </View>
      
      <View style={styles.stats}>
        <Text>Accuracy: {userStats?.accuracy}%</Text>
        <Text>Profit: {userStats?.netProfit} ILLUMIND</Text>
      </View>
    </View>
  );
};

🔍 Testing & Debugging

Integration Testing

// Test Suite for IllumindGame Integration
describe('IllumindGame Integration', () => {
  let client;
  
  beforeEach(() => {
    client = new IllumindClient({
      apiKey: process.env.TEST_API_KEY,
      network: 'testnet'
    });
  });
  
  describe('API Connectivity', () => {
    test('should connect to API', async () => {
      const currentRound = await client.rounds.getCurrent();
      expect(currentRound).toBeDefined();
      expect(currentRound.roundId).toBeGreaterThan(0);
    });
    
    test('should handle rate limiting', async () => {
      // Make many requests to test rate limiting
      const promises = Array(200).fill().map(() => 
        client.rounds.getCurrent()
      );
      
      await expect(Promise.all(promises)).rejects.toThrow('Rate limit exceeded');
    });
  });
  
  describe('Prediction Flow', () => {
    test('should make valid prediction', async () => {
      const currentRound = await client.rounds.getCurrent();
      
      const prediction = await client.predictions.create({
        roundId: currentRound.roundId,
        direction: 'UP',
        amount: '1000000000000000000' // 1 ILLUMIND
      });
      
      expect(prediction.predictionId).toBeDefined();
      expect(prediction.direction).toBe('UP');
    });
    
    test('should reject invalid prediction', async () => {
      await expect(client.predictions.create({
        roundId: 99999,
        direction: 'UP',
        amount: '1000000000000000000'
      })).rejects.toThrow('Invalid round');
    });
  });
  
  describe('WebSocket Connection', () => {
    test('should receive real-time updates', (done) => {
      client.ws.subscribe('rounds', (data) => {
        expect(data.roundId).toBeDefined();
        expect(data.timeRemaining).toBeGreaterThanOrEqual(0);
        done();
      });
      
      setTimeout(() => {
        done.fail('No real-time update received');
      }, 10000);
    });
  });
});

Error Handling Patterns

class RobustIllumindClient {
  constructor(apiKey) {
    this.client = new IllumindClient({ apiKey });
    this.retryConfig = {
      maxRetries: 3,
      backoffMs: 1000
    };
  }
  
  async withRetry(operation, context = '') {
    let lastError;
    
    for (let attempt = 1; attempt <= this.retryConfig.maxRetries; attempt++) {
      try {
        return await operation();
      } catch (error) {
        lastError = error;
        
        console.warn(`Attempt ${attempt} failed for ${context}:`, error.message);
        
        // Don't retry on certain errors
        if (this.isNonRetryableError(error)) {
          throw error;
        }
        
        if (attempt < this.retryConfig.maxRetries) {
          const delay = this.retryConfig.backoffMs * Math.pow(2, attempt - 1);
          await this.sleep(delay);
        }
      }
    }
    
    throw new Error(`Operation failed after ${this.retryConfig.maxRetries} attempts: ${lastError.message}`);
  }
  
  isNonRetryableError(error) {
    const nonRetryableCodes = [
      'INVALID_API_KEY',
      'INVALID_ROUND',
      'PREDICTION_EXISTS',
      'INSUFFICIENT_BALANCE'
    ];
    
    return nonRetryableCodes.includes(error.code);
  }
  
  async makePredictionWithRetry(predictionData) {
    return this.withRetry(
      () => this.client.predictions.create(predictionData),
      'make prediction'
    );
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

---

Need help with your integration? Join our Telegram or check our support documentation!