Video summary

Solana Memecoin Sniper in Python: Real-Time Telegram Alerts & Quick Profits! #solana #sniperbot #sol

Main summary

Key takeaways

Technology

Summary of the Video (Technological Concepts, Features, Guides/Tutorials)

The video demonstrates building a Solana “sniper” trading bot in Python designed to catch new liquidity pools on Raydium quickly. When a new pool appears, the bot:

  1. Detects pool creation in near real time using Helius WebSocket logs
  2. Retrieves transaction details to identify the token mint
  3. Optionally runs a “rug check” (safety screening)
  4. Queries Dexscreener for real-time token metrics (e.g., price, liquidity, market cap, social links)
  5. Sends a Telegram alert containing token information and links (including chart/buy links)
  6. Lets the user buy immediately using Nova (Telegram trading flow)

The creator emphasizes live demos, showing the bot detecting new Raydium pools, fetching token data, and sending Telegram messages quickly (claimed: within a few seconds of launch).

Product/Feature Analysis: How the Bot Works

Real-Time Detection

  • Uses Python with a WebSocket connection to Helius
  • Subscribes to logs tied to Raydium’s program ID
  • Treats relevant log events as new liquidity pool events

Transaction + Token Discovery

  • Retrieves the transaction signature as a “fingerprint”
  • Attempts multiple times (retries) to collect the token mint address, since data may not be instantly finalized
  • Examines transaction accounts to determine the token mint involved

Safety (“Rug”) Screening (Configurable)

  • If enabled, the bot performs a screening step that may consult external blacklists/suspicion sources

  • Filters are configured in config.py, including checks related to:

    • Mint authority (whether creators can mint more tokens)
    • Freeze authority (whether creators can freeze transfers)
    • Top holder concentration (threshold % of supply)
    • Minimum liquidity requirements (example: $20,000)
    • Whether to skip/allow tokens flagged by external databases
    • Blocklists by token name/symbol
    • Minimum number of markets / other gating criteria

  • If Dexscreener fails to index the token after retries, the bot discards the attempt and continues monitoring

Token Metrics Enrichment

  • Queries Dexscreener for:
    • Price
    • Market cap
    • Total liquidity
    • Social links
  • Includes actionable links in the Telegram message (chart link and possibly a “buy via Nova” link)

Codebase Structure (Modules/Files)

The video breaks the bot into multiple Python files:

  • main.py

    • Orchestrator
    • Sets up Helius WebSocket
    • Subscribes to Raydium-related logs
    • Calls routines to fetch token data, run checks, query Dexscreener, and send Telegram messages

  • config.py

    • Loads environment variables/settings
    • Defines risk-selective behavior (rug-check toggles + filter thresholds)

  • env_validator.py (auto-subtitle spelling varies, but described as this)

    • Validates required environment variables on startup
    • Stops the bot with clear errors if missing/misconfigured (e.g., Helius URI, Telegram credentials)

  • telegram.py

    • Builds and sends Telegram API calls
    • Uses an HTML-parsable message format (e.g., bold, line breaks)
    • Logs errors if Telegram credentials are wrong or the server fails

  • transactions.py

    • Handles the heavy lifting after an event:
      • Fetches transaction details (with retries/delays)
      • Extracts token mint address
      • Runs optional blacklist/suspicion checks
      • Queries Dexscreener (with retries)
      • Returns data to main.py to compose the Telegram alert

Step-by-Step Guide Included in the Video

1) Telegram Setup (Bot + Chat/Channel IDs)

  • Create a Telegram bot via BotFather (e.g., /start and a command-based creation flow)
  • Copy and save the bot token
  • Obtain chat/group ID using a “get chat ID” script/file (expects JSON output with the ID)
  • Create a Telegram Channel
  • Add the bot as a subscriber and grant admin permissions so it can post alerts

2) Helius Setup (API Endpoints)

  • Sign up to Helius
  • Copy an API key from the endpoints page
  • Paste it into the bot’s .env file for multiple Helius endpoints

3) Install Python + Dependencies

Install required libraries (examples mentioned):

  • websocket-client
  • requests
  • arrow
  • python-dotenv (noted in subtitles as python. EnV)

4) Run the Bot

  • Start main.py
  • Confirm it subscribed to Raydium program logs
  • Watch for Telegram alerts when new tokens/pools are detected

Nova Trading Flow (How Alerts Turn Into Trades)

After receiving a token alert in Telegram, the creator explains buying through Nova:

  • Click “Buy via Nova” from Telegram
  • Nova flow includes:
    • Creating/using a Nova account
    • Getting a Solana wallet address
    • Viewing/storing a private key / seed phrase (highly sensitive; store securely offline)
    • Funding the wallet with SOL to trade

In Nova:

  • View token metrics: price, liquidity, market cap
  • Security indicators:
    • Contract ownership status (renounced or not)
    • Freeze behavior
    • Minting capability
  • Set slippage tolerance
  • Buy by entering the SOL amount to trade (“XA option” described)
  • Sell later using 100% sell or percentage options
  • Confirm profit/loss expectations

Trading Risk/Analysis Claims Emphasized

  • The creator states most memecoins are scams and warns against greed
  • Recommends taking modest profits quickly (examples: ~10–20%)
  • Notes trading fees:
    • Nova charges ~1% per trade
    • Suggests profits may need to exceed ~2% to cover buy + sell fees

Caution: The video’s claims emphasize risk and caution, especially for memecoins.

Additional Promotional/Overlay Content (Non-Technical)

  • Giveaway: $100 worth of Solana to one winner, plus another $100 worth of “quaca coin” to a second winner
  • Courses: mentions algo/automation trading education (crypto automation via chat GPT and Forex algo trading)
  • Bot access claim: ties access to holding/obtaining “quaca coin” (roughly $20+), sending a wallet, and messaging the creator to receive the bot

Main Speakers / Sources

Primary Speaker

  • The YouTube channel creator who narrates the build, setup steps, and live trading demo

Technical Sources Used by the System

  • Helius: Solana data provider via WebSocket logs
  • Raydium: liquidity pools / program ID events
  • Dexscreener: token metrics and indexing
  • Telegram BotFather + Telegram Bot API: delivering alerts
  • Nova: trading/buy flow inside Telegram

Original video