Design, simulate, and execute multi-wallet pump.fun launch strategies on a visual canvas.
Place wallets as nodes, connect them with buys, rotations, and timed sells, and watch an accurate bonding-curve chart update as you build — then run the exact strategy on-chain.
Demo · How it works · Quick start · License
The Alpha (on-chain) build runs against your own wallets, RPC, and Jito access. None of this is bundled — you supply it. Create
.secrets/(git-ignored) with:
File What it is Where to get it .secrets/rpc-url.txtYour Solana RPC URL Helius (or any mainnet RPC) — paid plan recommended for landing speed .secrets/jito-uuid.txtYour Jito Block Engine UUID Jito — required for bundled launches .secrets/jito-tip-sol.txtJito tip per launch (default 0.1)your call; 0.1◎ lands reliably .secrets/wallets.jsonYour encrypted wallet keystore created by the app / npm run encrypt-keystore.secrets/pinata-jwt.txt(optional) Pinata JWT for metadata pinning Pinata Also copy
.env.example→.env.localand setLILY_KEYSTORE_PASSPHRASE(encrypts your wallets at rest — lose it and you lose the wallets). Everything in.secrets/and.env.localis git-ignored and never committed. Your keys, your funds, your RPC/Jito accounts — this repo ships none of them.
Lily Algo Launcher models a pump.fun launch as an editable graph. Every wallet is a node, and every connection is an action:
| Action | Meaning |
|---|---|
| Buy | A wallet buys into the token. |
| Rotate | A wallet sells its position; the proceeds sweep into another wallet, which buys back — relaying a position across wallets. |
| Sell | A timed exit: sell a percentage of a wallet's holdings after a delay. |
As you edit the graph, a simulator builds a trade tape and renders candles from it, so the chart always reflects the precise strategy you've designed — buy sizes, wait times, and exit timing included. The same graph compiles to an execution plan that runs the strategy on-chain.
The application has two modes, separated at build time:
- Demo — a fully off-chain simulator. No wallets, funds, or keys. This is the public build.
- Alpha — real on-chain execution against live wallets, intended for local use.
All execution and key-handling code is excluded from the Demo build at compile time, so the public version is a pure, safe design tool.
- Visual strategy editor — multi-select, group move, copy/paste, duplicate, undo/redo, pan/zoom, and a minimap.
- Accurate simulation — a faithful pump.fun bonding-curve model drives a live chart and trade tape.
- Strategy primitives — dev buy, follow buys with per-buy timing, rotation relays, and timed percentage exits.
- Creator reward routing — creator, wallet, GitHub, charity, and split (multi-shareholder) modes.
- Verifiable execution — every action renders as a status row with a block-explorer link, and each run is saved to a launch history.
- Built-in guardrails — strategy validation, funding pre-flight, spend limits, and idempotent execution.
- Frontend — React 19, TypeScript, Vite, @xyflow/react, lightweight-charts.
- Execution layer — Node.js, @solana/web3.js, @solana/spl-token, @pump-fun/pump-sdk.
Visual canvas ─► graph ─► simulator ─► live chart + trade tape (design & preview)
│
└──► execution plan ─► pre-flight audit ─► on-chain execution (run)
The graph is the single source of truth. A simulator timestamps every action and replays it through the bonding-curve model to produce the chart, so the preview matches the designed strategy exactly. For execution, the same graph is compiled into a plan, validated against spend limits and per-wallet funding, and then run: token creation and dev buy, independent buys, the rotation relay, and timed exits — as durable, resumable jobs.
Requirements: Node.js 20+ and npm.
git clone https://github.com/Enrichdotfun/lily-algo-launcher.git
cd lily-algo-launcher
npm install
npm run dev # opens the off-chain simulator at http://127.0.0.1:5273Running the on-chain (Alpha) mode requires a local execution service plus your own RPC and wallet configuration, and is intended for local development only. On-chain use is at your own risk and subject to the license and disclaimer.
- Design — add wallets and connect buys, rotations, and timed sells. The chart and trade tape update as you build.
- Configure — set the token name, ticker, image, and a creator-reward mode.
- Preview — review the simulated chart and the per-action trade tape.
- Run (Alpha) — run a pre-flight audit, then execute. Watch each action confirm with a block-explorer link, and review the run in launch history.
src/ Frontend — canvas, panels, charts, and the simulation/validation/model logic
server/ Execution layer — plan auditing, on-chain orchestration, and job management
scripts/ Maintenance utilities and the validation test harness
public/ Static assets
- Secrets never enter the repository. Keys and credentials are read at runtime from local, ignored files or environment variables.
- The public build contains no execution or key-handling code — it is removed at build time.
- Execution is access-controlled. On-chain actions run through a local, origin-restricted service with request authentication.
- Spend limits are enforced by a pre-flight audit before any transaction is signed.
Licensed under the PolyForm Noncommercial License 1.0.0.
You may use, study, and modify this software for noncommercial purposes only. Commercial use — including using it, or any derivative, to operate a business or a paid service — is not permitted without a separate commercial license. For commercial licensing, contact the maintainers.
This software can interact with live blockchains and spend real funds. It is provided as is, without warranty of any kind. You are solely responsible for any transactions you execute, for securing your credentials, and for complying with all applicable laws and third-party terms. Nothing here is financial advice.