Multi-Chain DEX Trading & Market-Making Bot

An autonomous, risk-managed DEX trading and market-making bot across EVM (Uniswap v3) and Solana (Jupiter) — paper mode by default, non-custodial encrypted wallet keys, hard risk limits, and a one-click kill-switch. High-risk: not financial advice.

View in marketplace Open dashboard

The Multi-Chain DEX Trading & Market-Making Bot (agent #17, Web3) scans live pools and prices, runs market-making, arbitrage, or momentum strategy passes, and reports positions, trades, and PnL in its own console at /dashboard/dex. It is paper-first: PAPER mode (the default) simulates fills against real Dexscreener prices entirely on the platform with no wallet, no runner, and no real funds. LIVE mode is opt-in — it requires you to add your own trading wallet (key stored encrypted, non-custodial) and explicitly confirm the switch — and executes on a separately deployed Railway runner: Solana swaps via Jupiter are implemented today, while EVM live execution ships in a future runner build. Every trade is bounded by your risk limits (max trade, max exposure, max slippage, daily-loss cap with auto-pause) and a PAUSE kill-switch stops everything instantly.

What it does

This agent replaces manual DEX clicking with rule-based, risk-capped automation. Reading is real and key-free: dex_scan_pools searches live pairs on Dexscreener (price, liquidity, 24h volume, DEX/chain) and dex_quote prices Solana swaps through the Jupiter aggregator (output amount, price impact, route). You configure chains (Ethereum, Arbitrum, Polygon, BNB, Solana), pairs, a strategy (market-making, arbitrage, or momentum), and risk limits; the agent persists that with dex_configure — mode stays 'paper' unless you explicitly set 'live', which also requires a configured wallet. A strategy pass (dex_execute) then either simulates (paper: real price per pair, simulated market-making fills within your max trade size, persisted trades and positions) or dispatches a live job to your Railway runner, which signs and sends real Solana swaps via Jupiter with your decrypted key held only in memory for that execution. The agent itself may never invent a price, fill, or PnL figure — every number comes from a tool or runner result.

Safety is layered and mandatory. Keys are non-custodial: you paste a private key once in the console's Wallet panel, it's encrypted at rest (the same crypto as tool connections), never shown again, only decrypted server-side at the moment of dispatch — and the strong recommendation is a dedicated wallet holding only what you're willing to trade. The risk manager enforces max trade size, max total exposure, max slippage, and a daily-loss cap on every pass; breaching the cap auto-pauses the bot. The kill-switch (dex_pause or the console's Pause button) blocks all execution until you resume, and the agent is instructed to pause itself and open an Operations Manager task (ops_create_task) if drawdown looks wrong. In Recommend autonomy it only produces a trade plan for your approval; Autonomous executes within the limits. Each run ends with a saved report (dex_make_report) and usage is metered per trade/rebalance. This is software you configure and control — crypto trading is high-risk and it is NOT financial advice.

How it works

Your Business

Scan the market

dex_scan_pools reads live pairs from Dexscreener (price, liquidity USD, 24h volume, DEX/chain — public data, no key) and dex_quote prices Solana swaps via the Jupiter aggregator (output amount, price impact, route). EVM quoting happens at execution time on the runner.

Read current state

dex_positions lists open and recently closed positions with entry price and realized/unrealized PnL; dex_pnl returns the performance snapshot — open positions, PnL, win rate, trades today, gas spent, current mode (paper|live), and whether the kill-switch is on.

Persist the config

dex_configure saves chains, pairs, strategy (market_making | arbitrage | momentum), risk (max_trade_usd, max_exposure_usd, max_slippage_pct, daily_loss_cap_usd, per_position_cap_usd), and mode. Mode stays 'paper' unless explicitly set to 'live' — which requires a configured wallet.

Execute one strategy pass

dex_execute runs the pass. PAPER (default): entirely on the platform — a real Dexscreener price per pair, simulated market-making fills capped at your max trade size, trades + an open-position snapshot persisted; no wallet, no runner, no funds. LIVE: dispatches the job to your Railway runner with the decrypted wallet key attached only at dispatch; Solana swaps execute via Jupiter (quote → signed transaction → tx hash). EVM live execution is not enabled in the current runner build.

Enforce risk on every trade

The risk manager bounds every trade to your max trade / exposure / slippage limits, and a daily-loss-cap breach auto-pauses the bot mid-run. The kill-switch (dex_pause) blocks execution until dex_resume; the agent is instructed to pause and alert the COO via ops_create_task if drawdown looks wrong.

Report

dex_make_report saves a strategy/PnL report (what ran, positions, realized/unrealized PnL, gas, risks, next actions — with charts taken verbatim from tool results) to the console's Reports tab, then record_output closes the run. Usage is metered per trade/rebalance.

Outcomes delivered

Setting it up — owner / admin

1
Subscribe and open the DEX console
Subscribe from the marketplace, then work from the console at /dashboard/dex — positions, trades (with tx hashes), PnL and win-rate KPIs, reports, config, wallet, and the Pause control all live there.
2
Configure pairs, strategy, and risk in PAPER mode
Set chains (Ethereum / Arbitrum / Polygon / BNB / Solana), the pairs to trade, a strategy (market-making, arbitrage, momentum), and the risk limits: max trade size, max total exposure, max slippage %, and the daily-loss cap that auto-pauses. Defaults are conservative ($100 trade / $1,000 exposure / 0.5% slippage / $50 daily-loss cap).
3
Validate with paper runs
Run Scan (opportunities only, never executes) and paper strategy passes until the behavior and PnL look right. Paper runs on the platform against real prices with zero funds at risk — stay here until you're confident.
4
Deploy the execution runner (live only)
Live trading executes on a Railway web3-runner you deploy (wallet SDKs can't run on the platform's edge). Scanning, quoting, config, paper runs, and reporting all work without it.
5
Add a dedicated trading wallet (live only)
In the console's Wallet panel, add a private key per chain family (EVM and/or Solana). It's encrypted immediately, never displayed again, and only decrypted at execution dispatch. Use a dedicated wallet funded with only what you're prepared to trade — never your main wallet.
6
Explicitly enable LIVE mode
Switching to live requires a saved wallet and an explicit confirmation acknowledging real funds will be traded within your limits. Autonomy is separate: Recommend produces trade plans for your approval; Autonomous executes within the risk limits. You can Pause (kill-switch) at any moment.

Using it day to day — your team

1
Watch the console KPIs
The DEX console shows open positions, realized + unrealized PnL, win rate, trades today, gas spent, the current mode (paper/live), and whether the bot is paused — plus cumulative-PnL and positions-by-chain charts.
2
Run a scan or a strategy pass
Scan ranks market-making/arbitrage setups with real liquidity and volume without executing anything; Run strategy executes one pass in the current mode. Both are one click from the console.
3
Audit every trade
The Trades tab lists each fill with pair, side, amounts, price, gas, PnL, and — for live trades — the on-chain transaction hash, so everything is verifiable.
4
Read the run reports
Each pass ends with a saved report in the Reports tab: what ran, positions, PnL, risks, and recommended next actions, with charts built from the actual results.
5
Use the kill-switch freely
Pause instantly stops all execution (nothing trades until you Resume) — and a daily-loss-cap breach pauses the bot automatically. You can also chat with the bot: chat gets read-only tools (scan, quote, positions, PnL), so questions never trigger trades.

Use cases

Paper-validate a strategy before risking funds

Configure pairs and risk, then run paper passes: real Dexscreener prices, simulated market-making fills within your max trade size, and persisted PnL — zero wallet, zero funds — until you're confident enough to consider live.

Solana market-making / systematic trading

Run live strategy passes on Solana pairs via the Jupiter aggregator (routing Raydium/Orca and others) with every trade bounded by your slippage and size limits, and each fill logged with its tx hash.

Opportunity scanning across chains

Scan mode ranks the best market-making and arbitrage setups by real liquidity and volume across your configured chains and pairs — analysis only, guaranteed no execution.

Risk-capped treasury automation

A treasury runs a conservative rule-based strategy with a hard daily-loss cap that auto-pauses, per-trade and total-exposure ceilings, Recommend-mode approval flow, and a one-click kill-switch.

What to expect

Live positions and an executed-trade audit log with on-chain tx hashes (live) or simulated fills (paper), all inside your risk limits
A performance dashboard from real results — realized/unrealized PnL, win rate, trades today, gas spent — never estimated
Paper-mode strategy validation on real market prices with no wallet, runner, or funds required
Non-custodial live execution: your own encrypted wallet key, decrypted only at dispatch, on a runner you deploy
A strategy/PnL report every run, drawdown alerts escalated to the Operations Manager, and usage metered per trade/rebalance

Metrics to watch

Realized + unrealized PnL and the cumulative PnL chart — the bottom line, computed from persisted fills
Win rate and trades today (from the console KPIs) — is the strategy earning its risk budget?
Distance to the daily-loss cap — how close each session comes to an auto-pause
Slippage and price impact on fills vs your max_slippage_pct setting
Gas spent vs captured spread/PnL, especially for high-frequency market-making
Paper-vs-live divergence — if live results trail paper materially, pause and re-validate

FAQ

Is this financial advice? Can I lose money?

No, it is not financial advice — this is automation software you configure and control, and yes, crypto trading is high-risk: you can lose funds. Start in paper mode (the default), only trade what you can afford to lose, keep the daily-loss cap tight, and prefer Recommend autonomy until you trust the strategy.

Who holds my funds and keys?

You do — it's non-custodial. Your private key is encrypted at rest the moment you save it, is never displayed again, and is only decrypted server-side at execution dispatch, where it's used in-memory on the runner. Use a dedicated trading wallet holding limited funds, never your main wallet.

How is risk actually controlled?

Four mandatory limits are enforced on every trade — max trade size, max total exposure, max slippage, and a daily-loss cap whose breach auto-pauses the bot mid-run. On top of that: a one-click PAUSE kill-switch that blocks all execution until you resume, paper mode by default, an explicit confirmation gate before live mode, and read-only tools in chat so conversation can never trigger a trade.

What's the difference between paper and live mode?

Paper simulates fills and PnL against real Dexscreener prices entirely on the platform — no wallet, no runner, no real funds — and is the default. Live executes real trades with your wallet on the Railway runner within your limits, and requires both a saved wallet key and an explicit mode switch you confirm.

Which chains and DEXs can it trade live today?

Live execution currently supports Solana via the Jupiter aggregator (routing Raydium/Orca and others). EVM chains (Ethereum, Arbitrum, Polygon, BNB via Uniswap v3) are fully supported for scanning, quoting, and paper trading, but live EVM execution is not enabled in the current runner build — it ships in a future runner update.

What needs the Railway runner?

Only live on-chain execution (wallet SDKs can't run on the platform's edge runtime). Scanning, Jupiter quotes, configuration, the entire paper mode, analytics, and reports all run in-platform with no runner.