fix: add missing features

Author: arnavj-poly

src/clob/client.rs

@@ -53,9 +53,9 @@ use crate::clob::types::{
     CreateRfqRequestRequest, CreateRfqRequestResponse, RfqQuote, RfqQuotesRequest, RfqRequest,
     RfqRequestsRequest,
 };
-use crate::clob::types::{SignableOrder, SignatureType, SignedOrder, TickSize};
+use crate::clob::types::{OrderType, Side, SignableOrder, SignatureType, SignedOrder, TickSize};
 use crate::error::{Error, Kind as ErrorKind, Synchronization};
-use crate::types::{Address, B256};
+use crate::types::{Address, B256, Decimal};
 use crate::{
     AMOY, POLYGON, Result, Timestamp, ToQueryParams as _, auth, contract_config,
     derive_proxy_wallet, derive_safe_wallet,
@@ -1227,6 +1227,55 @@ impl<S: State> Client<S> {
         crate::request(&self.inner.client, request, None).await
     }
 
+    /// Returns raw on-chain trade events for a market condition ID.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the request fails or the condition ID is invalid.
+    pub async fn market_trades_events(&self, condition_id: &str) -> Result<serde_json::Value> {
+        let request = self
+            .client()
+            .request(
+                Method::GET,
+                format!("{}markets/live-activity/{condition_id}", self.host()),
+            )
+            .build()?;
+
+        crate::request(&self.inner.client, request, None).await
+    }
+
+    /// Calculates the effective fill price for a market order by walking the orderbook.
+    ///
+    /// Fetches the orderbook for `token_id` and delegates to
+    /// [`crate::clob::utilities::calculate_market_price`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the orderbook request fails or there is no liquidity
+    /// and `order_type` is [`OrderType::FOK`].
+    pub async fn calculate_market_price(
+        &self,
+        token_id: U256,
+        side: Side,
+        amount: Decimal,
+        order_type: OrderType,
+    ) -> Result<Decimal> {
+        let book = self
+            .order_book(&OrderBookSummaryRequest {
+                token_id,
+                side: None,
+            })
+            .await?;
+
+        super::utilities::calculate_market_price(&book, side, amount, &order_type).ok_or_else(
+            || {
+                Error::validation(format!(
+                    "Insufficient liquidity to fill {amount} on {side:?} for {token_id}"
+                ))
+            },
+        )
+    }
+
     fn client(&self) -> &ReqwestClient {
         &self.inner.client
     }
@@ -2323,6 +2372,7 @@ impl<K: Kind> Client<Authenticated<K>> {
             metadata: None,
             builder_code: None,
             defer_exec: None,
+            user_usdc_balance: None,
             client: Client {
                 inner: Arc::clone(&self.inner),
                 #[cfg(feature = "heartbeats")]

src/clob/order_builder.rs

@@ -2,6 +2,7 @@ use std::marker::PhantomData;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use alloy::primitives::{B256, U256};
+use alloy::signers::Signer;
 use chrono::{DateTime, Utc};
 use rand::RngExt as _;
 use rust_decimal::prelude::ToPrimitive as _;
@@ -11,6 +12,7 @@ use crate::auth::Kind as AuthKind;
 use crate::auth::state::Authenticated;
 use crate::clob::Client;
 use crate::clob::types::request::OrderBookSummaryRequest;
+use crate::clob::types::response::PostOrderResponse;
 use crate::clob::types::{
     Amount, AmountInner, Order, OrderPayload, OrderType, Side, SignableOrder, SignatureType,
 };
@@ -51,6 +53,7 @@ pub struct OrderBuilder<OrderKind, K: AuthKind> {
     pub(crate) metadata: Option<B256>,
     pub(crate) builder_code: Option<B256>,
     pub(crate) defer_exec: Option<bool>,
+    pub(crate) user_usdc_balance: Option<Decimal>,
     pub(crate) _kind: PhantomData<OrderKind>,
 }
 
@@ -269,6 +272,18 @@ impl<K: AuthKind> OrderBuilder<Limit, K> {
             defer_exec: self.defer_exec,
         })
     }
+
+    /// Convenience: builds, signs, and posts this limit order in a single call.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any of the build, sign, or post steps fails.
+    pub async fn build_sign_and_post<S: Signer>(self, signer: &S) -> Result<PostOrderResponse> {
+        let client = self.client.clone();
+        let order = self.build().await?;
+        let signed = client.sign(signer, order).await?;
+        client.post_order(signed).await
+    }
 }
 
 impl<K: AuthKind> OrderBuilder<Market, K> {
@@ -286,6 +301,15 @@ impl<K: AuthKind> OrderBuilder<Market, K> {
         self
     }
 
+    /// Sets the user's USDC balance. When set on a BUY market order, `build()` shrinks
+    /// the USDC amount to cover platform + builder taker fees so the order stays within
+    /// the user's balance.
+    #[must_use]
+    pub fn user_usdc_balance(mut self, balance: Decimal) -> Self {
+        self.user_usdc_balance = Some(balance);
+        self
+    }
+
     // Attempts to calculate the market price from the top of the book for the particular token.
     // - Uses an orderbook depth search to find the cutoff price:
     //   - BUY + USDC: walk asks until notional >= USDC
@@ -408,6 +432,34 @@ impl<K: AuthKind> OrderBuilder<Market, K> {
             )));
         }
 
+        let amount = match (side, amount.0, self.user_usdc_balance) {
+            (Side::Buy, AmountInner::Usdc(raw), Some(balance))
+                if matches!(order_type, OrderType::FOK | OrderType::FAK) =>
+            {
+                let fee = self.client.fee_rate_bps(token_id).await?;
+                let fee_rate = Decimal::from(fee.base_fee) / Decimal::from(10_000_u32);
+                let fee_exponent = Decimal::from(fee.exponent.unwrap_or(0));
+                let builder_taker_fee = match self.builder_code {
+                    Some(code) if code != B256::ZERO => {
+                        let rate = self.client.builder_fee_rate(code).await?;
+                        Decimal::from(rate.builder_taker_fee_rate_bps) / Decimal::from(10_000_u32)
+                    }
+                    _ => Decimal::ZERO,
+                };
+
+                let adjusted = super::utilities::adjust_market_buy_amount(
+                    raw,
+                    balance,
+                    price,
+                    fee_rate,
+                    fee_exponent,
+                    builder_taker_fee,
+                );
+                Amount::usdc(adjusted)?
+            }
+            _ => amount,
+        };
+
         let raw_amount = amount.as_inner();
 
         let (taker_amount, maker_amount) = match (side, amount.0) {
@@ -465,6 +517,18 @@ impl<K: AuthKind> OrderBuilder<Market, K> {
             defer_exec: self.defer_exec,
         })
     }
+
+    /// Convenience: builds, signs, and posts this market order in a single call.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any of the build, sign, or post steps fails.
+    pub async fn build_sign_and_post<S: Signer>(self, signer: &S) -> Result<PostOrderResponse> {
+        let client = self.client.clone();
+        let order = self.build().await?;
+        let signed = client.sign(signer, order).await?;
+        client.post_order(signed).await
+    }
 }
 
 /// Removes trailing zeros, truncates to [`USDC_DECIMALS`] decimal places, and quanitizes as an