Struct DeribitInstrument 

pub struct DeribitInstrument {

    pub base_currency: Ustr,
    pub block_trade_commission: Option<Decimal>,
    pub block_trade_min_trade_amount: Option<Decimal>,
    pub block_trade_tick_size: Option<Decimal>,
    pub contract_size: Decimal,
    pub counter_currency: Option<Ustr>,
    pub creation_timestamp: i64,
    pub expiration_timestamp: Option<i64>,
    pub future_type: Option<String>,
    pub instrument_id: i64,
    pub instrument_name: Ustr,
    pub instrument_type: Option<String>,
    pub is_active: bool,
    pub kind: DeribitProductType,
    pub maker_commission: Decimal,
    pub max_leverage: Option<i64>,
    pub max_liquidation_commission: Option<Decimal>,
    pub min_trade_amount: Decimal,
    pub option_type: Option<DeribitOptionType>,
    pub price_index: Option<String>,
    pub quote_currency: Ustr,
    pub settlement_currency: Option<Ustr>,
    pub settlement_period: Option<String>,
    pub strike: Option<Decimal>,
    pub taker_commission: Decimal,
    pub tick_size: Decimal,
    pub tick_size_steps: Option<Vec<DeribitTickSizeStep>>,
}

Deribit instrument definition.

Fields

base_currency: Ustr

The underlying currency being traded

block_trade_commission: Option<Decimal>

Block trade commission for instrument

block_trade_min_trade_amount: Option<Decimal>

Minimum amount for block trading

block_trade_tick_size: Option<Decimal>

Specifies minimal price change for block trading

contract_size: Decimal

Contract size for instrument

counter_currency: Option<Ustr>

Counter currency for the instrument

creation_timestamp: i64

The time when the instrument was first created (milliseconds since UNIX epoch)

expiration_timestamp: Option<i64>

The time when the instrument will expire (milliseconds since UNIX epoch)

future_type: Option<String>

Future type (deprecated, use instrument_type instead)

instrument_id: i64

Instrument ID

instrument_name: Ustr

Unique instrument identifier (e.g., “BTC-PERPETUAL”)

instrument_type: Option<String>

Type of the instrument: “linear” or “reversed”

is_active: bool

Indicates if the instrument can currently be traded

kind: DeribitProductType

Product type: “future”, “option”, “spot”, “future_combo”, “option_combo”

maker_commission: Decimal

Maker commission for instrument

max_leverage: Option<i64>

Maximal leverage for instrument (only for futures)

max_liquidation_commission: Option<Decimal>

Maximal liquidation trade commission for instrument (only for futures)

min_trade_amount: Decimal

Minimum amount for trading

option_type: Option<DeribitOptionType>

The option type (only for options)

price_index: Option<String>

Name of price index that is used for this instrument

quote_currency: Ustr

The currency in which the instrument prices are quoted

settlement_currency: Option<Ustr>

Settlement currency for the instrument (not present for spot)

settlement_period: Option<String>

The settlement period (not present for spot)

strike: Option<Decimal>

The strike value (only for options)

taker_commission: Decimal

Taker commission for instrument

tick_size: Decimal

Specifies minimal price change and number of decimal places for instrument prices

tick_size_steps: Option<Vec<DeribitTickSizeStep>>

Tick size steps for different price ranges

Trait Implementations

impl Clone for DeribitInstrument

fn clone(&self) -> DeribitInstrument

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DeribitInstrument

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DeribitInstrument

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DeribitInstrument

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.