Struct ExchangeInfoResponse

pub struct ExchangeInfoResponse {
    pub exchange_filters: Vec<Map<String, Value>>,
    pub rate_limits: Vec<ExchangeInfoResponseRateLimitsItem>,
    pub server_time: i64,
    pub symbols: Vec<ExchangeInfoResponseSymbolsItem>,
    pub timezone: String,
}

ExchangeInfoResponse

JSON schema

{
 "type": "object",
 "required": [
   "exchangeFilters",
   "rateLimits",
   "serverTime",
   "symbols",
   "timezone"
 ],
 "properties": {
   "exchangeFilters": {
     "type": "array",
     "items": {
       "type": "object"
     }
   },
   "rateLimits": {
     "type": "array",
     "items": {
       "type": "object",
       "required": [
         "interval",
         "intervalNum",
         "limit",
         "rateLimitType"
       ],
       "properties": {
         "interval": {
           "examples": [
             "MINUTE"
           ],
           "type": "string"
         },
         "intervalNum": {
           "examples": [
             1
           ],
           "type": "integer",
           "format": "int32"
         },
         "limit": {
           "examples": [
             1200
           ],
           "type": "integer",
           "format": "int32"
         },
         "rateLimitType": {
           "examples": [
             "REQUEST_WEIGHT"
           ],
           "type": "string"
         }
       }
     }
   },
   "serverTime": {
     "examples": [
       1592882214236
     ],
     "type": "integer",
     "format": "int64"
   },
   "symbols": {
     "type": "array",
     "items": {
       "type": "object",
       "required": [
         "allowTrailingStop",
         "allowedSelfTradePreventionModes",
         "baseAsset",
         "baseAssetPrecision",
         "baseCommissionPrecision",
         "defaultSelfTradePreventionMode",
         "filters",
         "icebergAllowed",
         "isMarginTradingAllowed",
         "isSpotTradingAllowed",
         "ocoAllowed",
         "orderTypes",
         "permissions",
         "quoteAsset",
         "quoteAssetPrecision",
         "quoteCommissionPrecision",
         "quoteOrderQtyMarketAllowed",
         "status",
         "symbol"
       ],
       "properties": {
         "allowTrailingStop": {
           "examples": [
             false
           ],
           "type": "boolean"
         },
         "allowedSelfTradePreventionModes": {
           "type": "array",
           "items": {
             "examples": [
               "NONE"
             ],
             "type": "string"
           }
         },
         "baseAsset": {
           "examples": [
             "ETH"
           ],
           "type": "string"
         },
         "baseAssetPrecision": {
           "examples": [
             8
           ],
           "type": "integer",
           "format": "int32"
         },
         "baseCommissionPrecision": {
           "examples": [
             8
           ],
           "type": "integer",
           "format": "int32"
         },
         "defaultSelfTradePreventionMode": {
           "examples": [
             "NONE"
           ],
           "type": "string"
         },
         "filters": {
           "type": "array",
           "items": {
             "type": "object",
             "required": [
               "filterType",
               "maxPrice",
               "minPrice",
               "tickSize"
             ],
             "properties": {
               "filterType": {
                 "examples": [
                   "PRICE_FILTER"
                 ],
                 "type": "string"
               },
               "maxPrice": {
                 "examples": [
                   "100000.00000000"
                 ],
                 "type": "string"
               },
               "minPrice": {
                 "examples": [
                   "0.00000100"
                 ],
                 "type": "string"
               },
               "tickSize": {
                 "examples": [
                   "0.00000100"
                 ],
                 "type": "string"
               }
             }
           }
         },
         "icebergAllowed": {
           "type": "boolean"
         },
         "isMarginTradingAllowed": {
           "type": "boolean"
         },
         "isSpotTradingAllowed": {
           "type": "boolean"
         },
         "ocoAllowed": {
           "type": "boolean"
         },
         "orderTypes": {
           "type": "array",
           "items": {
             "examples": [
               "LIMIT"
             ],
             "type": "string"
           }
         },
         "permissions": {
           "type": "array",
           "items": {
             "examples": [
               "SPOT"
             ],
             "type": "string"
           }
         },
         "quoteAsset": {
           "examples": [
             "BTC"
           ],
           "type": "string"
         },
         "quoteAssetPrecision": {
           "examples": [
             8
           ],
           "type": "integer",
           "format": "int32"
         },
         "quoteCommissionPrecision": {
           "examples": [
             8
           ],
           "type": "integer",
           "format": "int32"
         },
         "quoteOrderQtyMarketAllowed": {
           "type": "boolean"
         },
         "status": {
           "examples": [
             "TRADING"
           ],
           "type": "string"
         },
         "symbol": {
           "examples": [
             "ETHBTC"
           ],
           "type": "string"
         }
       }
     }
   },
   "timezone": {
     "examples": [
       "UTC"
     ],
     "type": "string"
   }
 }
}

Fields

exchange_filters: Vec<Map<String, Value>>

rate_limits: Vec<ExchangeInfoResponseRateLimitsItem>

server_time: i64

symbols: Vec<ExchangeInfoResponseSymbolsItem>

timezone: String

Trait Implementations

impl Clone for ExchangeInfoResponse

fn clone(&self) -> ExchangeInfoResponse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExchangeInfoResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExchangeInfoResponse

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&ExchangeInfoResponse> for ExchangeInfoResponse

fn from(value: &ExchangeInfoResponse) -> Self

Converts to this type from the input type.

impl Serialize for ExchangeInfoResponse

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

where __S: Serializer,

Serialize this value into the given Serde serializer.