Enum nash_protocol::protocol::NashProtocolRequest

pub enum NashProtocolRequest {
    AssetNonces(AssetNoncesRequest),
    DhFill(DhFillPoolRequest, Option<Arc<Mutex<Option<OwnedSemaphorePermit>>>>),
    LimitOrder(LimitOrderRequest),
    Orderbook(OrderbookRequest),
    CancelOrders(CancelAllOrders),
    SignState(SignStatesRequest),
    ListMarkets(ListMarketsRequest),
}

An enum wrapping all the different protocol requests

Variants

AssetNonces(AssetNoncesRequest)

Tuple Fields of AssetNonces

0: AssetNoncesRequest

DhFill(DhFillPoolRequest, Option<Arc<Mutex<Option<OwnedSemaphorePermit>>>>)

Tuple Fields of DhFill

0: DhFillPoolRequest1: Option<Arc<Mutex<Option<OwnedSemaphorePermit>>>>

LimitOrder(LimitOrderRequest)

Tuple Fields of LimitOrder

0: LimitOrderRequest

Orderbook(OrderbookRequest)

Tuple Fields of Orderbook

0: OrderbookRequest

CancelOrders(CancelAllOrders)

Tuple Fields of CancelOrders

0: CancelAllOrders

SignState(SignStatesRequest)

Tuple Fields of SignState

0: SignStatesRequest

ListMarkets(ListMarketsRequest)

Tuple Fields of ListMarkets

0: ListMarketsRequest

Trait Implementations

impl Clone for NashProtocolRequest

fn clone(&self) -> NashProtocolRequest

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NashProtocolRequest

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

Formats the value using the given formatter.

impl NashProtocol for NashProtocolRequest

Implement NashProtocol for the enum, threading through to the base implementation for each of the captured types. This could probably be automated wiht a macro.

type Response = NashProtocolResponse

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

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

fn graphql<'life0, 'async_trait>(
    &'life0 self,
    state: Arc<RwLock<State>>
) -> Pin<Box<dyn Future<Output = Result<Value>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: '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
    'life0: 'async_trait,
    Self: 'async_trait, 

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

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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: '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
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

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

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
    'life0: 'async_trait,
    Self: 'async_trait, 

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
    'life0: 'async_trait,
    Self: 'async_trait,