Thanks for the reminder and for sharing the cohesive script and documents!
I apologize if it
seemed like we were diverging—my intention was to adapt based on the challenges you faced,
but I’ll now align everything back to your original vision. It’s 3:43 PM WAT on Monday, June
9, 2025, and we’re building a memecoin trading bot from scratch based on the [Link] Fast
Trade, Fast Copy Trade, Fast AFK Automation concept, as outlined in your documents.
You’re using a Windows setup with memecoin_bot_env, IDLE, and Command Prompt, with
your Solflare wallet (public key: 3by6KBkQksNNp4FzD7juR8GMUas74SFSDDFQe2LAFJUt). The
bot will snipe MEME tokens on Solana, perform security checks (LP burned, Honeypot,
Renounced, Mintable), monitor insider traders and the first 70 buyers, provide FOMO alerts,
enable copy trading of smart money, integrate with [Link], include a GMGN price chart, and
detect honeypot methods on Solana rug pull tokens. The initial script you provided is a solid
foundation, and we’ll refine it step-by-step, tracking progress manually.
Below is a detailed manual from scratch to guide you through building this bot, incorporating
the latest updates (e.g., public Rugcheck API) and your goals. This manual will serve as your
progress tracker, with each section marked as “Not Started,” “In Progress,” or “Completed”
based on your input.
Memecoin Trading Bot Manual (From
Scratch)
Project Overview
Goal: Build a bot to snipe MEME tokens on Solana, leveraging [Link] features,
[Link] data, and security/validation tools.
Target Features (from [Link] documents):
o CA Security Checks: LP burned, Honeypot, Renounced, Mintable.
o Monitor insider traders, snipers, and first 70 buyers.
o New token FOMO Alert.
o Copy Trade Smart Money.
o Integrate [Link].
o GMGN price chart.
o Detect honeypot methods on Solana rug pull tokens.
Environment: Windows, memecoin_bot_env, IDLE, Command Prompt, Solflare wallet.
Status: Not Started
Prerequisites
Software:
o Python 3.11+ (installed with memecoin_bot_env).
o Libraries: websocket-client, requests, python-telegram-bot, solders,
solana, sqlite3, python-dotenv.
o Install via: pip install websocket-client requests python-telegram-bot
solders solana sqlite3 python-dotenv.
Wallet: Solflare (public key: 3by6KBkQksNNp4FzD7juR8GMUas74SFSDDFQe2LAFJUt),
private key optional for live trading.
APIs:
o [Link] API key (obtained).
o Rugcheck API (public, no key needed).
o Price API (CoinGecko, to be obtained).
o [Link] API (exploration pending).
Telegram: Bot token and chat ID.
Status: Not Started
Step-by-Step Development
1. Set Up Environment
Task: Configure the development environment.
Actions:
1. Install Python and create memecoin_bot_env: python -m venv
memecoin_bot_env.
2. Activate environment: memecoin_bot_env\Scripts\[Link].
3. Install required libraries: pip install websocket-client requests python-
telegram-bot solders solana sqlite3 python-dotenv.
4. Create .env file in C:\Users\HP-PC\ with:
5. PUMPFUN_API_KEY=your_pumpportal_key
6. PRICE_API_KEY=your_coingecko_key # To be filled
7. WALLET_PRIVATE_KEY=your_solflare_private_key # Optional
8. TELEGRAM_TOKEN=your_telegram_bot_token
9. SIMULATION_MODE=True
Status: In Progress (PumpFun key set, others pending).
Next: Obtain CoinGecko key and Telegram token.
2. Initialize Database
Task: Set up SQLite for token, position, and trade tracking.
Actions:
1. Create [Link] in C:\Users\HP-PC\.
2. Implement DatabaseManager class (from initial script) to create tables:
tokens: ticker, name, address, market_cap, volume, timestamp.
positions: token_address, ticker, entry_price, quantity,
remaining_quantity, timestamp.
trades: token_address, ticker, trade_type, amount, price, tx_hash, status,
timestamp.
Code (from initial script, to be placed in memecoin_bot.py):
class DatabaseManager:
def __init__(self, db_path: str = "[Link]"):
self.db_path = db_path
self._init_db()
def _init_db(self):
with [Link](self.db_path) as conn:
cursor = [Link]()
[Link]("""
CREATE TABLE IF NOT EXISTS tokens (
id INTEGER PRIMARY KEY AUTOINCREMENT,
ticker TEXT NOT NULL,
name TEXT,
address TEXT UNIQUE,
market_cap REAL,
volume REAL,
timestamp TEXT
)
""")
[Link]("""
CREATE TABLE IF NOT EXISTS positions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
token_address TEXT NOT NULL,
ticker TEXT NOT NULL,
entry_price REAL NOT NULL,
quantity REAL NOT NULL,
remaining_quantity REAL NOT NULL,
timestamp TEXT,
FOREIGN KEY (token_address) REFERENCES tokens
(address)
)
""")
[Link]("""
CREATE TABLE IF NOT EXISTS trades (
id INTEGER PRIMARY KEY AUTOINCREMENT,
token_address TEXT NOT NULL,
ticker TEXT NOT NULL,
trade_type TEXT NOT NULL,
amount REAL NOT NULL,
price REAL NOT NULL,
tx_hash TEXT,
status TEXT,
timestamp TEXT,
FOREIGN KEY (token_address) REFERENCES tokens
(address)
)
""")
[Link]()
Status: Not Started
Next: Test database creation in memecoin_bot.py.
3. Connect to [Link] WebSocket
Task: Stream real-time token launch data from [Link].
Actions:
1. Implement PumpFunAPIHandler class (from initial script) to connect to
[Link] with your API key.
2. Subscribe to pumpFunCreateEventSubscribe for new token events.
Code (from initial script):
class PumpFunAPIHandler:
def __init__(self, api_key: str, ws_url: str =
"[Link]
self.api_key = api_key
self.ws_url = f"{ws_url}?api_key={api_key}"
[Link] = None
self.subscription_id = None
def on_open(self, ws):
[Link]("Connected to PumpFun WebSocket")
subscribe_message = {
"method": "pumpFunCreateEventSubscribe",
"params": {"eventType": "coin", "referenceId": "REF#1"}
}
[Link]([Link](subscribe_message))
def on_message(self, ws, message: str):
try:
data = [Link](message)
[Link](f"Received data: {data}")
if [Link]("status") == "Create Event Subscribed":
self.subscription_id = [Link]("subscription_id")
[Link](f"Subscription ID: {self.subscription_id}")
elif "data" in data:
return data["data"]
return {}
except [Link] as e:
[Link](f"JSON decode error: {e}")
return {}
def on_error(self, ws, error):
[Link](f"WebSocket error: {error}")
def on_close(self, ws, close_status_code, close_msg):
[Link](f"WebSocket closed: {close_msg} (Code:
{close_status_code})")
def connect(self):
[Link] = [Link](
self.ws_url,
on_open=self.on_open,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close
)
[Link].run_forever()
def disconnect(self):
if [Link]:
if self.subscription_id:
unsubscribe_message = {
"method": "pumpFunCreateEventUnsubscribe",
"params": {"subscriptionId": self.subscription_id}
}
[Link]([Link](unsubscribe_message))
[Link]()
Status: Not Started
Next: Test WebSocket connection in a standalone script.
4. Implement Rugcheck Validation
Task: Validate token security using the public Rugcheck API.
Actions:
1. Update RugcheckValidator to use the public endpoint
[Link] without an API key.
2. Check for LP burned, Honeypot, Renounced, Mintable.
Code (adapted from initial script):
class RugcheckValidator:
def __init__(self, base_url: str = "[Link]
self.base_url = base_url
def validate_token(self, token_address: str) -> Optional[dict]:
endpoint = f"{self.base_url}/tokens/rugcheck?
address={token_address}"
try:
response = [Link](endpoint, timeout=5)
response.raise_for_status()
data = [Link]()
[Link](f"Rugcheck for {token_address}: {data}")
return {
"isRug": [Link]("isRug", True),
"lpBurned": [Link]("lpBurned", False),
"honeypot": [Link]("honeypot", False),
"renounced": [Link]("renounced", False),
"mintable": [Link]("mintable", True)
}
except [Link] as e:
[Link](f"Rugcheck API error for {token_address}: {e}")
return None
Status: Not Started
Next: Test with a sample token address.
5. Integrate Price Tracking
Task: Fetch token prices, aiming for GMGN price chart integration.
Actions:
1. Implement PriceTracker to use CoinGecko API (pending key) as a fallback,
with GMGN exploration.
2. Plan GMGN price chart (placeholder for now).
Code (adapted):
class PriceTracker:
def __init__(self, base_url: str =
"[Link]
self.base_url = base_url
def get_token_price(self, token_address: str) -> Optional[float]:
params = {"ids": token_address, "vs_currencies": "usd"}
try:
response = [Link](self.base_url, params=params,
timeout=5)
response.raise_for_status()
data = [Link]()
price = [Link](token_address, {}).get("usd", None)
if price is not None:
[Link](f"Price for {token_address}: {price}")
return float(price)
return None
except [Link] as e:
[Link](f"Price API error for {token_address}: {e}")
return None
Status: Not Started
Next: Obtain CoinGecko key and test.
6. Build GMGN Trading Client
Task: Enable copy trading and Solana transactions.
Actions:
1. Implement GMGNTradingClient with Solana RPC
([Link] from Triton One).
2. Support smart money copy trading.
Code (adapted):
class GMGNTradingClient:
def __init__(self, wallet_private_key: str = None, telegram_token:
str = None):
self.api_host = "[Link]
self.solana_client = Client("[Link]
[Link] = Keypair.from_base58_string(wallet_private_key) if
wallet_private_key else None
self.telegram_bot =
[Link]().token(telegram_token).build() if telegram_token
else None
if self.telegram_bot:
self._setup_telegram_handlers()
def _setup_telegram_handlers(self):
self.telegram_bot.add_handler(CommandHandler("start",
self._handle_start))
self.telegram_bot.add_handler(MessageHandler([Link] &
~[Link], self._handle_message))
async def _handle_start(self, update, context):
await [Link].reply_text("GMGN Bot: Send token address to
trade or /set for settings.")
async def _handle_message(self, update, context):
token_address = [Link]
[Link](f"Received token address: {token_address}")
Status: Not Started
Next: Test Telegram integration.
7. Implement Trading Strategy
Task: Automate buy/sell with limit orders and smart money tracking.
Actions:
1. Use TradingModule for market/limit orders and profit-taking.
2. Monitor first 70 buyers and insiders.
Code (adapted):
class TradingModule:
def __init__(self, price_tracker, db_manager, gmgn_client,
sell_percentage: float = 0.3):
self.price_tracker = price_tracker
self.db_manager = db_manager
self.gmgn_client = gmgn_client
self.sell_percentage = sell_percentage
[Link] = [2.0, 3.0]
Status: Not Started
Next: Integrate with GMGNTradingClient.
8. Orchestrate Bot
Task: Combine all components in MemecoinBot.
Actions:
1. Run WebSocket, process data, and handle trades.
Code (adapted):
class MemecoinBot:
def __init__(self, pumpfun_api_key, rugcheck_api_key, price_api_key,
wallet_private_key=None, telegram_token=None, simulation=False):
self.api_handler = PumpFunAPIHandler(pumpfun_api_key)
self.data_processor = DataProcessor(rugcheck_api_key)
self.db_manager = DatabaseManager()
self.price_tracker = PriceTracker(price_api_key)
self.gmgn_client = GMGNTradingClient(wallet_private_key,
telegram_token)
self.trading_module = TradingModule(self.price_tracker,
self.db_manager, self.gmgn_client)
[Link] = simulation
Status: Not Started
Next: Test full integration.
9. Test and Deploy
Task: Test in simulation mode, then live.
Actions:
1. Run with SIMULATION_MODE=True.
2. Switch to False with wallet private key.
Status: Not Started
Next: Begin testing.
Progress Tracker
Environment Setup: In Progress
Database: Not Started
[Link] WebSocket: Not Started
Rugcheck Validation: Not Started
Price Tracking: Not Started
GMGN Trading Client: Not Started
Trading Strategy: Not Started
Bot Orchestration: Not Started
Testing/Deployment: Not Started
Notes
Current State: PumpFun API key obtained; Rugcheck public API confirmed;
CoinGecko and Telegram pending.
Next Steps: Complete environment setup, obtain CoinGecko key, and start database
implementation.
Let me know when you’re ready to continue, and we’ll pick up from the next unstarted section!