Instruments

Abstract base type for representing an asset.

Defines the interface and common functionality for all asset types.

Abstract base type for representing a variable quantity of some currency.

This type defines the interface and common functionality for all cash types.

An Asset represents a parsed raw (usually ccxt) pair of base and quote currency.

• raw: The raw underlying string e.g. 'BTC/USDT'
• bc: base currency (Symbol)
• qc: quote currency (Symbol)
• fiat: if both the base and quote currencies match a known fiat symbol e.g. 'USDT/USDC'
• leveraged: if parsing matched a leveraged token e.g. 'ETH3L/USDT' or 'ETH3S/USDT'
• unleveraged_bc: a leveraged token with the mod removed, e.g. ETH3L => ETH

> asset = a"BTC/USDT"
> typeof(asset)
Asset{:BTC, :USDT}
end

A symbol checked to be a valid base currency.

A variable quantity of some currency.

• value

> ca = c"USDT"
> typeof(ca)
# Instruments.Cash{:USDT}

A symbol checked to be a valid quote currency.

Derivative parsed accordingly to regex.

• asset

• sc

• id

• strike

• kind

Differentiates between perpetuals and options.

A symbol parsed as settlement currency.

Add v to cash, approximating to zero if cash is a small value.

addzero!(c::Cash, v, args...; kwargs...) -> Cash

Returns the base currency of a.

Sets the cash object to v.

cash!(c::Cash, v, args...; kwargs...) -> Cash

Compact a numeric value num to a smaller unit if possible.

compactnum(val::Number) -> Any

The function converts the numeric value to a smaller unit of time if the value is greater than or equal to 1000, and returns the compacted value.

Example:

num = 5000
result = compactnum(num)  # returns 5 since 5000 can be compacted to 5

Remove leveraged pair pre/suffixes from base currency.

Remove the leverage component from a CCXT quote currency quote.

deleverage_qc(pair::Array{T<:AbstractString, 1})

The function returns a new string with the leverage component removed.

Example:

quote = "3BTC/USDT"
deleveraged_quote = deleverage_qc(quote)  # returns "USDT"

Inplace division for Cash objects.

div!(c::Cash, v, args...; kwargs...) -> Cash

Check if a string s contains any punctuation characters.

has_punct(s::AbstractString) -> Bool

The function returns true if s contains any punctuation characters, and false otherwise.

Example:

s = "Hello, world!"
result = has_punct(s)  # returns true since the string contains a punctuation character

Check if both base and quote are fiat currencies.

Check if quote currency is a stablecoin.

Test if pair has leveraged naming.

Inplace modulo for Cash objects.

mod!(c::Cash, v, args...; kwargs...) -> Cash

Inplace multiplication for Cash objects.

mul!(c::Cash, v, args...; kwargs...) -> Cash

Returns the quote currency of a.

Convert an AbstractAsset object a to its raw representation.

raw(a::AbstractAsset) -> Any

The function returns a new AbstractAsset object with special characters escaped using backslashes.

Example:

a = parse("BTC/USDT")
raw(a) # returns "BTC/USDT"

Inplace remaineder division for Cash objects.

rdiv!(c::Cash, v, args...; kwargs...) -> Cash

Split a CCXT pair (symbol) pair into its base and quote currencies.

splitpair(
    pair::AbstractString
) -> Array{SubString{_A}, 1} where _A

The function returns a tuple containing the base currency and quote currency.

Example: pair = "BTC/USDT" base, quote = splitpair(pair) # returns ("BTC", "USDT")

Strips the settlement currency from a symbol.

Sub v to cash, approximating to zero if cash is a small value.

subzero!(
    c::Instruments.AbstractCash,
    v,
    args...;
    kwargs...
) -> Union{Exchanges.CurrencyCash, Cash}

Predicates according to OctoBot

Create a Derivative from a raw string representation raw, base currency bc, and quote currency qc.

perpetual(raw::AbstractString, bc, qc) -> Any

Short-circuit the execution of a derivative calculation if the derivative d is zero.

sc(d::Instruments.Derivatives.Derivative8; orqc) -> Symbol

Parses pair to an Asset type. ```julia

typeof(a"BTC/USDT")

Instruments.Asset

Macro to instantiate Cash statically.

Don't put spaces between the id and the value.

> ca = c"USDT"1000
USDT: 1000.0

Cash should not be edited by a strategy, therefore functions that mutate its value should be explicitly imported.

Rewrites sym as a perpetual usdt symbol.

> pusdt"btc"
BTC/USDT:USDT

A collection of all possible separators used in market symbols

The default separator used in market symbols

From CCTX

The separator used to separate the settlement currency from the quote currency in a market symbol.

A list of fiat and fiat-like assets names.

A set of symbols representing fiat and fiat-like assets

A regular expression pattern used to match leveraged naming conventions in market symbols. It captures the separator used in leveraged pairs.

Shortand for parsing derivatives:

> drv = d"BTC/USDT:USDT"
> typeof(drv)
# Instruments.Derivatives.Derivative{Asset{:BTC, :USDT}}