Upload 45 files

.env.example

@@ -2,6 +2,7 @@ API_ID=123456
 API_HASH=your_api_hash
 BOT_TOKEN=your_bot_token
 MONGO_URI=mongodb://localhost:27017/telegram_game_bot
+BOT_OWNER_ID=123456789
 # For mini-app buttons (must be the actual HTTPS URL of the hosted app, e.g. your HF space). t.me links cause BUTTON_URL_INVALID in web app buttons.
 WEBAPP_HTTPS_URL=https://huggingface.co/spaces/alexaincsl/alexagame
 # (Optional) t.me link if you want to send as plain text fallback: https://t.me/Alexagamebot/alexagamereward

Dockerfile

@@ -1,22 +1,19 @@
-# Use official Node.js light image
-FROM node:18-slim
-
-# Create app directory
-WORKDIR /usr/src/app
-
-# Install dependencies first (for better caching)
-COPY package*.json ./
-RUN npm install --production
-
-# Copy app source
-COPY . .
-
-# Expose port (standard for Hugging Face)
-EXPOSE 7860
-
-# Set environment
-ENV PORT=7860
-ENV NODE_ENV=production
-
-# Start the application
-CMD [ "npm", "start" ]
+FROM node:18-slim
+
+WORKDIR /usr/src/app
+
+COPY package*.json ./
+RUN npm install --production
+
+COPY . .
+
+ARG GIPHY_API_KEY=Ei3iNGXxdCwjwyxwvSaLq7BgNaOLPFEh
+ENV GIPHY_API_KEY=${GIPHY_API_KEY}
+RUN node scripts/downloadGifs.js
+
+EXPOSE 7860
+
+ENV PORT=7860
+ENV NODE_ENV=production
+
+CMD [ "npm", "start" ]

TASKS.md

@@ -13,6 +13,17 @@
 - [x] Pot system (entry × 2 = winner takes all)
 - [x] HTML markup for all messages
 - [x] Banner + video display ads on webapp pages
+- [x] Shop system (/shop, /buy, /gift with GIF messages)
+- [x] Collection/Inventory system (/collection, reply to see other user's)
+- [x] /wallet shows replied user's wallet when replying
+- [x] /rob requires amount (/rob 500), shows victim's actual balance if too low
+- [x] Auto-earn from chatting (max $1000/day, $1-15 per message)
+- [x] Admin: /add <value> — add money to user wallet
+- [x] Admin: /addblacklist — blacklist user from bot
+- [x] Admin: /unblacklist — remove from blacklist
+- [x] Admin: /blacklist — show all blacklisted users
+- [x] Blacklisted users silently blocked from all commands + buttons
+- [x] /coin command (renamed from /coinflip)
 
 ---
 

bot.js

@@ -6,6 +6,8 @@ const { NewMessage } = require("telegram/events");
 const connectDB = require('./db/mongo');
 const User = require('./models/User');
 const { startApi } = require('./api');
+const { processChatEarn } = require('./utils/chatEarn');
+const { getName } = require('./utils/getName');
 
 const requiredEnv = ['API_ID', 'API_HASH', 'BOT_TOKEN', 'MONGO_URI'];
 const missing = requiredEnv.filter(k => !process.env[k]);
@@ -22,6 +24,8 @@ const boardHandler = require('./handlers/boardHandler');
 const blackjack = require('./handlers/blackjack');
 const cardGame = require('./handlers/cardGameHandler');
 const strategy = require('./handlers/strategyGames');
+const shopHandler = require('./handlers/shop');
+const admin = require('./handlers/admin');
 
 const apiId = parseInt(process.env.API_ID || 0);
 const apiHash = process.env.API_HASH || "";
@@ -35,8 +39,6 @@ const stringSession = new StringSession("");
     await client.start({ botAuthToken: botToken });
     console.log("Bot is running...");
     global._tgClient = client;
-
-    // Set default parse mode to HTML globally
     client.setParseMode('html');
 
     const isAlive = async (event) => {
@@ -52,46 +54,86 @@ const stringSession = new StringSession("");
         return true;
     };
 
+    const isBlacklisted = async (userId) => {
+        const user = await User.findOne({ userId });
+        return user && user.blacklisted;
+    };
+
     client.addEventHandler(async (event) => {
         const text = event.message.message || '';
+        const userId = event.message.senderId?.toString();
+        if (!userId) return;
+
+        // Auto-earn from chatting (all messages, not just commands)
+        if (text && !text.startsWith('/')) {
+            await processChatEarn(userId);
+            return; // non-commands don't need further processing
+        }
         if (!text) return;
 
+        // Blacklist check for all commands
+        if (text.startsWith('/') && await isBlacklisted(userId)) {
+            return; // silently ignore blacklisted users
+        }
+
+        // ── Admin commands ──
+        if (text.startsWith("/add ") && !text.startsWith("/addblacklist")) await admin.addMoney(client, event);
+        if (text.startsWith("/addblacklist")) await admin.addBlacklist(client, event);
+        if (text.startsWith("/unblacklist")) await admin.unBlacklist(client, event);
+        if (text === "/blacklist") await admin.showBlacklist(client, event);
+
+        // ── General ──
         if (text === "/start") {
             await event.message.respond({ message:
                 "🎮 <b>Alexagame Bot</b>\n\n" +
-                "💰 /daily - Claim $3000 daily reward\n" +
-                "💰 /wallet - Balance &amp; stats\n" +
-                "⚔️ /kill (reply) - Kill for cash &amp; XP\n" +
-                "⚔️ /rob (reply) - Rob user (risky)\n" +
-                "⚔️ /revive - Revive for $1000\n\n" +
-                "♔ /chess &lt;bet&gt; - Chess (2P)\n" +
-                "⚪ /checkers &lt;bet&gt; - Checkers (2P)\n" +
-                "🕹️ /xox &lt;bet&gt; - Tic-Tac-Toe\n" +
-                "🕹️ /c4 &lt;bet&gt; - Connect 4\n" +
-                "🕹️ /hack &lt;bet&gt; &lt;len&gt; - PIN hack\n" +
-                "🕹️ /cards &lt;bet&gt; - Card flip game\n" +
-                "🕹️ /dice &lt;bet&gt; - Dice duel\n\n" +
-                "🃏 /bj &lt;bet&gt; - Blackjack\n" +
-                "🃏 /slots - Slot machine\n" +
-                "🃏 /mines - Avoid mines\n" +
-                "🃏 /coin - Coin flip\n" +
-                "🃏 /roulette - Russian roulette\n" +
-                "🃏 /hl - Higher or Lower\n\n" +
-                "🏳️ /surrender - Forfeit chess/checkers\n" +
-                "Use /daily or /missions to open the reward mini app!"
+                "💰 /daily — Claim $3000 daily reward\n" +
+                "💰 /wallet — Balance &amp; stats (reply = other user)\n" +
+                "🛒 /shop — Browse items\n" +
+                "🛍️ /buy &lt;id&gt; — Buy item for yourself\n" +
+                "🎁 /gift &lt;id&gt; — Gift item (reply to user)\n" +
+                "📦 /collection — View collection\n\n" +
+                "⚔️ /kill (reply) — Kill for cash &amp; XP\n" +
+                "⚔️ /rob &lt;amount&gt; (reply) — Rob user\n" +
+                "⚔️ /revive — Revive for $1000\n\n" +
+                "♔ /chess &lt;bet&gt; — Chess (2P)\n" +
+                "⚪ /checkers &lt;bet&gt; — Checkers (2P)\n" +
+                "🕹️ /xox &lt;bet&gt; — Tic-Tac-Toe\n" +
+                "🕹️ /c4 &lt;bet&gt; — Connect 4\n" +
+                "🕹️ /dice &lt;bet&gt; — Dice duel\n" +
+                "🕹️ /hack &lt;bet&gt; &lt;len&gt; — PIN hack\n" +
+                "🕹️ /cards &lt;bet&gt; — Card flip game\n\n" +
+                "🃏 /bj &lt;bet&gt; — Blackjack\n" +
+                "🃏 /slots — Slot machine\n" +
+                "🃏 /mines — Avoid mines\n" +
+                "🃏 /coin — Coin flip\n" +
+                "🃏 /roulette — Russian roulette\n" +
+                "🃏 /hl — Higher or Lower\n\n" +
+                "🏳️ /surrender — Forfeit chess/checkers\n" +
+                "💬 Chat in groups to auto-earn up to $1000/day!"
             });
         }
 
-        if (text === "/wallet") {
-            const userId = event.message.senderId.toString();
-            let user = await User.findOne({ userId });
-            if (!user) user = await User.create({ userId, username: event.message.sender?.username });
+        if (text === "/wallet" || text.startsWith("/wallet ")) {
+            let targetId = userId;
+            // If reply to user, show their wallet
+            if (event.message.replyTo) {
+                try {
+                    const replyMsg = await client.getMessages(event.chatId, { ids: [event.message.replyTo.replyToMsgId] });
+                    if (replyMsg && replyMsg[0] && replyMsg[0].senderId) targetId = replyMsg[0].senderId.toString();
+                } catch (e) {}
+            }
+            let user = await User.findOne({ userId: targetId });
+            if (!user) user = await User.create({ userId: targetId });
+            const name = await getName(client, targetId);
+            const isSelf = targetId === userId;
             await event.message.respond({ message:
-                `👤 <b>Lv.${user.level}</b> | XP: ${user.xp}\n` +
+                `👤 <b>${name}</b>${isSelf ? '' : "'s wallet"}\n` +
+                `🎖️ Lv.${user.level} | XP: ${user.xp}\n` +
                 `💰 Wallet: <b>$${user.wallet}</b>\n` +
                 `💳 Bank: <b>$${user.bank}</b>\n` +
                 `❤️ HP: ${user.health}%\n` +
-                `💀 Kills: ${user.kills||0} | 💸 Robs: ${user.robs||0}`
+                `💀 Kills: ${user.kills||0} | 💸 Robs: ${user.robs||0}\n` +
+                `📦 Items: ${user.inventory?.length || 0}`
             });
         }
 
@@ -100,14 +142,23 @@ const stringSession = new StringSession("");
         if (text.startsWith("/dp")) await economy.deposit(client, event);
         if (text.startsWith("/wd")) await economy.withdraw(client, event);
 
+        // Shop
+        if (text === "/shop") await shopHandler.shop(client, event);
+        if (text.startsWith("/buy")) await shopHandler.buy(client, event);
+        if (text.startsWith("/gift")) await shopHandler.gift(client, event);
+        if (text === "/collection" || (text.startsWith("/collection") && event.message.replyTo)) await shopHandler.inventory(client, event);
+
+        // Combat
         if (text.startsWith("/kill")) { if (await isAlive(event)) await combat.kill(client, event); }
         if (text.startsWith("/rob")) { if (await isAlive(event)) await combat.rob(client, event); }
         if (text === "/revive") await combat.revive(client, event);
 
+        // Strategy
         if (text.startsWith("/chess")) { if (await isAlive(event)) await strategy.startChess(client, event); }
         if (text.startsWith("/checkers")) { if (await isAlive(event)) await strategy.startCheckers(client, event); }
         if (text === "/surrender") await strategy.surrender(client, event);
 
+        // Multiplayer lobby
         if (text.startsWith("/cards")) { if (await isAlive(event)) await cardGame.initCardGame(client, event); }
         if (text.startsWith("/hack")) { if (await isAlive(event)) await multiHack.initHack(client, event); }
         if (text === "/join") {
@@ -117,10 +168,12 @@ const stringSession = new StringSession("");
         if (text.startsWith("/guess")) await multiHack.processGuess(client, event);
         if (text.startsWith("/flip")) await cardGame.processFlip(client, event);
 
+        // Board games
         if (text.startsWith("/xox")) { if (await isAlive(event)) await boardGames.startXOX(client, event); }
         if (text.startsWith("/c4")) { if (await isAlive(event)) await boardGames.startC4(client, event); }
         if (text.startsWith("/dice")) { if (await isAlive(event)) await games.startDice(client, event); }
 
+        // Casino
         if (text.startsWith("/bj")) { if (await isAlive(event)) await blackjack.startBJ(client, event); }
         if (text === "/slots") await inlineGames.startSlots(client, event);
         if (text === "/mines") await inlineGames.startMines(client, event);
@@ -130,8 +183,13 @@ const stringSession = new StringSession("");
 
     }, new NewMessage({}));
 
+    // Callback queries
     client.addEventHandler(async (update) => {
         if (update instanceof Api.UpdateBotCallbackQuery) {
+            // Check blacklist for button clicks
+            const cbUserId = update.userId.toString();
+            if (await isBlacklisted(cbUserId)) return;
+
             let handled = false;
             const cbData = update.data.toString();
             if (cbData.startsWith("cs|") || cbData.startsWith("ck|") || cbData.startsWith("csjn|") || cbData.startsWith("ckjn|") || cbData.startsWith("cssr|") || cbData.startsWith("cksr|")) {

data/shopItems.js

@@ -0,0 +1,26 @@
+/**
+ * Shop items catalog.
+ * gifDir: folder name under ./gifs/ containing .gif files (0.gif, 1.gif, etc.)
+ */
+const SHOP_ITEMS = [
+    { id: '1',  name: 'Rose',          emoji: '🌹', price: 500,   xpRate: 0.2, gifDir: 'rose' },
+    { id: '2',  name: 'Teddy Bear',    emoji: '🧸', price: 1200,  xpRate: 0.2, gifDir: 'teddy' },
+    { id: '3',  name: 'Diamond Ring',  emoji: '💍', price: 5000,  xpRate: 0.2, gifDir: 'ring' },
+    { id: '4',  name: 'Crown',         emoji: '👑', price: 10000, xpRate: 0.2, gifDir: 'crown' },
+    { id: '5',  name: 'Chocolate',     emoji: '🍫', price: 300,   xpRate: 0.2, gifDir: 'chocolate' },
+    { id: '6',  name: 'Star',          emoji: '⭐', price: 800,   xpRate: 0.2, gifDir: 'star' },
+    { id: '7',  name: 'Heart',         emoji: '❤️', price: 600,   xpRate: 0.2, gifDir: 'heart' },
+    { id: '8',  name: 'Trophy',        emoji: '🏆', price: 3000,  xpRate: 0.2, gifDir: 'trophy' },
+    { id: '9',  name: 'Fire',          emoji: '🔥', price: 1500,  xpRate: 0.2, gifDir: 'fire' },
+    { id: '10', name: 'Rocket',        emoji: '🚀', price: 2000,  xpRate: 0.2, gifDir: 'rocket' },
+];
+
+function getItem(id) {
+    return SHOP_ITEMS.find(i => i.id === id.toString());
+}
+
+function calcXP(price, rate) {
+    return Math.floor(price * (rate || 0.2));
+}
+
+module.exports = { SHOP_ITEMS, getItem, calcXP };

handlers/admin.js

@@ -0,0 +1,97 @@
+const User = require('../models/User');
+const { getName } = require('../utils/getName');
+
+// Bot owner ID — set in .env as BOT_OWNER_ID
+function isOwner(userId) {
+    const ownerId = process.env.BOT_OWNER_ID;
+    return ownerId && userId === ownerId;
+}
+
+// ── /add <value> (reply to user or /add <value> <userId>) ──
+const addMoney = async (client, event) => {
+    const userId = event.message.senderId.toString();
+    if (!isOwner(userId)) return;
+
+    const parts = event.message.message.split(" ");
+    const amount = parseInt(parts[1]);
+    if (isNaN(amount) || amount <= 0) return event.message.respond({ message: "Usage: /add &lt;amount&gt; (reply to user)" });
+
+    let targetId = parts[2]; // /add 500 userId
+    if (!targetId && event.message.replyTo) {
+        try {
+            const replyMsg = await client.getMessages(event.chatId, { ids: [event.message.replyTo.replyToMsgId] });
+            if (replyMsg && replyMsg[0] && replyMsg[0].senderId) targetId = replyMsg[0].senderId.toString();
+        } catch (e) {}
+    }
+    if (!targetId) return event.message.respond({ message: "Reply to a user or provide user ID: /add &lt;amount&gt; &lt;userId&gt;" });
+
+    let user = await User.findOne({ userId: targetId }) || await User.create({ userId: targetId });
+    user.wallet += amount;
+    await user.save();
+
+    const name = await getName(client, targetId);
+    await event.message.respond({ message: `✅ Added <b>$${amount}</b> to ${name}'s wallet. New balance: <b>$${user.wallet}</b>` });
+};
+
+// ── /addblacklist (reply or /addblacklist <userId>) ──
+const addBlacklist = async (client, event) => {
+    const userId = event.message.senderId.toString();
+    if (!isOwner(userId)) return;
+
+    let targetId = event.message.message.split(" ")[1];
+    if (!targetId && event.message.replyTo) {
+        try {
+            const replyMsg = await client.getMessages(event.chatId, { ids: [event.message.replyTo.replyToMsgId] });
+            if (replyMsg && replyMsg[0] && replyMsg[0].senderId) targetId = replyMsg[0].senderId.toString();
+        } catch (e) {}
+    }
+    if (!targetId) return event.message.respond({ message: "Reply to a user or: /addblacklist &lt;userId&gt;" });
+
+    let user = await User.findOne({ userId: targetId }) || await User.create({ userId: targetId });
+    user.blacklisted = true;
+    await user.save();
+
+    const name = await getName(client, targetId);
+    await event.message.respond({ message: `🚫 <b>${name}</b> (${targetId}) has been blacklisted.` });
+};
+
+// ── /unblacklist ──
+const unBlacklist = async (client, event) => {
+    const userId = event.message.senderId.toString();
+    if (!isOwner(userId)) return;
+
+    let targetId = event.message.message.split(" ")[1];
+    if (!targetId && event.message.replyTo) {
+        try {
+            const replyMsg = await client.getMessages(event.chatId, { ids: [event.message.replyTo.replyToMsgId] });
+            if (replyMsg && replyMsg[0] && replyMsg[0].senderId) targetId = replyMsg[0].senderId.toString();
+        } catch (e) {}
+    }
+    if (!targetId) return event.message.respond({ message: "Reply to a user or: /unblacklist &lt;userId&gt;" });
+
+    let user = await User.findOne({ userId: targetId });
+    if (!user) return event.message.respond({ message: "User not found." });
+    user.blacklisted = false;
+    await user.save();
+
+    const name = await getName(client, targetId);
+    await event.message.respond({ message: `✅ <b>${name}</b> (${targetId}) removed from blacklist.` });
+};
+
+// ── /blacklist ──
+const showBlacklist = async (client, event) => {
+    const userId = event.message.senderId.toString();
+    if (!isOwner(userId)) return;
+
+    const users = await User.find({ blacklisted: true }).select('userId username').lean();
+    if (users.length === 0) return event.message.respond({ message: "📋 Blacklist is empty." });
+
+    let msg = `🚫 <b>Blacklisted Users</b>\n\n`;
+    for (const u of users) {
+        const name = u.username || `User${u.userId.slice(-4)}`;
+        msg += `• ${name} — <code>${u.userId}</code>\n`;
+    }
+    await event.message.respond({ message: msg });
+};
+
+module.exports = { addMoney, addBlacklist, unBlacklist, showBlacklist, isOwner };

handlers/combat.js

@@ -1,33 +1,25 @@
 const User = require('../models/User');
-
 const leveling = require('../utils/leveling');
+const { getName } = require('../utils/getName');
 
 const kill = async (client, event) => {
     if (!event.message.replyTo) return event.message.respond({ message: "Reply to someone to kill them!" });
-    
+
     const killerId = event.message.senderId.toString();
     let replyMsg;
     try {
         replyMsg = await client.getMessages(event.chatId, { ids: [event.message.replyTo.replyToMsgId] });
-    } catch (e) {
-        return event.message.respond({ message: "Could not fetch the replied message." });
-    }
-    if (!replyMsg || !replyMsg[0] || !replyMsg[0].senderId) {
+    } catch (e) { return event.message.respond({ message: "Could not fetch the replied message." }); }
+    if (!replyMsg || !replyMsg[0] || !replyMsg[0].senderId)
         return event.message.respond({ message: "You can't kill bots or channels! Reply to a real user." });
-    }
-    const victimId = replyMsg[0].senderId.toString();
 
+    const victimId = replyMsg[0].senderId.toString();
     if (killerId === victimId) return event.message.respond({ message: "You can't kill yourself!" });
 
-    let killer = await User.findOne({ userId: killerId });
-    let victim = await User.findOne({ userId: victimId });
-
-    if (!killer) killer = await User.create({ userId: killerId });
-    if (!victim) victim = await User.create({ userId: victimId });
-
+    let killer = await User.findOne({ userId: killerId }) || await User.create({ userId: killerId });
+    let victim = await User.findOne({ userId: victimId }) || await User.create({ userId: victimId });
     if (victim.isDead) return event.message.respond({ message: "They are already dead!" });
 
-    // Reward for killing
     const reward = Math.floor(Math.random() * 500) + 100;
     killer.wallet += reward;
     killer.kills = (killer.kills || 0) + 1;
@@ -37,19 +29,11 @@ const kill = async (client, event) => {
     victim.health = 0;
 
     const xpRes = await leveling.addXP(killerId, 100);
+    const killerName = await getName(client, killerId);
+    const victimName = await getName(client, victimId);
 
-    // Get nice names
-    let killerName = killerId;
-    let victimName = victimId;
-    try {
-        const kEnt = await client.getEntity(killerId);
-        killerName = kEnt.firstName || kEnt.username || killerId;
-        const vEnt = await client.getEntity(victimId);
-        victimName = vEnt.firstName || vEnt.username || victimId;
-    } catch (e) {}
-
-    let msg = `💀 ${killerName} killed ${victimName}! You gained $${reward} and 100 XP.`;
-    if (xpRes.leveledUp) msg += `\n🆙 <b>LEVEL UP!</b> You are now level ${xpRes.level}!`;
+    let msg = `💀 <b>${killerName}</b> killed <b>${victimName}</b>! Gained $${reward} and 100 XP.`;
+    if (xpRes.leveledUp) msg += `\n🆙 <b>LEVEL UP!</b> Level ${xpRes.level}!`;
 
     await killer.save();
     await victim.save();
@@ -57,54 +41,44 @@ const kill = async (client, event) => {
 };
 
 const rob = async (client, event) => {
-    if (!event.message.replyTo) return event.message.respond({ message: "Reply to someone to rob them!" });
-    
+    if (!event.message.replyTo) return event.message.respond({ message: "Reply to someone to rob them!\nUsage: /rob &lt;amount&gt;" });
+
+    const parts = event.message.message.split(" ");
+    const amount = parseInt(parts[1]);
+    if (isNaN(amount) || amount <= 0) return event.message.respond({ message: "Usage: /rob &lt;amount&gt; (reply to user)\nExample: /rob 500" });
+
     const robberId = event.message.senderId.toString();
     let replyMsg;
     try {
         replyMsg = await client.getMessages(event.chatId, { ids: [event.message.replyTo.replyToMsgId] });
-    } catch (e) {
-        return event.message.respond({ message: "Could not fetch the replied message." });
-    }
-    if (!replyMsg || !replyMsg[0] || !replyMsg[0].senderId) {
-        return event.message.respond({ message: "You can't kill bots or channels! Reply to a real user." });
-    }
-    const victimId = replyMsg[0].senderId.toString();
+    } catch (e) { return event.message.respond({ message: "Could not fetch the replied message." }); }
+    if (!replyMsg || !replyMsg[0] || !replyMsg[0].senderId)
+        return event.message.respond({ message: "You can't rob bots or channels!" });
 
+    const victimId = replyMsg[0].senderId.toString();
     if (robberId === victimId) return event.message.respond({ message: "You can't rob yourself!" });
 
-    let robber = await User.findOne({ userId: robberId });
-    let victim = await User.findOne({ userId: victimId });
+    let robber = await User.findOne({ userId: robberId }) || await User.create({ userId: robberId });
+    let victim = await User.findOne({ userId: victimId }) || await User.create({ userId: victimId });
 
-    if (!robber) robber = await User.create({ userId: robberId });
-    if (!victim) victim = await User.create({ userId: victimId });
+    const victimName = await getName(client, victimId);
+    const robberName = await getName(client, robberId);
 
-    if (victim.wallet <= 0) return event.message.respond({ message: "They have no money in their wallet to rob!" });
+    if (victim.wallet <= 0) return event.message.respond({ message: `${victimName} has no money in their wallet to rob!` });
+    if (victim.wallet < amount) return event.message.respond({ message: `${victimName} only has <b>$${victim.wallet}</b> in their wallet!` });
 
     const success = Math.random() < 0.4;
-    
+
     if (success) {
-        const stolen = Math.floor(Math.random() * (victim.wallet * 0.7)) + 1;
-        robber.wallet += stolen;
+        robber.wallet += amount;
         robber.robs = (robber.robs || 0) + 1;
-        robber.totalEarned = (robber.totalEarned || 0) + stolen;
-        victim.wallet -= stolen;
-        
+        robber.totalEarned = (robber.totalEarned || 0) + amount;
+        victim.wallet -= amount;
+
         const xpRes = await leveling.addXP(robberId, 50);
+        let msg = `💸 <b>Robbery Success!</b>\n${robberName} snatched <b>$${amount}</b> from ${victimName}! +50 XP`;
+        if (xpRes.leveledUp) msg += `\n🆙 <b>LEVEL UP!</b> Level ${xpRes.level}!`;
 
-        // Get nice names
-        let robberName = robberId;
-        let victimName = victimId;
-        try {
-            const rEnt = await client.getEntity(robberId);
-            robberName = rEnt.firstName || rEnt.username || robberId;
-            const vEnt = await client.getEntity(victimId);
-            victimName = vEnt.firstName || vEnt.username || victimId;
-        } catch (e) {}
-
-        let msg = `💸 <b>Robbery Success!</b>\n${robberName} snatched $${stolen} from ${victimName} and 50 XP!`;
-        if (xpRes.leveledUp) msg += `\n🆙 <b>LEVEL UP!</b> You are now level ${xpRes.level}!`;
-        
         await robber.save();
         await victim.save();
         await event.message.respond({ message: msg });
@@ -125,17 +99,13 @@ const rob = async (client, event) => {
 const revive = async (client, event) => {
     const userId = event.message.senderId.toString();
     let user = await User.findOne({ userId });
-
     if (!user || !user.isDead) return event.message.respond({ message: "You are not dead!" });
-
     const cost = 1000;
     if (user.wallet < cost) return event.message.respond({ message: `You need $${cost} in your wallet to revive!` });
-
     user.wallet -= cost;
     user.isDead = false;
     user.health = 100;
     await user.save();
-
     await event.message.respond({ message: "💖 You have been revived! $1000 deducted from wallet." });
 };
 

handlers/shop.js

@@ -0,0 +1,158 @@
+const fs = require('fs');
+const path = require('path');
+const { Api } = require("telegram");
+const User = require('../models/User');
+const { SHOP_ITEMS, getItem, calcXP } = require('../data/shopItems');
+const leveling = require('../utils/leveling');
+const { getName } = require('../utils/getName');
+
+// ── Pick random gif from ./gifs/<dir>/ ──
+function getRandomGif(gifDir) {
+    const dir = path.join(__dirname, '..', 'gifs', gifDir);
+    try {
+        const files = fs.readdirSync(dir).filter(f => f.endsWith('.gif'));
+        if (files.length === 0) return null;
+        return path.join(dir, files[Math.floor(Math.random() * files.length)]);
+    } catch (e) { return null; }
+}
+
+// ── /shop ──
+const shop = async (client, event) => {
+    let msg = `🛒 <b>SHOP</b>\n\n`;
+    msg += `<code>ID  | Item           | Price</code>\n`;
+    msg += `<code>----|----------------|--------</code>\n`;
+    for (const item of SHOP_ITEMS) {
+        const id = item.id.padEnd(3);
+        const name = `${item.emoji} ${item.name}`.padEnd(16);
+        msg += `<code>${id} | ${name}| $${item.price}</code>\n`;
+    }
+    msg += `\n💰 /buy &lt;id&gt; — buy for yourself`;
+    msg += `\n🎁 /gift &lt;id&gt; — gift to someone (reply to user)`;
+    msg += `\n📦 /collection — view your inventory`;
+    await event.message.respond({ message: msg });
+};
+
+// ── /buy <id> ──
+const buy = async (client, event) => {
+    const userId = event.message.senderId.toString();
+    const itemId = event.message.message.split(" ")[1];
+    if (!itemId) return event.message.respond({ message: "Usage: /buy &lt;item id&gt;\nSee /shop for item list." });
+
+    const item = getItem(itemId);
+    if (!item) return event.message.respond({ message: "❌ Item not found! Use /shop to see items." });
+
+    let user = await User.findOne({ userId }) || await User.create({ userId });
+    if (user.wallet < item.price) return event.message.respond({ message: `❌ Not enough money! Need <b>$${item.price}</b>, you have $${user.wallet}.` });
+
+    const buyerName = await getName(client, userId);
+
+    user.wallet -= item.price;
+    const xpGain = calcXP(item.price);
+    user.inventory.push({
+        itemId: item.id,
+        itemName: item.name,
+        from: 'self',
+        fromName: buyerName,
+    });
+    await user.save();
+    await leveling.addXP(userId, xpGain);
+
+    const msg = `${item.emoji} <b>${buyerName}</b> bought a <b>${item.name}</b>!\n\n💰 -$${item.price} | ✨ +${xpGain} XP`;
+
+    const gif = getRandomGif(item.gifDir);
+    if (gif) {
+        try {
+            await client.sendMessage(event.chatId, { message: msg, file: gif });
+            return;
+        } catch (e) { console.error('[shop] gif send failed:', e.message); }
+    }
+    await event.message.respond({ message: msg });
+};
+
+// ── /gift <id> (reply to user) ──
+const gift = async (client, event) => {
+    if (!event.message.replyTo) return event.message.respond({ message: "Reply to someone to gift them an item!\nUsage: /gift &lt;item id&gt;" });
+
+    const gifterId = event.message.senderId.toString();
+    const itemId = event.message.message.split(" ")[1];
+    if (!itemId) return event.message.respond({ message: "Usage: /gift &lt;item id&gt;\nSee /shop for item list." });
+
+    const item = getItem(itemId);
+    if (!item) return event.message.respond({ message: "❌ Item not found! Use /shop to see items." });
+
+    let replyMsg;
+    try {
+        replyMsg = await client.getMessages(event.chatId, { ids: [event.message.replyTo.replyToMsgId] });
+    } catch (e) { return event.message.respond({ message: "Could not fetch replied message." }); }
+    if (!replyMsg || !replyMsg[0] || !replyMsg[0].senderId)
+        return event.message.respond({ message: "Can't gift to bots or channels!" });
+
+    const receiverId = replyMsg[0].senderId.toString();
+    if (gifterId === receiverId) return event.message.respond({ message: "Use /buy to get items for yourself!" });
+
+    let gifter = await User.findOne({ userId: gifterId }) || await User.create({ userId: gifterId });
+    if (gifter.wallet < item.price) return event.message.respond({ message: `❌ Not enough money! Need <b>$${item.price}</b>, you have $${gifter.wallet}.` });
+
+    let receiver = await User.findOne({ userId: receiverId }) || await User.create({ userId: receiverId });
+
+    const gifterName = await getName(client, gifterId);
+    const receiverName = await getName(client, receiverId);
+
+    gifter.wallet -= item.price;
+    const xpGain = calcXP(item.price);
+    await gifter.save();
+    await leveling.addXP(gifterId, xpGain);
+
+    receiver.inventory.push({
+        itemId: item.id,
+        itemName: item.name,
+        from: gifterId,
+        fromName: gifterName,
+    });
+    await receiver.save();
+
+    const msg = `🎁 <b>${gifterName}</b> gifted a <b>${item.emoji} ${item.name}</b> to <b>${receiverName}</b>!\n\n💰 -$${item.price} | ✨ +${xpGain} XP for ${gifterName}`;
+
+    const gif = getRandomGif(item.gifDir);
+    if (gif) {
+        try {
+            await client.sendMessage(event.chatId, { message: msg, file: gif });
+            return;
+        } catch (e) { console.error('[shop] gif send failed:', e.message); }
+    }
+    await event.message.respond({ message: msg });
+};
+
+// ── /collection (or /collection reply to user) ──
+const inventory = async (client, event) => {
+    let targetId = event.message.senderId.toString();
+    let targetName = await getName(client, targetId);
+
+    if (event.message.replyTo) {
+        try {
+            const replyMsg = await client.getMessages(event.chatId, { ids: [event.message.replyTo.replyToMsgId] });
+            if (replyMsg && replyMsg[0] && replyMsg[0].senderId) {
+                targetId = replyMsg[0].senderId.toString();
+                targetName = await getName(client, targetId);
+            }
+        } catch (e) {}
+    }
+
+    let user = await User.findOne({ userId: targetId });
+    if (!user || !user.inventory || user.inventory.length === 0)
+        return event.message.respond({ message: `📦 <b>${targetName}'s Collection</b>\n\n<i>Empty — no items yet!</i>\n\nUse /shop to browse items.` });
+
+    let msg = `📦 <b>${targetName}'s Collection</b>\n\n`;
+    for (const item of user.inventory) {
+        const shopItem = getItem(item.itemId);
+        const emoji = shopItem ? shopItem.emoji : '📦';
+        if (item.from === 'self') {
+            msg += `${emoji} <b>${item.itemName}</b> — bought by themselves\n`;
+        } else {
+            msg += `${emoji} <b>${item.itemName}</b> — gifted by ${item.fromName}\n`;
+        }
+    }
+    await event.message.respond({ message: msg });
+};
+
+module.exports = { shop, buy, gift, inventory };

models/User.js

@@ -1,5 +1,13 @@
 const mongoose = require('mongoose');
 
+const CollectionItemSchema = new mongoose.Schema({
+    itemId: String,
+    itemName: String,
+    from: String,       // 'self' or userId who gifted
+    fromName: String,   // display name of gifter
+    date: { type: Date, default: Date.now },
+}, { _id: false });
+
 const UserSchema = new mongoose.Schema({
     userId: { type: String, required: true, unique: true },
     username: String,
@@ -17,10 +25,16 @@ const UserSchema = new mongoose.Schema({
     lastKill: { type: Date, default: null },
     xp: { type: Number, default: 0 },
     level: { type: Number, default: 1 },
-    // Leaderboard stats
     kills: { type: Number, default: 0 },
     robs: { type: Number, default: 0 },
     totalEarned: { type: Number, default: 0 },
+    // Shop & inventory
+    inventory: { type: [CollectionItemSchema], default: [] },
+    // Chat activity auto-earn
+    lastChatEarnDate: { type: String, default: null }, // 'YYYY-MM-DD'
+    chatEarnedToday: { type: Number, default: 0 },
+    // Blacklist
+    blacklisted: { type: Boolean, default: false },
 });
 
 module.exports = mongoose.model('User', UserSchema);

scripts/downloadGifs.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+/**
+ * Downloads GIFs from Giphy API for each shop item.
+ * Run during Docker build or manually: node scripts/downloadGifs.js
+ * 
+ * Uses GIPHY_API_KEY env var or falls back to hardcoded key.
+ * Downloads 5 GIFs per item into ./gifs/<itemDir>/0.gif, 1.gif, etc.
+ */
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const API_KEY = process.env.GIPHY_API_KEY || 'Ei3iNGXxdCwjwyxwvSaLq7BgNaOLPFEh';
+const GIFS_PER_ITEM = 5;
+
+// Search terms mapped to each shop item gifDir
+const SEARCH_MAP = {
+    'rose':      'rose flower',
+    'teddy':     'teddy bear cute',
+    'ring':      'diamond ring',
+    'crown':     'crown king queen',
+    'chocolate': 'chocolate candy',
+    'star':      'star gold sparkle',
+    'heart':     'heart love red',
+    'trophy':    'trophy cup winner',
+    'fire':      'fire flame',
+    'rocket':    'rocket launch',
+};
+
+const GIFS_DIR = path.join(__dirname, '..', 'gifs');
+
+function fetch(url) {
+    return new Promise((resolve, reject) => {
+        const client = url.startsWith('https') ? https : http;
+        client.get(url, { headers: { 'User-Agent': 'AlexaGameBot/1.0' } }, (res) => {
+            // Follow redirects
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return fetch(res.headers.location).then(resolve).catch(reject);
+            }
+            const chunks = [];
+            res.on('data', c => chunks.push(c));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+            res.on('error', reject);
+        }).on('error', reject);
+    });
+}
+
+async function searchGiphy(query, limit) {
+    const url = `https://api.giphy.com/v1/gifs/search?api_key=${API_KEY}&q=${encodeURIComponent(query)}&limit=${limit}&rating=g&lang=en`;
+    const data = await fetch(url);
+    const json = JSON.parse(data.toString());
+    if (!json.data || json.data.length === 0) {
+        console.log(`  ⚠ No results for "${query}"`);
+        return [];
+    }
+    // Get the downsized GIF URLs (smaller, good for Telegram)
+    return json.data.map(g => {
+        // Prefer fixed_height_small or downsized
+        const img = g.images;
+        return img.fixed_height_small?.url || img.downsized?.url || img.original?.url;
+    }).filter(Boolean);
+}
+
+async function downloadFile(url, dest) {
+    const data = await fetch(url);
+    fs.writeFileSync(dest, data);
+}
+
+async function main() {
+    console.log('🎬 Downloading GIFs from Giphy...');
+    console.log(`   API Key: ${API_KEY.slice(0, 8)}...`);
+    console.log(`   GIFs per item: ${GIFS_PER_ITEM}`);
+    console.log(`   Output: ${GIFS_DIR}\n`);
+
+    // Create base dir
+    if (!fs.existsSync(GIFS_DIR)) fs.mkdirSync(GIFS_DIR, { recursive: true });
+
+    for (const [dir, query] of Object.entries(SEARCH_MAP)) {
+        const itemDir = path.join(GIFS_DIR, dir);
+        if (!fs.existsSync(itemDir)) fs.mkdirSync(itemDir, { recursive: true });
+
+        // Skip if already has enough GIFs
+        const existing = fs.readdirSync(itemDir).filter(f => f.endsWith('.gif'));
+        if (existing.length >= GIFS_PER_ITEM) {
+            console.log(`✅ ${dir}/ — already has ${existing.length} GIFs, skipping`);
+            continue;
+        }
+
+        console.log(`📥 ${dir}/ — searching "${query}"...`);
+        try {
+            const urls = await searchGiphy(query, GIFS_PER_ITEM);
+            let downloaded = 0;
+            for (let i = 0; i < urls.length && downloaded < GIFS_PER_ITEM; i++) {
+                const dest = path.join(itemDir, `${downloaded}.gif`);
+                try {
+                    await downloadFile(urls[i], dest);
+                    const size = fs.statSync(dest).size;
+                    if (size < 1000) {
+                        // Too small, probably an error
+                        fs.unlinkSync(dest);
+                        continue;
+                    }
+                    console.log(`   ✅ ${downloaded}.gif (${(size / 1024).toFixed(1)}KB)`);
+                    downloaded++;
+                } catch (e) {
+                    console.log(`   ❌ Failed to download: ${e.message}`);
+                }
+            }
+            if (downloaded === 0) {
+                console.log(`   ⚠ No GIFs downloaded for ${dir}`);
+            }
+        } catch (e) {
+            console.log(`   ❌ Search failed: ${e.message}`);
+        }
+    }
+
+    console.log('\n🎉 GIF download complete!');
+
+    // Summary
+    let total = 0;
+    for (const dir of Object.keys(SEARCH_MAP)) {
+        const itemDir = path.join(GIFS_DIR, dir);
+        const count = fs.existsSync(itemDir) ? fs.readdirSync(itemDir).filter(f => f.endsWith('.gif')).length : 0;
+        total += count;
+        console.log(`   ${dir}: ${count} GIFs`);
+    }
+    console.log(`   Total: ${total} GIFs`);
+}
+
+main().catch(e => {
+    console.error('Fatal error:', e.message);
+    process.exit(0); // Don't fail the build
+});

utils/chatEarn.js

@@ -0,0 +1,35 @@
+/**
+ * Auto-earn money for chatting in groups.
+ * Max $1000 per day per user, small random amount per message.
+ */
+const User = require('../models/User');
+
+const MAX_DAILY = 1000;
+const MIN_PER_MSG = 1;
+const MAX_PER_MSG = 15;
+
+async function processChatEarn(userId) {
+    try {
+        let user = await User.findOne({ userId });
+        if (!user) user = await User.create({ userId });
+        if (user.blacklisted) return;
+
+        const today = new Date().toISOString().split('T')[0];
+
+        if (user.lastChatEarnDate !== today) {
+            user.lastChatEarnDate = today;
+            user.chatEarnedToday = 0;
+        }
+
+        if (user.chatEarnedToday >= MAX_DAILY) return;
+
+        const earn = Math.floor(Math.random() * (MAX_PER_MSG - MIN_PER_MSG + 1)) + MIN_PER_MSG;
+        const actual = Math.min(earn, MAX_DAILY - user.chatEarnedToday);
+
+        user.wallet += actual;
+        user.chatEarnedToday += actual;
+        await user.save();
+    } catch (e) {}
+}
+
+module.exports = { processChatEarn };