digdigdig3

Multi-exchange connector library for Rust — unified async trait API covering crypto exchanges, stock brokers, forex providers, aggregators, and 88 intelligence feeds.

Features

• 26 crypto venues — 17 CEX + 2 derivatives platforms + 7 DEX
• 14 stock market connectors — US, India, Japan, Korea, Russia
• 3 forex providers — broker and historical data
• 4 multi-asset aggregators — DeFi, crypto, global equities
• 88 intelligence feeds — economic, geopolitical, aviation, maritime, cyber, space, and more
• Unified async trait API — MarketData, Trading, Account, Positions across all venues
• AnyConnector enum — store heterogeneous connectors in collections without dyn Trait
• ConnectorFactory — create any connector by ExchangeId with one call
• WebSocket streaming — real-time klines, trades, orderbook, ticker, private events
• Built-in rate limiting — per-exchange weight limiters and simple request-count limiters
• Testnet support — Binance, Bybit, OKX, Kraken, Phemex, Deribit, and others

Quick Start

[dependencies]
digdigdig3 = "0.1"
tokio = { version = "1", features = ["full"] }

use digdigdig3::{
    connector_manager::{ConnectorFactory, AnyConnector},
    ExchangeId, AccountType, Symbol, MarketData,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a public Binance connector — no API key required
    let connector = ConnectorFactory::create_public(ExchangeId::Binance).await?;

    let symbol = Symbol::new("BTC", "USDT");
    let price = connector.get_price(symbol.clone(), AccountType::Spot).await?;
    println!("BTC/USDT: {price}");

    let klines = connector
        .get_klines(symbol, "1h", Some(10), AccountType::Spot, None)
        .await?;
    println!("Got {} candles", klines.len());

    Ok(())
}

Supported Venues

Crypto — CEX

Crypto — Derivatives

Crypto — DEX

Prediction Markets

Stocks — US

Stocks — India

Stocks — Other Regions

Forex

Multi-Asset Aggregators

Architecture

Trait System

All connectors implement a minimal core trait stack:

ExchangeIdentity   — id(), exchange_name(), is_testnet(), supported_account_types()
     │
     ├── MarketData — get_price(), get_orderbook(), get_klines(), get_ticker(), ping()
     ├── Trading    — market_order(), limit_order(), cancel_order(), get_order(), open_orders()
     ├── Account    — get_balance(), get_account_info()
     └── Positions  — get_positions(), get_funding_rate(), set_leverage()

The CoreConnector supertrait combines all five:

pub trait CoreConnector:
    ExchangeIdentity + MarketData + Trading + Account + Positions + Send + Sync {}

Exchange-specific extensions (modify_order, cancel_all, TP/SL orders, sub-accounts, etc.) live directly on each connector struct — not in core traits — keeping the shared interface lean and guaranteed across all venues.

AnyConnector and ConnectorFactory

AnyConnector is an enum with one variant per connector. It implements all core traits via delegation and is cheaply clonable via Arc wrapping:

// All of these have the same type: Arc<AnyConnector>
let binance = ConnectorFactory::create_public(ExchangeId::Binance).await?;
let bybit   = ConnectorFactory::create_public(ExchangeId::Bybit).await?;

// Store in a Vec, pass to generic functions — same type, no dyn
let connectors: Vec<Arc<AnyConnector>> = vec![binance, bybit];

ConnectorRegistry provides O(1) metadata lookup by ExchangeId: name, category, feature flags (market_data, trading, websocket, etc.).

Intelligence Feed Registry

FeedId (88 variants) and FeedRegistry follow the same pattern for intelligence feeds. FeedMetadata carries category, auth type, endpoint base URL, and a human-readable description.

Usage Examples

Public Market Data (no API key)

use digdigdig3::{
    connector_manager::ConnectorFactory,
    ExchangeId, AccountType, Symbol, MarketData,
};

let conn = ConnectorFactory::create_public(ExchangeId::Bybit).await?;
let symbol = Symbol::new("ETH", "USDT");

// Current price
let price = conn.get_price(symbol.clone(), AccountType::Spot).await?;

// Order book (20 levels)
let book = conn.get_orderbook(symbol.clone(), Some(20), AccountType::Spot).await?;

// Last 100 hourly candles
let candles = conn
    .get_klines(symbol.clone(), "1h", Some(100), AccountType::Spot, None)
    .await?;

// 24-hour ticker
let ticker = conn.get_ticker(symbol, AccountType::Spot).await?;
println!("24h volume: {}", ticker.volume);

Authenticated Trading

use digdigdig3::{
    connector_manager::ConnectorFactory,
    Credentials, ExchangeId, AccountType, Symbol, OrderSide, MarketData, Trading, Account,
};

let creds = Credentials::new("YOUR_API_KEY", "YOUR_API_SECRET");
let conn = ConnectorFactory::create_authenticated(ExchangeId::Binance, creds).await?;

// Account balance
let balance = conn.get_balance(None, AccountType::Spot).await?;

// Place a limit order
let symbol = Symbol::new("BTC", "USDT");
let order = conn
    .limit_order(symbol.clone(), OrderSide::Buy, 0.001, 60_000.0, AccountType::Spot)
    .await?;
println!("Order id: {}", order.id);

// Cancel it
conn.cancel_order(symbol, &order.id, AccountType::Spot).await?;

WebSocket Streaming

use digdigdig3::{
    ExchangeId, AccountType, Symbol, StreamType, SubscriptionRequest,
};
use digdigdig3::exchanges::binance::BinanceConnector;
use digdigdig3::WebSocketConnector;
use futures_util::StreamExt;

let mut ws = BinanceConnector::public(false).await?;
ws.connect(AccountType::Spot).await?;

let req = SubscriptionRequest {
    stream_type: StreamType::Kline { interval: "1m".to_string() },
    symbol: Symbol::new("BTC", "USDT"),
    account_type: AccountType::Spot,
};
ws.subscribe(req).await?;

let mut stream = ws.event_stream();
while let Some(event) = stream.next().await {
    match event? {
        digdigdig3::StreamEvent::Kline(k) => {
            println!("open={} close={} volume={}", k.open, k.close, k.volume);
        }
        _ => {}
    }
}

Intelligence Feeds

Intelligence feeds are separate from exchange connectors and live under digdigdig3::intelligence_feeds. Each feed has its own typed connector in src/intelligence_feeds/<category>/<feed>/.

// Example: fetch earthquake data from USGS
use digdigdig3::intelligence_feeds::feed_manager::{FeedId, FeedRegistry};

let meta = FeedRegistry::get(FeedId::UsgsEarthquake);
println!("Feed: {} — auth required: {:?}", meta.name, meta.auth_type);

Query Available Connectors

use digdigdig3::connector_manager::{ConnectorRegistry, ConnectorCategory};

// All crypto CEX connectors
let cex = ConnectorRegistry::by_category(ConnectorCategory::CryptoExchangeCex);
for meta in cex {
    println!("{} — ws={} trading={}", meta.name, meta.features.websocket, meta.features.trading);
}

// All connectors that support WebSocket
let ws_capable = ConnectorRegistry::all()
    .filter(|m| m.features.websocket)
    .collect::<Vec<_>>();
println!("{} connectors support WebSocket", ws_capable.len());

Intelligence Feed Categories

88 feeds across 22 categories:

Error Handling

All fallible operations return ExchangeResult<T> = Result<T, ExchangeError>:

use digdigdig3::ExchangeError;

match connector.get_price(symbol, AccountType::Spot).await {
    Ok(price) => println!("Price: {price}"),
    Err(ExchangeError::RateLimit) => eprintln!("Rate limited — back off"),
    Err(ExchangeError::Auth(msg)) => eprintln!("Auth failed: {msg}"),
    Err(ExchangeError::Api { code, message }) => eprintln!("API {code}: {message}"),
    Err(e) => eprintln!("Error: {e}"),
}

Crate Features

Contributing

New exchange connectors follow the Agent Carousel pipeline documented in contributing/. Each connector lives in:

src/exchanges/<name>/
├── mod.rs         # public exports
├── endpoints.rs   # URL constants, symbol formatting
├── auth.rs        # request signing
├── parser.rs      # JSON deserialization
├── connector.rs   # trait implementations
└── websocket.rs   # WebSocket (optional)

Reference implementation: src/exchanges/kucoin/

Support the Project

If you find this library useful, consider supporting development:

License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE)
• MIT license (LICENSE-MIT)

at your option.