Documentation

RogueTrader is a decentralised trading platform on Solana where 30 AI agents — called RogueBots — continuously trade against each other on the price movements of crypto, stocks, forex, commodities and indexes using live Pyth oracle feeds.

Every trade is zero-sum: when one bot wins, the losing bots' pools pay out to the winner. No SOL ever enters or leaves the system through trading — it only redistributes between bot pools.

You participate by depositing SOL into the bots you think will outperform. In return you receive LP tokens that rise when your bot wins and fall when it loses.

There are no trading commissions and no fees on winnings — only the bid/ask spread on deposit and withdrawal. Think of it like picking fund managers, except the managers are AI, every trade settles on-chain, and the LP tokens in your wallet move like volatile memecoins — without any risk of being rugged.

The system runs continuously. Bots propose trades, other bots act as counterparties, and the outcome is determined by real-world price movements via Pyth oracle feeds.

1. Bot proposes a trade. A bot picks a direction (long or short) on a price feed (e.g. BTC/USD) and stakes a percentage of its free capital. Every trade runs for exactly 60 seconds.
2. Counterparties are assigned. All 29 other bots contribute proportionally from their free capital as the counterparty pool. The total counterparty pool matches the proposer's stake adjusted by the odds ratio.
3. Price is recorded. The entry price is read from Pyth at the moment of proposal.
4. 60 seconds pass. The trade expires after exactly one minute.
5. Settlement. The exit price is read from Pyth. If the price moved in the proposer's direction, the proposer wins the counterparty pool. If not, the counterparties win the proposer's stake. If the price didn't move, it's a tie and all capital is returned.

To back a bot, deposit SOL into its pool. You'll receive LP tokens representing your share of the pool.

1. Connect your wallet. Phantom, Solflare, or any Wallet Standard compatible wallet.
2. Navigate to a bot's page. Click any bot on the leaderboard.
3. Enter an amount in the deposit panel and confirm.
4. Sign the transaction with your wallet.

To exit a position, burn your LP tokens to receive SOL back from the bot's pool.

1. Go to the bot's page and switch to the Withdraw tab.
2. Enter the LP amount to burn (or click MAX for all).
3. Sign the transaction. SOL is sent directly to your wallet from the master vault.

Each bot has its own LP token (e.g. ZEUS-LP, KRONOS-LP). The LP token price reflects the bot's net asset value per token.

The homepage leaderboard ranks all 30 bots by LP price. Here's what each column means:

• LP Price — Current NAV per LP token in SOL. Started at 1.0000 for all bots. Above 1.0 means the bot is profitable overall, below means it's down.
• 1h / 24h — Percentage change in LP price over the last hour and day.
• Win Rate — Rolling win rate from the bot's last 10 proposed trades (configurable window). 50% is break-even.
• AUM — Total SOL in the bot's pool (assets under management).
• My Position — Your LP token value in SOL and unrealised P/L (visible when wallet connected).
• 1H Chart — Sparkline of LP price over the last hour.

30 bots are organised into 5 asset-class groups of 6. Each group trades specific Pyth price feeds spanning multiple global exchanges:

Bots within a group all have access to the same price feeds but differ in strategy, risk level, and trading frequency. See Markets Traded below for the full list of tickers, exchanges, and opening hours.

Equities and Indexes trade across Tokyo, Hong Kong, London, Frankfurt, and New York — giving ~21 hours of coverage on weekdays. Bots only propose new trades when at least one exchange in their group is open:

Weekday equity session breakdown (UTC):

00  02  04  06  08  10  12  14  16  18  20  22  24
├───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┤
████████████                                          Tokyo (00:00-06:00)
██████████████████                                    Hong Kong (01:30-08:00)
          ██████████████████████████                    Europe (07:00-16:30)
                      ██████████████████            US/NYSE (13:30-21:00)

When all exchanges in a group are closed (21:00-00:00 UTC for equities), bots show a "Closed" badge on the leaderboard. They still participate as counterparties in other bots' trades — they just don't propose new trades of their own.

All prices are sourced from Pyth Network oracle feeds. Each bot group has access to the following markets:

Each bot has a risk level that influences its trading frequency and sizing behaviour:

• Low Risk — Conservative. Longer intervals between trades (5-15 minutes). Steady, lower-variance returns. Best for passive exposure.
• Med Risk — Balanced. Moderate intervals (2-10 minutes). The most common risk level.
• High Risk — Aggressive. Short intervals (1-5 minutes). Higher variance, more frequent trading. Higher potential upside and downside.

All bots use the same trade sizing formula (Kelly criterion, max 5%) — the risk level affects how often they trade, not how much they stake per trade.

Each bot has a named archetype describing its trading personality. In the current version, all bots use random signal generation (signals will be upgraded to AI-driven strategies). The archetypes are:

• Momentum — Trades in the direction of recent price trends.
• Contrarian — Trades against recent moves, expecting mean reversion.
• Scalper — High-frequency, small-edge trades.
• Swing — Medium-term directional trades.
• Cycle — Trades based on cyclical patterns.
• Correlation — Cross-asset correlation plays.
• Value — Fundamentals-driven approach.
• On-Chain — Blockchain data-driven signals.
• Trend — Long-term trend following.
• Reversion — Statistical mean reversion.
• Rotation — Sector rotation strategy.
• Arb — Cross-market arbitrage signals.
• Reversal — Identifies trend reversals.

Every trade follows the same lifecycle:

1. Propose. A bot picks a direction (long or short) on a price feed (e.g. BTC/USD) and stakes a percentage of its free capital. The entry price is recorded from Pyth.
2. Lock. The proposer's stake and all 29 counterparties' matching stakes are locked (cannot be withdrawn during the trade).
3. Wait. Every trade runs for exactly 60 seconds.
4. Settle. After expiry, the exit price is read from Pyth. The outcome is determined by whether the price moved in the proposer's direction.
5. Redistribute. Winner takes the loser's stake. Ties return all capital.
6. Close. The trade account is closed and rent is reclaimed.

Bots use the Kelly criterion to size their trades. Kelly maximises long-term growth by staking proportionally to edge. RogueTrader uses half-Kelly (more conservative) with a hard cap at 5%.

confidence = signal strength (0.53 to 0.70)
kelly      = confidence - (1 - confidence)
half_kelly = kelly / 2
stake_bps  = clamp(half_kelly * 10,000, min=10, max=500)

Example: confidence = 0.60
  kelly      = 0.60 - 0.40 = 0.20
  half_kelly = 0.10
  stake_bps  = 1,000 → clamped to 500 (5% max)
  stake      = free_capital * 500 / 10,000 = 5% of free capital

The confidence value comes from the bot's signal generation. Currently this is random (0.53 to 0.70), producing stakes of approximately 150-500 basis points of free capital per trade.

To prevent a single large bot from draining all counterparties with one oversized trade, each counterparty's stake per trade is capped at a percentage of their free capital.

For each counterparty bot:
  proportional = cp_free * cp_pool_target / total_free
  cap          = cp_free * max_cp_exposure_bps / 10,000
  cp_stake     = min(proportional, cap)

If sum(capped stakes) < cp_pool_target:
  Scale down: proposer_stake = capped_total * p / q
  Trade still succeeds at smaller size

RogueTrader charges a 1% spread on both deposits and withdrawals. There are no trading fees — bots trade against each other at zero cost.

RogueTrader has a two-tier referral system. When a referred user deposits or withdraws, a portion of the spread goes to their referrer.

• Tier 1: Direct referrer receives 0.20% of the transaction amount.
• Tier 2: The referrer's referrer receives 0.10%.

Referrals are set on-chain via the PlayerState account. A referrer must have their own ReferralState account to be eligible. Referral relationships are permanent and cannot be changed once set.

A 10% tax is applied to winning bets on settlement. The taxed SOL accumulates in the rewards pool, a global balance on the ClearingHouseState account.

RogueTrader is a three-tier system: a Phoenix web application, a Node.js settler microservice, and an Anchor program on Solana.

Browser (LiveView + Wallet)
    |
    | WebSocket (Phoenix LiveView)
    |
Phoenix App (Elixir)
    ├─ 30 BotProcess GenServers
    ├─ BetSettler (settlement loop)
    ├─ StatsTracker (ETS cache)
    └─ PubSub (real-time UI)
    |
    | HTTP (HMAC-authenticated)
    |
Settler (Node.js microservice)
    ├─ Anchor client (TX building)
    ├─ Pyth Hermes (price feeds)
    └─ ALT manager (batched TXs)
    |
    | RPC
    |
Solana (Anchor program)
    ├─ ClearingHouseState (config)
    ├─ 30 AgentVault accounts
    ├─ 5 GroupConfig accounts
    └─ Trade accounts (ephemeral)

The on-chain program is written in Rust using the Anchor framework (v0.30.1). It has 21 instructions covering admin operations, user deposits/withdrawals, bot trading, and the rewards pool raffle.

The program uses 6 account types, all stored as Anchor PDAs:

ClearingHouseState   ~585 bytes   Global config, fees, stats, vault address
AgentVault           ~430 bytes   Per-bot: LP tracking, SOL balance, win rate
GroupConfig          ~720 bytes   Per-group: Pyth feed assignments
Trade                ~420 bytes   Per-trade: stakes, prices, counterparties
PlayerState          ~200 bytes   Per-user: referrer, deposit/withdraw stats
ReferralState        ~120 bytes   Per-referrer: earnings tracking

All price data comes from Pyth Network using the pull model with persistent PriceFeedAccount. This avoids creating temporary price accounts and eliminates rent leaks.

Settlement is a critical process that must maintain the invariant: the database never marks a trade as settled unless the on-chain state confirms it.

The core safety property of RogueTrader:

RogueTrader is fully self-custodial:

• Your wallet keys never leave your device. You sign every transaction locally.
• LP tokens are standard SPL tokens in your wallet. You can transfer them freely.
• Withdrawals are permissionless. The on-chain program processes withdrawals without any server cooperation. If the web UI goes down, you can withdraw directly through the Solana program.
• No admin withdrawal function. The authority cannot withdraw user funds. The only admin functions are configuration changes and emergency pause.
• The program is upgradeable by the deploy authority. This allows bug fixes but means users must trust the authority not to deploy malicious upgrades. Upgrade authority is documented in Contract Addresses.

On-chain accounts:

Program is verified by OtterSec on Solana Mainnet.

Build hash: c8c2642f8e50c1cc7f4313fb52a6c4c8b7a4cae9dacef2613c5bdc2ba42cfaeb