1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
//! OKX Exchange Example
//!
//! This example demonstrates basic usage of the OKX exchange implementation.
//!
//! Run with: cargo run --example okx_example
use ccxt_core::DefaultType;
use ccxt_core::exchange::Exchange;
use ccxt_exchanges::okx::OkxBuilder;
#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
// Initialize logging
tracing_subscriber::fmt::init();
println!("=== OKX Exchange Example ===\n");
// Create a public-only instance (no authentication)
let exchange = OkxBuilder::new()
.sandbox(false) // Use demo environment for safety
.default_type(DefaultType::Swap)
.build()?;
println!("Exchange: {} ({})", exchange.name(), exchange.id());
println!("Version: {}", exchange.version());
println!("Demo Mode: {}", exchange.options().testnet);
println!();
// Fetch and display markets
println!("Fetching markets...");
let markets = exchange.fetch_markets().await?;
println!("Found {} markets\n", markets.len());
// Display first 5 markets
println!("Sample markets:");
for market in markets.values().take(5) {
println!(
" {} - Base: {}, Quote: {}, Active: {}",
market.symbol, market.base, market.quote, market.active
);
}
println!();
// Load markets for subsequent calls
exchange.load_markets(false).await?;
// Fetch BTC/USDT ticker
println!("Fetching BTC/USDT ticker...");
match exchange.fetch_ticker("BTC/USDT").await {
Ok(ticker) => {
println!(" Symbol: {}", ticker.symbol);
if let Some(last) = ticker.last {
println!(" Last Price: {}", last);
}
if let Some(high) = ticker.high {
println!(" 24h High: {}", high);
}
if let Some(low) = ticker.low {
println!(" 24h Low: {}", low);
}
println!(" Timestamp: {}", ticker.timestamp);
}
Err(e) => println!(" Error: {}", e),
}
println!();
// Fetch order book
println!("Fetching BTC/USDT order book...");
match exchange.fetch_order_book("BTC/USDT", Some(5)).await {
Ok(orderbook) => {
println!(" Bids: {} levels", orderbook.bids.len());
println!(" Asks: {} levels", orderbook.asks.len());
if let Some(best_bid) = orderbook.bids.first() {
println!(" Best Bid: {} @ {}", best_bid.amount, best_bid.price);
}
if let Some(best_ask) = orderbook.asks.first() {
println!(" Best Ask: {} @ {}", best_ask.amount, best_ask.price);
}
}
Err(e) => println!(" Error: {}", e),
}
println!();
// Fetch recent trades (using new API)
println!("Fetching recent BTC/USDT trades...");
match exchange.fetch_trades("BTC/USDT", Some(5)).await {
Ok(trades) => {
println!(" Found {} trades", trades.len());
for trade in trades.iter().take(3) {
println!(
" {:?} {} @ {} ({})",
trade.side, trade.amount, trade.price, trade.timestamp
);
}
}
Err(e) => println!(" Error: {}", e),
}
println!();
// Display capabilities
println!("Exchange Capabilities:");
let caps = exchange.capabilities();
println!(" fetch_markets: {}", caps.fetch_markets());
println!(" fetch_ticker: {}", caps.fetch_ticker());
println!(" fetch_order_book: {}", caps.fetch_order_book());
println!(" fetch_trades: {}", caps.fetch_trades());
println!(" fetch_ohlcv: {}", caps.fetch_ohlcv());
println!(" create_order: {}", caps.create_order());
println!(" cancel_order: {}", caps.cancel_order());
println!(" fetch_balance: {}", caps.fetch_balance());
println!();
// Display supported timeframes
println!("Supported Timeframes:");
let timeframes = exchange.timeframes();
let mut tf_list: Vec<_> = timeframes.keys().collect();
tf_list.sort();
for tf in tf_list.iter().take(6) {
if let Some(value) = timeframes.get(*tf) {
println!(" {} -> {}", tf, value);
}
}
println!(" ... and {} more", timeframes.len().saturating_sub(6));
println!();
// Example with authentication (commented out for safety)
/*
println!("=== Authenticated Example ===\n");
// WARNING: Never commit real API credentials!
let api_key = std::env::var("OKX_API_KEY")
.expect("Set OKX_API_KEY environment variable");
let secret = std::env::var("OKX_SECRET")
.expect("Set OKX_SECRET environment variable");
let passphrase = std::env::var("OKX_PASSPHRASE")
.expect("Set OKX_PASSPHRASE environment variable");
let auth_exchange = OkxBuilder::new()
.api_key(&api_key)
.secret(&secret)
.passphrase(&passphrase)
.sandbox(true) // Use demo environment
.build()?;
// Fetch balance
println!("Fetching balance...");
let balance = auth_exchange.fetch_balance().await?;
if let Some(usdt) = balance.get("USDT") {
println!(" USDT Balance:");
println!(" Total: {}", usdt.total);
println!(" Free: {}", usdt.free);
println!(" Used: {}", usdt.used);
}
// Fetch open orders
println!("Fetching open orders...");
let orders = auth_exchange.fetch_open_orders(Some("BTC/USDT"), None, None).await?;
println!(" Found {} open orders", orders.len());
for order in &orders {
println!(
" {} - {:?} {:?} {} @ {:?}",
order.id, order.side, order.order_type, order.amount, order.price
);
}
*/
println!("=== Example Complete ===");
Ok(())
}