Exchanges API

A leveraged pair is a pair like BTC3L/USD.

• :yes : Leveraged pairs will not be filtered.
• :only : ONLY leveraged will be kept.
• :from : Selects non leveraged pairs, that also have at least one leveraged sibling.

Ccxt market types.

Lock held when fetching tickers (list).

The cache for tickers which lasts for 100 minutes by exchange pair.

The cache for currencies which lasts for 1 hour by exchange.

This lock is only used during currency construction.

Caches for tickers for 10-second and concurrently.

A named tuple representing a trade in the CCXT (CryptoCurrency eXchange Trading) library.

• timestamp

• symbol

• order

• type

• side

• takerOrMaker

• price

• amount

• cost

• fee

• fees

A CurrencyCash contextualizes a Cash instance w.r.t. an exchange. Operations are rounded to the currency precision.

• cash

• limits

• precision

• fees

• sandbox

Create a CurrencyCash object.

CurrencyCash(
    id::Type{<:ExchangeID},
    cash_type::Type{<:PlanarCore.Instruments.Cash},
    v;
    sandbox,
    account
) -> PlanarCore.Exchanges.CurrencyCash

A leverage tier represents a range of notional values with its max leverage.

Taker Or Maker

Buy or Sell

Get exchange time as DateTime via gateway.

Check if a timeframe is supported by an exchange.

issupported(tf::TimeFrames.TimeFrame, exc) -> Any

Loads all pairs for a given timeframe, matching the global exc (Exchange object) and config.

load_ohlcv(timeframe::AbstractString; kwargs...) -> Any

Loads all pairs for a given exchange and timeframe, matching the global config and zi (Zarr Instance).

load_ohlcv(
    exc::PlanarCore.ExchangeTypes.Exchange,
    timeframe::AbstractString;
    kwargs...
)

Load given pairs from the global exc (Exchange object) and zi (Zarr Instance).

load_ohlcv(
    pairs::Union{AbstractDict, AbstractArray},
    timeframe::AbstractString;
    kwargs...
) -> Union{Dict{String, Zarr.ZArray}, Dict{String, PlanarCore.Data.PairData}}

Load all pairs from the exchange according to the configured quote currency and timeframe.

load_ohlcv()

Updates pair data of the globally set Exchange instance.

save_ohlcv(
    pair,
    timeframe,
    data;
    kwargs...
) -> Union{Nothing, Zarr.ZArray}

Returns the currency from the exchange if found.

Converts a nested structure (Dict/Vector) recursively into a standard Julia Dict.

_elconvert(v) -> Any

Handles JSON3.Object and JSON3.Array types from gateway responses.

Get the precision of a market, for a given key ('amount' or 'price').

Binance-specific handleleverage — checks leverage key in response.

Fetch positions to detect current leverage.

Returns the limits, precision, and fees for a currency as a named tuple.

Normalize a margin-mode string to its canonical form.

_margin_str_norm(mode) -> Tuple{String, Bool}

Lowercases the input, replaces - and spaces with _, and returns the canonical (mode_str, hedged) tuple. Used by both the generic and Binance string marginmode! overloads so normalization stays in sync.

Get the limits for a market key, and a default.

Negative leverage value for cross margin (Phemex).

Ccxt fees can have different forms. Converts to Julia types.

Extract settlement currency from market.

The accounts available for the exchange.

Exchange authentication is handled by the gateway subprocess automatically when keys are set.

Checks if the exchange instance supports all the calls required by Planar.

check(exc::PlanarCore.ExchangeTypes.Exchange; type)

• exc: an Exchange object to perform the check on.
• type (optional, default is :basic): a symbol representing the type of check to perform.

Checks that the exchange supports the margin mode requested by a strategy.

check_margin_support!(
    exc::PlanarCore.ExchangeTypes.Exchange,
    margin::MarginMode
) -> Bool

Mirrors the existing isolated-margin support check: at strategy instantiation we verify against ccxt (via has) that the exchange the strategy instance is using actually supports the chosen margin mode.

• Any WithMargin mode (isolated or cross) requires setMarginMode.
• Hedged variants (IsolatedHedged, CrossHedged) additionally require setPositionMode (hedge / position-mode support).

A missing capability emits a clear @error (and false is returned) so the strategy fails fast instead of corrupting state later. This matches the lenient style of marginmode! (which warns on setMarginMode failure) but makes the missing hedged/cross support explicit.

Check that the exchange timeout is not too low wrt the interval.

The account currently being used by the exchange.

Default price precision for an exchange.

Bybit-specific dosetmargin.

Phemex-specific dosetmargin.

Set position (hedge) mode for exchange.

dosetpositionmode(exc, symbol; hedged, kwargs...) -> Any

Enables or disables hedge / position mode (setPositionMode). This is an account-wide setting (the symbol argument is optional). hedged MUST be a real boolean: it is passed via the request body (POST) so the JSON bool type is preserved — a query= string would send "true"/"false" which Python treats as truthy (Gotcha #8) and would silently force hedge mode.

Clears all caches.

Set exchange API keys directly on the gateway exchange instance.

Load exchange API keys from config and set on gateway exchange.

Get the markets of the ccxt instance, according to min_volume and quote currency.

filter_markets(
    exc;
    min_volume,
    quot,
    sep,
    type
) -> Dict{Any, Any}

Returns the matching futures exchange instance, if it exists, or the input exchange otherwise.

Convert a gateway response value into a standard Julia Dict.

gatewayconvert(v) -> Any

getexchange!: Get ccxt exchange by symbol, either from cache or create anew via CcxtGateway.

getexchange!(
    x::Symbol;
    ...
) -> PlanarCore.ExchangeTypes.Exchange
getexchange!(
    x::Symbol,
    params;
    account,
    sandbox,
    markets,
    kwargs...
) -> PlanarCore.ExchangeTypes.Exchange

Get the global exchange.

Get exchange timeout in milliseconds.

True if pair is a leveraged pair.

Check if exchange has tickers list.

hastickers(
    exc::PlanarCore.ExchangeTypes.Exchange
) -> Union{Missing, Bool}

Checks if sym (or spot) has volume at or below min_vol (true = skip).

Check if a given pair is active on an exchange.

Checks if a file is younger than a specified period.

isfileyounger(f::AbstractString, p::Dates.Period) -> Any

• f: a string that represents the path to the file.
• p: a Period object that represents the time period.

True if mkt is a leveraged market.

Check if market has percentage or absolute fees.

True if id is a quote id.

Check if rate limit is enabled via gateway.

Fetch the latest price for a specific pair from an exchange.

lastprice(
    pair::AbstractString,
    exc::PlanarCore.ExchangeTypes.Exchange;
    kwargs...
) -> Any

Set leverage for exchange.

leverage!(
    exc::PlanarCore.ExchangeTypes.Exchange,
    v,
    sym::AbstractString;
    side,
    timeout
) -> Any

Constructor that returns a function that checks if a pair is leveraged.

Binance-specific leverage formatting — integer leverage.

Load exchange markets from gateway or cache.

loadmarkets!(exc; cache, agemax)

• exc: an Exchange object that represents the exchange to load markets from.
• cache (optional, default is true): a boolean that indicates whether to rely on storage cache.
• agemax (optional, default is Day(1)): a Period object that represents the maximum cache valid period.

Binance marginmode! override — skip gateway round-trip in sandbox, record locally.

Set margin mode for exchange.

marginmode!(
    exc::PlanarCore.ExchangeTypes.Exchange,
    mode::MarginMode;
    ...
) -> Any
marginmode!(
    exc::PlanarCore.ExchangeTypes.Exchange,
    mode::MarginMode,
    symbol;
    kwargs...
) -> Any

Returns the market from the exchange for a given pair.

Get the maker and taker fee for a given pair from an exchange.

market_fees(
    pair,
    exc;
    only_taker
) -> NamedTuple{(:taker, :maker, :min, :max), <:NTuple{4, Any}}

Get the minimum and maximum amount, cost, and price for a given pair from an exchange.

market_limits(
    pair,
    exc;
    precision,
    default_leverage,
    default_amount,
    default_price,
    default_cost
) -> NamedTuple

Get the amount and price precision for a given pair from an exchange.

market_precision(pair, exc) -> Tuple{Any, Any}

Get vector of market ids from exchange.

• exclude (optional, default is nothing): a symbol or vector of symbols representing market types to exclude.

Any of (:spot, :future, :swap, :option, :margin, :delivery)

Get price ranges using tickers data from exchange.

price_ranges(pair::AbstractString, args...; exc, kwargs...)

Quote id of the market.

Get quote volume from ticker.

quotevol(tkr::AbstractDict) -> Any

Enable or disable rate limit via gateway.

Get exchange rate limit.

Calculate max concurrent requests from rate limits.

Get exchange rate limit tokens.

Enable sandbox mode for exchange via gateway.

sandbox!(
    exc::PlanarCore.ExchangeTypes.Exchange;
    flag,
    remove_keys
) -> Union{Nothing, Bool}

Initializes a gateway-based exchange struct.

setexchange!(
    exc::PlanarCore.ExchangeTypes.Exchange,
    args...;
    markets,
    kwargs...
) -> PlanarCore.ExchangeTypes.CcxtExchange

• exc: an Exchange object to be set up.
• markets (optional, default is :yes): whether to load markets during setup.

Configures the exchange timeframes, loads markets, and sets API keys.

Set the ccxt exchange has flags (already populated by Exchange constructor).

Trims the settlement currency in futures. (mkt is a ccxt market.)

spotsymbol(sym, mkt) -> Any

Convert the string n to Float64.

Fetch the ticker for a specific pair from an exchange via gateway.

ticker!(
    pair,
    exc::PlanarCore.ExchangeTypes.Exchange;
    timeout,
    func,
    delay
) -> Any

Get price from ticker.

tickerprice(tkr) -> Any

Fetch and filter tickers from an exchange, or use the global exchange.

tickers(; ...) -> Union{Dict{String, Any}, Vector{String}}
tickers(
    exc::PlanarCore.ExchangeTypes.Exchange;
    ...
) -> Union{Dict{String, Any}, Vector{String}}
tickers(
    exc::PlanarCore.ExchangeTypes.Exchange,
    quot;
    min_vol,
    skip_fiat,
    with_margin,
    with_leverage,
    as_vec,
    verbose,
    type,
    cross_match
) -> Union{Dict{String, Any}, Vector{String}}

Set exchange timeout (milliseconds) via gateway.

The current timestamp from the exchange via gateway.

Convert a value to a float number.

Convert a value to a number.

The currency cash as a number.

When deserializing an exchange, use the deserialized id to construct the exchange.

When serializing an exchange, serialize only its id.

When serializing an exchange, serialize only its id.

Define an exchange variable set to its matching exchange instance.

Fetch and cache tickers data via gateway.

Functions f(::Exchange) to call when an exchange is loaded

All possible exchanges that can be instantiated by ccxt.

A CcxtExchange wraps a ccxt exchange accessed via CcxtGateway.

Uses HTTP calls to the ccxt-gateway instead of Python ccxt bindings.

Same as ccxt precision mode enums.

Abstract exchange type.

Defines the interface for interacting with crypto exchanges.

Instantiates a new exchange from a symbol using CcxtGateway.

Instantiates a new exchange from a symbol using CcxtGateway. The exchange subprocess is automatically started on the gateway.

A structure for handling Exchange IDs in CCXT.

This structure is used to manage Exchange IDs in the CCXT library.

Checks which exchanges support a given feature via the gateway.

_supports_ws_method(exc::Exchange, sym::AbstractString, suffix::String) -> Bool

Check whether the WebSocket-based fetch method should be used for the given exchange, symbol, and method suffix.

Some exchanges advertise WS methods in their has dict but restrict them to specific market types (e.g., Binance fetchOrderBookWs only works for swap markets). This function encodes those exchange-specific restrictions.

Returns true by default (respects the has dict).

Closes the given exchange by removing it from caches.

Union type of many exchange ids (from Symbol arguments)

Return the given ExchangeID instance.

Create an ExchangeID instance from a string.

Create an ExchangeID instance from a symbol.