Merge pull request #16 from pawsengineer/develop

bump version to 0.1.5

Author: pawsengineer

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "polymarket-rs"
-version = "0.1.4"
+version = "0.1.5"
 edition = "2021"
 authors = ["Pawsengineer <play.pawsengineer@gmail.com>"]
 description = "Rust client library for the Polymarket CLOB and Data API"

Cargo.toml

@@ -2,7 +2,7 @@ use alloy_signer_local::PrivateKeySigner;
 use polymarket_rs::client::{AuthenticatedClient, TradingClient};
 use polymarket_rs::orders::OrderBuilder;
 use polymarket_rs::types::{CreateOrderOptions, OrderArgs, Side, SignatureType};
-use polymarket_rs::Result;
+use polymarket_rs::{OrderType, Result};
 use rust_decimal::Decimal;
 use std::str::FromStr;
 
@@ -66,46 +66,43 @@ async fn main() -> Result<()> {
         Side::Buy,
     );
 
-    let _options = CreateOrderOptions::default()
+    let options = CreateOrderOptions::default()
         .tick_size(Decimal::from_str("0.01").unwrap())
         .neg_risk(false);
 
-    // Note: This creates the order but doesn't post it
-    // Uncomment the following to actually post:
-    // let signed_order = trading_client.create_order(
-    //     &_order_args,
-    //     None,      // expiration (defaults to 0 = no expiration)
-    //     None,      // extras (defaults to ExtraOrderArgs::default())
-    //     _options,
-    // )?;
-    //
-    // println!("Created signed order with salt: {}", signed_order.salt);
-    //
-    // // Post the order
-    // let result = trading_client.post_order(signed_order, OrderType::Gtc).await?;
-    // println!("Order posted: {:?}", result);
+    let signed_order = trading_client.create_order(
+        &_order_args,
+        None, // expiration (defaults to 0 = no expiration)
+        None, // extras (defaults to ExtraOrderArgs::default())
+        options,
+    )?;
+
+    println!("Created signed order with salt: {}", signed_order.salt);
 
-    println!("Order creation example completed (not posted)");
+    // Post the order
+    let result = trading_client
+        .post_order(signed_order, OrderType::Gtc)
+        .await?;
+    println!("Order posted: {:?}", result);
 
     // Step 5: Cancel market orders (example - NOT executed)
     println!("\n5. Cancel market orders example...");
-    // Uncomment to cancel orders for a specific market:
-    // let result = trading_client.cancel_market_orders(Some("0xaaa"), None).await?;
+
+    // Cancel orders for a specific market:
+    let result = trading_client
+        .cancel_market_orders(Some("0xaaa"), None)
+        .await?;
     // Or cancel by asset_id:
     // let result = trading_client.cancel_market_orders(None, Some("100")).await?;
     // Or both:
     // let result = trading_client.cancel_market_orders(Some("0xaaa"), Some("100")).await?;
-    println!("Cancel market orders example completed (not executed)");
+    println!("Cancelled orders: {:?}", result);
 
     // Step 6: Get trade history
     println!("\n6. Fetching trade history...");
     let trades = trading_client.get_trades(Default::default()).await?;
     println!("Trade history: {:?}", trades);
 
-    println!("\n✓ Example completed successfully!");
-    println!("\nNOTE: This example did not post any actual orders.");
-    println!("Uncomment the posting code to execute real trades.");
-
     // ========================================================================
     // POLYPROXY WALLET EXAMPLE
     // ========================================================================

examples/authenticated_trading.rs

@@ -0,0 +1,111 @@
+use alloy_signer_local::PrivateKeySigner;
+use polymarket_rs::client::{AuthenticatedClient, TradingClient};
+use polymarket_rs::orders::OrderBuilder;
+use polymarket_rs::types::{
+    CreateOrderOptions, OrderArgs, OrderType, PostOrderArgs, Side, SignatureType,
+};
+use polymarket_rs::Result;
+use rust_decimal::Decimal;
+use std::str::FromStr;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Replace with your actual private key
+    let private_key =
+        std::env::var("PRIVATE_KEY").expect("PRIVATE_KEY environment variable not set");
+
+    let signer = PrivateKeySigner::from_str(&private_key).expect("Invalid private key");
+
+    let chain_id = 137; // Polygon Mainnet
+    let host = "https://clob.polymarket.com";
+
+    println!("Signer address: {}", signer.address());
+
+    // Step 1: Create or derive API credentials
+    println!("\n1. Creating/deriving API credentials...");
+    let auth_client = AuthenticatedClient::new(host, signer.clone(), chain_id, None, None);
+    let api_creds = auth_client.create_or_derive_api_key().await?;
+    println!("API Key: {}", api_creds.api_key);
+    println!("Successfully authenticated!");
+
+    // Step 2: Create a trading client
+    println!("\n2. Setting up trading client...");
+    let order_builder = OrderBuilder::new(signer.clone(), Some(SignatureType::Eoa), None);
+
+    let trading_client = TradingClient::new(
+        host,
+        signer.clone(),
+        chain_id,
+        api_creds.clone(),
+        order_builder,
+    );
+
+    // Step 3: Create multiple orders
+    println!("\n3. Creating multiple orders...");
+
+    // Specific token IDs
+    let token_id_1 = "";
+    let token_id_2 = "";
+
+    // Create order options (adjust tick_size and neg_risk as needed)
+    let options = CreateOrderOptions::default()
+        .tick_size(Decimal::from_str("0.01").unwrap())
+        .neg_risk(false);
+
+    // Create first order: BUY 10 tokens at 0.50
+    let order_args_1 = OrderArgs::new(
+        token_id_1,
+        Decimal::from_str("0.50").unwrap(), // price
+        Decimal::from_str("10.0").unwrap(), // size
+        Side::Buy,
+    );
+
+    let signed_order_1 = trading_client.create_order(&order_args_1, None, None, options.clone())?;
+    println!("Created order 1: BUY 10 @ 0.50");
+
+    // Create second order: SELL 15 tokens at 0.75
+    let order_args_2 = OrderArgs::new(
+        token_id_2,
+        Decimal::from_str("0.75").unwrap(), // price
+        Decimal::from_str("15.0").unwrap(), // size
+        Side::Sell,
+    );
+
+    let signed_order_2 = trading_client.create_order(&order_args_2, None, None, options.clone())?;
+    println!("Created order 2: SELL 15 @ 0.75");
+
+    // Create third order: BUY 5 tokens at 0.60
+    let order_args_3 = OrderArgs::new(
+        token_id_1,
+        Decimal::from_str("0.60").unwrap(), // price
+        Decimal::from_str("5.0").unwrap(),  // size
+        Side::Buy,
+    );
+
+    let signed_order_3 = trading_client.create_order(&order_args_3, None, None, options)?;
+    println!("Created order 3: BUY 5 @ 0.60");
+
+    // Step 4: Post all orders at once
+    println!("\n4. Posting multiple orders...");
+
+    let results = trading_client
+        .post_orders(&[
+            PostOrderArgs::new(signed_order_1, OrderType::Gtc),
+            PostOrderArgs::new(signed_order_2, OrderType::Gtc),
+            PostOrderArgs::new(signed_order_3, OrderType::Gtc),
+        ])
+        .await?;
+
+    println!("\n✅ Successfully posted {} orders!", results.len());
+
+    for (i, result) in results.iter().enumerate() {
+        println!("\nOrder {}:", i + 1);
+        println!("  Order ID: {}", result.order_id.as_str());
+        println!("  Status: {}", result.status);
+        println!("  Success: {}", result.success);
+        if !result.error_msg.is_empty() {
+            println!("  Error: {}", result.error_msg);
+        }
+    }
+    Ok(())
+}

examples/post_multiple_orders.rs

@@ -1,6 +1,7 @@
 use futures_util::StreamExt;
 use polymarket_rs::types::WsEvent;
-use polymarket_rs::websocket::MarketWsClient;
+use polymarket_rs::websocket::{MarketWsClient, ReconnectConfig, ReconnectingStream};
+use std::time::Duration;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -12,13 +13,29 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         "87769991026114894163580777793845523168226980076553814689875238288185044414090".to_string(),
     ];
 
-    println!("Connecting to CLOB WebSocket...");
+    println!("Connecting to CLOB WebSocket with auto-reconnect...");
     println!("Subscribing to {} token(s)", token_ids.len());
 
-    // Subscribe to market updates
-    let (mut stream, _handle) = client.subscribe_with_handle(token_ids).await?;
+    // Configure reconnection behavior
+    let reconnect_config = ReconnectConfig {
+        initial_delay: Duration::from_secs(1),
+        max_delay: Duration::from_secs(30),
+        multiplier: 2.0,
+        max_attempts: None, // Infinite reconnection attempts
+    };
+
+    // Create a reconnecting stream that will automatically reconnect on disconnection
+    let mut stream = ReconnectingStream::new(reconnect_config, move || {
+        let client = client.clone();
+        let token_ids = token_ids.clone();
+        async move {
+            println!("🔄 Connecting to WebSocket...");
+            let (stream, _handle) = client.subscribe_with_handle(token_ids).await?;
+            println!("✅ Connected successfully!");
+            Ok(stream)
+        }
+    });
 
-    println!("✅ Connected successfully!");
     println!("Waiting for events...\n");
 
     // Process events as they arrive
@@ -79,8 +96,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 }
             }
             Err(e) => {
-                log::warn!("❌ Error: {}", e);
-                break;
+                // With ReconnectingStream, errors are logged but the stream continues
+                // Only fatal errors (like max reconnection attempts) will terminate the stream
+                eprintln!("⚠️  Error: {} - Reconnecting...", e);
             }
         }
     }

examples/websocket_market.rs

@@ -5,7 +5,7 @@ use crate::signing::EthSigner;
 use crate::types::{
     ApiCreds, CancelOrdersResponse, CreateOrderOptions, ExtraOrderArgs, MarketOrderArgs, OpenOrder,
     OpenOrderParams, OpenOrdersResponse, OrderArgs, OrderBookSummary, OrderId, OrderType,
-    PostOrder, PostOrderResponse, Side, SignedOrderRequest, TradeParams,
+    PostOrder, PostOrderArgs, PostOrderResponse, Side, SignedOrderRequest, TradeParams,
 };
 
 /// Client for trading operations
@@ -122,6 +122,45 @@ impl TradingClient {
             .await
     }
 
+    /// Post multiple orders to the exchange
+    ///
+    /// # Arguments
+    /// * `orders` - Slice of order arguments with their types
+    ///
+    /// # Example
+    /// ```no_run
+    /// # use polymarket_rs::client::TradingClient;
+    /// # use polymarket_rs::types::{PostOrderArgs, OrderType};
+    /// # async fn example(trading_client: &TradingClient, order1: polymarket_rs::types::SignedOrderRequest, order2: polymarket_rs::types::SignedOrderRequest) -> polymarket_rs::Result<()> {
+    /// let results = trading_client.post_orders(&[
+    ///     PostOrderArgs::new(order1, OrderType::Gtc),
+    ///     PostOrderArgs::new(order2, OrderType::Gtc),
+    /// ]).await?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub async fn post_orders(&self, orders: &[PostOrderArgs]) -> Result<Vec<PostOrderResponse>> {
+        let owner = self.api_creds.api_key.clone();
+
+        // Build array of PostOrder structs
+        let post_orders: Vec<PostOrder> = orders
+            .iter()
+            .map(|arg| PostOrder::new(arg.order.clone(), owner.clone(), arg.order_type))
+            .collect();
+
+        let headers = create_l2_headers(
+            &self.signer,
+            &self.api_creds,
+            "POST",
+            "/orders",
+            Some(&post_orders),
+        )?;
+
+        self.http_client
+            .post("/orders", &post_orders, Some(headers))
+            .await
+    }
+
     /// Create and post an order in one step
     ///
     /// This is a convenience method that combines create_order and post_order.

src/client/trading.rs

@@ -39,7 +39,7 @@ pub use alloy_signer_local::PrivateKeySigner;
 pub use error::{Error, Result};
 pub use types::{
     ApiCreds, AssetType, ConditionId, CreateOrderOptions, ExtraOrderArgs, MarketOrderArgs,
-    OrderArgs, OrderId, OrderType, Side, SignatureType, TokenId,
+    OrderArgs, OrderId, OrderType, PostOrderArgs, Side, SignatureType, TokenId,
 };
 
 // Re-export clients

src/lib.rs

@@ -1,5 +1,5 @@
 use crate::error::{Error, Result};
-use crate::types::OrderSummary;
+use crate::types::PriceLevel;
 use crate::Side;
 use rust_decimal::Decimal;
 
@@ -18,18 +18,18 @@ use rust_decimal::Decimal;
 /// # Example
 /// ```no_run
 /// use polymarket_rs::orders::calculate_market_price;
-/// use polymarket_rs::types::OrderSummary;
+/// use polymarket_rs::types::PriceLevel;
 /// use polymarket_rs::Side;
 /// use rust_decimal::Decimal;
 ///
 /// let positions = vec![
-///     OrderSummary { price: Decimal::new(50, 2), size: Decimal::new(100, 0) },
-///     OrderSummary { price: Decimal::new(51, 2), size: Decimal::new(200, 0) },
+///     PriceLevel { price: Decimal::new(50, 2), size: Decimal::new(100, 0) },
+///     PriceLevel { price: Decimal::new(51, 2), size: Decimal::new(200, 0) },
 /// ];
 /// let price = calculate_market_price(&positions, Decimal::new(150, 0), Side::Buy).unwrap();
 /// ```
 pub fn calculate_market_price(
-    positions: &[OrderSummary],
+    positions: &[PriceLevel],
     shares_to_match: Decimal,
     side: Side,
 ) -> Result<Decimal> {
@@ -72,8 +72,8 @@ mod tests {
     use super::*;
     use rust_decimal_macros::dec;
 
-    fn order(price: Decimal, size: Decimal) -> OrderSummary {
-        OrderSummary { price, size }
+    fn order(price: Decimal, size: Decimal) -> PriceLevel {
+        PriceLevel { price, size }
     }
 
     #[test]