home / skills / jeremylongshore / claude-code-plugins-plus-skills / tracking-token-launches

This skill tracks new token launches across DEXes, analyzes contract risk, and verifies provenance to safeguard investments.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill tracking-token-launches

Review the files below or copy the command above to add this skill to your agents.

Files (12)
SKILL.md
4.8 KB
---
name: tracking-token-launches
description: |
  Track new token launches across DEXes with risk analysis and contract verification.
  Use when discovering new token launches, monitoring IDOs, or analyzing token contracts.
  Trigger with phrases like "track launches", "find new tokens", "new pairs on uniswap",
  "token risk analysis", or "monitor IDOs".

allowed-tools: Read, Write, Edit, Grep, Glob, Bash(python*launch_tracker*)
version: 1.0.0
author: Jeremy Longshore <[email protected]>
license: MIT
---

# Token Launch Tracker

## Overview

Monitor new token launches across decentralized exchanges. Detect PairCreated events from DEX factory contracts, fetch token metadata, and analyze contracts for risk indicators like mint functions, blacklists, proxy patterns, and ownership status.

## Prerequisites

Before using this skill, ensure you have:
- Python 3.8+ with `requests` library
- RPC endpoint access (public endpoints work for basic usage)
- Optional: Etherscan API key for contract verification checks
- Optional: Custom RPC URLs for higher rate limits

## Commands

### recent - Show Recent Launches
```bash
python launch_tracker.py recent --chain ethereum --hours 24
python launch_tracker.py recent --chain base --analyze --limit 20
python launch_tracker.py recent --chain bsc --dex "PancakeSwap V2" -f json
```

Options:
- `--chain, -c`: Chain to scan (ethereum, bsc, arbitrum, base, polygon)
- `--hours, -H`: Hours to look back (default: 24)
- `--dex, -d`: Filter by DEX name
- `--limit, -l`: Maximum results (default: 50)
- `--analyze, -a`: Include token and contract analysis
- `--rpc-url`: Custom RPC URL

### detail - Token Details
```bash
python launch_tracker.py detail --address 0x... --chain ethereum
```

Options:
- `--address, -a`: Token contract address (required)
- `--chain, -c`: Chain (default: ethereum)
- `--pair, -p`: Pair address (optional)
- `--etherscan-key`: API key for verification check

### risk - Risk Analysis
```bash
python launch_tracker.py risk --address 0x... --chain base
```

Analyzes contract for risk indicators:
- Mint function (HIGH risk)
- Proxy contract (MEDIUM risk)
- Not verified (MEDIUM risk)
- Blacklist functionality (MEDIUM risk)
- Active owner (LOW risk)

### summary - Launch Statistics
```bash
python launch_tracker.py summary --hours 24
python launch_tracker.py summary --chains ethereum,base,arbitrum
```

### dexes - List DEXes
```bash
python launch_tracker.py dexes --chain bsc
```

### chains - List Chains
```bash
python launch_tracker.py chains
```

## Instructions

1. **Check recent launches** on a specific chain:
   ```bash
   cd {baseDir}/scripts
   python launch_tracker.py recent --chain ethereum --hours 6
   ```

2. **Get detailed token info** for a specific address:
   ```bash
   python launch_tracker.py detail --address 0x6982508145454ce325ddbe47a25d4ec3d2311933 --chain ethereum
   ```

3. **Analyze token risk** before interaction:
   ```bash
   python launch_tracker.py risk --address 0x... --chain base --etherscan-key YOUR_KEY
   ```

4. **View cross-chain summary**:
   ```bash
   python launch_tracker.py summary --hours 24
   ```

5. **Export to JSON** for programmatic use:
   ```bash
   python launch_tracker.py -f json recent --chain ethereum --analyze > launches.json
   ```

## Supported Chains

| Chain | DEXes | Block Time |
|-------|-------|------------|
| Ethereum | Uniswap V2/V3, SushiSwap | 12s |
| BSC | PancakeSwap V2/V3 | 3s |
| Arbitrum | Uniswap V3, Camelot, SushiSwap | 0.25s |
| Base | Uniswap V3, Aerodrome | 2s |
| Polygon | Uniswap V3, QuickSwap, SushiSwap | 2s |

## Risk Indicators

| Indicator | Severity | Description |
|-----------|----------|-------------|
| Mint function | HIGH | Contract can mint new tokens |
| Proxy contract | MEDIUM | Implementation can be changed |
| Not verified | MEDIUM | Source code not public |
| Blacklist/whitelist | MEDIUM | Can restrict transfers |
| Active owner | LOW | Ownership not renounced |
| Small bytecode | INFO | Might be minimal/proxy |

## Output

- **Table format**: Formatted ASCII tables with token data
- **JSON format**: Structured data for programmatic use
- **Risk scores**: 0-100 scale (higher = riskier)
- **Links**: Explorer and DEXScreener URLs

## Error Handling

See `{baseDir}/references/errors.md` for comprehensive error handling including:
- RPC connection issues and fallback chain
- Rate limiting and backoff strategies
- Contract analysis edge cases

## Examples

See `{baseDir}/references/examples.md` for detailed examples including:
- Finding high-risk tokens
- Multi-chain monitoring scripts
- Python integration

## Resources

- [Uniswap V2 Factory](https://docs.uniswap.org/contracts/v2/reference/smart-contracts/factory)
- [PancakeSwap Factory](https://docs.pancakeswap.finance/developers/smart-contracts)
- [DEXScreener](https://dexscreener.com/) - Real-time pair data
- [Etherscan API](https://docs.etherscan.io/) - Contract verification

Overview

This skill tracks new token launches across decentralized exchanges and provides contract-level risk analysis and verification. It detects PairCreated events, collects token metadata, and assigns risk indicators so you can prioritize which tokens to inspect. Use it to monitor IDOs, discover newly minted pairs, and export findings for automation or reporting.

How this skill works

The tracker watches factory contracts on supported chains for PairCreated events to discover new pairs. For each token it fetches on-chain metadata, checks contract verification (optional via Etherscan), and runs static checks for risk signals like mint functions, proxy patterns, blacklists, and ownership. Results are presented in table or JSON form and include risk scores and explorer/DexScreener links.

When to use it

  • Discover freshly created trading pairs on Uniswap, PancakeSwap, and other DEXes.
  • Monitor upcoming IDOs or token drops within a given time window.
  • Pre-trade due diligence to surface mint, whitelist, or proxy risks.
  • Automate alerts for high-risk or suspicious token launches.
  • Export launch data programmatically for analytics or dashboards.

Best practices

  • Run scans with a reliable RPC or custom endpoints to avoid rate limits.
  • Provide an Etherscan (or equivalent) API key to improve verification checks.
  • Combine recent-mode scanning with --analyze to get quick risk summaries.
  • Filter by DEX or chain to reduce noise when monitoring many networks.
  • Export JSON for downstream processing and keep human review for flagged results.

Example use cases

  • Scan Ethereum for new pairs in the last 6 hours and analyze risky tokens before adding liquidity.
  • Set up a cron job to run recent --chain base --hours 1 and push high-risk alerts to a Slack channel.
  • Audit a specific token address with detail or risk commands before participating in an IDO.
  • Generate a cross-chain summary of launches in the last 24 hours for market research.
  • List supported DEXes on BSC to refine monitoring scope for PancakeSwap activity.

FAQ

Which chains and DEXes are supported?

Supported chains include Ethereum, BSC, Arbitrum, Base, and Polygon with popular DEXes like Uniswap, PancakeSwap, SushiSwap, Aerodrome, QuickSwap, and Camelot.

How reliable is the risk analysis?

Risk analysis is heuristic and uses static contract checks (mint functions, proxies, verification status, blacklists, ownership). Treat scores as guidance and perform manual review for critical decisions.

Do I need an API key?

An Etherscan-style API key is optional but improves contract verification checks and reduces false negatives for source verification.