RapidLaunch Solana AI Autolauncher

RapidLaunch Solana AI Autolauncher watches the RapidLaunch tweet feed and turns selected tweets into launch-ready Pump.fun or Bags token candidates.

It is built for speed: filter the feed first, send only useful tweets to an LLM, generate token metadata, then launch through the RapidLaunch API with configurable wallet and strategy controls.

What it does

• Connects to the encrypted RapidLaunch websocket feed.
• Keeps a rolling window of the latest 30 captured tweets.
• Matches tweets against account metadata in data/targeting.json.
• Filters by account, category, subcategory, crypto relevance, followers, keywords, and exclude keywords.
• Uses OpenAI or Claude to generate memecoin-style token metadata.
• Launches Solana tokens through RapidLaunch on Pump.fun or Bags.
• Supports wallet aliases, wallet groups, sniper wallets, auto-sell presets, and Pump.fun supply-transfer presets.
• Supports live mode by default, with dry-run available when testing.

Requirements

• Node.js >=20.6.0
• A RapidLaunch account
• A RapidLaunch Solana wallet configured and funded
• A RapidLaunch auth token from RapidLaunch Settings -> Account
• An OpenAI or Anthropic API key if using LLM generation

Setup

npm install
Copy-Item .env.example .env
notepad .env
notepad config/rules/rules.json

Minimum .env:

RAPIDLAUNCH_AUTH_TOKEN=your_rapidlaunch_settings_account_token

For OpenAI:

OPENAI_API_KEY=...
OPENAI_BASE_URL=https://api.openai.com/v1

For Claude:

ANTHROPIC_API_KEY=...
ANTHROPIC_BASE_URL=https://api.anthropic.com/v1

Config files

• config/automation.json - small entrypoint that points to the other config files.
• config/runtime/settings.json - live/dry-run behavior, rolling window, output logs.
• config/llm/settings.json - LLM provider, model, metadata limits, image fallback.
• config/images/settings.json - generated token image settings.
• config/llm/style-notes.json - LLM style/persona notes.
• config/llm/few-shot-examples.json - examples that teach the LLM the desired output style.
• config/launch/defaults.json - default RapidLaunch launch fields.
• config/wallets/aliases.json - wallet aliases and groups.
• config/strategies/presets.json - reusable buy/sell/transfer presets.
• config/rules/rules.json - tweet matching rules.
• config/automation.example.txt - annotated reference with normal comments.
• data/targeting.json - account metadata used for deterministic rule matching.

config/automation.json is intentionally tiny:

{
  "runtime_file": "config/runtime/settings.json",
  "llm_file": "config/llm/settings.json",
  "images_file": "config/images/settings.json",
  "defaults_file": "config/launch/defaults.json",
  "wallets_file": "config/wallets/aliases.json",
  "strategies_file": "config/strategies/presets.json",
  "rules_file": "config/rules/rules.json"
}

Most users only need to edit:

• config/rules/rules.json to change what tweets trigger candidates;
• config/wallets/aliases.json to map wallet names;
• config/strategies/presets.json to change buy/sell behavior;
• config/llm/settings.json, config/llm/style-notes.json, and config/llm/few-shot-examples.json to change text generation style;
• config/images/settings.json to change image generation.

Commands

Start the bot:

npm start

That command loads .env, reads config/automation.json, connects to the RapidLaunch feed, watches for matching tweets, generates candidates, and launches when rules match.

Run the bot without launching:

npm run dry-run

Run plain feed ingestion only:

npm run ingest

Backtest rules against saved tweets:

npm run backtest

Backtest a limited number of saved tweets:

npm run backtest -- --limit 100

Fetch RapidLaunch wallets:

node --env-file=.env src/cli.js wallets

Check balances for a token:

node --env-file=.env src/cli.js balances --mint <mint> --platform pump

Sell from selected wallets:

node --env-file=.env src/cli.js sell --mint <mint> --percentage 100 --wallet dev --wallet sniper1 --confirm

Launch the latest saved candidate:

node --env-file=.env src/cli.js launch-candidate --file data/launch-candidates.jsonl --confirm

How the bot works

The bot is split into a few simple stages.

1. Feed connection

The app connects to wss://rapidlaunch.io/ws using your RapidLaunch auth token. Incoming frames are decrypted by src/feedSource.js.

2. Rolling tweet window

Every live tweet is captured into a rolling window. By default only the latest 30 tweets are kept in:

data/recent-tweets.json

This keeps the active pipeline small and avoids processing stale feed items.

3. Freshness check

The bot is designed to act early. By default, a tweet must be processed within 45 seconds of being captured:

{
  "runtime": {
    "max_tweet_age_ms": 45000
  }
}

Older tweets are ignored by live automation.

4. Targeting lookup

The tweet author is normalized and looked up in data/targeting.json. That file gives the bot useful context about the account before any LLM call happens.

Example:

{
  "btc": {
    "category": null,
    "subcategory": "crypto project",
    "crypto_relevance": "high",
    "followers": 204684,
    "verified": "blue"
  }
}

5. Rule matching

Rules in config/rules/rules.json decide which tweets matter.

A rule can match on:

• exact accounts
• account category
• account subcategory
• crypto relevance
• minimum follower count
• required keywords
• excluded keywords

Example:

{
  "id": "high-signal-crypto-pump",
  "enabled": true,
  "accounts": ["btc", "coinbase"],
  "account_subcategories": ["crypto project", "crypto exchange"],
  "crypto_relevance": ["high"],
  "keywords": ["launch", "coming soon", "breaking", "first time ever"],
  "exclude_keywords": ["hack", "exploit", "lawsuit", "scam"],
  "min_followers": 50000,
  "strategy": "dev-only",
  "launch": {
    "platform": "pump",
    "buy_amount": 0.1
  }
}

id is just the rule label used in logs and candidate records. It is there so you can tell which rule fired. It does not affect matching.

Account handles in accounts must exist in data/targeting.json. If a handle is not in that file, the bot has no metadata for it and the rule will not match that account.

Fields that can be left empty:

• accounts: [] means any known account can match.
• account_categories: [] disables category filtering.
• account_subcategories: [] disables subcategory filtering.
• crypto_relevance: [] disables crypto-relevance filtering.
• keywords: [] disables required keyword filtering.
• exclude_keywords: [] disables exclude-keyword filtering.
• snipers: [] means no sniper wallets for that launch.
• website_url, telegram_url, and similar optional URL fields can be "".

6. LLM generation

Only matched tweets are sent to the LLM. The LLM generates:

• token name
• ticker
• short description
• image prompt
• reason for the candidate

The bot then builds the RapidLaunch deploy payload:

{
  "name": "...",
  "symbol": "...",
  "platform": "pump",
  "buy_amount": 0.1,
  "image_url": "...",
  "description": "...",
  "twitter_url": "https://x.com/account/status/id"
}

Token images

By default, token images are generated locally from the LLM's image_prompt.

Image settings live in:

config/images/settings.json

Generated images are saved under:

data/generated-images/

The launch candidate stores the local image path as image_file_path. When launching, the bot uploads that local file to RapidLaunch as image_file.

If image generation is disabled:

{
  "enabled": false
}

the bot falls back to tweet media first, then llm.fallback_image_url, and sends RapidLaunch an image_url instead.

7. Candidate logging

Every generated candidate is written to:

data/launch-candidates.jsonl

8. Launch

In live mode, candidates are sent to:

POST /solana/deploy

npm start runs the live bot and passes --confirm for you. npm run dry-run runs the same pipeline without sending deploy requests.

LLM style

The generator is intentionally tuned for Solana memecoins. It should produce names and descriptions that are short, specific, and funny rather than corporate or generic.

Style lives in:

config/llm/style-notes.json

Few-shot examples live in:

config/llm/few-shot-examples.json

config/llm/settings.json references those files:

{
  "style_notes_file": "config/llm/style-notes.json",
  "few_shot_examples_file": "config/llm/few-shot-examples.json"
}

Supported providers:

• openai
• openai_compatible
• claude
• anthropic
• mock

OpenAI uses structured JSON schema output. Claude uses forced tool output. The result is still locally validated before a candidate can be launched.

Default metadata limits:

• name: 32 UTF-8 bytes
• symbol: 10 uppercase alphanumeric characters
• description: 220 characters

Wallets

RapidLaunch is still the source of truth for wallets. First fetch the wallets configured in your RapidLaunch account:

node --env-file=.env src/cli.js wallets

Then map public keys to friendly names in config/wallets/aliases.json:

{
  "wallets": {
    "aliases": {
      "dev": "DevWalletPublicKeyHere",
      "sniper1": "SniperWalletPublicKeyHere",
      "sniper2": "AnotherSniperWalletPublicKeyHere"
    },
    "groups": {
      "snipers": ["sniper1", "sniper2"],
      "all": ["dev", "sniper1", "sniper2"]
    }
  }
}

Rules and strategies can use dev, sniper1, snipers, or all instead of raw public keys.

Strategies

Strategies are reusable presets for buy, sell, and transfer behavior.

Example:

{
  "strategies": {
    "presets": {
      "dev-only": {
        "buy": {
          "buy_amount": 0.1,
          "mode": "default",
          "snipers": []
        }
      },
      "bundle-snipers-auto-sell": {
        "buy": {
          "buy_amount": 0.1,
          "mode": "bundle",
          "snipers": ["snipers"]
        },
        "sell": {
          "enabled": true,
          "wallet_refs": ["all"],
          "delay_ms": 1500
        }
      },
      "dev-buy-transfer-all": {
        "buy": {
          "buy_amount": 0.1,
          "mode": "default"
        },
        "transfer": {
          "enabled": true,
          "recipient": "dev",
          "transfer_all": true
        }
      }
    }
  }
}

How they map:

• buy.buy_amount -> RapidLaunch buy_amount
• buy.mode -> RapidLaunch mode
• buy.snipers -> RapidLaunch snipers
• sell -> RapidLaunch auto_sell
• transfer -> Pump.fun supply_transfer

Sniper wallet buy amounts are configured in RapidLaunch Settings -> Wallets. This config chooses which sniper wallets participate.

Supported RapidLaunch API calls

• GET /wallets
• POST /solana/deploy
• POST /solana/token-balances
• POST /solana/sell-multiple

Supported launch platforms:

• Pump.fun: pump
• Bags: bags

pumpfun is accepted in local config and normalized to RapidLaunch's API value, pump.

Project structure

config/
  automation.json           Small entrypoint that references config files
  automation.example.txt    Annotated config reference
  runtime/
    settings.json           Live/dry-run and feed freshness settings
  llm/
    settings.json           LLM provider/model/settings
    style-notes.json        LLM style notes
    few-shot-examples.json  LLM examples
  images/
    settings.json           Token image generation settings
  launch/
    defaults.json           Default RapidLaunch launch fields
  wallets/
    aliases.json            Wallet aliases/groups
  strategies/
    presets.json            Buy/sell/transfer presets
  rules/
    rules.json              Tweet matching rules
data/
  targeting.json            Account metadata for rule matching
src/
  cli.js                    CLI entrypoint
  feedSource.js             RapidLaunch websocket client
  autoLauncher.js           Automation orchestrator
  ruleMatcher.js            Rule matching
  llmLaunchGenerator.js     OpenAI/Claude metadata generation
  rapidLaunchApi.js         RapidLaunch HTTP client
  strategyConfig.js         Strategy presets
  walletConfig.js           Wallet aliases/groups
  targeting.js              Account metadata loader
  tweetWindow.js            Rolling tweet window

Development

Syntax-check the project:

npm run check

Validate config JSON:

node -e "for (const f of ['config/automation.json','config/runtime/settings.json','config/llm/settings.json','config/images/settings.json','config/launch/defaults.json','config/wallets/aliases.json','config/strategies/presets.json','config/rules/rules.json','config/llm/style-notes.json','config/llm/few-shot-examples.json']) { JSON.parse(require('fs').readFileSync(f,'utf8')); } console.log('ok')"

Notes

Keep .env private. The RapidLaunch auth token can act through your configured RapidLaunch account while it is valid.