HyperGrad is a builder-deployed perpetuals DEX on Hyperliquid for Solana memecoins that graduate from pump.fun.

• A coin that holds a $500K market cap joins grad:GRAD, an index perp of graduates.
• A coin that holds $500K for a full day, with real liquidity behind it, also gets its own perp, such as grad:MWIF (2x).
• Past $5M it becomes a blue chip with leverage up to 3x.
• An oracle prices every market from three independent Solana sources every 3 seconds, with a standby oracle on a second server.
• A market maker keeps both sides of every book quoted.
• A manager scans, rebalances and retires markets on its own.
• A dashboard, Telegram alerts and a preflight doctor keep you informed.

_{The dashboard, shown here with demo data.}

• Why HyperGrad
• How it works
• Quick start
• Preflight: doctor
• Market maker
• Oracle sources and failover
• Running on a server
• Telegram alerts
• Commands
• Configuration
• What code cannot do
• Project layout
• Risks and limits
• Documentation
• Links

HIP-3 lets anyone who stakes 500,000 HYPE run their own perp DEX on Hyperliquid's matching engine. The deployer brings the markets and the oracle; Hyperliquid handles order books, margin and liquidations. trade.xyz used this to build stock and commodity perps, and on October 29, 2026 ICE, the owner of the NYSE, signed with it to bring those markets to the US.

Memecoins are the obvious gap. On Solana you can only buy them. HyperGrad lets traders short them and use leverage, and it starts with an index so that a single thin coin cannot be turned against the market.

A coin gets its own perp at the same $500K that brings it into the index, but only once it has held that cap for 24 hours, has at least $100K of pool liquidity and $500K of daily volume, and is two days old. Leverage on these young markets is capped at 2x. Hyperliquid will not accept an open interest cap below $1M, so a small pool can still be pushed against perp traders; the hold time, the liquidity floor, low leverage and the oracle freeze are there to make that expensive. The full policy is in docs/03_LISTING_POLICY.md.

Memecoins trade at fractions of a cent and Hyperliquid prices allow five significant figures, so HyperGrad lists bundles the way Hyperliquid lists kPEPE: MWIF is one million WIF. The bundle size is picked when a coin is listed.

You need Python 3.10 or newer and a Hyperliquid wallet. Everything defaults to testnet.

1. Run setup.bat. It creates .venv, installs dependencies and copies .env.example to .env.
2. Fill in .env: deployer key, oracle key, market maker key, Telegram.
3. Run doctor.bat and fix anything marked FAIL.
4. Run scan.bat, then leave start_manager.bat running. Coins need about 6 hours of history to reach tier 0.
5. Open the dashboard with start_dashboard.bat.
6. When the index has coins, create the DEX:

   .venv\Scripts\activate
   python -m hip3 init-dex

7. Start start_oracle.bat and keep it running while any market is live.
8. Set market_maker.enabled to true and start start_mm.bat.
9. List single perps as candidates appear: python -m hip3 list <mint>.

python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env            # then fill it in
python -m hip3 doctor
python -m hip3 scan
python -m hip3 manager &        # leave running
python -m hip3 serve            # http://localhost:8787
python -m hip3 init-dex         # once the index has coins
python -m hip3 oracle &         # keep running
python -m hip3 mm               # after enabling it in config.json

python -m hip3 doctor runs every check it can without sending a transaction. Run it before init-dex and after every change to .env or config.json.

It exits with code 1 if anything failed, so it can gate a deploy script.

An empty order book is a dead market. python -m hip3 mm keeps a ladder on both sides of every market in market_maker.markets.

Orders are ALO (add liquidity only), so the bot never takes and never pays taker fees. It pulls every quote when a market is halted, when the oracle freezes or goes stale, and when you stop it with Ctrl+C. python -m hip3 mm --dry-run prints the ladder without trading, and python -m hip3 mm-cancel pulls everything.

Fund a separate account with USDC and put its key in HL_MM_PRIVATE_KEY. The deployer key should never trade.

Each source gets one vote; the spot price is their median.

oracle.min_sources sets how many must answer before a price moves. With all three on, set it to 2, so a single broken feed freezes a price instead of moving it.

Standby oracle. Run a second copy on another server with oracle.standby_primary_url set to the primary's dashboard (reach it over an SSH tunnel or a private network). The standby computes every tick and only sends while the primary's /api/health reports no push in the last failover_after_sec. Allow its key once:

python -m hip3 add-oracle-signer 0xSTANDBY_ADDRESS

Funding. funding.multiplier and funding.clamp_8h are applied at listing. Run python -m hip3 apply-funding after changing them.

Backtest. Before giving a coin its own perp:

python -m hip3 backtest <mint>

It replays the coin's one-minute history from GeckoTerminal through HIP-3's mark rule (1% per update, one update every 3 s) and reports how far and how long the mark would have trailed the real price.

The oracle cannot sleep, so production runs on a VPS. Docker is the shortest path:

scp -r ./HIP-3/* root@SERVER:/opt/hypergrad/
ssh root@SERVER 'bash /opt/hypergrad/deploy/vps-setup.sh'      # Docker, firewall, NTP, updates
ssh root@SERVER 'nano /opt/hypergrad/.env'
ssh root@SERVER 'cd /opt/hypergrad && docker compose run --rm oracle doctor'
ssh root@SERVER 'cd /opt/hypergrad && docker compose up -d'    # oracle, manager, dashboard
ssh root@SERVER 'cd /opt/hypergrad && docker compose --profile mm up -d'   # plus the market maker
ssh -L 8787:localhost:8787 root@SERVER                         # dashboard on your machine

The dashboard binds to localhost inside the server on purpose. Reach it through an SSH tunnel rather than opening a port.

Where to rent a server, which Solana RPC to pick and how to lay out primary and standby are in docs/06_OPERATIONS.md.

1. Create a bot with @BotFather and copy its token into TELEGRAM_BOT_TOKEN.
2. Send the bot any message, or add it to a group.
3. Run python -m hip3 tg-chatid and copy the id into TELEGRAM_CHAT_ID. Separate several ids with commas.
4. Run telegram_test.bat to confirm delivery.

Identical alerts are suppressed for 5 minutes and sending never blocks the oracle. Choose the alert types with telegram.kinds in config.json.

Settings live in config.json, secrets in .env. Restart the processes after changes.

Some steps need money, an account, a signature or a lawyer. Each one is explained with links in docs/06_OPERATIONS.md.

• Testnet funds. Deposit once on mainnet, then claim from the testnet faucet.
• The 500,000 HYPE stake (~$45M). Crowdfund it through Kinetiq Launch, bring in a partner, or stake your own.
• A server near Hyperliquid. Tokyo has the lowest latency: AWS Lightsail, Vultr. A second provider for the standby: Hetzner, DigitalOcean.
• A private Solana RPC: Helius, QuickNode, Triton.
• Market-making capital or partners. The built-in bot is a start; deep books need professional market makers.
• A trading front end with a builder code, built on @nktkas/hyperliquid.
• Legal advice on where to operate, terms of use, and HIP-3* allowlists if KYC is needed.
• A public oracle methodology and listing policy, so traders and stakers know the rules.

HIP-3/
├── hip3/                     Python package (python -m hip3)
│   ├── __main__.py           CLI
│   ├── doctor.py             preflight checks
│   ├── scanner.py            discovery, metrics, tiers
│   ├── index.py              GRAD weights and chained level
│   ├── listing.py            init-dex, list, halt, funding, oracle signers
│   ├── oracle.py             multi-source oracle with standby mode
│   ├── mm.py                 market maker
│   ├── manager.py            scan loop, delistings, listing candidates
│   ├── watchdog.py           alerts when the oracle goes quiet
│   ├── backtest.py           mark-lag replay on historical candles
│   ├── notify.py             Telegram
│   ├── hl_client.py          Hyperliquid info and signed perpDeploy actions
│   ├── pricing.py            median, bundles, price formatting
│   ├── server.py             dashboard and /api/health
│   └── sources/              pump.fun, DexScreener, Jupiter, Solana RPC, on-chain pools
├── web/                      dashboard
├── tests/                    pytest suite
├── deploy/                   VPS setup script, systemd units
├── economics/model.py        stake return calculator
├── docs/                     concept, rules, policy, economics, roadmap, operations
├── .github/workflows/ci.yml  tests and Docker build on every push
├── Dockerfile, docker-compose.yml
├── config.json, .env.example
└── *.bat                     Windows launchers

• Stake at risk. A bad oracle input can be slashed by up to 100% of 500,000 HYPE, whether the cause is malice, a bug or a stolen key. Keep the oracle key separate and the deployer key offline.
• Rugs outrun the mark. Hyperliquid moves a HIP-3 mark at most 1% per update, so in a −90% crash positions sit on a stale price for a while. Leverage stays low and margin isolated for this reason. backtest shows how bad it would have been for a given coin.
• Market maker inventory. The bot can end up holding a position in a coin that rugs. max_position_usd limits the damage; size it to what you can lose.
• Data dependencies. The pump.fun API is unofficial and may change; the scanner falls back to DexScreener alone. Run the oracle with at least two sources on mainnet.
• Start on testnet. Run every market there before mainnet, including halts, failover and the market maker.
• Not financial or legal advice. Perpetual futures on memecoins can wipe out a trader's margin, and whether you may operate such a market depends on where you and your users are.

• Hyperliquid: HIP-3, deployer actions, fees, API wallets, builder codes, testnet faucet
• SDKs: hyperliquid-python-sdk, @nktkas/hyperliquid
• Data: DexScreener API, Jupiter Price API, GeckoTerminal API
• Capital: Kinetiq Launch
• Infrastructure: AWS Lightsail, Vultr, Hetzner, Helius, QuickNode
• Telegram Bot API

MIT. HyperGrad is an independent project and is not affiliated with Hyperliquid, pump.fun or trade.xyz.