A local RPC that charges you nothing.
RAKE0 runs on your own machine. It sits between your terminal and your real RPC, strips the terminal's fee out of every transaction, and gives the rent back. You add it once as a Custom RPC and forget about it.
Every terminal on Solana is an RPC client with a UI. It builds a swap, staples a transfer to its own wallet on top, and sends it to whatever RPC is in the settings field.
RAKE0 is that settings field — except it runs locally, on your machine, and the fee does not survive the trip.
http://127.0.0.1:8899
Nothing to sign up for. No hosted endpoint. Your upstream stays yours, your keys never move, and nobody sees your flow.
| Terminal as usual | Through RAKE0 | |
|---|---|---|
| 0.5 SOL round trip | ~0.0075 SOL gone | 0 |
| Rent | locked in closed accounts | refunded in-tx |
| RPC URL | the terminal's default | http://127.0.0.1:8899 |
| Everything else | — | unchanged |
You need an upstream RPC you already trust — your own Helius, Triton, QuickNode or a validator you run. A public endpoint works for testing but is too slow to trade on.
1. Run it
docker run -d --name rake0 \
-p 127.0.0.1:8899:8899 \
-e RAKE0_UPSTREAM="https://your-upstream-rpc" \
ghcr.io/rake0/rake0:latestOr from source, if you would rather build it:
cargo install rake0
rake0 --upstream "https://your-upstream-rpc"2. Point your terminal at it
Settings → RPC → Custom RPC → paste:
http://127.0.0.1:8899
Save, reload the terminal.
3. Confirm it is alive
curl -s localhost:8899/health{"ok":true,"upstream":"...","stripped":true} means it is running and rewriting. From here every transaction the terminal sends passes through RAKE0 first.
~/.config/rake0/config.toml, or the same keys as RAKE0_* environment variables.
upstream = "https://your-upstream-rpc"
listen = "127.0.0.1:8899"
strip_fee = true # remove frontend transfer instructions
close_ata = true # close opened token accounts, refund rent
fallback = true # forward the original tx on any failure
log_fees = true # print what was stripped| Key | Effect |
|---|---|
upstream |
Your real RPC. Required. |
listen |
Bind address. Keep it on 127.0.0.1 unless you know why. |
strip_fee |
The whole point. Turn off to compare. |
close_ata |
Refund path. Disable if a terminal gets confused. |
fallback |
Safety net. Leave it on. |
log_fees |
Shows stripped transfers in the log — useful the first day. |
Before you change anything:
rake0 check --terminal https://your-terminalIt simulates a 0.1 SOL round trip against that terminal and prints every fee transfer it finds, with the wallet it lands in. Most people are surprised by the number.
flowchart LR
T["your terminal"] -->|sendTransaction| R["rake0 :8899"]
R --> P["parse the tx"]
P --> D["drop the fee instruction"]
D --> S["re-simulate"]
S -->|clean tx| U["your upstream RPC"]
A terminal fee is not part of the swap — it is an extra transfer instruction stapled to the end of the transaction. RAKE0 reads the instruction list, removes the transfer that pays the frontend, re-simulates against the same accounts, and forwards the result.
If the re-simulated quote moved, it rebuilds first. If anything at all fails, the original transaction is forwarded untouched — you never end up worse than without it. Then it closes the token accounts the route opened so the rent comes back to you in the same transaction.
Standard JSON-RPC. sendTransaction and simulateTransaction are rewritten; every other method passes straight through to your upstream.
| Client | Works |
|---|---|
| Any terminal with a Custom RPC field | yes |
| Desktop clients | yes |
| Telegram bots with an RPC setting | yes |
| Your own scripts and bots | yes, it is just an RPC URL |
# ~/.config/systemd/user/rake0.service
[Unit]
Description=RAKE0
After=network-online.target
[Service]
ExecStart=/usr/local/bin/rake0 --upstream https://your-upstream-rpc
Restart=always
[Install]
WantedBy=default.targetsystemctl --user enable --now rake0Logs: journalctl --user -u rake0 -f. If log_fees is on you will see each stripped transfer as it happens.
- The launchpad's own fee. That is the venue's price.
- The priority fee. That goes to the validator.
- The network fee. Five thousand lamports, not negotiable.
Everything else on the receipt is fair game.
- No keys. You sign locally, exactly as before. RAKE0 only touches a serialized transaction.
- No custody. It holds nothing and can move nothing.
- No hosted hop. It runs on your machine, so nobody logs your flow.
- No route rewriting. Accounts, mints and amounts stay as the terminal built them; only the fee transfer is dropped.
- Fallback. Any failure forwards the original, so a broken rewrite is a no-op rather than a failed trade.
Do I have to change wallets? No. Same wallet, same signing, same accounts.
Does it slow trades down? It is a local parse and a simulation against your own upstream. The hop is over loopback.
What if a terminal stops working with it?
It renames the fee instruction and rake0 check shows the fee again. Parser update, nothing else — your Custom RPC field stays as it is.
Can I run it on a VPS instead?
Yes. Bind to the public interface, put TLS in front, keep fallback on.
Is there a token? Not yet.
Is it live?
Devnet works today. Mainnet works; start with small size and log_fees on.
Unofficial. Not affiliated with any terminal, launchpad, wallet or validator. Behaviour and flags can change; the commit log is authoritative.
MIT.