Struct BaseExchange 

pub struct BaseExchange {
    pub config: ExchangeConfig,
    pub http_client: HttpClient,
    pub market_cache: Arc<RwLock<MarketCache>>,
    pub market_loading_lock: Arc<Mutex<()>>,
    pub capabilities: ExchangeCapabilities,
    pub urls: HashMap<String, String>,
    pub timeframes: HashMap<String, String>,
    pub precision_mode: PrecisionMode,
}

Base exchange implementation

Fields

config: ExchangeConfig

Exchange configuration

http_client: HttpClient

HTTP client for API requests (handles rate limiting internally)

market_cache: Arc<RwLock<MarketCache>>

Thread-safe market data cache

market_loading_lock: Arc<Mutex<()>>

Mutex to serialize market loading operations and prevent concurrent API calls

capabilities: ExchangeCapabilities

Exchange capability flags

urls: HashMap<String, String>

API endpoint URLs

timeframes: HashMap<String, String>

Timeframe mappings (e.g., “1m” -> “1”)

precision_mode: PrecisionMode

Precision mode for price/amount formatting

Implementations

impl BaseExchange

pub fn new(config: ExchangeConfig) -> Result<BaseExchange, Error>

Creates a new exchange instance

Arguments

• config - Exchange configuration

Returns

Returns a Result containing the initialized exchange instance.

Errors

Returns an error if HTTP client or rate limiter initialization fails.

pub async fn load_markets( &self, reload: bool, ) -> Result<Arc<HashMap<String, Arc<Market>>>, Error>

Loads market data from the exchange

Arguments

• reload - Whether to force reload even if markets are already cached

Returns

Returns a HashMap of markets indexed by symbol.

Errors

Returns an error if market data cannot be fetched. This base implementation always returns NotImplemented error as exchanges must override this method.

pub async fn load_markets_with_loader<F, Fut>( &self, reload: bool, loader: F, ) -> Result<Arc<HashMap<String, Arc<Market>>>, Error>

where F: FnOnce() -> Fut, Fut: Future<Output = Result<(Vec<Market>, Option<Vec<Currency>>), Error>>,

Loads market data with a custom loader function, ensuring thread-safe concurrent access.

This method serializes market loading operations to prevent multiple concurrent API calls when multiple tasks call load_markets simultaneously. Only the first caller will execute the loader; subsequent callers will wait for the lock and then return cached data.

Arguments

• reload - Whether to force reload even if markets are already cached
• loader - An async closure that performs the actual market data fetching. Should return Result<()> and is responsible for calling set_markets.

Returns

Returns a HashMap of markets indexed by symbol.

Errors

Returns an error if the loader function fails.

Example

let markets = self.base().load_markets_with_loader(reload, || async {
    let markets = self.fetch_markets_from_api().await?;
    Ok((markets, None))
}).await?;

pub async fn set_markets( &self, markets: Vec<Market>, currencies: Option<Vec<Currency>>, ) -> Result<Arc<HashMap<String, Arc<Market>>>, Error>

Sets market and currency data in the cache

Arguments

• markets - Vector of market definitions to cache
• currencies - Optional vector of currency definitions to cache

Returns

Returns Ok(markets) on successful cache update, preserving ownership for the caller.

Errors

This method should not fail under normal circumstances.

pub async fn market(&self, symbol: &str) -> Result<Arc<Market>, Error>

Gets market information by trading symbol

Arguments

• symbol - Trading pair symbol (e.g., “BTC/USDT”)

Returns

Returns the market definition for the specified symbol.

Errors

Returns an error if markets are not loaded or the symbol is not found.

pub async fn market_by_id(&self, id: &str) -> Result<Arc<Market>, Error>

Gets market information by exchange-specific market ID

Arguments

• id - Exchange-specific market identifier

Returns

Returns the market definition for the specified ID.

Errors

Returns an error if the market ID is not found.

pub async fn currency(&self, code: &str) -> Result<Arc<Currency>, Error>

Gets currency information by currency code

Arguments

• code - Currency code (e.g., “BTC”, “USDT”)

Returns

Returns the currency definition for the specified code.

Errors

Returns an error if the currency is not found.

pub async fn symbols(&self) -> Result<Vec<String>, Error>

Gets all available trading symbols

Returns

Returns a vector of all trading pair symbols.

pub fn throttle(&self) -> Result<(), Error>

👎Deprecated since 0.2.0: Rate limiting is now handled internally by HttpClient. This method is a no-op.

Applies rate limiting if enabled

Deprecated

Rate limiting is now fully managed by HttpClient internally. This method is a no-op and will be removed in a future version.

pub fn check_required_credentials(&self) -> Result<(), Error>

Checks that required API credentials are configured

Returns

Returns Ok(()) if both API key and secret are present.

Errors

Returns an authentication error if credentials are missing.

pub fn nonce(&self) -> i64

Gets a nonce value (current timestamp in milliseconds)

Returns

Returns current Unix timestamp in milliseconds.

pub fn build_query_string(&self, params: &HashMap<String, Value>) -> String

Builds a URL query string from parameters

Arguments

• params - Parameter key-value pairs

Returns

Returns a URL-encoded query string (e.g., “key1=value1&key2=value2”).

pub fn parse_json(&self, response: &str) -> Result<Value, Error>

Parses a JSON response string

Arguments

• response - JSON string to parse

Returns

Returns the parsed Value on success.

Errors

Returns an error if JSON parsing fails.

pub fn handle_http_error(&self, status_code: u16, response: &str) -> Error

Handles HTTP error responses by mapping status codes to appropriate errors

Arguments

• status_code - HTTP status code
• response - Response body text

Returns

Returns an appropriate Error variant based on the status code.

pub fn safe_string(&self, dict: &Value, key: &str) -> Option<String>

Safely extracts a string value from a JSON object

Arguments

• dict - JSON value to extract from
• key - Key to look up

Returns

Returns Some(String) if the key exists and value is a string, None otherwise.

pub fn safe_integer(&self, dict: &Value, key: &str) -> Option<i64>

Safely extracts an integer value from a JSON object

Arguments

• dict - JSON value to extract from
• key - Key to look up

Returns

Returns Some(i64) if the key exists and value is an integer, None otherwise.

pub fn safe_float(&self, dict: &Value, key: &str) -> Option<f64>

Safely extracts a float value from a JSON object

Arguments

• dict - JSON value to extract from
• key - Key to look up

Returns

Returns Some(f64) if the key exists and value is a float, None otherwise.

pub fn safe_bool(&self, dict: &Value, key: &str) -> Option<bool>

Safely extracts a boolean value from a JSON object

Arguments

• dict - JSON value to extract from
• key - Key to look up

Returns

Returns Some(bool) if the key exists and value is a boolean, None otherwise.

pub fn parse_ticker( &self, ticker_data: &Value, market: Option<&Market>, ) -> Result<Ticker, Error>

Parses raw ticker data from exchange API response

Arguments

• ticker_data - Raw ticker JSON data from exchange
• market - Optional market information to populate symbol field

Returns

Returns a parsed Ticker struct.

Errors

Returns an error if required fields are missing.

pub fn parse_trade( &self, trade_data: &Value, market: Option<&Market>, ) -> Result<Trade, Error>

Parses raw trade data from exchange API response

Arguments

• trade_data - Raw trade JSON data from exchange
• market - Optional market information to populate symbol field

Returns

Returns a parsed Trade struct.

Errors

Returns an error if required fields (symbol, side) are missing.

pub fn parse_order( &self, order_data: &Value, market: Option<&Market>, ) -> Result<Order, Error>

Parses raw order data from exchange API response

Arguments

• order_data - Raw order JSON data from exchange
• market - Optional market information to populate symbol field

Returns

Returns a parsed Order struct with all available fields populated.

pub fn parse_balance(&self, balance_data: &Value) -> Result<Balance, Error>

Parses raw balance data from exchange API response

Arguments

• balance_data - Raw balance JSON data from exchange

Returns

Returns a Balance map containing all currency balances with free, used, and total amounts.

pub fn parse_order_book( &self, orderbook_data: &Value, timestamp: Option<i64>, ) -> Result<OrderBook, Error>

Parses raw order book data from exchange API response

Arguments

• orderbook_data - Raw order book JSON data from exchange
• timestamp - Optional timestamp for the order book snapshot

Returns

Returns a parsed OrderBook struct containing bid and ask sides.

pub async fn calculate_fee( &self, symbol: &str, _order_type: OrderType, _side: OrderSide, amount: Decimal, price: Decimal, taker_or_maker: Option<&str>, ) -> Result<Fee, Error>

Calculates trading fee for a given order

Arguments

• symbol - Trading pair symbol
• order_type - Order type (limit, market, etc.)
• side - Order side (buy or sell)
• amount - Trade amount in base currency
• price - Trade price in quote currency
• taker_or_maker - Optional taker or maker designation

Returns

Returns a Fee struct containing the currency, cost, and rate.

pub async fn amount_to_precision( &self, symbol: &str, amount: Decimal, ) -> Result<Decimal, Error>

Converts an amount to the precision required by the market

pub async fn price_to_precision( &self, symbol: &str, price: Decimal, ) -> Result<Decimal, Error>

Converts a price to the precision required by the market

pub async fn cost_to_precision( &self, symbol: &str, cost: Decimal, ) -> Result<Decimal, Error>

Converts a cost to the precision required by the market

pub async fn calculate_cost( &self, symbol: &str, amount: Decimal, price: Decimal, ) -> Result<Decimal, Error>

Calculates the cost of a trade

Arguments

• symbol - Trading pair symbol
• amount - Trade amount in base currency
• price - Trade price in quote currency

Returns

Returns the total cost (amount × price) in quote currency.

Trait Implementations

impl Debug for BaseExchange

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.