Struct Market

pub struct Market { /* private fields */ }

Market

Through this class you access the functionalities offered by the market, either create purchase order, choose the state of the market, etc …

Implementations

impl Market

pub fn new<'m>(api: CryptoMktApi, market_name: &'m str) -> Self

Create new instance

pub fn get_name(&self) -> String

Get the market name (Ej ETHCLP)

Examples found in repository

examples/simple.rs (line 17)

fn main() {
    let client = CryptoMktClient::new(API_KEY, API_SECRET);

    // Get all markets available
    let markets = client.get_markets();
    for m in markets.iter() {
        println!("{}", m.get_name());

        // Get the current ticker for the market
        match m.get_current_ticker() {
            Ok(ticker) => {
                println!("{:?}", ticker);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }

        println!("------- Orders ------");
        match m.get_orders_book(OrderType::Buy, 0, 20) {
            Ok(orders) => {
                println!("{:?}", orders);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }

        println!("------- Trades ------");
        match m.get_trades("2018-05-15", "2018-05-16", 0, 20) {
            Ok(trades) => {
                println!("{:?}", trades);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }
    }
}

pub fn get_current_ticker(&self) -> Result<Ticker, CryptoMktErrorType>

Get the current ticker

Examples found in repository

examples/simple.rs (line 20)

fn main() {
    let client = CryptoMktClient::new(API_KEY, API_SECRET);

    // Get all markets available
    let markets = client.get_markets();
    for m in markets.iter() {
        println!("{}", m.get_name());

        // Get the current ticker for the market
        match m.get_current_ticker() {
            Ok(ticker) => {
                println!("{:?}", ticker);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }

        println!("------- Orders ------");
        match m.get_orders_book(OrderType::Buy, 0, 20) {
            Ok(orders) => {
                println!("{:?}", orders);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }

        println!("------- Trades ------");
        match m.get_trades("2018-05-15", "2018-05-16", 0, 20) {
            Ok(trades) => {
                println!("{:?}", trades);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }
    }
}

pub fn get_orders_book( &self, orders_type: OrderType, page: u32, limit: u32, ) -> Result<Vec<Book>, CryptoMktErrorType>

Get the order books

Examples found in repository

examples/simple.rs (line 30)

fn main() {
    let client = CryptoMktClient::new(API_KEY, API_SECRET);

    // Get all markets available
    let markets = client.get_markets();
    for m in markets.iter() {
        println!("{}", m.get_name());

        // Get the current ticker for the market
        match m.get_current_ticker() {
            Ok(ticker) => {
                println!("{:?}", ticker);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }

        println!("------- Orders ------");
        match m.get_orders_book(OrderType::Buy, 0, 20) {
            Ok(orders) => {
                println!("{:?}", orders);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }

        println!("------- Trades ------");
        match m.get_trades("2018-05-15", "2018-05-16", 0, 20) {
            Ok(trades) => {
                println!("{:?}", trades);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }
    }
}

pub fn get_trades<'m>( &self, start: &'m str, end: &'m str, page: u32, limit: u32, ) -> Result<Vec<Trade>, CryptoMktErrorType>

Get Trades

Examples found in repository

examples/simple.rs (line 40)

fn main() {
    let client = CryptoMktClient::new(API_KEY, API_SECRET);

    // Get all markets available
    let markets = client.get_markets();
    for m in markets.iter() {
        println!("{}", m.get_name());

        // Get the current ticker for the market
        match m.get_current_ticker() {
            Ok(ticker) => {
                println!("{:?}", ticker);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }

        println!("------- Orders ------");
        match m.get_orders_book(OrderType::Buy, 0, 20) {
            Ok(orders) => {
                println!("{:?}", orders);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }

        println!("------- Trades ------");
        match m.get_trades("2018-05-15", "2018-05-16", 0, 20) {
            Ok(trades) => {
                println!("{:?}", trades);
            }
            Err(e) => {
                println!("{:?}", e);
            }
        }
    }
}

pub fn get_user_orders_by_state( &self, state: OrderState, page: u32, limit: u32, ) -> Result<Vec<Order>, CryptoMktErrorType>

Get user orders by state

pub fn create_order( &self, order_type: OrderType, amount: f32, price: f32, ) -> Result<Vec<Order>, CryptoMktErrorType>

Create order

pub fn get_order_status<'m>( &self, order_id: &'m str, ) -> Result<Order, CryptoMktErrorType>

Get Order status

pub fn cancel_order<'m>( &self, order_id: &'m str, ) -> Result<Order, CryptoMktErrorType>

Cancel Order

pub fn get_order_instant( &self, order_type: OrderType, amount: f32, ) -> Result<OrdersInstant, CryptoMktErrorType>

Get order instant

An instant order corresponds to a purchase or sale request within the Instant Exchange of CryptoMarket.

pub fn create_order_instant( &self, order_type: OrderType, amount: f32, ) -> Result<String, CryptoMktErrorType>

Create an instant order in the Instant Exchange of CryptoMarket