Olympic Trades — Protocol Docs

Introduction

Olympic Trades is a virtual trading protocol deployed on the Solana blockchain. It mirrors live on-chain coin prices in real time and lets users execute simulated trades against those prices — no real capital at risk, fully transparent results on-chain.

The protocol is built around a single goal: letting traders prove skill without losing money, then compete globally for real prizes. Think of it as the Olympics for on-chain trading — recurring, merit-based, and fully verifiable.

What the protocol is not

Olympic Trades is not a trading terminal, a paper trading app, or a prediction market. It is an on-chain protocol where:

• Trades are executed virtually against real oracle prices at the exact moment of submission.
• Positions and P&L are stored in Solana program accounts — not a centralized database.
• Competition results are provably fair and auditable by anyone with a block explorer.

Quickstart

Follow these steps to participate in the Olympic Trades beta once the protocol launches (Roadmap Step 05).

1. Install a Solana wallet — Phantom or Backpack are recommended.
2. Acquire $OLYMP tokens via the fair launch on Pump.fun or secondary DEX markets.
3. Connect your wallet at app.olympictrades.in and deposit $OLYMP as your entry.
4. Open a virtual position on any supported coin pair. The protocol records your entry price from the oracle feed at the timestamp of your transaction.
5. Close your position at any time. Your P&L is settled on-chain and your leaderboard rank updates in the same block.

Architecture

The protocol is composed of three on-chain layers: a price feed aggregator, a virtual position manager, and a leaderboard state machine. All three are Solana programs written in Rust using the Anchor framework.

No centralized server touches trade logic. The front-end app reads on-chain state and submits signed transactions; it has no write access to your positions or scores.

$OLYMP Overview

$OLYMP is the native token of the Olympic Trades ecosystem. It was launched via a fair launch on Pump.fun with no pre-mine, no team allocation at launch, and no private sale. Anyone could buy in at the same conditions from block zero.

Token utility

• Protocol access — holding $OLYMP is required to open virtual positions on the protocol.
• Competition entry — competitions require an entry fee paid in $OLYMP, which funds the prize pool.
• Governance — future on-chain voting over competition parameters, fee rates, and treasury grants.
• Airdrop eligibility — beta testers who hold $OLYMP during the testing window qualify for additional airdrop rewards.

Tokenomics

Because $OLYMP launched via Pump.fun's fair launch mechanism, the full initial supply entered circulation through the bonding curve. There are no locked team tokens, no vesting schedules, and no seed-round allocations.

Contract Addresses

All official addresses will be published here at launch. Do not interact with any contract claiming to be $OLYMP before the official announcement.

Price Feed

The protocol consumes real-time price data via Solana's leading oracle networks. Every virtual trade is priced at the oracle's reported value at the exact slot your transaction lands — the same price a real DEX swap would see.

Supported oracle sources

Price staleness protection

If a price feed has not updated within a configurable staleness window (default: 10 seconds), the position manager will reject new trade opens for that pair until a fresh price is confirmed. This prevents manipulation via stale oracle data.

pub fn validate_price(feed: &PriceFeed, clock: &Clock) -> Result<i64> {
    let price = feed.get_price_no_older_than(
        &clock, 10 // max staleness in seconds
    ).ok_or(OlympError::StalePriceFeed)?;
    Ok(price.price)
}

Virtual Trades

A virtual trade is a signed Solana transaction that instructs the Position Manager program to record a synthetic long or short position at the current oracle price. No real asset is bought or sold.

Opening a position

import { OlympClient } from '@olymp/sdk';

const client = new OlympClient({ wallet, connection });

// Open a virtual long on SOL/USDC
const tx = await client.openPosition({
  pair:      'SOL/USDC',
  direction: 'long',
  size:      1000, // virtual USDC notional
});
await tx.confirm();

Closing a position

// Close position — P&L settled on-chain at this block's oracle price
const result = await client.closePosition({ positionId: tx.positionId });
console.log(`P&L: ${result.pnl} virtual USDC`);

Supported pairs (Beta)

At Beta launch, the following pairs will be available. Additional pairs are added by governance vote.

Scoring & Ranking

Each participant's leaderboard score is a composite metric — raw P&L alone does not determine rank. This prevents participants from simply sizing up a single trade.

The composite score is computed by an on-chain Solana program at the end of each competition epoch. The computation is deterministic and verifiable — anyone can replay the calculation from raw on-chain position data.

Smart Contracts

All protocol logic lives in Anchor programs on Solana. There are no admin keys that can freeze your positions or alter your score.

Program accounts

Competition Rules

Olympic Trades competitions run in fixed-length epochs. The first competition launches after the Beta Testing Campaign (Roadmap Step 07). Subsequent competitions are annual.

Eligibility

• Wallet must hold $OLYMP tokens at the snapshot block before epoch start.
• Entry fee paid in $OLYMP — amount announced per-epoch.
• Minimum 10 closed trades during the epoch to qualify for prize distribution.
• No bot restrictions — algorithmic trading is permitted and expected.

Competition lifecycle

1. Registration window — wallets pay the entry fee and register their ParticipantAccount.
2. Trading epoch — all registered wallets can open and close virtual positions.
3. Scoring settlement — on-chain program computes final scores at epoch close.
4. Prize distribution — PrizeDistributor program pays out $OLYMP to ranked winners automatically.

Prize Pool

The prize pool for each competition epoch is funded entirely by participant entry fees. There is no treasury subsidy for the first competition — what participants put in is what winners take out (minus a small protocol fee for ongoing development).

Exact prize pool size depends on total participant count and entry fee. Announced per-epoch once registration opens.

Beta Airdrop

Beta testers who actively use the protocol during the testing window (Roadmap Step 06) will receive a $OLYMP airdrop proportional to their participation.

How to qualify

• Hold $OLYMP at the snapshot block when beta registration opens.
• Open and close at least 5 virtual positions during the beta window.
• Submit at least one bug report or feedback form via the official beta portal.
• Do not use bots that spam transactions with no trading intent — this will disqualify your wallet.

Airdrop scoring

Airdrop amounts are weighted by trade count, feedback quality score (rated by the team), and $OLYMP holdings at snapshot. Heavy traders who also file detailed feedback receive the highest allocations.

Wallet Integration

Olympic Trades supports any Solana wallet via standard wallet-adapter interfaces. We recommend Phantom or Backpack for end users. For programmatic integration, use the @olymp/sdk package (published at protocol launch).

npm install @olymp/sdk @solana/wallet-adapter-react

import { OlympClient } from '@olymp/sdk';
import { useWallet, useConnection } from '@solana/wallet-adapter-react';

function MyTradingApp() {
  const { wallet } = useWallet();
  const { connection } = useConnection();
  const olymp = new OlympClient({ wallet, connection });
  // olymp.openPosition(), olymp.closePosition(), olymp.getScore()
}

API Reference

A read-only REST API will be available at api.olympictrades.in/v1 from the Beta launch. All write operations must go through signed on-chain transactions.

Roadmap

Eight sequential milestones from launch to annual competitions. Each stage unlocks the next.

Security

All core on-chain programs will undergo independent security audits before mainnet deployment. Audit reports will be linked here once complete.

Admin key policy

No admin key can modify your open positions, alter your score, or withdraw from the prize pool. The only privileged operations reserved for the upgrade authority are: deploying program upgrades (which will be transferred to a multisig before the first competition) and initializing new epoch accounts.

Bug bounty

A bug bounty program will be active from Beta launch. Critical vulnerabilities in on-chain programs are eligible for rewards in $OLYMP. Details published in the beta announcement.