pump-time-vli

An open-source Pump.fun sniper that uses Time × Volume × Liquidity to exit, not fixed % take-profits. Paper-trading by default. Burner wallet recommended. Not financial advice. Inspired by a widely discussed r/solana thread about a high-frequency wallet using time-windowed exits tied to liquidity and trade activity.

---

⬇️ Downloads

Latest binaries (signed, with SHA256):

SHA256

SHA256

SHA256

Verify checksums before running: shasum -a 256 <file>

---

Table of contents

• Why
• Features
• How it works
• Installation
• Configuration
• Usage
• Strategy (Time × Volume × Liquidity)
• Safety
• Roadmap
• FAQ
• Related open-source work
• References
• License

---

Why

Fixed % TPs on newborn Pump.fun tokens are a great way to bleed out (see the Reddit OP who burned 2 SOL doing exactly that). The wallet discussed there appears to profit by entering around the dev’s first buy and exiting with time-windowed, volume/liquidity-aware skims and trails, not one-size-fits-all targets. This repo implements a minimal, auditable version of that time × volume × liquidity approach so the community can test and iterate openly.

---

Features

• Low-latency signals from PumpPortal WebSocket: subscribeNewToken, subscribeAccountTrade (creator/dev), and subscribeMigration.
• One-call trade execution on the Pump curve or Raydium via PumpPortal Lightning API (with simulation + Jito relay usage under the hood). Optionally sign locally via the Local Transaction API.
• Post-migration routing via Jupiter Swap API v6 (or self-host it for control/rate limits).
• Market data for price/volume/liquidity via Birdeye WebSocket subscriptions (new listings, base/quote price, wallet txs).
• Jito “fast landing” and bundles for better fills in races.
• Optional Helius enhanced websockets / LaserStream gRPC for ultra-low-latency redundancy.
• Pre-trade rug checks via RugCheck API gate.
• Paper-trading mode by default with structured logs for analysis.

---

How it works

1. Detect → Listen for new token events, derive creator address, and watch creator (dev) first buy; gate the opportunity with RugCheck and minimal activity checks.
2. Enter → If passed, submit a Lightning buy with a priority fee; optionally use Jito (bundles / private relays) to improve landing.
3. Track → On migration, attach Raydium pool metadata; stream price/volume via Birdeye.
4. Exit → Apply epoch-based trailing floors and liquidity-aware skims; use Jupiter or direct Raydium route depending on quote.

---

Installation

Option A — Binaries

Download your OS build above, verify SHA256, unzip/tar, then run the executable.

Option B — From source

git clone https://github.com/pmpfn/pump-time-vli.git

# Create virtual environment
uv sync

# Activate (Unix/macOS)
source .venv/bin/activate  

# Activate (Windows)
.venv\Scripts\activate

# Copy example config
cp .env.example .env  # Unix/macOS

# Windows
copy .env.example .env

uv pip install -e .

uv run src/bot_runner.py

---

Configuration

Edit .env:

# Trading + data
PUMPPORTAL_API_KEY=...
PUMPPORTAL_WALLET=...               # if using Lightning wallet setup
RPC_HELIUS_URL=...                  # optional redundancy

# Market data / routing
BIRDEYE_API_KEY=...
JUPITER_API_KEY=...                 # optional (public works but rate-limited)

# Risk
RUGCHECK_API_KEY=...

# Execution tuning
JITO_BLOCK_ENGINE=https://mainnet.block-engine.jito.wtf/api/v1/bundles
PRIORITY_FEE_SOL=0.00005

# Positioning
MAX_POSITION_SOL=0.02
LIVE=0                                # 0=paper, 1=live

• PumpPortal provides Lightning wallet + API key generation and a Local Transaction API if you prefer local signing.
• Birdeye requires an API key for WS.
• Jito uses the block engine endpoint for bundles/low-latency sends.

---

Usage

# Paper-trading with console dashboard & logs
pnpm dev

# Live trading (requires LIVE=1 and funded wallet)
pnpm live

Modes

• Paper: All orders simulated, full decision logs for post-mortem.
• Live: Explicit opt-in (LIVE=1), hard caps from .env enforced.

---

Strategy (Time × Volume × Liquidity)

• Entry

  • Only consider a token if the creator/dev buys within N seconds of creation (default: 20s), RugCheck passes, and early trade activity exceeds a minimal threshold.

• Epochs & exits

  • Split hold time into epochs: T0 (0–30s), T1 (30–120s), T2 (2–10m), T3 (10–60m), T4 (>1d).
  • Trailing floors tighten early, loosen later (e.g., 35% → 45% → 55–65%).
  • Skims at multiples (e.g., 2×/3×/5×) gated by trade count & realized volume.
  • Liquidity-aware sizing: don’t dump more than a small % of 24h vol or available pool liquidity on Raydium.

• Forced exit on rug signals, dev mass-sell, or pool liquidity collapse.

• Routing: After migration, prefer Jupiter but fall back to direct Raydium if quotes route worse.

This mirrors the thread’s core insight that fixed TPs underperform versus time/volume/liquidity-aware exits on newborns.

---

Safety

• Burner wallet only.
• Paper first.
• RugCheck gate on.
• No promises: newborn memecoins are highly path-dependent and adversarial.

---

Roadmap

• Liquidity-sensitive exit sizing (Raydium pool depth heuristics).
• Self-hosted Jupiter v6 for deterministic routing and independence.
• Helius LaserStream integration for even lower signal latency.
• Web UI dashboard (PnL distribution, hold-time histograms, per-epoch ROI).
• Copy-trading module (paper-follow first, guarded live later).

---

FAQ

Q: Why PumpPortal instead of rolling raw transactions only? A: It gives you battle-tested transaction building and Lightning sending with private/public Jito relays—great for prototyping. You can still switch to Local Transaction API + your own RPC as you harden.

Q: Does this guarantee early fills vs everyone else? A: No. You’re competing with faster infra and better tips. Use priority fees and Jito bundles to improve landing; don’t expect miracles.

Q: Can I run without Birdeye? A: You can, but you’ll lose an easy WS feed for price/volume/listings; you’ll need to stitch your own streams.

---

Related open-source work

• Chainstack pumpfun/bonkfun bot (educational, listeners & migrations).
• 1fge/pump-fun-sniper-bot (Go; bonding curve, Jito patterns; archived but instructive).
• L9T-Development/Pumpfun-Sniper-Bot (TypeScript; gRPC to Pump AMM).
• cutupdev/Solana-Pumpfun-Sniper-Bot (Rust; performance-oriented).

These mostly use fixed TP/SL or simple timeouts; your differentiator here is a clean, testable time × volume × liquidity exit machine.

---

License

MIT—see LICENSE. No warranty. This project does not constitute financial advice.