Refactor REST API tests and enhance WebSocket tests

- Updated REST API tests to improve order handling and logging.
- Introduced a new `order_` member variable to store order details for reuse.
- Enhanced error logging for order creation, modification, and cancellation.
- Adjusted order quantities for better precision in tests.
- Refactored WebSocket tests to include connection and disconnection tracking.
- Added a new test for repeated connect/disconnect scenarios to validate stability.
- Improved logging for market data and user data events.

Author: kzhdev

CHANGELOG.md

@@ -5,19 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [unreleased] -
+## [0.1.1] - 2026-02-01
 
 ### Added
 - DataHandler class to process Coinbase market and user data
 - Unit test for UserThreadWebsocketCallbacks multiple client support
 - IsMarketDataConnected and IsUserDataConnected methods
+- WebSocket connection lifecycle callbacks for market/user data
+- WebSocketClient stop method for explicit shutdown
+- WebSocket test for repeated connect/disconnect cycles
 
 ### Changed
 - Try to find dependent slick components using `find_package` before falling back to `FetchContent`
 - Changed header files from .h to .hpp
 - Decoupled UserThreadWebsocketCallbacks from WebSocketeClient to support multiple WebSocketClient
 - Create market data and user data websocket when url is set
 - UserThreadWebsocketCallbacks now drains multiple queued messages per tick for higher throughput
+- Updated slick-net to v1.2.3 and report version when found
+- Added stricter warning and release optimization flags for MSVC and non-MSVC builds
+- WebSocketCallbacks now receive WebSocketClient pointers on all events, and error callbacks take rvalue strings
+- WebSocketClient now initializes sockets on subscribe and dispatches connect/disconnect events through the data queue
+- UserThreadWebsocketCallbacks now track per-client sequence numbers and active client sets
 
 ### Fixed
 - Various WebSocket unit tests not waiting for snapshot
@@ -30,6 +38,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - PriceBookResponse parsing when pricebook is missing
 - Order status string typo and size_ratio field name
 - Missing default return in FCM trading session state parsing
+- WebSocket teardown now waits briefly for disconnect callbacks and clears per-client sequence state
+- REST API tests now clean up created orders on failures and log API errors for debugging
 
 ## [0.1.0] - 2026-01-13 
 

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.30)
 set(CMAKE_CXX_STANDARD 20)
 
 project(coinbase-advanced-cpp
-    VERSION 0.1.0
+    VERSION 0.1.1
     LANGUAGES CXX)
 
 if (CMAKE_BUILD_TYPE MATCHES Debug)
@@ -19,7 +19,6 @@ find_package(OpenSSL CONFIG REQUIRED)
 find_package(jwt-cpp CONFIG REQUIRED)
 
 find_package(slick-net 1.2.2 CONFIG QUIET)
-
 if (NOT slick-net_FOUND)
     message(STATUS "fetching slick-net...")
     include(FetchContent)
@@ -28,9 +27,11 @@ if (NOT slick-net_FOUND)
     FetchContent_Declare(
         slick-net
         GIT_REPOSITORY https://github.com/SlickQuant/slick-net.git
-        GIT_TAG v1.2.2
+        GIT_TAG v1.2.3
     )
     FetchContent_MakeAvailable(slick-net)
+else()
+    message(STATUS "slick-net: ${slick-net_VERSION}")
 endif()
 
 add_library(coinbase-advanced-cpp INTERFACE)
@@ -51,11 +52,24 @@ if (MSVC)
     add_definitions(-D_WIN32_WINNT=0x0A00)
     set(CMAKE_SUPPRESS_REGENERATION true)   # supress zero_check
     set_target_properties(coinbase-advanced-cpp PROPERTIES LINK_INCREMENTAL ON)
-    target_compile_options(coinbase-advanced-cpp INTERFACE "/MP" "/FS" "/bigobj" "/wd4101")
+    target_compile_options(coinbase-advanced-cpp INTERFACE
+        /MP
+        /FS
+        /bigobj
+        /wd4101
+        /W4
+        $<$<CONFIG:Release>:/O2>
+        $<$<CONFIG:Release>:/GL>  # Whole program optimization
+    )
     # Faster linking
     add_link_options(/DEBUG:FASTLINK)
 else()
-    set(CMAKE_CXX_FLAGS_RELEASE "-O3")
+    add_compile_options(
+        -Wall -Wextra -Wpedantic
+        $<$<CONFIG:Release>:-O3>
+        $<$<CONFIG:Release>:-march=native>
+        $<$<CONFIG:Release>:-flto>
+    )
 endif()
 
 option(BUILD_COINBASE_ADVANCED_TESTS "Build tests" ON)
@@ -102,4 +116,4 @@ install(FILES
     DESTINATION lib/cmake/coinbase-advanced-cpp
 )
 
-message(STATUS "coinbase-advance-cpp: ${PROJECT_VERSION}")
+message(STATUS "${PROJECT_NAME}: ${PROJECT_VERSION}")

README.md

@@ -12,11 +12,14 @@ A modern C++ SDK for interacting with the Coinbase Advanced API, providing both
 
 - **REST API Support**: Complete implementation of Coinbase Advanced API endpoints for accounts, orders, products, trades, and more
 - **WebSocket Support**: Real-time market data streaming with level2, ticker, market trades, and user data channels
+  - Connection lifecycle callbacks for connect/disconnect events
+  - Per-client sequence number tracking for multiple concurrent connections
+  - Explicit shutdown control with `stop()` method
 - **Comprehensive Order Types**: Support for market, limit, stop limit, bracket, and TWAP orders
 - **Type Safety**: Full C++ type definitions for all API responses with JSON serialization/deserialization
 - **Modern C++**: Uses C++20 features, RAII, smart pointers, and modern C++ best practices
 - **Async/Await Support**: Built-in async support using C++ coroutines
-- **Thread-Safe**: Designed for multi-threaded applications
+- **Thread-Safe**: Designed for multi-threaded applications with lock-free data structures
 
 ## Architecture
 
@@ -111,23 +114,61 @@ auto cancel_response = client.cancel_orders({"order_id_123"});
 
 #### WebSocket Client
 
+The SDK provides two callback mechanisms for handling WebSocket data:
+
+1. **`WebsocketCallbacks`**: Callbacks are invoked directly on the WebSocket thread. Use this for simple applications or when you want immediate processing.
+
+2. **`UserThreadWebsocketCallbacks`**: Callbacks are invoked on your own thread. The WebSocket data is queued in a lock-free queue, and you control when to process it by calling `processData()`. Use this for better control over threading and to avoid blocking the WebSocket thread.
+
+##### Using WebsocketCallbacks (WebSocket Thread)
+
 ```cpp
 #include <coinbase/websocket.h>
 
 class MyCallbacks : public coinbase::WebsocketCallbacks {
 public:
-    void onLevel2Snapshot(uin64_t seq_num, const coinbase::Level2UpdateBatch& snapshot) override {
+    // Connection lifecycle callbacks
+    void onMarketDataConnected(coinbase::WebSocketClient* client) override {
+        // Handle market data connection established
+    }
+
+    void onMarketDataDisconnected(coinbase::WebSocketClient* client) override {
+        // Handle market data disconnection
+    }
+
+    void onUserDataConnected(coinbase::WebSocketClient* client) override {
+        // Handle user data connection established
+    }
+
+    void onUserDataDisconnected(coinbase::WebSocketClient* client) override {
+        // Handle user data disconnection
+    }
+
+    // Data callbacks
+    void onLevel2Snapshot(coinbase::WebSocketClient* client, uint64_t seq_num,
+                          const coinbase::Level2UpdateBatch& snapshot) override {
         // Handle level2 snapshot
     }
-    
-    void onLevel2Updates(uin64_t seq_num, const coinbase::Level2UpdateBatch& updates) override {
+
+    void onLevel2Updates(coinbase::WebSocketClient* client, uint64_t seq_num,
+                         const coinbase::Level2UpdateBatch& updates) override {
         // Handle level2 updates
     }
-    
-    void onMarketTrades(uin64_t seq_num, const std::vector<coinbase::MarketTrade>& trades) override {
+
+    void onMarketTrades(coinbase::WebSocketClient* client, uint64_t seq_num,
+                        const std::vector<coinbase::MarketTrade>& trades) override {
         // Handle market trades
     }
-    
+
+    // Error callbacks
+    void onMarketDataError(coinbase::WebSocketClient* client, std::string&& err) override {
+        // Handle market data errors
+    }
+
+    void onUserDataError(coinbase::WebSocketClient* client, std::string&& err) override {
+        // Handle user data errors
+    }
+
     // ... other callback methods
 };
 
@@ -142,8 +183,57 @@ std::vector<coinbase::WebSocketChannel> channels = {
     coinbase::WebSocketChannel::TICKER
 };
 client.subscribe(product_ids, channels);
+
+// Explicitly stop WebSocket connections when done
+client.stop();
 ```
 
+##### Using UserThreadWebsocketCallbacks (User Thread)
+
+```cpp
+#include <coinbase/websocket.h>
+
+class MyCallbacks : public coinbase::UserThreadWebsocketCallbacks {
+public:
+    // Same callback signatures as WebsocketCallbacks
+    void onMarketDataConnected(coinbase::WebSocketClient* client) override {
+        // Handle market data connection established
+    }
+
+    void onLevel2Snapshot(coinbase::WebSocketClient* client, uint64_t seq_num,
+                          const coinbase::Level2UpdateBatch& snapshot) override {
+        // Handle level2 snapshot
+    }
+
+    // ... other callback methods
+};
+
+// Create callbacks and WebSocket client
+MyCallbacks callbacks;
+coinbase::WebSocketClient client(&callbacks);
+
+// Subscribe to channels
+client.subscribe({"BTC-USD", "ETH-USD"}, {
+    coinbase::WebSocketChannel::LEVEL2,
+    coinbase::WebSocketChannel::TICKER
+});
+
+// In your main loop or dedicated thread, process queued data
+while (running) {
+    // Process up to 100 queued messages per call
+    callbacks.processData(100);
+
+    // Your other application logic here
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+}
+
+client.stop();
+```
+
+**Key Differences:**
+- **`WebsocketCallbacks`**: Immediate processing on WebSocket I/O thread. Simple but can block WebSocket operations if callbacks are slow.
+- **`UserThreadWebsocketCallbacks`**: Deferred processing on your thread. Better performance and control, but requires calling `processData()` regularly. Uses lock-free queues for efficient data transfer between threads.
+
 ## API Endpoints
 
 ### REST API