Building Mini-Games for Memecoin Engagement: Complete Development Guide

┌────────────────────────────────────────────────────┐
│              REWARD DISTRIBUTION MODEL              │
├────────────────────────────────────────────────────┤
│                                                     │
│   Winner Prize Pool:    70% of entry fees          │
│   Platform Fee:         10% (project treasury)     │
│   Burn Mechanism:       5% (deflationary)          │
│   Jackpot Fund:         10% (big prize events)     │
│   Development Fund:     5% (game improvements)     │
│                                                     │
└────────────────────────────────────────────────────┘

// Using Chainlink VRF for on-chain randomness
const getRandomNumber = async () => {
  const vrfCoordinator = await ethers.getContractAt(
    'VRFCoordinatorV2',
    VRF_COORDINATOR_ADDRESS
  );
  
  const requestId = await vrfCoordinator.requestRandomWords(
    KEY_HASH,
    SUBSCRIPTION_ID,
    REQUEST_CONFIRMATIONS,
    CALLBACK_GAS_LIMIT,
    NUM_WORDS
  );
  
  return requestId;
};

const crypto = require('crypto');

function generateSecureRandom(min, max) {
  const range = max - min + 1;
  const bytesNeeded = Math.ceil(Math.log2(range) / 8);
  const randomBytes = crypto.randomBytes(bytesNeeded);
  const randomValue = randomBytes.readUIntBE(0, bytesNeeded);
  return min + (randomValue % range);
}

const { Telegraf, Markup } = require('telegraf');

const bot = new Telegraf(process.env.TELEGRAM_BOT_TOKEN);

// Game state
const games = new Map();
const players = new Map();

// Start game
bot.command('predict', async (ctx) => {
  const gameId = Date.now().toString();
  
  games.set(gameId, {
    id: gameId,
    predictions: { up: [], down: [] },
    startTime: Date.now(),
    endTime: Date.now() + 5 * 60 * 1000, // 5 minutes
    startPrice: await getCurrentPrice(),
    endPrice: null,
    prizePool: 0
  });
  
  ctx.reply(
    `🎮 **Price Prediction Game Started!**\
\
Will the price go 📈 UP or 📉 DOWN in 5 minutes?\
\
Entry: 1000 tokens`,
    Markup.inlineKeyboard([
      [
        Markup.button.callback('📈 UP', `predict_up_${gameId}`),
        Markup.button.callback('📉 DOWN', `predict_down_${gameId}`)
      ]
    ])
  );
  
  // End game after 5 minutes
  setTimeout(() => endGame(gameId, ctx), 5 * 60 * 1000);
});

// Handle prediction
bot.action(/predict_(up|down)_(.+)/, async (ctx) => {
  const [, direction, gameId] = ctx.match;
  const game = games.get(gameId);
  
  if (!game) {
    return ctx.answerCbQuery('Game not found!');
  }
  
  // Check if player already predicted
  const existingPrediction = [...game.predictions.up, ...game.predictions.down]
    .find(p => p.userId === ctx.from.id);
  
  if (existingPrediction) {
    return ctx.answerCbQuery('You already made a prediction!');
  }
  
  // Add prediction (would deduct tokens in production)
  game.predictions[direction].push({
    userId: ctx.from.id,
    username: ctx.from.username || 'Anonymous'
  });
  game.prizePool += 1000; // Entry fee
  
  ctx.answerCbQuery(`You predicted ${direction.toUpperCase()}!`);
});

// End game and determine winner
async function endGame(gameId, ctx) {
  const game = games.get(gameId);
  if (!game) return;
  
  game.endPrice = await getCurrentPrice();
  const priceChange = game.endPrice - game.startPrice;
  const winningDirection = priceChange >= 0 ? 'up' : 'down';
  
  const winners = game.predictions[winningDirection];
  const prizePerWinner = Math.floor(game.prizePool / winners.length);
  
  ctx.reply(
    `🏆 **Game Results!**\
\
Price went ${winningDirection === 'up' ? '📈 UP' : '📉 DOWN'}\
Winners: ${winners.length}\
Prize per winner: ${prizePerWinner} tokens`
  );
  
  // Distribute prizes (would call smart contract in production)
  games.delete(gameId);
}

async function getCurrentPrice() {
  // Fetch from CoinGecko or DEX
  const response = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=your-token&vs_currencies=usd');
  const data = await response.json();
  return data['your-token'].usd;
}

bot.launch();

const { EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');

// Question database
const questions = [
  {
    question: "What is the maximum supply of Bitcoin?",
    options: ["18 million", "21 million", "25 million", "30 million"],
    correct: 1,
    category: "Crypto Basics"
  },
  {
    question: "Who created Bitcoin?",
    options: ["Vitalik Buterin", "Satoshi Nakamoto", "Charlie Lee", "Andreas Antonopoulos"],
    correct: 1,
    category: "Crypto History"
  },
  // Add more questions...
];

// Trivia command
async function startTrivia(message) {
  const question = questions[Math.floor(Math.random() * questions.length)];
  
  const embed = new EmbedBuilder()
    .setColor(0x00FF00)
    .setTitle('🎮 Crypto Trivia')
    .setDescription(question.question)
    .addFields(
      { name: 'Options', value: question.options.map((opt, i) => `${i + 1}. ${opt}`).join('\n') }
    )
    .setFooter({ text: 'You have 30 seconds to answer!' });
  
  const buttons = new ActionRowBuilder()
    .addComponents(
      ...question.options.map((_, i) => 
        new ButtonBuilder()
          .setCustomId(`trivia_${i}`)
          .setLabel(`${i + 1}`)
          .setStyle(ButtonStyle.Primary)
      )
    );
  
  const msg = await message.channel.send({ embeds: [embed], components: [buttons] });
  
  // Collect response
  const filter = i => i.customId.startsWith('trivia_') && i.user.id === message.author.id;
  
  try {
    const interaction = await msg.awaitMessageComponent({ filter, time: 30000 });
    const answer = parseInt(interaction.customId.split('_')[1]);
    
    if (answer === question.correct) {
      await interaction.update({
        content: '✅ Correct! +100 points',
        embeds: [],
        components: []
      });
    } else {
      await interaction.update({
        content: `❌ Wrong! The correct answer was: ${question.options[question.correct]}`,
        embeds: [],
        components: []
      });
    }
  } catch {
    await msg.edit({ content: '⏰ Time\'s up!', embeds: [], components: [] });
  }
}

// Leaderboard database (use Redis or database in production)
const leaderboard = new Map();

function updateLeaderboard(userId, score) {
  const current = leaderboard.get(userId) || { score: 0, games: 0, wins: 0 };
  leaderboard.set(userId, {
    score: current.score + score,
    games: current.games + 1,
    wins: score > 0 ? current.wins + 1 : current.wins
  });
}

function getTopPlayers(limit = 10) {
  return Array.from(leaderboard.entries())
    .sort((a, b) => b[1].score - a[1].score)
    .slice(0, limit)
    .map(([userId, stats], index) => ({
      rank: index + 1,
      userId,
      ...stats
    }));
}

function formatLeaderboard(topPlayers) {
  return topPlayers.map(p => 
    `#${p.rank}. <@${p.userId}> - ${p.score} pts (${p.wins} wins)`
  ).join('\n');
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract GameTreasury is Ownable {
    IERC20 public token;
    
    mapping(address => uint256) public balances;
    mapping(uint256 => bool) public processedGames;
    
    event Deposit(address indexed user, uint256 amount);
    event Withdrawal(address indexed user, uint256 amount);
    event PrizeAwarded(address indexed winner, uint256 amount, uint256 gameId);
    
    constructor(address _token) Ownable(msg.sender) {
        token = IERC20(_token);
    }
    
    function deposit(uint256 amount) external {
        require(token.transferFrom(msg.sender, address(this), amount), "Transfer failed");
        balances[msg.sender] += amount;
        emit Deposit(msg.sender, amount);
    }
    
    function withdraw(uint256 amount) external {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        require(token.transfer(msg.sender, amount), "Transfer failed");
        emit Withdrawal(msg.sender, amount);
    }
    
    function awardPrize(
        address winner,
        uint256 amount,
        uint256 gameId,
        bytes memory signature
    ) external {
        require(!processedGames[gameId], "Game already processed");
        processedGames[gameId] = true;
        
        // Verify signature from game server
        require(verifySignature(winner, amount, gameId, signature), "Invalid signature");
        
        require(token.transfer(winner, amount), "Transfer failed");
        emit PrizeAwarded(winner, amount, gameId);
    }
    
    function verifySignature(
        address winner,
        uint256 amount,
        uint256 gameId,
        bytes memory signature
    ) internal view returns (bool) {
        bytes32 hash = keccak256(abi.encodePacked(winner, amount, gameId));
        bytes32 ethSignedHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
        
        address signer = recoverSigner(ethSignedHash, signature);
        return signer == owner();
    }
    
    function recoverSigner(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (bytes32 r, bytes32 s, uint8 v) = splitSignature(signature);
        return ecrecover(hash, v, r, s);
    }
    
    function splitSignature(bytes memory sig) internal pure returns (bytes32 r, bytes32 s, uint8 v) {
        require(sig.length == 65, "Invalid signature length");
        assembly {
            r := mload(add(sig, 32))
            s := mload(add(sig, 64))
            v := byte(0, mload(add(sig, 96)))
        }
    }
}