How To Build Your Solana Sniper Bot (4)????????

pip install python-telegram-bot 

npm install node-telegram-bot-api 

from telegram import Update 
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, CallbackContext 
 
# Replace 'YOUR_BOT_TOKEN' with the token you received from BotFather 
BOT_TOKEN = 'YOUR_BOT_TOKEN' 
 
# Define a start command handler 
def start(update: Update, context: CallbackContext): 
    update.message.reply_text('Hello! I am your Telegram bot. How can I assist you?') 
 
# Define a help command handler 
def help(update: Update, context: CallbackContext): 
    update.message.reply_text('Here are the commands you can use:\n/start - Start the bot\n/help - Get help') 
 
# Define a function to echo user messages 
def echo(update: Update, context: CallbackContext): 
    update.message.reply_text(update.message.text) 
 
def main(): 
    # Initialize the Updater with your bot token 
    updater = Updater(BOT_TOKEN, use_context=True) 
 
    # Get the dispatcher to register handlers 
    dp = updater.dispatcher 
 
    # Register command handlers 
    dp.add_handler(CommandHandler("start", start)) 
    dp.add_handler(CommandHandler("help", help)) 
 
    # Register a message handler to echo messages 
    dp.add_handler(MessageHandler(Filters.text & ~Filters.command, echo)) 
 
    # Start the bot 
    updater.start_polling() 
    updater.idle() 
 
if __name__ == '__main__': 
    main() 

python my_bot.py 

updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=BOT_TOKEN) 
updater.bot.set_webhook(f"https://yourdomain.com/{BOT_TOKEN}") 

npm install typescript ts-node @solana/web3.js axios dotenv bs58 fs mongoose node-telegram-bot-api 

{ 
  "name": "solana-sniper-bot", 
  "version": "1.0.0", 
  "description": "", 
  "main": "index.js", 
  "scripts": { 
    "start": "ts-node index.ts", 
    "build": "tsc", 
    "clean": "tsc --build --clean", 
    "dev": "tsc && node ./dist/index.js" 
  }, 
  "author": "", 
  "license": "ISC", 
  "dependencies": { 
    "@solana/web3.js": "^1.98.0", 
    "axios": "^1.8.1", 
    "bs58": "^6.0.0", 
    "dotenv": "^16.4.7", 
    "fs": "^0.0.1-security", 
    "mongoose": "^8.10.1", 
    "node-telegram-bot-api": "^0.66.0", 
    "typescript": "^5.7.3" 
  }, 
  "devDependencies": { 
    "@types/node": "^22.13.5", 
    "@types/node-telegram-bot-api": "^0.64.7", 
    "ts-node": "^10.9.2" 
  } 
} 
 

{ 
  "compilerOptions": { 
    "target": "es2016", 
    "module": "commonjs", 
    "outDir": "./dist", 
    "esModuleInterop": true, 
    "forceConsistentCasingInFileNames": true, 
    "strict": true, 
    "skipLibCheck": true 
  } 
} 

TELEGRAM_BOT_TOKEN="" 
BIRDEYE_API_KEY="" 
SOLANA_RPC_URL="" 
BOT_WALLET_PUBLIC_KEY="" 

import TelegramBot from "node-telegram-bot-api"; 
import { connectDatabase } from "./config/db"; 
import { addUser, getUserById } from "./service/userService"; 
import { IK_START, getIKSnipe } from "./components/inlineKeyboard"; 
import { messageHandler } from "./bot/message.handler"; 
import { callbackQueryHandler } from "./bot/callbackquery.handler"; 
import fs from "fs"; 
 
import dotenv from "dotenv"; 
 
dotenv.config(); 
 
const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN; 
 
const BotMenu = [ 
  { 
    command: "start", 
    description: "???? Start", 
  }, 
  { 
    command: "setting", 
    description: "⚙️ setting", 
  }, 
  { 
    command: "position", 
    description: "???? Position", 
  }, 
  { 
    command: "referral", 
    description: "???? Referral Stats", 
  }, 
  { command: "help", description: "❓ Help" }, 
]; 
 
const bot = new TelegramBot(TELEGRAM_BOT_TOKEN!, { 
  polling: true, 
  webHook: false, 
  onlyFirstMatch: true, 
  filepath: false, 
}); 
 
const userSnipeConfig = new Map(); 
 
const startBot = () => { 
  // Connect Database 
  connectDatabase(); 
 
  bot.setMyCommands(BotMenu); 
 
  bot.onText(/^\/start$/, async (msg: TelegramBot.Message) => { 
    console.log("???? input start cmd:"); 
 
    const chatId = msg.chat.id; 
    let user; 
    const existingUser = await getUserById(chatId); 
    if (existingUser) { 
      console.log("User already exist: ", chatId); 
      user = existingUser; 
    } 
    else { 
      console.log("New User: ", chatId); 
 
      const userChat = msg.chat; 
      user = await addUser({ 
        chat_id: userChat.id, 
        username: userChat.username, 
        first_name: userChat.first_name, 
        last_name: userChat.last_name 
      }); 
    } 
 
    // Snipe Config Init 
    let snipe_config:any = { 
      token: null, 
      slippage: 50, 
      snipe_fee: 0.005, 
      snipe_tip: 0.005, 
      tp: null, 
      sl: null, 
      snipe_amount: null, 
    }; 
 
    userSnipeConfig.set(chatId, snipe_config); 
 
    const image = fs.createReadStream("./public/sniper.jpg"); 
    const caption = `Welcome to <b>Lucky Sniper</b> Bot!✨\n⬇You can deposit SOL to your wallet and start sniping!????\n\n????Your Wallet:\n<code>${user.public_key}</code>`; 
    await bot.sendPhoto(msg.chat.id, image, { 
      parse_mode: "HTML", 
      caption: caption, 
      reply_markup: { 
        inline_keyboard: IK_START, 
      }, 
    }); 
  }); 
 
  bot.onText(/^\/snipe/, async (msg: TelegramBot.Message) => { 
 
  }); 
 
  bot.on("message", (msg: TelegramBot.Message) => { 
    console.log("message handler"); 
    messageHandler(bot, msg, userSnipeConfig); 
  }); 
 
  bot.on("callback_query", async (cb_query: TelegramBot.CallbackQuery) => { 
    console.log("callback_query handler"); 
    callbackQueryHandler(bot, cb_query, userSnipeConfig); 
  }); 
}; 
 
startBot(); 
 

export const BOT_FEE_PERCENT = 1; // 1% 
 
export enum BotCaption { 
  strInputTokenAddress = `???? Enter Token Address`, 
  strInvalidSolanaTokenAddress = `⚠️ Invalid Solana Token Address! Again enter correct Token Address!`, 
  strInputSwapSolAmount = `???? Enter Swap SOL Amount`, 
  strInvalidSolAmount = `⚠️ Invalid Swap SOL Amount ⚠️`, 
  HelpCaption = `???? TG Solana Trading Bot ????`, 
  strWelcome = `<b>Welcome to Solana Trading bot</b> ????\n`, 
  SET_PRIORITY_FEE = `???? Priority Fee SOL Amount \n\n<i>???? Enter SOL Value in format "0.0X"</i>`, 
  SET_JITOTIP = `???? Jito Tip SOL Amount \n\n<i>???? Enter SOL Value in format "0.0X"</i>`, 
  SET_SNIPE_AMOUNT = `???? Snipe Amount \n\n<i>???? Enter Snipe Amount in format "0.0X"</i>`, 
  SET_SLIPPAGE = `⚖ Slippage \n\n<i>???? Enter Slippage in format "xx%"</i>`, 
  SET_TakeProfit = `⚖ Take Profit \n\n<i>???? Enter Take Profit in format "xx%"</i>`, 
  SET_StopLoss = `⚖ Stop Loss \n\n<i>???? Enter Stop Loss in format "xx%"</i>`, 
  strInvalidInput = `⚠️ Invalid Input ⚠️`, 
  SET_PK = `???? Private KEY \n\n<i>???? Enter Wallet Private KEY</i>`, 
  SET_DES = `⚙ User Setting.\nYou can set any settings on here. You can set any settings on here.`, 
  SWAP_FAILED = `⚠️ Swap Failed ⚠️`, 
  SNIPE_CONFIG_FAILED = `⚠️ Snipe Configuration Failed ⚠️`, 
  AUTO_SWAP_ON = "???? Auto Swap ON", 
  AUTO_SWAP_OFF = "???? Auto Swap OFF", 
  strAlreadyRefer = `???? You have already referred a friend.`, 
  strReferSuccess = `???? You have successfully referred a friend.`, 
  strInvalidReferUser = `⚠️ Invalid User ⚠️`, 
} 

import { getShortenedCA } from "../utils/utils"; 
 
// Start Inline Keyboard 
export const IK_START = [ 
  [ 
    { 
      text: "???? Buy", 
      callback_data: "BUY", 
    }, 
    { 
      text: "???? Sell", 
      callback_data: "SELL", 
    }, 
  ], 
  [ 
    { 
      text: "⚙ Settings", 
      callback_data: "SETTINGS", 
    }, 
  ], 
  [ 
    { 
      text: "???? Snipe", 
      callback_data: "SNIPE_SETTINGS", 
    }, 
  ], 
]; 
 
// Snipe Inline Keyboard 
export function getIKSnipe({ 
  token = null, 
  slippage = 50, 
  snipe_fee = 0.005, 
  snipe_tip = 0.005, 
  tp = null, 
  sl = null, 
  snipe_amount = null, 
}: { 
  token: string | null; 
  slippage: number; 
  snipe_fee: number; 
  snipe_tip: number; 
  tp: number | null; 
  sl: number | null; 
  snipe_amount: number | null; 
}): any { 
  const IK_SNIPE = [ 
    [ 
      { 
        text: "???? Back", 
        callback_data: "BACK", 
      }, 
      { 
        text: "???? Refresh", 
        callback_data: "REFRESH", 
      }, 
    ], 
    [ 
      { 
        text: `${token ? "????" : "????"} Token: ${ 
          token ? getShortenedCA(token) : "---" 
        }`, 
        callback_data: `TOKEN-${token}`, 
      }, 
    ], 
    [ 
      { 
        text: `Snipe Fee: ${snipe_fee} SOL`, 
        callback_data: `SNIPE_FEE-${snipe_fee}`, 
      }, 
      { 
        text: `Snipe Tip: ${snipe_tip} SOL`, 
        callback_data: `SNIPE_TIP-${snipe_tip}`, 
      }, 
    ], 
    [ 
      { 
        text: `Slippage: ${slippage}%`, 
        callback_data: `SLIPPAGE-${slippage}%`, 
      }, 
    ], 
    [ 
      { 
        text: `${tp ? "????" : "????"} Take Profit(TP): ${tp ? tp : "---"} %`, 
        callback_data: `TP-${tp ? tp : "null"}`, 
      }, 
      { 
        text: `${sl ? "????" : "????"} Stop Loss(SL): ${sl ? sl : "---"} %`, 
        callback_data: `SL-${sl ? sl : "null"}`, 
      }, 
    ], 
    [ 
      { 
        text: `${snipe_amount == 0.2 ? "✅ " : ""}Snipe 0.2 SOL`, 
        callback_data: `SNIPE-0.2`, 
      }, 
      { 
        text: `${snipe_amount == 0.5 ? "✅ " : ""}Snipe 0.5 SOL`, 
        callback_data: `SNIPE-0.5`, 
      }, 
    ], 
    [ 
      { 
        text: `${snipe_amount == 1 ? "✅ " : ""}Snipe 1 SOL`, 
        callback_data: `SNIPE-1`, 
      }, 
      { 
        text: `${ 
          snipe_amount && 
          snipe_amount != 0.2 && 
          snipe_amount != 0.5 && 
          snipe_amount != 1 
            ? "✅ " 
            : "" 
        }Snipe ${snipe_amount ? snipe_amount : "X"} SOL`, 
        callback_data: `SNIPE-${snipe_amount}`, 
      }, 
    ], 
    [ 
      { 
        text: `???? Create a snipe`, 
        callback_data: `CREATE_SNIPE`, 
      }, 
    ], 
    [ 
      { 
        text: `???? Created Snipes`, 
        callback_data: `LIST_SNIPE`, 
      }, 
    ], 
  ]; 
 
  return IK_SNIPE; 
} 

import TelegramBot from "node-telegram-bot-api"; 
import fs from "fs"; 
 
export async function sendIKSnipe( 
  bot: TelegramBot, 
  chatId: number, 
  IK_SNIPE: any, 
  caption?: string 
) { 
  const image = fs.createReadStream("./public/sniper.jpg"); 
 
  if (!caption) { 
    caption = `⬇You can create a new snipe or check current active snipes!????`; 
  } 
 
  await bot.sendPhoto(chatId, image, { 
    parse_mode: "HTML", 
    caption: caption, 
    reply_markup: { 
      inline_keyboard: IK_SNIPE, 
    }, 
  }); 
} 

import TelegramBot from "node-telegram-bot-api"; 
import { getUserById, addUser } from "../service/userService"; 
import { getIKSnipe } from "../components/inlineKeyboard"; 
import fs from "fs"; 
import { BotCaption } from "../config/constants"; 
import { sendIKSnipe } from "./botAction"; 
import { addSwap } from "../service/swapService"; 
import { isValidSnipeConfig } from "../utils/utils"; 
import buyToken from "../swap/buy"; 
 
export async function callbackQueryHandler( 
  bot: TelegramBot, 
  cb_query: TelegramBot.CallbackQuery, 
  userSnipeConfig: Map<number, any> 
) { 
  const cb_query_cmd = cb_query.data; 
  const chatId = cb_query.message?.chat.id; 
  const messageId = cb_query.message?.message_id || 0; 
  if (!cb_query_cmd || !chatId) return; 
 
  let user; 
  const existingUser = await getUserById(chatId); 
  if (existingUser) { 
    console.log("User already exist: ", chatId); 
    user = existingUser; 
  } else { 
    console.log("New User: ", chatId); 
    user = await addUser({ 
      chat_id: chatId, 
      username: cb_query.from.username, 
      first_name: cb_query.from.first_name, 
      last_name: cb_query.from.last_name, 
    }); 
  } 
 
  switch (cb_query_cmd.split("-")[0]) { 
    case "SNIPE_SETTINGS": // Snipe Button 
      const snipe_config = userSnipeConfig.get(chatId); 
      console.log("Callback snipe_config: ", snipe_config); 
 
      const IK_SNIPE = getIKSnipe(snipe_config); 
      sendIKSnipe(bot, chatId, IK_SNIPE); 
      break; 
    case "BACK": //Back Button 
      bot.deleteMessage(chatId, messageId); 
      return; 
    case "TOKEN": //Token Button 
      await bot.sendMessage(chatId, BotCaption.strInputTokenAddress, { 
        parse_mode: "HTML", 
        reply_markup: { 
          force_reply: true, 
          selective: true, 
        }, 
      }); 
      break; 
    case "SNIPE_FEE": //Snipe fee Button 
      await bot.sendMessage(chatId, BotCaption.SET_PRIORITY_FEE, { 
        parse_mode: "HTML", 
        reply_markup: { 
          force_reply: true, 
          selective: true, 
        }, 
      }); 
      break; 
    case "SNIPE_TIP": //Snipe tip Button 
      await bot.sendMessage(chatId, BotCaption.SET_JITOTIP, { 
        parse_mode: "HTML", 
        reply_markup: { 
          force_reply: true, 
          selective: true, 
        }, 
      }); 
      break; 
    case "SLIPPAGE": //Slippage Button 
      await bot.sendMessage(chatId, BotCaption.SET_SLIPPAGE, { 
        parse_mode: "HTML", 
        reply_markup: { 
          force_reply: true, 
          selective: true, 
        }, 
      }); 
      break; 
    case "TP": //TP Button 
      await bot.sendMessage(chatId, BotCaption.SET_TakeProfit, { 
        parse_mode: "HTML", 
        reply_markup: { 
          force_reply: true, 
          selective: true, 
        }, 
      }); 
      break; 
    case "SL": //SL Button 
      await bot.sendMessage(chatId, BotCaption.SET_StopLoss, { 
        parse_mode: "HTML", 
        reply_markup: { 
          force_reply: true, 
          selective: true, 
        }, 
      }); 
      break; 
    case "SNIPE": //Snipe-[x] Button 
      const amount = cb_query_cmd.split("-")[1]; 
      if (amount == "0.2" || amount == "0.5" || amount == "1") { 
        const snipe_config = userSnipeConfig.get(chatId); 
        const updated_config = { 
          ...snipe_config, 
          snipe_amount: parseFloat(amount), 
        }; 
        console.log("Message snipe_config: ", updated_config); 
        userSnipeConfig.set(chatId, updated_config); 
        const IK_SNIPE = getIKSnipe(updated_config); 
        sendIKSnipe(bot, chatId, IK_SNIPE); 
      } else { 
        await bot.sendMessage(chatId, BotCaption.SET_SNIPE_AMOUNT, { 
          parse_mode: "HTML", 
          reply_markup: { 
            force_reply: true, 
            selective: true, 
          }, 
        }); 
      } 
      break; 
    case "REFRESH": //Refresh Button 
      // Snipe Config Init 
      const init_snipe_config: any = { 
        token: null, 
        slippage: 50, 
        snipe_fee: 0.005, 
        snipe_tip: 0.005, 
        tp: null, 
        sl: null, 
        snipe_amount: null, 
      }; 
 
      userSnipeConfig.set(chatId, init_snipe_config); 
      const INIT_IK_SNIPE = getIKSnipe(init_snipe_config); 
      sendIKSnipe(bot, chatId, INIT_IK_SNIPE); 
      break; 
    case "CREATE_SNIPE": //Create Snipe Button 
      const completed_snipe_config = userSnipeConfig.get(chatId); 
      const isValid = isValidSnipeConfig(completed_snipe_config); 
      if (isValid) { 
        // buyToken 
        const result = await buyToken( 
          chatId, 
          user.private_key, 
          completed_snipe_config.snipe_amount, 
          completed_snipe_config.token, 
          completed_snipe_config.snipe_fee, 
          completed_snipe_config.slippage 
        ); 
        if (result && result.status == "success") { 
          await bot.sendMessage( 
            chatId, 
            `Success Buy Token!????\nTxID: <code>${result.tx_hash}</code>`, 
            { parse_mode: "HTML" } 
          ); 
        } else { 
          await bot.sendMessage(chatId, "Failed Buy Token!"); 
        } 
        await addSwap(completed_snipe_config, chatId); 
      } else { 
        await