Struct OrderArgs 

pub struct OrderArgs {
    pub token_id: String,
    pub price: Decimal,
    pub size: Decimal,
    pub side: Side,
}

Fields

token_id: String

price: Decimal

size: Decimal

side: Side

Implementations

impl OrderArgs

pub fn new(token_id: &str, price: Decimal, size: Decimal, side: Side) -> Self

Examples found in repository

examples/order.rs (line 53)

async fn main() -> Result<()> {
    let base_url =
        env::var("POLY_API_URL").unwrap_or_else(|_| "https://clob.polymarket.com".into());
    let private_key = env_var("POLY_PRIVATE_KEY");
    let chain_id = env::var("POLY_CHAIN_ID")
        .ok()
        .and_then(|value| value.parse::<u64>().ok())
        .unwrap_or(137);

    // CLOB auth process, more info here https://docs.polymarket.com/developers/CLOB/authentication
    let l1_client = ClobClient::with_l1_headers(&base_url, &private_key, chain_id);
    let creds = l1_client.create_or_derive_api_key(None).await?;
    let mut client = ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());

    if let Ok(funder) = env::var("POLY_FUNDER") {
        client.set_funder(&funder)?;
    }

    let gamma_params = GammaListParams {
        limit: Some(5), // how many markets to fetch max
        ..Default::default()
    };
    let markets_response = client.get_markets(None, Some(&gamma_params)).await?;
    let market = markets_response
        .data
        .get(1) // TODO: for some reason market[0] doesnt countain token id, nor condition id. needs fixing
        .expect("Gamma markets returned no data");

    let token_id = market.clob_token_ids.first().unwrap();

    let book = client.get_order_book(&token_id).await?;
    let best_bid = book.bids.first().expect("order book has no bids").price;
    let best_ask = book.asks.first().expect("order book has no asks").price;
    let book_mid = (best_bid + best_ask) / Decimal::from(2);
    let min_order_size: Decimal = 2.into();
    let order_size = min_order_size;
    let order_price = book_mid;

    let args = OrderArgs::new(&token_id, order_price, order_size, Side::BUY);
    let signed_order = client.create_order(&args, None, None, None).await?;

    let response = client.post_order(signed_order, OrderType::GTC).await?;
    println!("order posted: {}", response);

    Ok(())
}

examples/wss_user.rs (line 96)

async fn main() -> Result<()> {
    let base_url =
        env::var("POLY_API_URL").unwrap_or_else(|_| "https://clob.polymarket.com".into());
    let private_key = env_var("POLY_PRIVATE_KEY");
    let chain_id = env::var("POLY_CHAIN_ID")
        .ok()
        .and_then(|value| value.parse::<u64>().ok())
        .unwrap_or(137);

    let l1_client = ClobClient::with_l1_headers(&base_url, &private_key, chain_id);
    let creds = l1_client.create_or_derive_api_key(None).await?;
    let mut l2_client =
        ClobClient::with_l2_headers(&base_url, &private_key, chain_id, creds.clone());

    if let Ok(funder) = env::var("POLY_FUNDER") {
        l2_client.set_funder(&funder)?;
    }

    let min_liquidity = env::var("POLY_WSS_MIN_LIQUIDITY")
        .ok()
        .and_then(|value| Decimal::from_str(&value).ok())
        .unwrap_or_else(|| Decimal::from(1_000_000));

    let gamma_params = GammaListParams {
        limit: Some(5),
        liquidity_num_min: Some(min_liquidity),
        ..Default::default()
    };
    let markets_response = l2_client.get_markets(None, Some(&gamma_params)).await?;

    let market_ids: Vec<String> = markets_response
        .data
        .iter()
        .filter(|market| market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity)
        .map(|market| market.condition_id.clone())
        .filter(|id| !id.is_empty())
        .take(2)
        .collect();

    if market_ids.is_empty() {
        return Err(PolyError::validation(
            "Gamma did not return any markets with condition_ids",
        ));
    }

    let primary_market = markets_response
        .data
        .iter()
        .find(|market| {
            !market.clob_token_ids.is_empty()
                && market.liquidity_num.unwrap_or(Decimal::ZERO) >= min_liquidity
        })
        .ok_or_else(|| {
            PolyError::validation("No Gamma markets returned a CLOB token id for trading")
        })?;
    let token_id = primary_market.clob_token_ids.first().unwrap().clone();

    let book = l2_client.get_order_book(&token_id).await?;
    let _best_ask = book.asks.first().ok_or_else(|| {
        PolyError::validation("Order book has no asks; cannot derive a safe price")
    })?;
    let tick_size = primary_market.minimum_tick_size;
    let max_bid_level = book
        .bids
        .iter()
        .max_by(|a, b| {
            a.size
                .partial_cmp(&b.size)
                .unwrap_or(std::cmp::Ordering::Equal)
        })
        .ok_or_else(|| PolyError::validation("Order book has no depth data"))?;
    let far_price =
        max_bid_level.price - tick_size * Decimal::from_u32(10).unwrap_or(Decimal::ZERO);
    let order_price = if far_price > Decimal::ZERO {
        far_price
    } else {
        max_bid_level.price - tick_size
    };
    let order_size = Decimal::new(5, 0); // 0.1 size
    let order_args = OrderArgs::new(&token_id, order_price, order_size, Side::BUY);

    let mut user_client = WssUserClient::new(creds.clone());
    user_client.subscribe(market_ids.clone()).await?;

    println!(
        "Subscribed to user channel for markets {market_ids:?} (waiting for your cancel/update)..."
    );
    let signed_order = l2_client
        .create_order(&order_args, None, None, None)
        .await?;
    let response = l2_client.post_order(signed_order, OrderType::GTC).await?;
    let order_id = response
        .get("orderID")
        .and_then(|value| value.as_str())
        .ok_or_else(|| PolyError::validation("Post order response missing orderID"))?
        .to_string();
    println!(
        "Placed order on {} @ {}: {response:#}",
        token_id, order_price
    );
    println!(
        "Order id {} - cancel it via the `wss_cancel` example while this stream is running.",
        order_id
    );

    loop {
        match user_client.next_event().await {
            Ok(WssUserEvent::Order(order)) => {
                println!(
                    "order {} {} matched={} price={} side={}",
                    order.id,
                    order.message_type,
                    order.size_matched,
                    order.price,
                    order.side.as_str()
                );
                if order.message_type.eq_ignore_ascii_case("CANCELLATION") {
                    println!("Order {} cancelled; exiting.", order.id);
                    break;
                }
            }
            Ok(WssUserEvent::Trade(trade)) => {
                println!(
                    "trade {} {} {}@{} status={}",
                    trade.id,
                    trade.side.as_str(),
                    trade.size,
                    trade.price,
                    trade.status
                );
            }
            Err(err) => {
                eprintln!("user stream error: {}", err);
                break;
            }
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for OrderArgs

fn clone(&self) -> OrderArgs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrderArgs

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

Formats the value using the given formatter.

impl Default for OrderArgs

fn default() -> Self

Returns the “default value” for a type.