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
//! Bybit Exchange Example
//!
//! This example demonstrates basic usage of the Bybit exchange implementation.
//!
//! Run with: cargo run --example bybit_example
use ccxt_exchanges::bybit::BybitBuilder;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Initialize logging
tracing_subscriber::fmt::init();
println!("=== Bybit Exchange Example ===\n");
// Create a public-only instance (no authentication)
let exchange = BybitBuilder::new()
.testnet(true) // Use testnet environment for safety
.build()?;
println!("Exchange: {} ({})", exchange.name(), exchange.id());
println!("Version: {}", exchange.version());
println!("Testnet: {}", exchange.options().testnet);
println!("Account Type: {}", exchange.options().account_type);
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 exchange info
println!("Exchange Info:");
println!(" ID: {}", exchange.id());
println!(" Name: {}", exchange.name());
println!(" Version: {}", exchange.version());
println!(" Certified: {}", exchange.certified());
println!(" Pro (WebSocket): {}", exchange.pro());
println!(" Rate Limit: {} req/s", exchange.rate_limit());
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("BYBIT_API_KEY")
.expect("Set BYBIT_API_KEY environment variable");
let secret = std::env::var("BYBIT_SECRET")
.expect("Set BYBIT_SECRET environment variable");
let auth_exchange = BybitBuilder::new()
.api_key(&api_key)
.secret(&secret)
.testnet(true) // Use testnet environment
.recv_window(10000) // Custom receive window
.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(())
}