Struct ListCandlesRequest 

pub struct ListCandlesRequest {
    pub market: String,
    pub before: Option<String>,
    pub chronological: Option<bool>,
    pub interval: Option<CandleInterval>,
    pub limit: Option<i64>,
    pub range: Option<DateTimeRange>,
}

Get candles associated with market, filtering on several optional fields.

Fields

market: String

before: Option<String>

page before if using pagination

chronological: Option<bool>

interval: Option<CandleInterval>

what kind of candle interval do we want?

limit: Option<i64>

max trades to return

range: Option<DateTimeRange>

range of time to get candles

Implementations

impl ListCandlesRequest

pub fn make_query(&self) -> QueryBody<Variables>

Trait Implementations

impl Clone for ListCandlesRequest

fn clone(&self) -> ListCandlesRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ListCandlesRequest

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

Formats the value using the given formatter.

impl NashProtocol for ListCandlesRequest

type Response = ListCandlesResponse

fn graphql<'life0, 'async_trait>( &'life0 self, _state: Arc<RwLock<State>>, ) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Convert the protocol request to GraphQL from communication with Nash server

fn response_from_json<'life0, 'async_trait>( &'life0 self, response: Value, state: Arc<RwLock<State>>, ) -> Pin<Box<dyn Future<Output = Result<ResponseOrError<Self::Response>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Convert JSON response to request to the protocol’s associated type

fn run_before<'life0, 'async_trait>( &'life0 self, state: Arc<RwLock<State>>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ProtocolHook>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn acquire_permit<'life0, 'async_trait>( &'life0 self, _state: Arc<RwLock<State>>, ) -> Pin<Box<dyn Future<Output = Option<OwnedSemaphorePermit>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

If you want to limit the amount of concurrency of a protocol return a Semaphore here

fn process_response<'life0, 'life1, 'async_trait>( &'life0 self, _response: &'life1 Self::Response, _state: Arc<RwLock<State>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Any state changes that result from execution of the protocol request The default implementation does nothing to state

fn process_error<'life0, 'life1, 'async_trait>( &'life0 self, _response: &'life1 ErrorResponse, _state: Arc<RwLock<State>>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Any errors that result from execution of the protocol request The default implementation does nothing to state

fn run_after<'life0, 'async_trait>( &'life0 self, _state: Arc<RwLock<State>>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<ProtocolHook>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl TryFrom<&GetHistoricRatesRequest> for ListCandlesRequest

type Error = OpenLimitsError

The type returned in the event of a conversion error.

fn try_from(req: &GetHistoricRatesRequest) -> Result<Self>

Performs the conversion.