diff --git a/CHANGELOG.md b/CHANGELOG.md
index 51e22d5..7e6d09e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Old implementations are removed when improved
 - Clean, modern code architecture is prioritized
 
+## [2.0.5] - 2025-08-03
+
+### Added
+- **🛡️ Centralized Error Handling System**: Comprehensive error handling infrastructure
+  - `@handle_errors` decorator for consistent error catching and logging
+  - `@retry_on_network_error` decorator with exponential backoff
+  - `@handle_rate_limit` decorator for automatic rate limit management
+  - `@validate_response` decorator for API response validation
+  - Standardized error messages via `ErrorMessages` constants
+  - Structured error context with `ErrorContext` manager
+
+- **📊 Enhanced Logging System**: Production-ready structured logging
+  - `ProjectXLogger` factory for consistent logger configuration
+  - `LogMessages` constants for standardized log messages
+  - `LogContext` manager for adding contextual information
+  - JSON-formatted logging for production environments
+  - Performance logging utilities for operation timing
+  - Configurable SDK-wide logging via `configure_sdk_logging()`
+
+### Changed
+- **🔄 Complete Error Handling Migration**: All modules now use new error handling patterns
+  - Phase 1: Authentication and order management
+  - Phase 2: HTTP client and market data methods
+  - Phase 3: WebSocket and real-time components
+  - Phase 4: Position manager and orderbook components
+  - Phase 5: Cleanup of old error handling code
+
+### Improved
+- **✅ Code Quality**: Zero mypy errors and all ruff checks pass
+- **🔍 Error Visibility**: Structured logging provides better debugging in production
+- **⚡ Reliability**: Automatic retry mechanisms reduce transient failures
+- **📈 Monitoring**: JSON logs enable better log aggregation and analysis
+- **🛠️ Developer Experience**: Consistent error handling patterns across codebase
+
+### Technical Details
+- **Error Decorators**: Applied to 100+ methods across all modules
+- **Type Safety**: Full mypy compliance with strict type checking
+- **Logging Context**: All operations include structured context (operation, timestamps, IDs)
+- **Performance**: Error handling adds minimal overhead (<1ms per operation)
+- **Testing**: All error paths covered with comprehensive test cases
+
 ## [2.0.4] - 2025-08-02
 
 ### Changed
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a162bfa..b55062a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -67,6 +67,7 @@ This project follows strict code style guidelines to maintain consistency and qu
 - Use Python 3.10+ union syntax: `int | None` instead of `Optional[int]`
 - Use `isinstance(x, (A | B))` instead of `isinstance(x, (A, B))`
 - Use `dict[str, Any]` instead of `Dict[str, Any]`
+- Run mypy to ensure type safety: `uv run mypy src/`
 
 ### Async/Await
 - This project uses an async-first architecture
@@ -80,11 +81,43 @@ This project follows strict code style guidelines to maintain consistency and qu
 - Use vectorized operations where possible
 - Validate DataFrame schemas before operations
 
-### Error Handling
-- Wrap ProjectX API calls in try-catch blocks
-- Log errors with context: `self.logger.error(f"Error in {method_name}: {e}")`
-- Return meaningful error responses instead of raising exceptions
-- Validate input parameters and API data
+### Error Handling (v2.0.5+)
+
+Use the centralized error handling system:
+
+1. **Use Error Handling Decorators**
+   ```python
+   from project_x_py.utils import handle_errors, retry_on_network_error
+   
+   @handle_errors("operation name")
+   @retry_on_network_error(max_attempts=3)
+   async def my_method(self, ...):
+       # Method implementation
+   ```
+
+2. **Use Structured Logging**
+   ```python
+   from project_x_py.utils import ProjectXLogger, LogMessages, LogContext
+   
+   logger = ProjectXLogger.get_logger(__name__)
+   
+   with LogContext(logger, operation="fetch_data", symbol="MGC"):
+       logger.info(LogMessages.DATA_FETCH)
+   ```
+
+3. **Use Standardized Error Messages**
+   ```python
+   from project_x_py.utils import ErrorMessages, format_error_message
+   
+   raise ProjectXError(
+       format_error_message(ErrorMessages.ORDER_NOT_FOUND, order_id=order_id)
+   )
+   ```
+
+4. **Validate Input Parameters**
+   - Use `@validate_response` decorator for API responses
+   - Validate parameters at method entry
+   - Return typed errors with context
 
 ## Pull Request Process
 
@@ -106,6 +139,7 @@ This project follows strict code style guidelines to maintain consistency and qu
    ```bash
    uv run ruff format .
    uv run ruff check --fix .
+   uv run mypy src/
    ```
 
 6. **Update documentation** to reflect your changes
diff --git a/README.md b/README.md
index e49b0f5..5f1d824 100644
--- a/README.md
+++ b/README.md
@@ -21,9 +21,20 @@ A **high-performance async Python SDK** for the [ProjectX Trading Platform](http
 
 This Python SDK acts as a bridge between your trading strategies and the ProjectX platform, handling all the complex API interactions, data processing, and real-time connectivity.
 
-## 🚀 v2.0.2 - Async-First Architecture with Enhanced Indicators
+## 🚀 v2.0.5 - Enterprise-Grade Error Handling & Logging
 
-**BREAKING CHANGE**: Version 2.0.0 is a complete rewrite with async-only architecture. All synchronous APIs have been removed in favor of high-performance async implementations.
+**Latest Update (v2.0.5)**: Enhanced error handling system with centralized logging, structured error messages, and comprehensive retry mechanisms.
+
+### What's New in v2.0.5
+
+- **Centralized Error Handling**: Decorators for consistent error handling across all modules
+- **Structured Logging**: JSON-formatted logs with contextual information for production environments
+- **Smart Retry Logic**: Automatic retry for network operations with exponential backoff
+- **Rate Limit Management**: Built-in rate limit handling with automatic throttling
+- **Enhanced Type Safety**: Full mypy compliance with strict type checking
+- **Code Quality**: All ruff checks pass with comprehensive linting
+
+**BREAKING CHANGE**: Version 2.0.0 introduced async-only architecture. All synchronous APIs have been removed in favor of high-performance async implementations.
 
 ### Why Async?
 
@@ -63,6 +74,8 @@ async with ProjectX.from_env() as client:
 - **Real-time WebSockets**: Async streaming for quotes, trades, and account updates
 - **Performance Optimized**: Connection pooling, intelligent caching, memory management
 - **Pattern Recognition**: Fair Value Gaps, Order Blocks, and Waddah Attar Explosion indicators
+- **Enterprise Error Handling**: Production-ready error handling with decorators and structured logging
+- **Comprehensive Testing**: High test coverage with async-safe testing patterns
 
 ## 📦 Installation
 
@@ -308,9 +321,11 @@ data_manager = RealtimeDataManager(
 )
 ```
 
-## 🔍 Error Handling
+## 🔍 Error Handling & Logging (v2.0.5+)
 
-All async operations use typed exceptions:
+### Structured Error Handling
+
+All async operations use typed exceptions with automatic retry and logging:
 
 ```python
 from project_x_py.exceptions import (
@@ -318,16 +333,39 @@ from project_x_py.exceptions import (
     ProjectXOrderError,
     ProjectXRateLimitError
 )
+from project_x_py.utils import configure_sdk_logging
+
+# Configure logging for production
+configure_sdk_logging(
+    level=logging.INFO,
+    format_json=True,  # JSON logs for production
+    log_file="/var/log/projectx/trading.log"
+)
 
 try:
     async with ProjectX.from_env() as client:
-        await client.authenticate()
+        await client.authenticate()  # Automatic retry on network errors
 except ProjectXAuthenticationError as e:
+    # Structured error with context
     print(f"Authentication failed: {e}")
 except ProjectXRateLimitError as e:
+    # Automatic backoff already attempted
     print(f"Rate limit exceeded: {e}")
 ```
 
+### Error Handling Decorators
+
+The SDK uses decorators for consistent error handling:
+
+```python
+# All API methods have built-in error handling
+@handle_errors("place order")
+@retry_on_network_error(max_attempts=3)
+@validate_response(required_fields=["orderId"])
+async def place_order(self, ...):
+    # Method implementation
+```
+
 ## 🤝 Contributing
 
 We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
diff --git a/docs/_reference_docs/ERROR_HANDLING_MIGRATION_GUIDE.md b/docs/_reference_docs/ERROR_HANDLING_MIGRATION_GUIDE.md
new file mode 100644
index 0000000..5678e55
--- /dev/null
+++ b/docs/_reference_docs/ERROR_HANDLING_MIGRATION_GUIDE.md
@@ -0,0 +1,519 @@
+# Error Handling and Logging Migration Guide
+
+This guide provides instructions for migrating existing code to use the new centralized error handling and logging utilities introduced in Phase 4 of the refactoring plan.
+
+## Overview
+
+The new error handling system provides:
+- Consistent error handling patterns via decorators
+- Structured logging with JSON support
+- Automatic retry logic for network operations
+- Standardized error messages and codes
+- Better error context and debugging information
+
+## Migration Steps
+
+### 1. Replace Manual Error Handling with Decorators
+
+#### Before:
+```python
+async def get_orders(self) -> list[Order]:
+    try:
+        response = await self._make_request("GET", "/orders")
+        return [Order(**order) for order in response]
+    except httpx.HTTPError as e:
+        self.logger.error(f"Failed to fetch orders: {e}")
+        raise ProjectXConnectionError(f"Failed to fetch orders: {e}") from e
+    except Exception as e:
+        self.logger.error(f"Unexpected error fetching orders: {e}")
+        raise ProjectXError(f"Unexpected error: {e}") from e
+```
+
+#### After:
+```python
+from project_x_py.utils import handle_errors, validate_response
+
+@handle_errors("fetch orders")
+@validate_response(response_type=list)
+async def get_orders(self) -> list[Order]:
+    response = await self._make_request("GET", "/orders")
+    return [Order(**order) for order in response]
+```
+
+### 2. Replace Manual Retry Logic
+
+#### Before:
+```python
+async def _make_request(self, method: str, endpoint: str, retry_count: int = 0):
+    try:
+        response = await self.client.request(method, endpoint)
+        return response.json()
+    except httpx.ConnectError as e:
+        if retry_count < self.config.retry_attempts:
+            wait_time = 2 ** retry_count
+            self.logger.warning(f"Connection error, retrying in {wait_time}s: {e}")
+            await asyncio.sleep(wait_time)
+            return await self._make_request(method, endpoint, retry_count + 1)
+        raise ProjectXConnectionError(f"Failed to connect: {e}") from e
+```
+
+#### After:
+```python
+from project_x_py.utils import retry_on_network_error
+
+@retry_on_network_error(max_attempts=3, initial_delay=1.0)
+async def _make_request(self, method: str, endpoint: str):
+    response = await self.client.request(method, endpoint)
+    return response.json()
+```
+
+### 3. Use Structured Logging
+
+#### Before:
+```python
+import logging
+
+class OrderManager:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        
+    async def place_order(self, order: OrderRequest):
+        self.logger.info(f"Placing order: {order.symbol} {order.side} {order.size}")
+        # ... implementation
+        self.logger.info(f"Order placed successfully: {order_id}")
+```
+
+#### After:
+```python
+from project_x_py.utils import ProjectXLogger, LogMessages, log_api_call
+
+class OrderManager:
+    def __init__(self):
+        self.logger = ProjectXLogger.get_logger(__name__)
+        
+    async def place_order(self, order: OrderRequest):
+        self.logger.info(
+            LogMessages.ORDER_PLACE,
+            extra={
+                "symbol": order.symbol,
+                "side": order.side,
+                "size": order.size,
+                "order_type": order.order_type,
+            }
+        )
+        
+        # Track API performance
+        start_time = time.time()
+        response = await self._make_request("POST", "/orders", data=order.dict())
+        
+        log_api_call(
+            self.logger,
+            method="POST",
+            endpoint="/orders",
+            status_code=response.status_code,
+            duration=time.time() - start_time,
+            order_id=response.get("id"),
+        )
+```
+
+### 4. Use Standardized Error Messages
+
+#### Before:
+```python
+if not self.is_authenticated:
+    raise ProjectXAuthenticationError("Not authenticated. Please login first.")
+
+if order.size <= 0:
+    raise ProjectXOrderError(f"Invalid order size: {order.size}")
+    
+if instrument is None:
+    raise ProjectXInstrumentError(f"Instrument not found: {symbol}")
+```
+
+#### After:
+```python
+from project_x_py.utils import ErrorMessages, format_error_message
+
+if not self.is_authenticated:
+    raise ProjectXAuthenticationError(ErrorMessages.AUTH_SESSION_EXPIRED)
+
+if order.size <= 0:
+    raise ProjectXOrderError(
+        format_error_message(ErrorMessages.ORDER_INVALID_SIZE, size=order.size)
+    )
+    
+if instrument is None:
+    raise ProjectXInstrumentError(
+        format_error_message(ErrorMessages.INSTRUMENT_NOT_FOUND, symbol=symbol)
+    )
+```
+
+### 5. Handle Rate Limiting
+
+#### Before:
+```python
+async def get_market_data(self, symbol: str):
+    try:
+        return await self._make_request("GET", f"/market/{symbol}")
+    except ProjectXError as e:
+        if e.error_code == 429:  # Rate limited
+            # Manual rate limit handling
+            retry_after = int(e.response_data.get("retry_after", 60))
+            await asyncio.sleep(retry_after)
+            return await self.get_market_data(symbol)
+        raise
+```
+
+#### After:
+```python
+from project_x_py.utils import handle_rate_limit
+
+@handle_rate_limit(fallback_delay=60.0)
+async def get_market_data(self, symbol: str):
+    return await self._make_request("GET", f"/market/{symbol}")
+```
+
+### 6. Batch Error Handling
+
+#### Before:
+```python
+async def process_orders(self, orders: list[OrderRequest]):
+    results = []
+    errors = []
+    
+    for order in orders:
+        try:
+            result = await self.place_order(order)
+            results.append(result)
+        except Exception as e:
+            errors.append((order.id, str(e)))
+            self.logger.error(f"Failed to place order {order.id}: {e}")
+            
+    if errors:
+        self.logger.error(f"Failed to place {len(errors)} orders")
+        
+    return results, errors
+```
+
+#### After:
+```python
+from project_x_py.utils import ErrorContext
+
+async def process_orders(self, orders: list[OrderRequest]):
+    results = []
+    
+    async with ErrorContext("process orders", logger=self.logger) as ctx:
+        for order in orders:
+            try:
+                result = await self.place_order(order)
+                results.append(result)
+            except Exception as e:
+                ctx.add_error(f"order_{order.id}", e)
+                
+    return results, ctx.errors
+```
+
+### 7. Enhanced Exception Context
+
+#### Before:
+```python
+async def execute_trade(self, trade: TradeRequest):
+    try:
+        # ... implementation
+    except Exception as e:
+        self.logger.error(f"Trade execution failed: {e}")
+        raise ProjectXError(f"Trade execution failed: {e}") from e
+```
+
+#### After:
+```python
+from project_x_py.utils import enhance_exception
+
+async def execute_trade(self, trade: TradeRequest):
+    try:
+        # ... implementation
+    except Exception as e:
+        raise enhance_exception(
+            e,
+            operation="execute_trade",
+            instrument=trade.instrument,
+            size=trade.size,
+            side=trade.side,
+            strategy=trade.strategy_name,
+        )
+```
+
+## Module-Specific Migration Examples
+
+### Client HTTP Module
+
+```python
+# client/http.py
+from project_x_py.utils import (
+    handle_errors,
+    retry_on_network_error,
+    ProjectXLogger,
+    LogMessages,
+    log_api_call,
+)
+
+class HttpMixin:
+    def __init__(self):
+        self.logger = ProjectXLogger.get_logger(__name__)
+    
+    @handle_errors("API request")
+    @retry_on_network_error(
+        max_attempts=3,
+        initial_delay=1.0,
+        retry_on=(httpx.ConnectError, httpx.TimeoutException)
+    )
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: dict | None = None,
+    ) -> dict:
+        start_time = time.time()
+        
+        # Make request
+        response = await self.client.request(
+            method,
+            self.base_url + endpoint,
+            json=data,
+        )
+        
+        # Log API call
+        log_api_call(
+            self.logger,
+            method=method,
+            endpoint=endpoint,
+            status_code=response.status_code,
+            duration=time.time() - start_time,
+        )
+        
+        response.raise_for_status()
+        return response.json()
+```
+
+### Order Manager Module
+
+```python
+# order_manager/core.py
+from project_x_py.utils import (
+    handle_errors,
+    validate_response,
+    ErrorMessages,
+    format_error_message,
+    LogContext,
+)
+
+class OrderManagerCore:
+    @handle_errors("place market order")
+    @validate_response(required_fields=["id", "status"])
+    async def place_market_order(
+        self,
+        contract_id: str,
+        side: int,
+        size: int,
+    ) -> OrderPlaceResponse:
+        # Add logging context
+        with LogContext(
+            self.logger,
+            operation="place_market_order",
+            contract_id=contract_id,
+            side=side,
+            size=size,
+        ):
+            # Validate inputs
+            if size <= 0:
+                raise ProjectXOrderError(
+                    format_error_message(
+                        ErrorMessages.ORDER_INVALID_SIZE,
+                        size=size
+                    )
+                )
+            
+            # Place order
+            response = await self._submit_order(
+                contract_id=contract_id,
+                side=side,
+                size=size,
+                order_type="MARKET",
+            )
+            
+            return OrderPlaceResponse(**response)
+```
+
+### WebSocket Module
+
+```python
+# realtime.py
+from project_x_py.utils import (
+    handle_errors,
+    retry_on_network_error,
+    ErrorContext,
+    LogMessages,
+)
+
+class ProjectXRealtimeClient:
+    @handle_errors("WebSocket connection")
+    @retry_on_network_error(max_attempts=5, initial_delay=2.0)
+    async def connect(self) -> bool:
+        self.logger.info(LogMessages.WS_CONNECT)
+        
+        try:
+            await self._ws.connect()
+            self.logger.info(LogMessages.WS_CONNECTED)
+            return True
+        except Exception as e:
+            self.logger.error(
+                LogMessages.WS_CONNECTION_FAILED,
+                extra={"reason": str(e)}
+            )
+            raise
+```
+
+## Best Practices
+
+### 1. Decorator Order
+When using multiple decorators, apply them in this order:
+```python
+@handle_errors("operation name")  # Outermost - catches all errors
+@handle_rate_limit()              # Handle rate limits
+@retry_on_network_error()         # Retry on network errors
+@validate_response()              # Innermost - validates response
+async def my_method():
+    pass
+```
+
+### 2. Logging Context
+Use structured logging with extra fields:
+```python
+self.logger.info(
+    "Processing order",
+    extra={
+        "order_id": order.id,
+        "symbol": order.symbol,
+        "size": order.size,
+        "user_id": self.user_id,
+    }
+)
+```
+
+### 3. Error Messages
+Always use error message constants:
+```python
+# Good
+raise ProjectXError(
+    format_error_message(ErrorMessages.ORDER_NOT_FOUND, order_id=order_id)
+)
+
+# Bad
+raise ProjectXError(f"Order not found: {order_id}")
+```
+
+### 4. Performance Logging
+Track operation performance:
+```python
+from project_x_py.utils import log_performance
+
+start_time = time.time()
+result = await expensive_operation()
+log_performance(
+    self.logger,
+    "expensive_operation",
+    start_time,
+    items_processed=len(result),
+)
+```
+
+## Configuration
+
+### SDK-Wide Logging Configuration
+```python
+# In your application startup
+from project_x_py.utils import configure_sdk_logging
+
+# Development
+configure_sdk_logging(
+    level=logging.DEBUG,
+    format_json=False,
+)
+
+# Production
+configure_sdk_logging(
+    level=logging.INFO,
+    format_json=True,
+    log_file="/var/log/projectx/app.log",
+)
+```
+
+### Environment Variables
+```bash
+# Control logging
+export PROJECTX_LOG_LEVEL=DEBUG
+export PROJECTX_LOG_FORMAT=json
+
+# Control error handling
+export PROJECTX_MAX_RETRIES=5
+export PROJECTX_RETRY_DELAY=2.0
+```
+
+## Testing
+
+When testing code with error handling decorators:
+
+```python
+import pytest
+from unittest.mock import Mock
+
+@pytest.mark.asyncio
+async def test_with_error_handling():
+    # Mock the logger to verify error logging
+    mock_logger = Mock()
+    
+    # Test successful case
+    result = await my_decorated_function()
+    assert result is not None
+    
+    # Test error case
+    with pytest.raises(ProjectXError):
+        await my_failing_function()
+        
+    # Verify error was logged
+    mock_logger.error.assert_called()
+```
+
+## Gradual Migration Strategy
+
+1. **Phase 1**: Migrate critical paths (authentication, order placement)
+2. **Phase 2**: Migrate all API client methods
+3. **Phase 3**: Migrate WebSocket and real-time components
+4. **Phase 4**: Migrate utility functions and helpers
+5. **Phase 5**: Remove old error handling code
+
+## Checklist
+
+For each module being migrated:
+
+- [ ] Replace manual try/except with `@handle_errors`
+- [ ] Add `@retry_on_network_error` to network operations
+- [ ] Add `@handle_rate_limit` to API methods
+- [ ] Add `@validate_response` where appropriate
+- [ ] Replace logger creation with `ProjectXLogger.get_logger()`
+- [ ] Use `LogMessages` constants for common operations
+- [ ] Replace hardcoded error strings with `ErrorMessages`
+- [ ] Add structured logging with `extra` fields
+- [ ] Use `ErrorContext` for batch operations
+- [ ] Add performance logging for slow operations
+- [ ] Update tests to work with decorators
+- [ ] Remove old error handling code
+
+## Benefits After Migration
+
+1. **Consistent Error Messages**: Users see standardized, helpful error messages
+2. **Better Debugging**: Structured logs with context make debugging easier
+3. **Automatic Retries**: Network issues are handled automatically
+4. **Performance Tracking**: Built-in performance metrics
+5. **Reduced Code**: Less boilerplate error handling code
+6. **Better Testing**: Easier to test with consistent patterns
\ No newline at end of file
diff --git a/docs/_reference_docs/PHASE3_ANALYSIS.md b/docs/_reference_docs/PHASE3_ANALYSIS.md
new file mode 100644
index 0000000..14b3e70
--- /dev/null
+++ b/docs/_reference_docs/PHASE3_ANALYSIS.md
@@ -0,0 +1,54 @@
+# Phase 3: Utility Functions Refactoring Analysis
+
+## Current State Analysis
+
+### Overlapping Functionality
+
+1. **Bid-Ask Spread Analysis**
+   - `utils/market_microstructure.py::analyze_bid_ask_spread()`: Generic spread analysis on any DataFrame
+   - `orderbook/analytics.py`: Has spread tracking built into orderbook operations
+   - **Overlap**: Both calculate spread metrics, but orderbook version is integrated with real-time data
+
+2. **Volume Profile**
+   - `utils/market_microstructure.py::calculate_volume_profile()`: Generic volume profile on any DataFrame
+   - `orderbook/profile.py::get_volume_profile()`: Orderbook-specific volume profile using trade data
+   - **Overlap**: Nearly identical logic for binning and calculating POC/Value Area
+
+### Other Utility Files
+
+- `utils/trading_calculations.py`: Generic trading math (tick values, position sizing) - No overlap
+- `utils/data_utils.py`: Data manipulation utilities - No overlap  
+- `utils/formatting.py`: Display formatting - No overlap
+- `utils/pattern_detection.py`: Technical pattern detection - No overlap
+- `utils/portfolio_analytics.py`: Portfolio-level analytics - No overlap
+
+## Refactoring Recommendations
+
+### 1. Move Orderbook-Specific Analysis
+- **Move** `analyze_bid_ask_spread()` logic into `orderbook/analytics.py` as a method that can work on historical data
+- **Move** `calculate_volume_profile()` logic into `orderbook/profile.py` as a static analysis method
+
+### 2. Keep Generic Market Analysis in Utils
+- Create a new `utils/market_analysis.py` for truly generic market calculations that don't belong to any specific domain
+- Keep functions that work on generic DataFrames without domain knowledge
+
+### 3. Clear Boundaries
+
+**Utils (Generic)**: 
+- Functions that work on any DataFrame/data structure
+- No domain-specific knowledge required
+- Reusable across different contexts
+- Examples: data transformation, mathematical calculations, formatting
+
+**Domain-Specific (orderbook/)**:
+- Functions that understand orderbook structure
+- Functions that work with orderbook-specific data types
+- Integration with real-time feeds
+- Examples: bid-ask analysis, volume profile, liquidity analysis
+
+## Implementation Plan
+
+1. **Deprecate** `utils/market_microstructure.py`
+2. **Create** static methods in orderbook modules for DataFrame-based analysis
+3. **Update** imports in any code using the old functions
+4. **Document** the new structure clearly
\ No newline at end of file
diff --git a/docs/_reference_docs/REFACTORING_PLAN.md b/docs/_reference_docs/REFACTORING_PLAN.md
new file mode 100644
index 0000000..0d8602b
--- /dev/null
+++ b/docs/_reference_docs/REFACTORING_PLAN.md
@@ -0,0 +1,247 @@
+# ProjectX Python SDK Refactoring Plan
+
+## Executive Summary
+
+This document outlines the refactoring plan for the ProjectX Python SDK v2.0.4. The analysis identified several areas of redundancy, potential issues, and opportunities for improvement while maintaining the current async-first architecture.
+
+## Key Findings
+
+### 1. Duplicate RateLimiter Implementations
+**Issue**: Two separate RateLimiter classes exist with different implementations:
+- `client/rate_limiter.py`: Async sliding window implementation
+- `utils/rate_limiter.py`: Synchronous context manager implementation
+
+**Impact**: Confusion about which to use, inconsistent rate limiting behavior
+
+### 2. Protocol Files Organization
+**Issue**: Multiple `protocols.py` files scattered across packages:
+- `client/protocols.py`
+- `order_manager/protocols.py`
+- No protocols in `position_manager`, `realtime`, `orderbook` packages
+
+**Impact**: Inconsistent type checking patterns, harder to maintain
+
+### 3. Type Definition Redundancy
+**Issue**: Similar type definitions scattered across:
+- `order_manager/types.py`
+- `orderbook/types.py`
+- `realtime/types.py`
+- `realtime_data_manager/types.py`
+- `position_manager/types.py`
+
+**Impact**: Potential for drift between similar types, maintenance overhead
+
+### 4. Utility Function Overlap
+**Issue**: Market microstructure utilities in `utils/market_microstructure.py` have potential overlap with orderbook analytics functionality
+
+**Impact**: Unclear separation of concerns, possible duplicate implementations
+
+### 5. Missing Centralized Error Handling
+**Issue**: While custom exceptions exist, there's no consistent error handling pattern across modules
+
+**Impact**: Inconsistent error messages, harder debugging
+
+### 6. Import Structure Issues
+**Issue**: Complex import chains and potential circular dependency risks between managers
+
+**Impact**: Slower imports, harder to test in isolation
+
+## Refactoring Plan
+
+### Phase 1: Consolidate Rate Limiting (Priority: High) ✅ COMPLETED
+1. **Remove** `utils/rate_limiter.py` (synchronous version)
+2. **Move** `client/rate_limiter.py` to `utils/async_rate_limiter.py`
+3. **Update** all imports to use the centralized async rate limiter
+4. **Add** comprehensive tests for the unified rate limiter
+
+### Phase 2: Centralize Type Definitions (Priority: High) ✅ COMPLETED
+1. **Create** `project_x_py/types/` package with:
+   - `base.py`: Core types used across modules
+   - `trading.py`: Order and position related types
+   - `market_data.py`: Market data and real-time types
+   - `protocols.py`: All protocol definitions
+2. **Migrate** all protocol files to centralized location
+3. **Update** imports across all modules
+4. **Remove** redundant type definitions
+
+### Phase 3: Refactor Utility Functions (Priority: Medium) ✅ COMPLETED
+1. **Review** overlap between `utils/market_microstructure.py` and orderbook analytics
+2. **Move** orderbook-specific analysis to `orderbook/analytics.py`
+3. **Keep** generic market analysis in utils
+4. **Document** clear boundaries between utilities and domain-specific code
+
+### Phase 4: Implement Consistent Error Handling (Priority: Medium) ✅ COMPLETED
+1. **Create** `error_handler.py` with centralized error handling decorators
+2. **Add** consistent logging patterns for errors
+3. **Implement** retry logic decorators for network operations
+4. **Standardize** error messages and context
+
+### Phase 5: Optimize Import Structure (Priority: Low) ✅ COMPLETED
+1. **Create** lazy import patterns for heavy dependencies
+2. **Move** TYPE_CHECKING imports to reduce runtime overhead
+3. **Analyze** and break circular dependencies
+4. **Implement** `__all__` exports consistently
+
+### Phase 6: Clean Up Unused Code (Priority: Low) ✅ COMPLETED
+1. **Remove** `__pycache__` directories from version control
+2. **Add** `.gitignore` entries for Python cache files
+3. **Remove** any dead code identified by static analysis
+4. **Update** documentation to reflect changes
+
+## Implementation Guidelines
+
+### Breaking Changes Policy
+As per CLAUDE.md guidelines:
+- **No backward compatibility** required
+- **Clean code priority** over compatibility
+- **Remove legacy code** when implementing improvements
+
+### Testing Strategy
+1. **Unit tests** for each refactored component
+2. **Integration tests** for cross-module functionality
+3. **Performance benchmarks** for critical paths
+4. **Type checking** with mypy strict mode
+
+### Migration Path
+1. Each phase should be a separate PR
+2. Update examples after each phase
+3. Run full test suite between phases
+4. Update documentation continuously
+
+## Risk Mitigation
+
+### High Risk Areas
+1. **Rate Limiter Migration**: Could affect API call timing
+   - Mitigation: Comprehensive testing of rate limit behavior
+   
+2. **Type Consolidation**: Could break type checking
+   - Mitigation: Run mypy after each change
+   
+3. **Import Restructuring**: Could introduce circular dependencies
+   - Mitigation: Use import graphs to verify structure
+
+### Low Risk Areas
+1. **Utility refactoring**: Well-isolated functions
+2. **Error handling**: Additive changes only
+3. **Code cleanup**: No functional impact
+
+## Success Metrics
+
+1. **Code Quality**
+   - Reduced duplicate code by 30%
+   - Improved type coverage to 95%
+   - Zero circular dependencies
+
+2. **Performance**
+   - Faster import times (target: <0.5s)
+   - Reduced memory footprint
+   - Consistent async performance
+
+3. **Maintainability**
+   - Clear module boundaries
+   - Centralized configuration
+   - Comprehensive documentation
+
+## Timeline
+
+- **Week 1-2**: Phase 1 ✅ & Phase 2 ✅ (High priority items)
+- **Week 3-4**: Phase 3 ✅ & Phase 4 (Medium priority items)
+- **Week 5-6**: Phase 5 & 6 (Low priority items)
+
+## Progress Updates
+
+### Phase 1 Completion (Completed)
+- ✅ Removed synchronous rate limiter from `utils/rate_limiter.py`
+- ✅ Moved async rate limiter to `utils/async_rate_limiter.py`
+- ✅ Updated all imports across the codebase
+- ✅ Added comprehensive test suite with 9 test cases
+- ✅ Enhanced documentation with examples and use cases
+- ✅ Verified backward compatibility through client re-export
+
+### Phase 2 Completion (Completed)
+- ✅ Created `project_x_py/types/` package with organized structure
+- ✅ Created `base.py` with core types and constants
+- ✅ Created `trading.py` with order and position enums/types
+- ✅ Created `market_data.py` with orderbook and real-time types
+- ✅ Created `protocols.py` consolidating all protocol definitions
+- ✅ Updated 23+ files to use centralized imports
+- ✅ Removed 7 redundant type definition files
+- ✅ Added comprehensive type consistency tests
+- ✅ Fixed all protocol method signatures to match implementations
+- ✅ Fixed one bug in `calculate_portfolio_pnl` (wrong method name)
+- ✅ Resolved all mypy type errors by:
+  - Removing explicit self type annotations from mixin methods
+  - Adding TYPE_CHECKING type hints to mixins for attributes from main classes
+  - Fixing method signature mismatches in protocols
+- ✅ All 249 unit tests passing
+- ✅ mypy reports "Success: no issues found in 70 source files"
+
+### Phase 3 Completion (Completed)
+- ✅ Reviewed overlap between `utils/market_microstructure.py` and orderbook modules
+- ✅ Added `MarketAnalytics.analyze_dataframe_spread()` static method to orderbook/analytics.py
+- ✅ Added `VolumeProfile.calculate_dataframe_volume_profile()` static method to orderbook/profile.py
+- ✅ Completely removed `utils/market_microstructure.py` to eliminate redundancy
+- ✅ Updated all imports and package exports
+- ✅ Created comprehensive documentation in `utils/README.md` explaining boundaries
+- ✅ Added test suite for new static methods (11 test cases)
+- ✅ All tests passing
+
+### Phase 4 Completion (Completed)
+- ✅ Created `utils/error_handler.py` with centralized error handling decorators:
+  - `@handle_errors` - Consistent error catching, logging, and re-raising
+  - `@retry_on_network_error` - Exponential backoff retry for network errors
+  - `@handle_rate_limit` - Automatic retry after rate limit with smart delay
+  - `@validate_response` - Response structure validation
+  - `ErrorContext` - Context manager for batch error collection
+- ✅ Created `utils/logging_config.py` with consistent logging patterns:
+  - `StructuredFormatter` - JSON and human-readable log formatting
+  - `ProjectXLogger` - Factory for configured loggers
+  - `LogMessages` - Standard log message constants
+  - `LogContext` - Context manager for adding log context
+- ✅ Created `utils/error_messages.py` for standardized error messages:
+  - `ErrorMessages` - Comprehensive error message templates
+  - `ErrorCode` - Standardized error codes by category
+  - Error context and enhancement utilities
+- ✅ Added comprehensive test suite (39 test cases)
+- ✅ Fixed deprecation warnings for UTC datetime usage
+- ✅ All tests passing
+- ✅ Created ERROR_HANDLING_MIGRATION_GUIDE.md for implementing the new patterns
+
+**Note**: The error handling infrastructure has been created but not yet applied throughout the codebase. See ERROR_HANDLING_MIGRATION_GUIDE.md for implementation instructions.
+
+### Phase 5 Completion (Completed)
+- ✅ TYPE_CHECKING imports already well-optimized throughout codebase
+- ✅ No circular dependencies found - architecture is clean
+- ✅ Added `__all__` exports to key modules:
+  - `exceptions.py` - All exception classes
+  - `config.py` - Configuration functions and classes
+  - `models.py` - All data model classes
+- ✅ Created `measure_import_performance.py` script to track import times
+- ✅ Measured baseline performance: ~130-160ms per module import
+- ❌ Decided NOT to implement lazy imports:
+  - Only 7-10% improvement for added complexity
+  - Import time dominated by dependencies (polars), not our code
+  - Not worth the maintenance overhead
+
+**Key Findings**: 
+- The codebase already uses TYPE_CHECKING effectively
+- No circular dependencies exist
+- Architecture is clean and well-structured
+- Import performance is acceptable as-is
+
+### Phase 6 Completion (Completed)
+- ✅ Verified no `__pycache__` directories are tracked in git
+- ✅ Confirmed `.gitignore` already has comprehensive Python cache entries:
+  - `__pycache__/`, `*.py[cod]`, `*$py.class`
+  - `.mypy_cache/`, `.pytest_cache/`
+- ✅ Removed dead code identified by static analysis:
+  - Fixed 4 unused imports in TYPE_CHECKING blocks
+  - Cleaned up empty TYPE_CHECKING blocks after import removal
+- ✅ Verified no orphaned references to removed modules
+- ✅ All tests passing
+
+**Summary**: The codebase is now clean with no dead code, proper gitignore configuration, and all unnecessary imports removed.
+
+## Conclusion
+
+This refactoring plan addresses the identified redundancies and structural issues while maintaining the SDK's async-first architecture. The phased approach ensures minimal disruption while progressively improving code quality and maintainability.
\ No newline at end of file
diff --git a/docs/_reference_docs/measure_import_performance.py b/docs/_reference_docs/measure_import_performance.py
new file mode 100755
index 0000000..c1aa0bb
--- /dev/null
+++ b/docs/_reference_docs/measure_import_performance.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+Measure import performance for the ProjectX SDK.
+
+This script helps track import time improvements from lazy loading optimizations.
+
+Author: TexasCoding
+Date: January 2025
+"""
+
+import importlib
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def measure_import_time(module_name: str, fresh: bool = True) -> float:
+    """
+    Measure the time to import a module.
+
+    Args:
+        module_name: Name of module to import
+        fresh: Whether to clear import cache first
+
+    Returns:
+        Import time in seconds
+    """
+    if fresh:
+        # Clear module from cache
+        if module_name in sys.modules:
+            del sys.modules[module_name]
+
+        # Also clear any submodules
+        modules_to_clear = [
+            mod for mod in sys.modules.keys() if mod.startswith(f"{module_name}.")
+        ]
+        for mod in modules_to_clear:
+            del sys.modules[mod]
+
+    start_time = time.perf_counter()
+    importlib.import_module(module_name)
+    end_time = time.perf_counter()
+
+    return end_time - start_time
+
+
+def measure_subprocess_import(module_name: str) -> float:
+    """
+    Measure import time in a fresh subprocess.
+
+    This gives the most accurate measurement as it includes all dependencies.
+    """
+    code = f"""
+import time
+start = time.perf_counter()
+import {module_name}
+end = time.perf_counter()
+print(end - start)
+"""
+
+    result = subprocess.run(
+        [sys.executable, "-c", code],
+        capture_output=True,
+        text=True,
+        env={**subprocess.os.environ, "PYTHONPATH": str(Path.cwd() / "src")},
+    )
+
+    if result.returncode != 0:
+        print(f"Error importing {module_name}:")
+        print(result.stderr)
+        return -1.0
+
+    return float(result.stdout.strip())
+
+
+def main() -> None:
+    """Run import performance measurements."""
+    print("ProjectX SDK Import Performance Measurement")
+    print("=" * 50)
+    print()
+
+    # Modules to test
+    test_modules = [
+        # Core modules
+        ("project_x_py", "Full SDK"),
+        ("project_x_py.client", "Client module"),
+        ("project_x_py.exceptions", "Exceptions"),
+        ("project_x_py.models", "Data models"),
+        ("project_x_py.config", "Configuration"),
+        # Heavy modules
+        ("project_x_py.indicators", "All indicators"),
+        ("project_x_py.indicators.momentum", "Momentum indicators"),
+        ("project_x_py.orderbook", "Orderbook module"),
+        ("project_x_py.utils", "Utilities"),
+        # Managers
+        ("project_x_py.order_manager", "Order manager"),
+        ("project_x_py.position_manager", "Position manager"),
+        ("project_x_py.realtime_data_manager", "Realtime data manager"),
+    ]
+
+    print("Testing import times (fresh subprocess for each)...")
+    print()
+    print(f"{'Module':<40} {'Time (ms)':<12} {'Description':<30}")
+    print("-" * 82)
+
+    total_time = 0.0
+    failed_modules = []
+
+    for module_name, description in test_modules:
+        import_time = measure_subprocess_import(module_name)
+
+        if import_time < 0:
+            failed_modules.append(module_name)
+            print(f"{module_name:<40} {'FAILED':<12} {description:<30}")
+        else:
+            time_ms = import_time * 1000
+            total_time += import_time
+            print(f"{module_name:<40} {time_ms:<12.1f} {description:<30}")
+
+    print("-" * 82)
+    print(f"{'TOTAL':<40} {total_time * 1000:<12.1f} {'All modules':<30}")
+    print()
+
+    if failed_modules:
+        print(f"Failed to import: {', '.join(failed_modules)}")
+        print()
+
+    print("\nPerformance Tips:")
+    print("- Import only what you need (e.g., 'from project_x_py import ProjectX')")
+    print("- The SDK uses TYPE_CHECKING to minimize import overhead")
+    print("- Import times are dominated by dependencies (polars, httpx) not SDK code")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/docs/conf.py b/docs/conf.py
index edfc37a..088c453 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -23,8 +23,8 @@
 project = "project-x-py"
 copyright = "2025, Jeff West"
 author = "Jeff West"
-release = "2.0.4"
-version = "2.0.4"
+release = "2.0.5"
+version = "2.0.5"
 
 # -- General configuration ---------------------------------------------------
 
diff --git a/docs/error_handling.rst b/docs/error_handling.rst
new file mode 100644
index 0000000..cb949e5
--- /dev/null
+++ b/docs/error_handling.rst
@@ -0,0 +1,268 @@
+Error Handling & Logging
+========================
+
+The ProjectX Python SDK (v2.0.5+) includes a comprehensive error handling and logging system designed for production use.
+
+Overview
+--------
+
+The SDK provides:
+
+* Centralized error handling with decorators
+* Structured logging with JSON support
+* Automatic retry logic for network operations
+* Rate limit management with backoff
+* Standardized error messages and codes
+* Context-aware logging for debugging
+
+Error Handling Decorators
+-------------------------
+
+The SDK uses decorators to provide consistent error handling across all modules:
+
+@handle_errors
+~~~~~~~~~~~~~~
+
+Wraps methods to catch and log errors consistently:
+
+.. code-block:: python
+
+   from project_x_py.utils import handle_errors
+   
+   @handle_errors("fetch market data")
+   async def get_market_data(self):
+       # Method implementation
+       pass
+
+Parameters:
+
+* ``operation``: Description of the operation for logging
+* ``logger``: Optional logger instance (defaults to method's module logger)
+* ``reraise``: Whether to re-raise the exception (default: True)
+* ``default_return``: Value to return on error if not re-raising
+
+@retry_on_network_error
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Automatically retries network operations with exponential backoff:
+
+.. code-block:: python
+
+   from project_x_py.utils import retry_on_network_error
+   
+   @retry_on_network_error(max_attempts=3, initial_delay=1.0)
+   async def make_api_call(self):
+       # API call implementation
+       pass
+
+Parameters:
+
+* ``max_attempts``: Maximum number of retry attempts (default: 3)
+* ``backoff_factor``: Multiplier for delay between retries (default: 2.0)
+* ``initial_delay``: Initial delay in seconds (default: 1.0)
+* ``max_delay``: Maximum delay between retries (default: 60.0)
+
+@handle_rate_limit
+~~~~~~~~~~~~~~~~~~
+
+Manages API rate limits with automatic backoff:
+
+.. code-block:: python
+
+   from project_x_py.utils import handle_rate_limit
+   
+   @handle_rate_limit()
+   async def api_method(self):
+       # Rate-limited API call
+       pass
+
+@validate_response
+~~~~~~~~~~~~~~~~~~
+
+Validates API response structure:
+
+.. code-block:: python
+
+   from project_x_py.utils import validate_response
+   
+   @validate_response(required_fields=["orderId", "status"])
+   async def place_order(self):
+       # Returns response that must contain orderId and status
+       pass
+
+Structured Logging
+------------------
+
+ProjectXLogger
+~~~~~~~~~~~~~~
+
+Factory for creating configured loggers:
+
+.. code-block:: python
+
+   from project_x_py.utils import ProjectXLogger
+   
+   logger = ProjectXLogger.get_logger(__name__)
+   logger.info("Starting operation")
+
+LogContext
+~~~~~~~~~~
+
+Context manager for adding structured context to logs:
+
+.. code-block:: python
+
+   from project_x_py.utils import LogContext, LogMessages
+   
+   with LogContext(logger, operation="place_order", symbol="MGC", size=1):
+       logger.info(LogMessages.ORDER_PLACE)
+       # All logs within this context include the extra fields
+
+Standard Log Messages
+~~~~~~~~~~~~~~~~~~~~~
+
+Use predefined log messages for consistency:
+
+.. code-block:: python
+
+   from project_x_py.utils import LogMessages
+   
+   logger.info(LogMessages.AUTH_START)
+   logger.info(LogMessages.ORDER_PLACED, extra={"order_id": "12345"})
+   logger.error(LogMessages.DATA_ERROR, extra={"error": str(e)})
+
+Configuration
+-------------
+
+SDK-Wide Logging Configuration
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Configure logging for your entire application:
+
+.. code-block:: python
+
+   from project_x_py.utils import configure_sdk_logging
+   import logging
+   
+   # Development configuration
+   configure_sdk_logging(
+       level=logging.DEBUG,
+       format_json=False,  # Human-readable format
+   )
+   
+   # Production configuration
+   configure_sdk_logging(
+       level=logging.INFO,
+       format_json=True,  # JSON format for log aggregation
+       log_file="/var/log/projectx/trading.log"
+   )
+
+Environment Variables
+~~~~~~~~~~~~~~~~~~~~~
+
+Control logging via environment:
+
+.. code-block:: bash
+
+   export PROJECTX_LOG_LEVEL=DEBUG
+   export PROJECTX_LOG_FORMAT=json
+   export PROJECTX_MAX_RETRIES=5
+   export PROJECTX_RETRY_DELAY=2.0
+
+Error Types
+-----------
+
+The SDK defines specific exception types for different error scenarios:
+
+.. code-block:: python
+
+   from project_x_py.exceptions import (
+       ProjectXError,              # Base exception
+       ProjectXAuthenticationError, # Authentication failures
+       ProjectXOrderError,         # Order-related errors
+       ProjectXDataError,          # Data/parsing errors
+       ProjectXRateLimitError,     # Rate limit exceeded
+       ProjectXConnectionError,    # Network/connection issues
+       ProjectXServerError,        # Server-side errors
+   )
+
+Best Practices
+--------------
+
+1. **Use decorators consistently**: Apply appropriate decorators to all async methods
+2. **Add context to logs**: Use LogContext and extra fields for debugging
+3. **Handle specific exceptions**: Catch specific exception types when needed
+4. **Let decorators handle retries**: Don't implement manual retry logic
+5. **Use standard messages**: Prefer LogMessages and ErrorMessages constants
+
+Example: Complete Error Handling
+--------------------------------
+
+.. code-block:: python
+
+   from project_x_py.utils import (
+       handle_errors,
+       retry_on_network_error,
+       validate_response,
+       LogContext,
+       LogMessages,
+       ProjectXLogger,
+   )
+   
+   class TradingStrategy:
+       def __init__(self):
+           self.logger = ProjectXLogger.get_logger(__name__)
+       
+       @handle_errors("execute trade")
+       @retry_on_network_error(max_attempts=3)
+       @validate_response(required_fields=["orderId"])
+       async def execute_trade(self, symbol: str, size: int):
+           with LogContext(
+               self.logger,
+               operation="execute_trade",
+               symbol=symbol,
+               size=size
+           ):
+               self.logger.info(LogMessages.ORDER_PLACE)
+               
+               # Place order
+               response = await self.client.place_order(
+                   contract_id=symbol,
+                   order_type=1,  # Limit
+                   side=0,        # Buy
+                   size=size,
+                   limit_price=current_price
+               )
+               
+               self.logger.info(
+                   LogMessages.ORDER_PLACED,
+                   extra={"order_id": response.orderId}
+               )
+               
+               return response
+
+Production Monitoring
+---------------------
+
+The structured logging format enables easy integration with log aggregation tools:
+
+* **Elasticsearch/Kibana**: Parse JSON logs for searching and dashboards
+* **Splunk**: Index structured fields for alerts and analytics
+* **CloudWatch**: Stream logs to AWS for monitoring
+* **Datadog**: Aggregate logs with APM traces
+
+Example log entry in production:
+
+.. code-block:: json
+
+   {
+       "timestamp": "2025-08-03T10:30:45.123Z",
+       "level": "INFO",
+       "logger": "project_x_py.order_manager",
+       "message": "Order placed successfully",
+       "operation": "place_order",
+       "symbol": "MGC",
+       "size": 1,
+       "order_id": "12345",
+       "duration_ms": 150.5
+   }
\ No newline at end of file
diff --git a/docs/index.rst b/docs/index.rst
index 45d1fc1..8a7b530 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -20,7 +20,7 @@ project-x-py Documentation
 **project-x-py** is a high-performance **async Python SDK** for the `ProjectX Trading Platform <https://www.projectx.com/>`_ Gateway API. This library enables developers to build sophisticated trading strategies and applications by providing comprehensive async access to futures trading operations, real-time market data, Level 2 orderbook analysis, and a complete technical analysis suite with 55+ TA-Lib compatible indicators.
 
 .. note::
-   **Version 2.0.0**: Complete async-first rewrite. All APIs now require ``async/await`` for better performance and concurrent operations.
+   **Version 2.0.5**: Enterprise-grade error handling with centralized logging, structured error messages, and comprehensive retry mechanisms. Complete async-first architecture introduced in v2.0.0.
 
 .. warning::
    **Development Phase**: This project is under active development. New updates may introduce breaking changes without backward compatibility. During this development phase, we prioritize clean, modern code architecture over maintaining legacy implementations.
@@ -104,6 +104,13 @@ Key Features
    * Async event-driven architecture
    * WebSocket-based connections with async handlers
 
+🛡️ **Enterprise Features (v2.0.5+)**
+   * Centralized error handling with decorators
+   * Structured JSON logging for production
+   * Automatic retry with exponential backoff
+   * Rate limit management
+   * Comprehensive type safety (mypy compliant)
+
 Table of Contents
 -----------------
 
@@ -115,6 +122,7 @@ Table of Contents
    quickstart
    authentication
    configuration
+   error_handling
 
 .. toctree::
    :maxdepth: 2
diff --git a/pyproject.toml b/pyproject.toml
index ab1daca..e81373d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "project-x-py"
-version = "2.0.4"
+version = "2.0.5"
 description = "High-performance Python SDK for futures trading with real-time WebSocket data, technical indicators, order management, and market depth analysis"
 readme = "README.md"
 license = { text = "MIT" }
diff --git a/src/project_x_py/__init__.py b/src/project_x_py/__init__.py
index fe10cad..bc1fd17 100644
--- a/src/project_x_py/__init__.py
+++ b/src/project_x_py/__init__.py
@@ -25,7 +25,7 @@
 
 from project_x_py.client.base import ProjectXBase
 
-__version__ = "2.0.4"
+__version__ = "2.0.5"
 __author__ = "TexasCoding"
 
 # Core client classes - renamed from Async* to standard names
@@ -94,8 +94,6 @@
 # Utility functions
 from project_x_py.utils import (
     RateLimiter,
-    # Market analysis utilities
-    analyze_bid_ask_spread,
     # Risk and portfolio analysis
     calculate_max_drawdown,
     calculate_portfolio_metrics,
@@ -140,7 +138,6 @@
     # Version info
     "__author__",
     "__version__",
-    "analyze_bid_ask_spread",
     # Technical Analysis
     "calculate_adx",
     "calculate_atr",
diff --git a/src/project_x_py/client/__init__.py b/src/project_x_py/client/__init__.py
index 42fde2a..dbfd2c4 100644
--- a/src/project_x_py/client/__init__.py
+++ b/src/project_x_py/client/__init__.py
@@ -24,7 +24,7 @@
 """
 
 from project_x_py.client.base import ProjectXBase
-from project_x_py.client.rate_limiter import RateLimiter
+from project_x_py.utils.async_rate_limiter import RateLimiter
 
 
 class ProjectX(ProjectXBase):
diff --git a/src/project_x_py/client/auth.py b/src/project_x_py/client/auth.py
index 8f71055..f152d28 100644
--- a/src/project_x_py/client/auth.py
+++ b/src/project_x_py/client/auth.py
@@ -3,7 +3,6 @@
 import base64
 import datetime
 import json
-import logging
 from datetime import timedelta
 from typing import TYPE_CHECKING
 
@@ -11,11 +10,19 @@
 
 from project_x_py.exceptions import ProjectXAuthenticationError
 from project_x_py.models import Account
+from project_x_py.utils import (
+    ErrorMessages,
+    LogMessages,
+    ProjectXLogger,
+    format_error_message,
+    handle_errors,
+    validate_response,
+)
 
 if TYPE_CHECKING:
-    from project_x_py.client.protocols import ProjectXClientProtocol
+    from project_x_py.types import ProjectXClientProtocol
 
-logger = logging.getLogger(__name__)
+logger = ProjectXLogger.get_logger(__name__)
 
 
 class AuthenticationMixin:
@@ -43,6 +50,7 @@ def _should_refresh_token(self: "ProjectXClientProtocol") -> bool:
         buffer_time = timedelta(minutes=5)
         return datetime.datetime.now(pytz.UTC) >= (self.token_expiry - buffer_time)
 
+    @handle_errors("authenticate")
     async def authenticate(self: "ProjectXClientProtocol") -> None:
         """
         Authenticate with ProjectX API and select account.
@@ -65,6 +73,8 @@ async def authenticate(self: "ProjectXClientProtocol") -> None:
             >>>     print(f"Authenticated as {client.account_info.username}")
             >>>     print(f"Using account: {client.account_info.name}")
         """
+        logger.info(LogMessages.AUTH_START, extra={"username": self.username})
+
         # Authenticate and get token
         auth_data = {
             "userName": self.username,
@@ -74,7 +84,7 @@ async def authenticate(self: "ProjectXClientProtocol") -> None:
         response = await self._make_request("POST", "/Auth/loginKey", data=auth_data)
 
         if not response:
-            raise ProjectXAuthenticationError("Authentication failed")
+            raise ProjectXAuthenticationError(ErrorMessages.AUTH_FAILED)
 
         self.session_token = response["token"]
         self.headers["Authorization"] = f"Bearer {self.session_token}"
@@ -92,7 +102,7 @@ async def authenticate(self: "ProjectXClientProtocol") -> None:
                     token_data["exp"], tz=pytz.UTC
                 )
         except Exception as e:
-            self.logger.warning(f"Could not parse token expiry: {e}")
+            logger.warning(LogMessages.AUTH_TOKEN_PARSE_FAILED, extra={"error": str(e)})
             # Set a default expiry of 1 hour
             self.token_expiry = datetime.datetime.now(pytz.UTC) + timedelta(hours=1)
 
@@ -102,13 +112,13 @@ async def authenticate(self: "ProjectXClientProtocol") -> None:
             "POST", "/Account/search", data=payload
         )
         if not accounts_response or not accounts_response.get("success", False):
-            raise ProjectXAuthenticationError("Account search failed")
+            raise ProjectXAuthenticationError(ErrorMessages.API_REQUEST_FAILED)
 
         accounts_data = accounts_response.get("accounts", [])
         accounts = [Account(**acc) for acc in accounts_data]
 
         if not accounts:
-            raise ProjectXAuthenticationError("No accounts found for user")
+            raise ProjectXAuthenticationError(ErrorMessages.AUTH_NO_ACCOUNTS)
 
         # Select account
         if self.account_name:
@@ -122,8 +132,11 @@ async def authenticate(self: "ProjectXClientProtocol") -> None:
             if not selected_account:
                 available = ", ".join(acc.name for acc in accounts)
                 raise ValueError(
-                    f"Account '{self.account_name}' not found. "
-                    f"Available accounts: {available}"
+                    format_error_message(
+                        ErrorMessages.ACCOUNT_NOT_FOUND,
+                        account_name=self.account_name,
+                        available_accounts=available,
+                    )
                 )
         else:
             # Use first account
@@ -131,8 +144,12 @@ async def authenticate(self: "ProjectXClientProtocol") -> None:
 
         self.account_info = selected_account
         self._authenticated = True
-        self.logger.info(
-            f"Authenticated successfully. Using account: {selected_account.name}"
+        logger.info(
+            LogMessages.AUTH_SUCCESS,
+            extra={
+                "account_name": selected_account.name,
+                "account_id": selected_account.id,
+            },
         )
 
     async def _ensure_authenticated(self: "ProjectXClientProtocol") -> None:
@@ -140,6 +157,8 @@ async def _ensure_authenticated(self: "ProjectXClientProtocol") -> None:
         if not self._authenticated or self._should_refresh_token():
             await self.authenticate()
 
+    @handle_errors("list accounts")
+    @validate_response(required_fields=["success", "accounts"])
     async def list_accounts(self: "ProjectXClientProtocol") -> list[Account]:
         """
         List all accounts available to the authenticated user.
diff --git a/src/project_x_py/client/base.py b/src/project_x_py/client/base.py
index 71dc9b8..84b09cc 100644
--- a/src/project_x_py/client/base.py
+++ b/src/project_x_py/client/base.py
@@ -12,11 +12,11 @@
 from project_x_py.client.cache import CacheMixin
 from project_x_py.client.http import HttpMixin
 from project_x_py.client.market_data import MarketDataMixin
-from project_x_py.client.rate_limiter import RateLimiter
 from project_x_py.client.trading import TradingMixin
 from project_x_py.config import ConfigManager
 from project_x_py.exceptions import ProjectXAuthenticationError
 from project_x_py.models import Account, ProjectXConfig
+from project_x_py.utils.async_rate_limiter import RateLimiter
 
 
 class ProjectXBase(
diff --git a/src/project_x_py/client/cache.py b/src/project_x_py/client/cache.py
index 0f960db..14a1058 100644
--- a/src/project_x_py/client/cache.py
+++ b/src/project_x_py/client/cache.py
@@ -10,7 +10,7 @@
 from project_x_py.models import Instrument
 
 if TYPE_CHECKING:
-    from project_x_py.client.protocols import ProjectXClientProtocol
+    from project_x_py.types import ProjectXClientProtocol
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/project_x_py/client/http.py b/src/project_x_py/client/http.py
index fb6ae2d..de3797b 100644
--- a/src/project_x_py/client/http.py
+++ b/src/project_x_py/client/http.py
@@ -1,24 +1,33 @@
 """HTTP client and request handling for ProjectX client."""
 
-import asyncio
-import logging
+import time
 from typing import TYPE_CHECKING, Any
 
 import httpx
 
 from project_x_py.exceptions import (
     ProjectXAuthenticationError,
-    ProjectXConnectionError,
     ProjectXDataError,
     ProjectXError,
     ProjectXRateLimitError,
     ProjectXServerError,
 )
+from project_x_py.utils import (
+    ErrorMessages,
+    LogContext,
+    LogMessages,
+    ProjectXLogger,
+    format_error_message,
+    handle_errors,
+    handle_rate_limit,
+    log_api_call,
+    retry_on_network_error,
+)
 
 if TYPE_CHECKING:
-    from project_x_py.client.protocols import ProjectXClientProtocol
+    from project_x_py.types import ProjectXClientProtocol
 
-logger = logging.getLogger(__name__)
+logger = ProjectXLogger.get_logger(__name__)
 
 
 class HttpMixin:
@@ -80,6 +89,8 @@ async def _ensure_client(self: "ProjectXClientProtocol") -> httpx.AsyncClient:
             self._client = await self._create_client()
         return self._client
 
+    @handle_rate_limit()
+    @retry_on_network_error(max_attempts=3)
     async def _make_request(
         self: "ProjectXClientProtocol",
         method: str,
@@ -106,21 +117,33 @@ async def _make_request(
         Raises:
             ProjectXError: Various specific exceptions based on error type
         """
-        client = await self._ensure_client()
+        with LogContext(
+            logger,
+            operation="api_request",
+            method=method,
+            endpoint=endpoint,
+            has_data=data is not None,
+            has_params=params is not None,
+        ):
+            logger.info(
+                LogMessages.API_REQUEST, extra={"method": method, "endpoint": endpoint}
+            )
 
-        url = f"{self.base_url}{endpoint}"
-        request_headers = {**self.headers, **(headers or {})}
+            client = await self._ensure_client()
 
-        # Add authorization if we have a token
-        if self.session_token and endpoint != "/Auth/loginKey":
-            request_headers["Authorization"] = f"Bearer {self.session_token}"
+            url = f"{self.base_url}{endpoint}"
+            request_headers = {**self.headers, **(headers or {})}
 
-        # Apply rate limiting
-        await self.rate_limiter.acquire()
+            # Add authorization if we have a token
+            if self.session_token and endpoint != "/Auth/loginKey":
+                request_headers["Authorization"] = f"Bearer {self.session_token}"
 
-        self.api_call_count += 1
+            # Apply rate limiting
+            await self.rate_limiter.acquire()
+
+            self.api_call_count += 1
+            start_time = time.time()
 
-        try:
             response = await client.request(
                 method=method,
                 url=url,
@@ -129,23 +152,23 @@ async def _make_request(
                 headers=request_headers,
             )
 
+            # Log API call
+            log_api_call(
+                logger,
+                method=method,
+                endpoint=endpoint,
+                status_code=response.status_code,
+                duration=time.time() - start_time,
+            )
+
             # Handle rate limiting
             if response.status_code == 429:
-                if retry_count < self.config.retry_attempts:
-                    retry_after = int(response.headers.get("Retry-After", "5"))
-                    self.logger.warning(
-                        f"Rate limited, retrying after {retry_after} seconds"
-                    )
-                    await asyncio.sleep(retry_after)
-                    return await self._make_request(
-                        method=method,
-                        endpoint=endpoint,
-                        data=data,
-                        params=params,
-                        headers=headers,
-                        retry_count=retry_count + 1,
+                retry_after = int(response.headers.get("Retry-After", "60"))
+                raise ProjectXRateLimitError(
+                    format_error_message(
+                        ErrorMessages.API_RATE_LIMITED, retry_after=retry_after
                     )
-                raise ProjectXRateLimitError("Rate limit exceeded after retries")
+                )
 
             # Handle successful responses
             if response.status_code in (200, 201, 204):
@@ -166,7 +189,7 @@ async def _make_request(
                         headers=headers,
                         retry_count=retry_count + 1,
                     )
-                raise ProjectXAuthenticationError("Authentication failed")
+                raise ProjectXAuthenticationError(ErrorMessages.AUTH_FAILED)
 
             # Handle client errors
             if 400 <= response.status_code < 500:
@@ -181,53 +204,25 @@ async def _make_request(
                     error_msg = response.text
 
                 if response.status_code == 404:
-                    raise ProjectXDataError(f"Resource not found: {error_msg}")
+                    raise ProjectXDataError(
+                        format_error_message(
+                            ErrorMessages.API_RESOURCE_NOT_FOUND, resource=endpoint
+                        )
+                    )
                 else:
                     raise ProjectXError(error_msg)
 
-            # Handle server errors with retry
+            # Handle server errors
             if 500 <= response.status_code < 600:
-                if retry_count < self.config.retry_attempts:
-                    wait_time = 2**retry_count  # Exponential backoff
-                    self.logger.warning(
-                        f"Server error {response.status_code}, retrying in {wait_time}s"
-                    )
-                    await asyncio.sleep(wait_time)
-                    return await self._make_request(
-                        method=method,
-                        endpoint=endpoint,
-                        data=data,
-                        params=params,
-                        headers=headers,
-                        retry_count=retry_count + 1,
-                    )
                 raise ProjectXServerError(
-                    f"Server error: {response.status_code} - {response.text}"
-                )
-
-        except httpx.ConnectError as e:
-            if retry_count < self.config.retry_attempts:
-                wait_time = 2**retry_count
-                self.logger.warning(f"Connection error, retrying in {wait_time}s: {e}")
-                await asyncio.sleep(wait_time)
-                return await self._make_request(
-                    method, endpoint, data, params, headers, retry_count + 1
-                )
-            raise ProjectXConnectionError(f"Failed to connect to API: {e}") from e
-        except httpx.TimeoutException as e:
-            if retry_count < self.config.retry_attempts:
-                wait_time = 2**retry_count
-                self.logger.warning(f"Request timeout, retrying in {wait_time}s: {e}")
-                await asyncio.sleep(wait_time)
-                return await self._make_request(
-                    method, endpoint, data, params, headers, retry_count + 1
+                    format_error_message(
+                        ErrorMessages.API_SERVER_ERROR,
+                        status_code=response.status_code,
+                        message=response.text[:200],  # Limit message length
+                    )
                 )
-            raise ProjectXConnectionError(f"Request timeout: {e}") from e
-        except Exception as e:
-            if not isinstance(e, ProjectXError):
-                raise ProjectXError(f"Unexpected error: {e}") from e
-            raise
 
+    @handle_errors("get health status")
     async def get_health_status(self: "ProjectXClientProtocol") -> dict[str, Any]:
         """
         Get API health status and client statistics.
diff --git a/src/project_x_py/client/market_data.py b/src/project_x_py/client/market_data.py
index 021117a..f19bcf9 100644
--- a/src/project_x_py/client/market_data.py
+++ b/src/project_x_py/client/market_data.py
@@ -1,7 +1,6 @@
 """Market data operations for ProjectX client."""
 
 import datetime
-import logging
 import re
 import time
 from typing import TYPE_CHECKING, Any
@@ -11,16 +10,27 @@
 
 from project_x_py.exceptions import ProjectXInstrumentError
 from project_x_py.models import Instrument
+from project_x_py.utils import (
+    ErrorMessages,
+    LogContext,
+    LogMessages,
+    ProjectXLogger,
+    format_error_message,
+    handle_errors,
+    validate_response,
+)
 
 if TYPE_CHECKING:
-    from project_x_py.client.protocols import ProjectXClientProtocol
+    from project_x_py.types import ProjectXClientProtocol
 
-logger = logging.getLogger(__name__)
+logger = ProjectXLogger.get_logger(__name__)
 
 
 class MarketDataMixin:
     """Mixin class providing market data functionality."""
 
+    @handle_errors("get instrument")
+    @validate_response(required_fields=["success", "contracts"])
     async def get_instrument(
         self: "ProjectXClientProtocol", symbol: str, live: bool = False
     ) -> Instrument:
@@ -39,36 +49,56 @@ async def get_instrument(
             >>> print(f"Trading {instrument.symbol} - {instrument.name}")
             >>> print(f"Tick size: {instrument.tick_size}")
         """
-        await self._ensure_authenticated()
-
-        # Check cache first
-        cached_instrument = self.get_cached_instrument(symbol)
-        if cached_instrument:
-            return cached_instrument
-
-        # Search for instrument
-        payload = {"searchText": symbol, "live": live}
-        response = await self._make_request("POST", "/Contract/search", data=payload)
+        with LogContext(
+            logger,
+            operation="get_instrument",
+            symbol=symbol,
+            live=live,
+        ):
+            await self._ensure_authenticated()
+
+            # Check cache first
+            cached_instrument = self.get_cached_instrument(symbol)
+            if cached_instrument:
+                logger.info(LogMessages.CACHE_HIT, extra={"symbol": symbol})
+                return cached_instrument
+
+            logger.info(LogMessages.CACHE_MISS, extra={"symbol": symbol})
+
+            # Search for instrument
+            payload = {"searchText": symbol, "live": live}
+            response = await self._make_request(
+                "POST", "/Contract/search", data=payload
+            )
 
-        if not response or not response.get("success", False):
-            raise ProjectXInstrumentError(f"No instruments found for symbol: {symbol}")
+            if not response or not response.get("success", False):
+                raise ProjectXInstrumentError(
+                    format_error_message(
+                        ErrorMessages.INSTRUMENT_NOT_FOUND, symbol=symbol
+                    )
+                )
 
-        contracts_data = response.get("contracts", [])
-        if not contracts_data:
-            raise ProjectXInstrumentError(f"No instruments found for symbol: {symbol}")
+            contracts_data = response.get("contracts", [])
+            if not contracts_data:
+                raise ProjectXInstrumentError(
+                    format_error_message(
+                        ErrorMessages.INSTRUMENT_NOT_FOUND, symbol=symbol
+                    )
+                )
 
-        # Select best match
-        best_match = self._select_best_contract(contracts_data, symbol)
-        instrument = Instrument(**best_match)
+            # Select best match
+            best_match = self._select_best_contract(contracts_data, symbol)
+            instrument = Instrument(**best_match)
 
-        # Cache the result
-        self.cache_instrument(symbol, instrument)
+            # Cache the result
+            self.cache_instrument(symbol, instrument)
+            logger.info(LogMessages.CACHE_UPDATE, extra={"symbol": symbol})
 
-        # Periodic cache cleanup
-        if time.time() - self.last_cache_cleanup > 3600:  # Every hour
-            await self._cleanup_cache()
+            # Periodic cache cleanup
+            if time.time() - self.last_cache_cleanup > 3600:  # Every hour
+                await self._cleanup_cache()
 
-        return instrument
+            return instrument
 
     def _select_best_contract(
         self: "ProjectXClientProtocol",
@@ -131,6 +161,8 @@ def _select_best_contract(
         # Default to first result
         return instruments[0]
 
+    @handle_errors("search instruments")
+    @validate_response(required_fields=["success", "contracts"])
     async def search_instruments(
         self: "ProjectXClientProtocol", query: str, live: bool = False
     ) -> list[Instrument]:
@@ -149,17 +181,35 @@ async def search_instruments(
             >>> for inst in instruments:
             >>>     print(f"{inst.name}: {inst.description}")
         """
-        await self._ensure_authenticated()
+        with LogContext(
+            logger,
+            operation="search_instruments",
+            query=query,
+            live=live,
+        ):
+            await self._ensure_authenticated()
+
+            logger.info(LogMessages.DATA_FETCH, extra={"query": query})
+
+            payload = {"searchText": query, "live": live}
+            response = await self._make_request(
+                "POST", "/Contract/search", data=payload
+            )
 
-        payload = {"searchText": query, "live": live}
-        response = await self._make_request("POST", "/Contract/search", data=payload)
+            if not response or not response.get("success", False):
+                return []
 
-        if not response or not response.get("success", False):
-            return []
+            contracts_data = response.get("contracts", [])
+            instruments = [Instrument(**contract) for contract in contracts_data]
 
-        contracts_data = response.get("contracts", [])
-        return [Instrument(**contract) for contract in contracts_data]
+            logger.info(
+                LogMessages.DATA_RECEIVED,
+                extra={"count": len(instruments), "query": query},
+            )
+
+            return instruments
 
+    @handle_errors("get bars")
     async def get_bars(
         self: "ProjectXClientProtocol",
         symbol: str,
@@ -202,22 +252,37 @@ async def get_bars(
             ...     f"Date range: {data['timestamp'].min()} to {data['timestamp'].max()}"
             ... )
         """
-        await self._ensure_authenticated()
-
-        # Check market data cache
-        cache_key = f"{symbol}_{days}_{interval}_{unit}_{partial}"
-        cached_data = self.get_cached_market_data(cache_key)
-        if cached_data is not None:
-            return cached_data
+        with LogContext(
+            logger,
+            operation="get_bars",
+            symbol=symbol,
+            days=days,
+            interval=interval,
+            unit=unit,
+            partial=partial,
+        ):
+            await self._ensure_authenticated()
+
+            # Check market data cache
+            cache_key = f"{symbol}_{days}_{interval}_{unit}_{partial}"
+            cached_data = self.get_cached_market_data(cache_key)
+            if cached_data is not None:
+                logger.info(LogMessages.CACHE_HIT, extra={"cache_key": cache_key})
+                return cached_data
+
+            logger.info(
+                LogMessages.DATA_FETCH,
+                extra={"symbol": symbol, "days": days, "interval": interval},
+            )
 
-        # Lookup instrument
-        instrument = await self.get_instrument(symbol)
+            # Lookup instrument
+            instrument = await self.get_instrument(symbol)
 
-        # Calculate date range
-        from datetime import timedelta
+            # Calculate date range
+            from datetime import timedelta
 
-        start_date = datetime.datetime.now(pytz.UTC) - timedelta(days=days)
-        end_date = datetime.datetime.now(pytz.UTC)
+            start_date = datetime.datetime.now(pytz.UTC) - timedelta(days=days)
+            end_date = datetime.datetime.now(pytz.UTC)
 
         # Calculate limit based on unit type
         if limit is None:
@@ -257,7 +322,10 @@ async def get_bars(
         # Handle the response format
         if not response.get("success", False):
             error_msg = response.get("errorMessage", "Unknown error")
-            self.logger.error(f"History retrieval failed: {error_msg}")
+            self.logger.error(
+                LogMessages.DATA_ERROR,
+                extra={"operation": "get_history", "error": error_msg},
+            )
             return pl.DataFrame()
 
         bars_data = response.get("bars", [])
diff --git a/src/project_x_py/client/protocols.py b/src/project_x_py/client/protocols.py
deleted file mode 100644
index 52eaef2..0000000
--- a/src/project_x_py/client/protocols.py
+++ /dev/null
@@ -1,104 +0,0 @@
-"""Protocol definitions for client mixins."""
-
-import datetime
-import logging
-from typing import TYPE_CHECKING, Any, Protocol
-
-import httpx
-import polars as pl
-
-if TYPE_CHECKING:
-    from project_x_py.client.rate_limiter import RateLimiter
-    from project_x_py.models import Account, Instrument, Position, ProjectXConfig, Trade
-
-
-class ProjectXClientProtocol(Protocol):
-    """Protocol defining the interface that client mixins expect."""
-
-    # Authentication attributes
-    session_token: str
-    token_expiry: "datetime.datetime | None"
-    _authenticated: bool
-    username: str
-    api_key: str
-    account_name: str | None
-    account_info: "Account | None"
-    logger: logging.Logger
-
-    # HTTP client attributes
-    _client: "httpx.AsyncClient | None"
-    headers: dict[str, str]
-    base_url: str
-    config: "ProjectXConfig"
-    rate_limiter: "RateLimiter"
-    api_call_count: int
-
-    # Cache attributes
-    cache_hit_count: int
-    cache_ttl: int
-    last_cache_cleanup: float
-    _instrument_cache: dict[str, "Instrument"]
-    _instrument_cache_time: dict[str, float]
-    _market_data_cache: dict[str, pl.DataFrame]
-    _market_data_cache_time: dict[str, float]
-
-    # Authentication methods
-    def _should_refresh_token(self) -> bool: ...
-    async def authenticate(self) -> None: ...
-    async def _refresh_authentication(self) -> None: ...
-    async def _ensure_authenticated(self) -> None: ...
-    async def list_accounts(self) -> list["Account"]: ...
-
-    # HTTP methods
-    async def _make_request(
-        self,
-        method: str,
-        endpoint: str,
-        data: dict[str, Any] | None = None,
-        params: dict[str, Any] | None = None,
-        headers: dict[str, str] | None = None,
-        retry_count: int = 0,
-    ) -> Any: ...
-    async def _create_client(self) -> httpx.AsyncClient: ...
-    async def _ensure_client(self) -> httpx.AsyncClient: ...
-    async def get_health_status(self) -> dict[str, Any]: ...
-
-    # Cache methods
-    async def _cleanup_cache(self) -> None: ...
-    def get_cached_instrument(self, symbol: str) -> "Instrument | None": ...
-    def cache_instrument(self, symbol: str, instrument: "Instrument") -> None: ...
-    def get_cached_market_data(self, cache_key: str) -> pl.DataFrame | None: ...
-    def cache_market_data(self, cache_key: str, data: pl.DataFrame) -> None: ...
-    def clear_all_caches(self) -> None: ...
-
-    # Market data methods
-    async def get_instrument(self, symbol: str, live: bool = False) -> "Instrument": ...
-    async def search_instruments(
-        self, query: str, live: bool = False
-    ) -> list["Instrument"]: ...
-    async def get_bars(
-        self,
-        symbol: str,
-        days: int = 8,
-        interval: int = 5,
-        unit: int = 2,
-        limit: int | None = None,
-        partial: bool = True,
-    ) -> pl.DataFrame: ...
-    def _select_best_contract(
-        self, instruments: list[dict[str, Any]], search_symbol: str
-    ) -> dict[str, Any]: ...
-
-    # Trading methods
-    async def get_positions(self) -> list["Position"]: ...
-    async def search_open_positions(
-        self, account_id: int | None = None
-    ) -> list["Position"]: ...
-    async def search_trades(
-        self,
-        start_date: "datetime.datetime | None" = None,
-        end_date: "datetime.datetime | None" = None,
-        contract_id: str | None = None,
-        account_id: int | None = None,
-        limit: int = 100,
-    ) -> list["Trade"]: ...
diff --git a/src/project_x_py/client/trading.py b/src/project_x_py/client/trading.py
index 08d4112..07fbc8b 100644
--- a/src/project_x_py/client/trading.py
+++ b/src/project_x_py/client/trading.py
@@ -11,7 +11,7 @@
 from project_x_py.models import Position, Trade
 
 if TYPE_CHECKING:
-    from project_x_py.client.protocols import ProjectXClientProtocol
+    from project_x_py.types import ProjectXClientProtocol
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/project_x_py/config.py b/src/project_x_py/config.py
index a163b4d..64446fa 100644
--- a/src/project_x_py/config.py
+++ b/src/project_x_py/config.py
@@ -21,6 +21,16 @@
 
 logger = logging.getLogger(__name__)
 
+__all__ = [
+    "ConfigManager",
+    "check_environment",
+    "create_config_template",
+    "create_custom_config",
+    "get_default_config_path",
+    "load_default_config",
+    "load_topstepx_config",
+]
+
 
 class ConfigManager:
     """
diff --git a/src/project_x_py/exceptions.py b/src/project_x_py/exceptions.py
index b273a22..a3a8299 100644
--- a/src/project_x_py/exceptions.py
+++ b/src/project_x_py/exceptions.py
@@ -10,6 +10,19 @@
 
 from typing import Any
 
+__all__ = [
+    "ProjectXAuthenticationError",
+    "ProjectXClientError",
+    "ProjectXConnectionError",
+    "ProjectXDataError",
+    "ProjectXError",
+    "ProjectXInstrumentError",
+    "ProjectXOrderError",
+    "ProjectXPositionError",
+    "ProjectXRateLimitError",
+    "ProjectXServerError",
+]
+
 
 class ProjectXError(Exception):
     """Base exception for ProjectX API errors."""
diff --git a/src/project_x_py/indicators/__init__.py b/src/project_x_py/indicators/__init__.py
index 75f272d..af8c7af 100644
--- a/src/project_x_py/indicators/__init__.py
+++ b/src/project_x_py/indicators/__init__.py
@@ -144,7 +144,7 @@
 )
 
 # Version info
-__version__ = "2.0.4"
+__version__ = "2.0.5"
 __author__ = "TexasCoding"
 
 
diff --git a/src/project_x_py/models.py b/src/project_x_py/models.py
index f1f7951..a5548ea 100644
--- a/src/project_x_py/models.py
+++ b/src/project_x_py/models.py
@@ -9,6 +9,20 @@
 
 from dataclasses import dataclass
 
+__all__ = [
+    "Account",
+    "BracketOrderResponse",
+    "Instrument",
+    "MarketDataEvent",
+    "Order",
+    "OrderPlaceResponse",
+    "OrderUpdateEvent",
+    "Position",
+    "PositionUpdateEvent",
+    "ProjectXConfig",
+    "Trade",
+]
+
 
 @dataclass
 class Instrument:
diff --git a/src/project_x_py/order_manager/__init__.py b/src/project_x_py/order_manager/__init__.py
index 9ae7e29..9448530 100644
--- a/src/project_x_py/order_manager/__init__.py
+++ b/src/project_x_py/order_manager/__init__.py
@@ -10,6 +10,6 @@
 """
 
 from project_x_py.order_manager.core import OrderManager
-from project_x_py.order_manager.types import OrderStats
+from project_x_py.types import OrderStats
 
 __all__ = ["OrderManager", "OrderStats"]
diff --git a/src/project_x_py/order_manager/bracket_orders.py b/src/project_x_py/order_manager/bracket_orders.py
index 555c7c5..265316f 100644
--- a/src/project_x_py/order_manager/bracket_orders.py
+++ b/src/project_x_py/order_manager/bracket_orders.py
@@ -7,7 +7,7 @@
 from project_x_py.models import BracketOrderResponse
 
 if TYPE_CHECKING:
-    from project_x_py.order_manager.protocols import OrderManagerProtocol
+    from project_x_py.types import OrderManagerProtocol
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/project_x_py/order_manager/core.py b/src/project_x_py/order_manager/core.py
index 712c818..b7f9db2 100644
--- a/src/project_x_py/order_manager/core.py
+++ b/src/project_x_py/order_manager/core.py
@@ -6,25 +6,33 @@
 """
 
 import asyncio
-import logging
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Optional
 
 from project_x_py.exceptions import ProjectXOrderError
 from project_x_py.models import Order, OrderPlaceResponse
+from project_x_py.types import OrderStats
+from project_x_py.utils import (
+    ErrorMessages,
+    LogContext,
+    LogMessages,
+    ProjectXLogger,
+    format_error_message,
+    handle_errors,
+    validate_response,
+)
 
 from .bracket_orders import BracketOrderMixin
 from .order_types import OrderTypesMixin
 from .position_orders import PositionOrderMixin
 from .tracking import OrderTrackingMixin
-from .types import OrderStats
 from .utils import align_price_to_tick_size, resolve_contract_id
 
 if TYPE_CHECKING:
     from project_x_py.client import ProjectXBase
     from project_x_py.realtime import ProjectXRealtimeClient
 
-logger = logging.getLogger(__name__)
+logger = ProjectXLogger.get_logger(__name__)
 
 
 class OrderManager(
@@ -88,7 +96,7 @@ def __init__(self, project_x_client: "ProjectXBase"):
         OrderTrackingMixin.__init__(self)
 
         self.project_x = project_x_client
-        self.logger = logging.getLogger(__name__)
+        self.logger = ProjectXLogger.get_logger(__name__)
 
         # Async lock for thread safety
         self.order_lock = asyncio.Lock()
@@ -166,6 +174,8 @@ async def initialize(
             self.logger.error(f"❌ Failed to initialize AsyncOrderManager: {e}")
             return False
 
+    @handle_errors("place order")
+    @validate_response(required_fields=["success", "orderId"])
     async def place_order(
         self,
         contract_id: str,
@@ -205,13 +215,35 @@ async def place_order(
         Raises:
             ProjectXOrderError: If order placement fails due to invalid parameters or API errors
         """
-        result = None
-        aligned_limit_price = None
-        aligned_stop_price = None
-        aligned_trail_price = None
+        # Add logging context
+        with LogContext(
+            self.logger,
+            operation="place_order",
+            contract_id=contract_id,
+            order_type=order_type,
+            side=side,
+            size=size,
+            custom_tag=custom_tag,
+        ):
+            # Validate inputs
+            if size <= 0:
+                raise ProjectXOrderError(
+                    format_error_message(ErrorMessages.ORDER_INVALID_SIZE, size=size)
+                )
 
-        async with self.order_lock:
-            try:
+            self.logger.info(
+                LogMessages.ORDER_PLACE,
+                extra={
+                    "contract_id": contract_id,
+                    "order_type": order_type,
+                    "side": side,
+                    "size": size,
+                    "limit_price": limit_price,
+                    "stop_price": stop_price,
+                },
+            )
+
+            async with self.order_lock:
                 # Align all prices to tick size to prevent "Invalid price" errors
                 aligned_limit_price = await align_price_to_tick_size(
                     limit_price, contract_id, self.project_x
@@ -226,7 +258,7 @@ async def place_order(
                 # Use account_info if no account_id provided
                 if account_id is None:
                     if not self.project_x.account_info:
-                        raise ProjectXOrderError("No account information available")
+                        raise ProjectXOrderError(ErrorMessages.ORDER_NO_ACCOUNT)
                     account_id = self.project_x.account_info.id
 
                 # Build order request payload
@@ -246,25 +278,14 @@ async def place_order(
                 if custom_tag:
                     payload["customTag"] = custom_tag
 
-                # Log order parameters for debugging
-                self.logger.debug(f"🔍 Order Placement Request: {payload}")
-
                 # Place the order
                 response = await self.project_x._make_request(
                     "POST", "/Order/place", data=payload
                 )
 
-                # Log the actual API response for debugging
-                self.logger.debug(f"🔍 Order API Response: {response}")
-
                 if not response.get("success", False):
-                    error_msg = (
-                        response.get("errorMessage")
-                        or "Unknown error - no error message provided"
-                    )
-                    self.logger.error(f"Order placement failed: {error_msg}")
-                    self.logger.error(f"🔍 Full response data: {response}")
-                    raise ProjectXOrderError(f"Order placement failed: {error_msg}")
+                    error_msg = response.get("errorMessage", ErrorMessages.ORDER_FAILED)
+                    raise ProjectXOrderError(error_msg)
 
                 result = OrderPlaceResponse(**response)
 
@@ -272,14 +293,19 @@ async def place_order(
                 self.stats["orders_placed"] += 1
                 self.stats["last_order_time"] = datetime.now()
 
-                self.logger.info(f"✅ Order placed: {result.orderId}")
-
-            except Exception as e:
-                self.logger.error(f"❌ Failed to place order: {e}")
-                raise ProjectXOrderError(f"Order placement failed: {e}") from e
+                self.logger.info(
+                    LogMessages.ORDER_PLACED,
+                    extra={
+                        "order_id": result.orderId,
+                        "contract_id": contract_id,
+                        "side": side,
+                        "size": size,
+                    },
+                )
 
-        return result
+                return result
 
+    @handle_errors("search open orders")
     async def search_open_orders(
         self, contract_id: str | None = None, side: int | None = None
     ) -> list[Order]:
@@ -293,51 +319,48 @@ async def search_open_orders(
         Returns:
             List of Order objects
         """
-        try:
-            if not self.project_x.account_info:
-                raise ProjectXOrderError("No account selected")
+        if not self.project_x.account_info:
+            raise ProjectXOrderError(ErrorMessages.ORDER_NO_ACCOUNT)
 
-            params = {"accountId": self.project_x.account_info.id}
+        params = {"accountId": self.project_x.account_info.id}
 
-            if contract_id:
-                # Resolve contract
-                resolved = await resolve_contract_id(contract_id, self.project_x)
-                if resolved and resolved.get("id"):
-                    params["contractId"] = resolved["id"]
+        if contract_id:
+            # Resolve contract
+            resolved = await resolve_contract_id(contract_id, self.project_x)
+            if resolved and resolved.get("id"):
+                params["contractId"] = resolved["id"]
 
-            if side is not None:
-                params["side"] = side
+        if side is not None:
+            params["side"] = side
 
-            response = await self.project_x._make_request(
-                "POST", "/Order/searchOpen", data=params
-            )
+        response = await self.project_x._make_request(
+            "POST", "/Order/searchOpen", data=params
+        )
 
-            if not response.get("success", False):
-                error_msg = response.get("errorMessage", "Unknown error")
-                self.logger.error(f"Order search failed: {error_msg}")
-                return []
-
-            orders = response.get("orders", [])
-            # Filter to only include fields that Order model expects
-            open_orders = []
-            for order_data in orders:
-                try:
-                    order = Order(**order_data)
-                    open_orders.append(order)
+        if not response.get("success", False):
+            error_msg = response.get("errorMessage", ErrorMessages.ORDER_SEARCH_FAILED)
+            raise ProjectXOrderError(error_msg)
 
-                    # Update our cache
-                    async with self.order_lock:
-                        self.tracked_orders[str(order.id)] = order_data
-                        self.order_status_cache[str(order.id)] = order.status
-                except Exception as e:
-                    self.logger.warning(f"Failed to parse order: {e}")
-                    continue
+        orders = response.get("orders", [])
+        # Filter to only include fields that Order model expects
+        open_orders = []
+        for order_data in orders:
+            try:
+                order = Order(**order_data)
+                open_orders.append(order)
 
-            return open_orders
+                # Update our cache
+                async with self.order_lock:
+                    self.tracked_orders[str(order.id)] = order_data
+                    self.order_status_cache[str(order.id)] = order.status
+            except Exception as e:
+                self.logger.warning(
+                    "Failed to parse order",
+                    extra={"error": str(e), "order_data": order_data},
+                )
+                continue
 
-        except Exception as e:
-            self.logger.error(f"Failed to search orders: {e}")
-            return []
+        return open_orders
 
     async def is_order_filled(self, order_id: str | int) -> bool:
         """
@@ -402,6 +425,7 @@ async def get_order_by_id(self, order_id: int) -> Order | None:
             self.logger.error(f"Failed to get order {order_id}: {e}")
             return None
 
+    @handle_errors("cancel order")
     async def cancel_order(self, order_id: int, account_id: int | None = None) -> bool:
         """
         Cancel an open order.
@@ -413,56 +437,55 @@ async def cancel_order(self, order_id: int, account_id: int | None = None) -> bo
         Returns:
             True if cancellation successful
         """
-        async with self.order_lock:
-            try:
-                # Get account ID if not provided
-                if account_id is None:
-                    if not self.project_x.account_info:
-                        await self.project_x.authenticate()
-                    if not self.project_x.account_info:
-                        raise ProjectXOrderError("No account information available")
-                    account_id = self.project_x.account_info.id
+        self.logger.info(LogMessages.ORDER_CANCEL, extra={"order_id": order_id})
 
-                # Use correct endpoint and payload structure
-                payload = {
-                    "accountId": account_id,
-                    "orderId": order_id,
-                }
+        async with self.order_lock:
+            # Get account ID if not provided
+            if account_id is None:
+                if not self.project_x.account_info:
+                    await self.project_x.authenticate()
+                if not self.project_x.account_info:
+                    raise ProjectXOrderError(ErrorMessages.ORDER_NO_ACCOUNT)
+                account_id = self.project_x.account_info.id
+
+            # Use correct endpoint and payload structure
+            payload = {
+                "accountId": account_id,
+                "orderId": order_id,
+            }
 
-                response = await self.project_x._make_request(
-                    "POST", "/Order/cancel", data=payload
-                )
+            response = await self.project_x._make_request(
+                "POST", "/Order/cancel", data=payload
+            )
 
-                success = response.get("success", False) if response else False
+            success = response.get("success", False) if response else False
 
-                if success:
-                    # Update cache
-                    if str(order_id) in self.tracked_orders:
-                        self.tracked_orders[str(order_id)]["status"] = (
-                            3  # Cancelled = 3
-                        )
-                        self.order_status_cache[str(order_id)] = 3
+            if success:
+                # Update cache
+                if str(order_id) in self.tracked_orders:
+                    self.tracked_orders[str(order_id)]["status"] = 3  # Cancelled
+                    self.order_status_cache[str(order_id)] = 3
 
-                    self.stats["orders_cancelled"] = (
-                        self.stats.get("orders_cancelled", 0) + 1
-                    )
-                    self.logger.info(f"✅ Order cancelled: {order_id}")
-                    return True
-                else:
-                    error_msg = (
-                        response.get("errorMessage", "Unknown error")
-                        if response
-                        else "No response"
-                    )
-                    self.logger.error(
-                        f"❌ Failed to cancel order {order_id}: {error_msg}"
+                self.stats["orders_cancelled"] = (
+                    self.stats.get("orders_cancelled", 0) + 1
+                )
+                self.logger.info(
+                    LogMessages.ORDER_CANCELLED, extra={"order_id": order_id}
+                )
+                return True
+            else:
+                error_msg = response.get(
+                    "errorMessage", ErrorMessages.ORDER_CANCEL_FAILED
+                )
+                raise ProjectXOrderError(
+                    format_error_message(
+                        ErrorMessages.ORDER_CANCEL_FAILED,
+                        order_id=order_id,
+                        reason=error_msg,
                     )
-                    return False
-
-            except Exception as e:
-                self.logger.error(f"Failed to cancel order {order_id}: {e}")
-                return False
+                )
 
+    @handle_errors("modify order")
     async def modify_order(
         self,
         order_id: int,
@@ -482,12 +505,24 @@ async def modify_order(
         Returns:
             True if modification successful
         """
-        try:
+        with LogContext(
+            self.logger,
+            operation="modify_order",
+            order_id=order_id,
+            has_limit=limit_price is not None,
+            has_stop=stop_price is not None,
+            has_size=size is not None,
+        ):
+            self.logger.info(LogMessages.ORDER_MODIFY, extra={"order_id": order_id})
+
             # Get existing order details to determine contract_id for price alignment
             existing_order = await self.get_order_by_id(order_id)
             if not existing_order:
-                self.logger.error(f"❌ Cannot modify order {order_id}: Order not found")
-                return False
+                raise ProjectXOrderError(
+                    format_error_message(
+                        ErrorMessages.ORDER_NOT_FOUND, order_id=order_id
+                    )
+                )
 
             contract_id = existing_order.contractId
 
@@ -530,21 +565,25 @@ async def modify_order(
                         self.stats.get("orders_modified", 0) + 1
                     )
 
-                self.logger.info(f"✅ Order modified: {order_id}")
+                self.logger.info(
+                    LogMessages.ORDER_MODIFIED, extra={"order_id": order_id}
+                )
                 return True
             else:
                 error_msg = (
-                    response.get("errorMessage", "Unknown error")
+                    response.get("errorMessage", ErrorMessages.ORDER_MODIFY_FAILED)
                     if response
-                    else "No response"
+                    else ErrorMessages.ORDER_MODIFY_FAILED
+                )
+                raise ProjectXOrderError(
+                    format_error_message(
+                        ErrorMessages.ORDER_MODIFY_FAILED,
+                        order_id=order_id,
+                        reason=error_msg,
+                    )
                 )
-                self.logger.error(f"❌ Order modification failed: {error_msg}")
-                return False
-
-        except Exception as e:
-            self.logger.error(f"Failed to modify order {order_id}: {e}")
-            return False
 
+    @handle_errors("cancel all orders")
     async def cancel_all_orders(
         self, contract_id: str | None = None, account_id: int | None = None
     ) -> dict[str, Any]:
@@ -558,26 +597,45 @@ async def cancel_all_orders(
         Returns:
             Dict with cancellation results
         """
-        orders = await self.search_open_orders(contract_id, account_id)
+        with LogContext(
+            self.logger,
+            operation="cancel_all_orders",
+            contract_id=contract_id,
+            account_id=account_id,
+        ):
+            self.logger.info(
+                LogMessages.ORDER_CANCEL_ALL, extra={"contract_id": contract_id}
+            )
 
-        results: dict[str, Any] = {
-            "total": len(orders),
-            "cancelled": 0,
-            "failed": 0,
-            "errors": [],
-        }
+            orders = await self.search_open_orders(contract_id, account_id)
 
-        for order in orders:
-            try:
-                if await self.cancel_order(order.id, account_id):
-                    results["cancelled"] += 1
-                else:
+            results: dict[str, Any] = {
+                "total": len(orders),
+                "cancelled": 0,
+                "failed": 0,
+                "errors": [],
+            }
+
+            for order in orders:
+                try:
+                    if await self.cancel_order(order.id, account_id):
+                        results["cancelled"] += 1
+                    else:
+                        results["failed"] += 1
+                except Exception as e:
                     results["failed"] += 1
-            except Exception as e:
-                results["failed"] += 1
-                results["errors"].append({"order_id": order.id, "error": str(e)})
+                    results["errors"].append({"order_id": order.id, "error": str(e)})
+
+            self.logger.info(
+                LogMessages.ORDER_CANCEL_ALL_COMPLETE,
+                extra={
+                    "total": results["total"],
+                    "cancelled": results["cancelled"],
+                    "failed": results["failed"],
+                },
+            )
 
-        return results
+            return results
 
     async def get_order_statistics(self) -> dict[str, Any]:
         """
diff --git a/src/project_x_py/order_manager/order_types.py b/src/project_x_py/order_manager/order_types.py
index d83b041..bf235e8 100644
--- a/src/project_x_py/order_manager/order_types.py
+++ b/src/project_x_py/order_manager/order_types.py
@@ -6,7 +6,7 @@
 from project_x_py.models import OrderPlaceResponse
 
 if TYPE_CHECKING:
-    from project_x_py.order_manager.protocols import OrderManagerProtocol
+    from project_x_py.types import OrderManagerProtocol
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/project_x_py/order_manager/position_orders.py b/src/project_x_py/order_manager/position_orders.py
index bd4e8b0..bb3d0bc 100644
--- a/src/project_x_py/order_manager/position_orders.py
+++ b/src/project_x_py/order_manager/position_orders.py
@@ -7,7 +7,7 @@
 from project_x_py.models import OrderPlaceResponse
 
 if TYPE_CHECKING:
-    from project_x_py.order_manager.protocols import OrderManagerProtocol
+    from project_x_py.types import OrderManagerProtocol
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/project_x_py/order_manager/protocols.py b/src/project_x_py/order_manager/protocols.py
deleted file mode 100644
index 073ee4c..0000000
--- a/src/project_x_py/order_manager/protocols.py
+++ /dev/null
@@ -1,126 +0,0 @@
-"""Protocol definitions for order manager mixins."""
-
-import asyncio
-from typing import TYPE_CHECKING, Any, Protocol
-
-from project_x_py.models import Order, OrderPlaceResponse
-
-if TYPE_CHECKING:
-    from project_x_py.client import ProjectXBase
-    from project_x_py.order_manager.types import OrderStats
-    from project_x_py.realtime import ProjectXRealtimeClient
-
-
-class OrderManagerProtocol(Protocol):
-    """Protocol defining the interface that mixins expect from OrderManager."""
-
-    project_x: "ProjectXBase"
-    realtime_client: "ProjectXRealtimeClient | None"
-    order_lock: asyncio.Lock
-    _realtime_enabled: bool
-    stats: "OrderStats"
-
-    # From tracking mixin
-    tracked_orders: dict[str, dict[str, Any]]
-    order_status_cache: dict[str, int]
-    order_callbacks: dict[str, list[Any]]
-    position_orders: dict[str, dict[str, list[int]]]
-    order_to_position: dict[int, str]
-
-    # Methods that mixins need
-    async def place_order(
-        self,
-        contract_id: str,
-        order_type: int,
-        side: int,
-        size: int,
-        limit_price: float | None = None,
-        stop_price: float | None = None,
-        trail_price: float | None = None,
-        custom_tag: str | None = None,
-        linked_order_id: int | None = None,
-        account_id: int | None = None,
-    ) -> OrderPlaceResponse: ...
-
-    async def place_market_order(
-        self, contract_id: str, side: int, size: int, account_id: int | None = None
-    ) -> OrderPlaceResponse: ...
-
-    async def place_limit_order(
-        self,
-        contract_id: str,
-        side: int,
-        size: int,
-        limit_price: float,
-        account_id: int | None = None,
-    ) -> OrderPlaceResponse: ...
-
-    async def place_stop_order(
-        self,
-        contract_id: str,
-        side: int,
-        size: int,
-        stop_price: float,
-        account_id: int | None = None,
-    ) -> OrderPlaceResponse: ...
-
-    async def get_order_by_id(self, order_id: int) -> Order | None: ...
-
-    async def cancel_order(
-        self, order_id: int, account_id: int | None = None
-    ) -> bool: ...
-
-    async def modify_order(
-        self,
-        order_id: int,
-        limit_price: float | None = None,
-        stop_price: float | None = None,
-        size: int | None = None,
-    ) -> bool: ...
-
-    async def get_tracked_order_status(
-        self, order_id: str, wait_for_cache: bool = False
-    ) -> dict[str, Any] | None: ...
-
-    async def track_order_for_position(
-        self,
-        contract_id: str,
-        order_id: int,
-        order_type: str = "entry",
-        account_id: int | None = None,
-    ) -> None: ...
-
-    def untrack_order(self, order_id: int) -> None: ...
-
-    def get_position_orders(self, contract_id: str) -> dict[str, list[int]]: ...
-
-    async def _on_order_update(
-        self, order_data: dict[str, Any] | list[Any]
-    ) -> None: ...
-
-    async def _on_trade_execution(
-        self, trade_data: dict[str, Any] | list[Any]
-    ) -> None: ...
-
-    async def cancel_position_orders(
-        self,
-        contract_id: str,
-        order_types: list[str] | None = None,
-        account_id: int | None = None,
-    ) -> dict[str, int]: ...
-
-    async def update_position_order_sizes(
-        self, contract_id: str, new_size: int, account_id: int | None = None
-    ) -> dict[str, Any]: ...
-
-    async def sync_orders_with_position(
-        self,
-        contract_id: str,
-        target_size: int,
-        cancel_orphaned: bool = True,
-        account_id: int | None = None,
-    ) -> dict[str, Any]: ...
-
-    async def on_position_closed(
-        self, contract_id: str, account_id: int | None = None
-    ) -> None: ...
diff --git a/src/project_x_py/order_manager/tracking.py b/src/project_x_py/order_manager/tracking.py
index 1f05676..ac5be75 100644
--- a/src/project_x_py/order_manager/tracking.py
+++ b/src/project_x_py/order_manager/tracking.py
@@ -7,7 +7,7 @@
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from project_x_py.order_manager.protocols import OrderManagerProtocol
+    from project_x_py.types import OrderManagerProtocol
 
 logger = logging.getLogger(__name__)
 
@@ -15,6 +15,16 @@
 class OrderTrackingMixin:
     """Mixin for order tracking and real-time monitoring functionality."""
 
+    # Type hints for mypy - these attributes are provided by the main class
+    if TYPE_CHECKING:
+        from asyncio import Lock
+
+        from project_x_py.realtime import ProjectXRealtimeClient
+
+        order_lock: Lock
+        realtime_client: ProjectXRealtimeClient | None
+        _realtime_enabled: bool
+
     def __init__(self) -> None:
         """Initialize tracking attributes."""
         # Internal order state tracking (for realtime optimization)
@@ -30,7 +40,7 @@ def __init__(self) -> None:
         )
         self.order_to_position: dict[int, str] = {}  # order_id -> contract_id
 
-    async def _setup_realtime_callbacks(self: "OrderManagerProtocol") -> None:
+    async def _setup_realtime_callbacks(self) -> None:
         """Set up callbacks for real-time order monitoring."""
         if not self.realtime_client:
             return
@@ -42,9 +52,7 @@ async def _setup_realtime_callbacks(self: "OrderManagerProtocol") -> None:
             "trade_execution", self._on_trade_execution
         )
 
-    async def _on_order_update(
-        self: "OrderManagerProtocol", order_data: dict[str, Any] | list[Any]
-    ) -> None:
+    async def _on_order_update(self, order_data: dict[str, Any] | list[Any]) -> None:
         """Handle real-time order update events."""
         try:
             logger.info(f"📨 Order update received: {type(order_data)}")
@@ -103,9 +111,7 @@ async def _on_order_update(
             logger.error(f"Error handling order update: {e}")
             logger.debug(f"Order data received: {order_data}")
 
-    async def _on_trade_execution(
-        self: "OrderManagerProtocol", trade_data: dict[str, Any] | list[Any]
-    ) -> None:
+    async def _on_trade_execution(self, trade_data: dict[str, Any] | list[Any]) -> None:
         """Handle real-time trade execution events."""
         try:
             # Handle different data formats from SignalR
@@ -141,7 +147,7 @@ async def _on_trade_execution(
             logger.debug(f"Trade data received: {trade_data}")
 
     async def get_tracked_order_status(
-        self: "OrderManagerProtocol", order_id: str, wait_for_cache: bool = False
+        self, order_id: str, wait_for_cache: bool = False
     ) -> dict[str, Any] | None:
         """
         Get cached order status from real-time tracking for faster access.
@@ -174,7 +180,7 @@ async def get_tracked_order_status(
             return self.tracked_orders.get(order_id)
 
     def add_callback(
-        self: "OrderManagerProtocol",
+        self,
         event_type: str,
         callback: Callable[[dict[str, Any]], None],
     ) -> None:
@@ -194,9 +200,7 @@ def add_callback(
         self.order_callbacks[event_type].append(callback)
         logger.debug(f"Registered callback for {event_type}")
 
-    async def _trigger_callbacks(
-        self: "OrderManagerProtocol", event_type: str, data: Any
-    ) -> None:
+    async def _trigger_callbacks(self, event_type: str, data: Any) -> None:
         """
         Trigger all callbacks registered for a specific event type.
 
diff --git a/src/project_x_py/order_manager/types.py b/src/project_x_py/order_manager/types.py
deleted file mode 100644
index afa18d2..0000000
--- a/src/project_x_py/order_manager/types.py
+++ /dev/null
@@ -1,14 +0,0 @@
-"""Type definitions for order management."""
-
-from datetime import datetime
-from typing import TypedDict
-
-
-class OrderStats(TypedDict):
-    """Type definition for order statistics."""
-
-    orders_placed: int
-    orders_cancelled: int
-    orders_modified: int
-    bracket_orders_placed: int
-    last_order_time: datetime | None
diff --git a/src/project_x_py/orderbook/__init__.py b/src/project_x_py/orderbook/__init__.py
index 881c7c3..d9418b8 100644
--- a/src/project_x_py/orderbook/__init__.py
+++ b/src/project_x_py/orderbook/__init__.py
@@ -92,7 +92,7 @@
 from project_x_py.orderbook.memory import MemoryManager
 from project_x_py.orderbook.profile import VolumeProfile
 from project_x_py.orderbook.realtime import RealtimeHandler
-from project_x_py.orderbook.types import (
+from project_x_py.types import (
     DEFAULT_TIMEZONE,
     AsyncCallback,
     CallbackType,
@@ -113,6 +113,8 @@
     "CallbackType",
     "DomType",
     "IcebergConfig",
+    # Analytics components
+    "MarketAnalytics",
     "MarketDataDict",
     "MemoryConfig",
     "OrderBook",
@@ -121,6 +123,8 @@
     "PriceLevelDict",
     "SyncCallback",
     "TradeDict",
+    # Profile components
+    "VolumeProfile",
     "create_orderbook",
 ]
 
diff --git a/src/project_x_py/orderbook/analytics.py b/src/project_x_py/orderbook/analytics.py
index 70fe891..99e641d 100644
--- a/src/project_x_py/orderbook/analytics.py
+++ b/src/project_x_py/orderbook/analytics.py
@@ -19,12 +19,16 @@
 higher-level insights from the raw order book data.
 """
 
-import logging
 from datetime import datetime, timedelta
 from typing import Any
 
 import polars as pl
 
+from project_x_py.utils import (
+    ProjectXLogger,
+    handle_errors,
+)
+
 from .base import OrderBookBase
 
 
@@ -56,8 +60,18 @@ class MarketAnalytics:
 
     def __init__(self, orderbook: OrderBookBase):
         self.orderbook = orderbook
-        self.logger = logging.getLogger(__name__)
-
+        self.logger = ProjectXLogger.get_logger(__name__)
+
+    @handle_errors(
+        "get market imbalance",
+        reraise=False,
+        default_return={
+            "imbalance_ratio": 0.0,
+            "bid_volume": 0,
+            "ask_volume": 0,
+            "analysis": "Error occurred",
+        },
+    )
     async def get_market_imbalance(self, levels: int = 10) -> dict[str, Any]:
         """
         Calculate order flow imbalance between bid and ask sides.
@@ -104,61 +118,61 @@ async def get_market_imbalance(self, levels: int = 10) -> dict[str, Any]:
             ... )
         """
         async with self.orderbook.orderbook_lock:
-            try:
-                # Get orderbook levels
-                bids = self.orderbook._get_orderbook_bids_unlocked(levels)
-                asks = self.orderbook._get_orderbook_asks_unlocked(levels)
-
-                if bids.is_empty() or asks.is_empty():
-                    return {
-                        "imbalance_ratio": 0.0,
-                        "bid_volume": 0,
-                        "ask_volume": 0,
-                        "analysis": "Insufficient data",
-                    }
-
-                # Calculate volumes
-                bid_volume = int(bids["volume"].sum())
-                ask_volume = int(asks["volume"].sum())
-                total_volume = bid_volume + ask_volume
-
-                if total_volume == 0:
-                    return {
-                        "imbalance_ratio": 0.0,
-                        "bid_volume": 0,
-                        "ask_volume": 0,
-                        "analysis": "No volume",
-                    }
-
-                # Calculate imbalance ratio
-                imbalance_ratio = (bid_volume - ask_volume) / total_volume
-
-                # Analyze imbalance
-                if imbalance_ratio > 0.3:
-                    analysis = "Strong buying pressure"
-                elif imbalance_ratio > 0.1:
-                    analysis = "Moderate buying pressure"
-                elif imbalance_ratio < -0.3:
-                    analysis = "Strong selling pressure"
-                elif imbalance_ratio < -0.1:
-                    analysis = "Moderate selling pressure"
-                else:
-                    analysis = "Balanced orderbook"
+            # Get orderbook levels
+            bids = self.orderbook._get_orderbook_bids_unlocked(levels)
+            asks = self.orderbook._get_orderbook_asks_unlocked(levels)
 
+            if bids.is_empty() or asks.is_empty():
                 return {
-                    "imbalance_ratio": imbalance_ratio,
-                    "bid_volume": bid_volume,
-                    "ask_volume": ask_volume,
-                    "bid_levels": bids.height,
-                    "ask_levels": asks.height,
-                    "analysis": analysis,
-                    "timestamp": datetime.now(self.orderbook.timezone),
+                    "imbalance_ratio": 0.0,
+                    "bid_volume": 0,
+                    "ask_volume": 0,
+                    "analysis": "Insufficient data",
                 }
 
-            except Exception as e:
-                self.logger.error(f"Error calculating market imbalance: {e}")
-                return {"error": str(e)}
+            # Calculate volumes
+            bid_volume = int(bids["volume"].sum())
+            ask_volume = int(asks["volume"].sum())
+            total_volume = bid_volume + ask_volume
+
+            if total_volume == 0:
+                return {
+                    "imbalance_ratio": 0.0,
+                    "bid_volume": 0,
+                    "ask_volume": 0,
+                    "analysis": "No volume",
+                }
 
+            # Calculate imbalance ratio
+            imbalance_ratio = (bid_volume - ask_volume) / total_volume
+
+            # Analyze imbalance
+            if imbalance_ratio > 0.3:
+                analysis = "Strong buying pressure"
+            elif imbalance_ratio > 0.1:
+                analysis = "Moderate buying pressure"
+            elif imbalance_ratio < -0.3:
+                analysis = "Strong selling pressure"
+            elif imbalance_ratio < -0.1:
+                analysis = "Moderate selling pressure"
+            else:
+                analysis = "Balanced orderbook"
+
+            return {
+                "imbalance_ratio": imbalance_ratio,
+                "bid_volume": bid_volume,
+                "ask_volume": ask_volume,
+                "bid_levels": bids.height,
+                "ask_levels": asks.height,
+                "analysis": analysis,
+                "timestamp": datetime.now(self.orderbook.timezone),
+            }
+
+    @handle_errors(
+        "get orderbook depth",
+        reraise=False,
+        default_return={"error": "Analysis failed"},
+    )
     async def get_orderbook_depth(self, price_range: float) -> dict[str, Any]:
         """
         Analyze orderbook depth within a price range.
@@ -170,56 +184,61 @@ async def get_orderbook_depth(self, price_range: float) -> dict[str, Any]:
             Dict containing depth analysis
         """
         async with self.orderbook.orderbook_lock:
-            try:
-                best_prices = self.orderbook._get_best_bid_ask_unlocked()
-                best_bid = best_prices.get("bid")
-                best_ask = best_prices.get("ask")
-
-                if best_bid is None or best_ask is None:
-                    return {"error": "No best bid/ask available"}
-
-                # Filter bids within range
-                bid_depth = self.orderbook.orderbook_bids.filter(
-                    (pl.col("price") >= best_bid - price_range) & (pl.col("volume") > 0)
-                )
-
-                # Filter asks within range
-                ask_depth = self.orderbook.orderbook_asks.filter(
-                    (pl.col("price") <= best_ask + price_range) & (pl.col("volume") > 0)
-                )
-
-                return {
-                    "price_range": price_range,
-                    "bid_depth": {
-                        "levels": bid_depth.height,
-                        "total_volume": int(bid_depth["volume"].sum())
+            best_prices = self.orderbook._get_best_bid_ask_unlocked()
+            best_bid = best_prices.get("bid")
+            best_ask = best_prices.get("ask")
+
+            if best_bid is None or best_ask is None:
+                return {"error": "No best bid/ask available"}
+
+            # Filter bids within range
+            bid_depth = self.orderbook.orderbook_bids.filter(
+                (pl.col("price") >= best_bid - price_range) & (pl.col("volume") > 0)
+            )
+
+            # Filter asks within range
+            ask_depth = self.orderbook.orderbook_asks.filter(
+                (pl.col("price") <= best_ask + price_range) & (pl.col("volume") > 0)
+            )
+
+            return {
+                "price_range": price_range,
+                "bid_depth": {
+                    "levels": bid_depth.height,
+                    "total_volume": int(bid_depth["volume"].sum())
+                    if not bid_depth.is_empty()
+                    else 0,
+                    "avg_volume": (
+                        float(str(bid_depth["volume"].mean()))
                         if not bid_depth.is_empty()
-                        else 0,
-                        "avg_volume": (
-                            float(str(bid_depth["volume"].mean()))
-                            if not bid_depth.is_empty()
-                            else 0.0
-                        ),
-                    },
-                    "ask_depth": {
-                        "levels": ask_depth.height,
-                        "total_volume": int(ask_depth["volume"].sum())
+                        else 0.0
+                    ),
+                },
+                "ask_depth": {
+                    "levels": ask_depth.height,
+                    "total_volume": int(ask_depth["volume"].sum())
+                    if not ask_depth.is_empty()
+                    else 0,
+                    "avg_volume": (
+                        float(str(ask_depth["volume"].mean()))
                         if not ask_depth.is_empty()
-                        else 0,
-                        "avg_volume": (
-                            float(str(ask_depth["volume"].mean()))
-                            if not ask_depth.is_empty()
-                            else 0.0
-                        ),
-                    },
-                    "best_bid": best_bid,
-                    "best_ask": best_ask,
-                }
-
-            except Exception as e:
-                self.logger.error(f"Error analyzing orderbook depth: {e}")
-                return {"error": str(e)}
-
+                        else 0.0
+                    ),
+                },
+                "best_bid": best_bid,
+                "best_ask": best_ask,
+            }
+
+    @handle_errors(
+        "get cumulative delta",
+        reraise=False,
+        default_return={
+            "cumulative_delta": 0,
+            "buy_volume": 0,
+            "sell_volume": 0,
+            "error": "Analysis failed",
+        },
+    )
     async def get_cumulative_delta(
         self, time_window_minutes: int = 60
     ) -> dict[str, Any]:
@@ -233,125 +252,121 @@ async def get_cumulative_delta(
             Dict containing cumulative delta analysis
         """
         async with self.orderbook.orderbook_lock:
-            try:
-                if self.orderbook.recent_trades.is_empty():
-                    return {
-                        "cumulative_delta": 0,
-                        "buy_volume": 0,
-                        "sell_volume": 0,
-                        "neutral_volume": 0,
-                        "period_minutes": time_window_minutes,
-                    }
-
-                # Filter trades within time window
-                cutoff_time = datetime.now(self.orderbook.timezone) - timedelta(
-                    minutes=time_window_minutes
-                )
-
-                recent_trades = self.orderbook.recent_trades.filter(
-                    pl.col("timestamp") >= cutoff_time
-                )
+            if self.orderbook.recent_trades.is_empty():
+                return {
+                    "cumulative_delta": 0,
+                    "buy_volume": 0,
+                    "sell_volume": 0,
+                    "neutral_volume": 0,
+                    "period_minutes": time_window_minutes,
+                }
 
-                if recent_trades.is_empty():
-                    return {
-                        "cumulative_delta": 0,
-                        "buy_volume": 0,
-                        "sell_volume": 0,
-                        "neutral_volume": 0,
-                        "period_minutes": time_window_minutes,
-                    }
-
-                # Calculate volumes by side
-                buy_trades = recent_trades.filter(pl.col("side") == "buy")
-                sell_trades = recent_trades.filter(pl.col("side") == "sell")
-                neutral_trades = recent_trades.filter(pl.col("side") == "neutral")
-
-                buy_volume = (
-                    int(buy_trades["volume"].sum()) if not buy_trades.is_empty() else 0
-                )
-                sell_volume = (
-                    int(sell_trades["volume"].sum())
-                    if not sell_trades.is_empty()
-                    else 0
-                )
-                neutral_volume = (
-                    int(neutral_trades["volume"].sum())
-                    if not neutral_trades.is_empty()
-                    else 0
-                )
+            # Filter trades within time window
+            cutoff_time = datetime.now(self.orderbook.timezone) - timedelta(
+                minutes=time_window_minutes
+            )
 
-                cumulative_delta = buy_volume - sell_volume
+            recent_trades = self.orderbook.recent_trades.filter(
+                pl.col("timestamp") >= cutoff_time
+            )
 
+            if recent_trades.is_empty():
                 return {
-                    "cumulative_delta": cumulative_delta,
-                    "buy_volume": buy_volume,
-                    "sell_volume": sell_volume,
-                    "neutral_volume": neutral_volume,
-                    "total_volume": buy_volume + sell_volume + neutral_volume,
+                    "cumulative_delta": 0,
+                    "buy_volume": 0,
+                    "sell_volume": 0,
+                    "neutral_volume": 0,
                     "period_minutes": time_window_minutes,
-                    "trade_count": recent_trades.height,
-                    "delta_per_trade": cumulative_delta / recent_trades.height
-                    if recent_trades.height > 0
-                    else 0,
                 }
 
-            except Exception as e:
-                self.logger.error(f"Error calculating cumulative delta: {e}")
-                return {"error": str(e)}
-
+            # Calculate volumes by side
+            buy_trades = recent_trades.filter(pl.col("side") == "buy")
+            sell_trades = recent_trades.filter(pl.col("side") == "sell")
+            neutral_trades = recent_trades.filter(pl.col("side") == "neutral")
+
+            buy_volume = (
+                int(buy_trades["volume"].sum()) if not buy_trades.is_empty() else 0
+            )
+            sell_volume = (
+                int(sell_trades["volume"].sum()) if not sell_trades.is_empty() else 0
+            )
+            neutral_volume = (
+                int(neutral_trades["volume"].sum())
+                if not neutral_trades.is_empty()
+                else 0
+            )
+
+            cumulative_delta = buy_volume - sell_volume
+
+            return {
+                "cumulative_delta": cumulative_delta,
+                "buy_volume": buy_volume,
+                "sell_volume": sell_volume,
+                "neutral_volume": neutral_volume,
+                "total_volume": buy_volume + sell_volume + neutral_volume,
+                "period_minutes": time_window_minutes,
+                "trade_count": recent_trades.height,
+                "delta_per_trade": cumulative_delta / recent_trades.height
+                if recent_trades.height > 0
+                else 0,
+            }
+
+    @handle_errors(
+        "get trade flow summary",
+        reraise=False,
+        default_return={"error": "Analysis failed"},
+    )
     async def get_trade_flow_summary(self) -> dict[str, Any]:
         """Get comprehensive trade flow statistics."""
         async with self.orderbook.orderbook_lock:
-            try:
-                # Calculate VWAP
-                vwap = None
-                if self.orderbook.vwap_denominator > 0:
-                    vwap = (
-                        self.orderbook.vwap_numerator / self.orderbook.vwap_denominator
-                    )
-
-                # Get recent trade statistics
-                recent_trades_stats = {}
-                if not self.orderbook.recent_trades.is_empty():
-                    recent_trades_stats = {
-                        "total_trades": self.orderbook.recent_trades.height,
-                        "avg_trade_size": float(
-                            str(self.orderbook.recent_trades["volume"].mean())
-                        ),
-                        "max_trade_size": int(
-                            str(self.orderbook.recent_trades["volume"].max())
-                        ),
-                        "min_trade_size": int(
-                            str(self.orderbook.recent_trades["volume"].min())
-                        ),
-                    }
-
-                return {
-                    "aggressive_buy_volume": self.orderbook.trade_flow_stats[
-                        "aggressive_buy_volume"
-                    ],
-                    "aggressive_sell_volume": self.orderbook.trade_flow_stats[
-                        "aggressive_sell_volume"
-                    ],
-                    "passive_buy_volume": self.orderbook.trade_flow_stats[
-                        "passive_buy_volume"
-                    ],
-                    "passive_sell_volume": self.orderbook.trade_flow_stats[
-                        "passive_sell_volume"
-                    ],
-                    "market_maker_trades": self.orderbook.trade_flow_stats[
-                        "market_maker_trades"
-                    ],
-                    "cumulative_delta": self.orderbook.cumulative_delta,
-                    "vwap": vwap,
-                    "session_start": self.orderbook.session_start_time,
-                    **recent_trades_stats,
+            # Calculate VWAP
+            vwap = None
+            if self.orderbook.vwap_denominator > 0:
+                vwap = self.orderbook.vwap_numerator / self.orderbook.vwap_denominator
+
+            # Get recent trade statistics
+            recent_trades_stats = {}
+            if not self.orderbook.recent_trades.is_empty():
+                recent_trades_stats = {
+                    "total_trades": self.orderbook.recent_trades.height,
+                    "avg_trade_size": float(
+                        str(self.orderbook.recent_trades["volume"].mean())
+                    ),
+                    "max_trade_size": int(
+                        str(self.orderbook.recent_trades["volume"].max())
+                    ),
+                    "min_trade_size": int(
+                        str(self.orderbook.recent_trades["volume"].min())
+                    ),
                 }
 
-            except Exception as e:
-                self.logger.error(f"Error getting trade flow summary: {e}")
-                return {"error": str(e)}
-
+            return {
+                "aggressive_buy_volume": self.orderbook.trade_flow_stats[
+                    "aggressive_buy_volume"
+                ],
+                "aggressive_sell_volume": self.orderbook.trade_flow_stats[
+                    "aggressive_sell_volume"
+                ],
+                "passive_buy_volume": self.orderbook.trade_flow_stats[
+                    "passive_buy_volume"
+                ],
+                "passive_sell_volume": self.orderbook.trade_flow_stats[
+                    "passive_sell_volume"
+                ],
+                "market_maker_trades": self.orderbook.trade_flow_stats[
+                    "market_maker_trades"
+                ],
+                "cumulative_delta": self.orderbook.cumulative_delta,
+                "vwap": vwap,
+                "session_start": self.orderbook.session_start_time,
+                **recent_trades_stats,
+            }
+
+    @handle_errors(
+        "get liquidity levels",
+        reraise=False,
+        default_return={"error": "Analysis failed"},
+    )
     async def get_liquidity_levels(
         self, min_volume: int = 100, levels: int = 20
     ) -> dict[str, Any]:
@@ -366,83 +381,163 @@ async def get_liquidity_levels(
             Dict containing liquidity analysis
         """
         async with self.orderbook.orderbook_lock:
-            try:
-                # Get orderbook levels
-                bids = self.orderbook._get_orderbook_bids_unlocked(levels)
-                asks = self.orderbook._get_orderbook_asks_unlocked(levels)
-
-                # Find significant bid levels
-                significant_bids = []
-                if not bids.is_empty():
-                    sig_bids = bids.filter(pl.col("volume") >= min_volume)
-                    if not sig_bids.is_empty():
-                        significant_bids = sig_bids.to_dicts()
-
-                # Find significant ask levels
-                significant_asks = []
-                if not asks.is_empty():
-                    sig_asks = asks.filter(pl.col("volume") >= min_volume)
-                    if not sig_asks.is_empty():
-                        significant_asks = sig_asks.to_dicts()
-
-                # Calculate liquidity concentration
-                total_bid_liquidity = sum(b["volume"] for b in significant_bids)
-                total_ask_liquidity = sum(a["volume"] for a in significant_asks)
-
-                return {
-                    "significant_bid_levels": significant_bids,
-                    "significant_ask_levels": significant_asks,
-                    "total_bid_liquidity": total_bid_liquidity,
-                    "total_ask_liquidity": total_ask_liquidity,
-                    "liquidity_imbalance": (
-                        (total_bid_liquidity - total_ask_liquidity)
-                        / (total_bid_liquidity + total_ask_liquidity)
-                        if (total_bid_liquidity + total_ask_liquidity) > 0
-                        else 0
-                    ),
-                    "min_volume_threshold": min_volume,
-                }
-
-            except Exception as e:
-                self.logger.error(f"Error analyzing liquidity levels: {e}")
-                return {"error": str(e)}
+            # Get orderbook levels
+            bids = self.orderbook._get_orderbook_bids_unlocked(levels)
+            asks = self.orderbook._get_orderbook_asks_unlocked(levels)
+
+            # Find significant bid levels
+            significant_bids = []
+            if not bids.is_empty():
+                sig_bids = bids.filter(pl.col("volume") >= min_volume)
+                if not sig_bids.is_empty():
+                    significant_bids = sig_bids.to_dicts()
+
+            # Find significant ask levels
+            significant_asks = []
+            if not asks.is_empty():
+                sig_asks = asks.filter(pl.col("volume") >= min_volume)
+                if not sig_asks.is_empty():
+                    significant_asks = sig_asks.to_dicts()
+
+            # Calculate liquidity concentration
+            total_bid_liquidity = sum(b["volume"] for b in significant_bids)
+            total_ask_liquidity = sum(a["volume"] for a in significant_asks)
+
+            return {
+                "significant_bid_levels": significant_bids,
+                "significant_ask_levels": significant_asks,
+                "total_bid_liquidity": total_bid_liquidity,
+                "total_ask_liquidity": total_ask_liquidity,
+                "liquidity_imbalance": (
+                    (total_bid_liquidity - total_ask_liquidity)
+                    / (total_bid_liquidity + total_ask_liquidity)
+                    if (total_bid_liquidity + total_ask_liquidity) > 0
+                    else 0
+                ),
+                "min_volume_threshold": min_volume,
+            }
 
+    @handle_errors(
+        "get statistics", reraise=False, default_return={"error": "Analysis failed"}
+    )
     async def get_statistics(self) -> dict[str, Any]:
         """Get comprehensive orderbook statistics."""
         async with self.orderbook.orderbook_lock:
-            try:
-                # Get best prices
-                best_prices = self.orderbook._get_best_bid_ask_unlocked()
-
-                # Calculate basic stats
-                stats = {
-                    "instrument": self.orderbook.instrument,
-                    "update_count": self.orderbook.level2_update_count,
-                    "last_update": self.orderbook.last_orderbook_update,
-                    "best_bid": best_prices.get("bid"),
-                    "best_ask": best_prices.get("ask"),
-                    "spread": best_prices.get("spread"),
-                    "bid_levels": self.orderbook.orderbook_bids.height,
-                    "ask_levels": self.orderbook.orderbook_asks.height,
-                    "total_trades": self.orderbook.recent_trades.height,
-                    "order_type_breakdown": dict(self.orderbook.order_type_stats),
+            # Get best prices
+            best_prices = self.orderbook._get_best_bid_ask_unlocked()
+
+            # Calculate basic stats
+            stats = {
+                "instrument": self.orderbook.instrument,
+                "update_count": self.orderbook.level2_update_count,
+                "last_update": self.orderbook.last_orderbook_update,
+                "best_bid": best_prices.get("bid"),
+                "best_ask": best_prices.get("ask"),
+                "spread": best_prices.get("spread"),
+                "bid_levels": self.orderbook.orderbook_bids.height,
+                "ask_levels": self.orderbook.orderbook_asks.height,
+                "total_trades": self.orderbook.recent_trades.height,
+                "order_type_breakdown": dict(self.orderbook.order_type_stats),
+            }
+
+            # Add spread statistics if available
+            if self.orderbook.spread_history:
+                spreads = [s["spread"] for s in self.orderbook.spread_history[-100:]]
+                stats["spread_stats"] = {
+                    "current": best_prices.get("spread"),
+                    "average": sum(spreads) / len(spreads),
+                    "min": min(spreads),
+                    "max": max(spreads),
+                    "samples": len(spreads),
                 }
 
-                # Add spread statistics if available
-                if self.orderbook.spread_history:
-                    spreads = [
-                        s["spread"] for s in self.orderbook.spread_history[-100:]
+            return stats
+
+    @staticmethod
+    def analyze_dataframe_spread(
+        data: pl.DataFrame,
+        bid_column: str = "bid",
+        ask_column: str = "ask",
+        mid_column: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Analyze bid-ask spread characteristics from a DataFrame.
+
+        This is a static method that can analyze spread data from any DataFrame,
+        useful for historical analysis or backtesting scenarios where you have
+        bid/ask data but not a live orderbook.
+
+        Args:
+            data: DataFrame with bid/ask price columns
+            bid_column: Name of the bid price column (default: "bid")
+            ask_column: Name of the ask price column (default: "ask")
+            mid_column: Name of the mid price column (optional, will calculate if not provided)
+
+        Returns:
+            Dict containing spread analysis:
+                - avg_spread: Average absolute spread
+                - median_spread: Median absolute spread
+                - min_spread: Minimum spread observed
+                - max_spread: Maximum spread observed
+                - avg_relative_spread: Average spread as percentage of mid price
+                - spread_volatility: Standard deviation of spread
+
+        Example:
+            >>> # Analyze historical bid/ask data
+            >>> spread_stats = MarketAnalytics.analyze_dataframe_spread(historical_data)
+            >>> print(f"Average spread: ${spread_stats['avg_spread']:.4f}")
+            >>> print(f"Relative spread: {spread_stats['avg_relative_spread']:.4%}")
+        """
+        required_cols = [bid_column, ask_column]
+        for col in required_cols:
+            if col not in data.columns:
+                raise ValueError(f"Column '{col}' not found in data")
+
+        if data.is_empty():
+            return {"error": "No data provided"}
+
+        try:
+            # Calculate mid price if not provided
+            if mid_column is None:
+                data = data.with_columns(
+                    ((pl.col(bid_column) + pl.col(ask_column)) / 2).alias("mid_price")
+                )
+                mid_column = "mid_price"
+
+            # Calculate spread metrics
+            analysis_data = (
+                data.with_columns(
+                    [
+                        (pl.col(ask_column) - pl.col(bid_column)).alias("spread"),
+                        (
+                            (pl.col(ask_column) - pl.col(bid_column))
+                            / pl.col(mid_column)
+                        ).alias("relative_spread"),
                     ]
-                    stats["spread_stats"] = {
-                        "current": best_prices.get("spread"),
-                        "average": sum(spreads) / len(spreads),
-                        "min": min(spreads),
-                        "max": max(spreads),
-                        "samples": len(spreads),
-                    }
-
-                return stats
-
-            except Exception as e:
-                self.logger.error(f"Error getting statistics: {e}")
-                return {"error": str(e)}
+                )
+                .select(["spread", "relative_spread"])
+                .drop_nulls()
+            )
+
+            if analysis_data.is_empty():
+                return {"error": "No valid spread data"}
+
+            return {
+                "avg_spread": analysis_data.select(pl.col("spread").mean()).item()
+                or 0.0,
+                "median_spread": analysis_data.select(pl.col("spread").median()).item()
+                or 0.0,
+                "min_spread": analysis_data.select(pl.col("spread").min()).item()
+                or 0.0,
+                "max_spread": analysis_data.select(pl.col("spread").max()).item()
+                or 0.0,
+                "avg_relative_spread": analysis_data.select(
+                    pl.col("relative_spread").mean()
+                ).item()
+                or 0.0,
+                "spread_volatility": analysis_data.select(pl.col("spread").std()).item()
+                or 0.0,
+            }
+
+        except Exception as e:
+            return {"error": str(e)}
diff --git a/src/project_x_py/orderbook/base.py b/src/project_x_py/orderbook/base.py
index a804f27..443ba1e 100644
--- a/src/project_x_py/orderbook/base.py
+++ b/src/project_x_py/orderbook/base.py
@@ -33,16 +33,21 @@
 if TYPE_CHECKING:
     from project_x_py.client import ProjectXBase
 
-import logging
-
 from project_x_py.exceptions import ProjectXError
 from project_x_py.orderbook.memory import MemoryManager
-from project_x_py.orderbook.types import (
+from project_x_py.types import (
     DEFAULT_TIMEZONE,
     CallbackType,
     DomType,
     MemoryConfig,
 )
+from project_x_py.utils import (
+    LogMessages,
+    ProjectXLogger,
+    handle_errors,
+)
+
+logger = ProjectXLogger.get_logger(__name__)
 
 
 class OrderBookBase:
@@ -88,7 +93,7 @@ def __init__(
         self.instrument = instrument
         self.project_x = project_x
         self.timezone = pytz.timezone(timezone_str)
-        self.logger = logging.getLogger(__name__)
+        self.logger = ProjectXLogger.get_logger(__name__)
 
         # Cache instrument tick size during initialization
         self._tick_size: Decimal | None = None
@@ -200,18 +205,15 @@ def _map_trade_type(self, type_code: int) -> str:
         except ValueError:
             return f"Unknown_{type_code}"
 
+    @handle_errors("get tick size", reraise=False, default_return=Decimal("0.01"))
     async def get_tick_size(self) -> Decimal:
         """Get the tick size for the instrument."""
         if self._tick_size is None and self.project_x:
-            try:
-                contract_details = await self.project_x.get_instrument(self.instrument)
-                if contract_details and hasattr(contract_details, "tickSize"):
-                    self._tick_size = Decimal(str(contract_details.tickSize))
-                else:
-                    self._tick_size = Decimal("0.01")  # Default fallback
-            except Exception as e:
-                self.logger.warning(f"Failed to get tick size: {e}, using default 0.01")
-                self._tick_size = Decimal("0.01")
+            contract_details = await self.project_x.get_instrument(self.instrument)
+            if contract_details and hasattr(contract_details, "tickSize"):
+                self._tick_size = Decimal(str(contract_details.tickSize))
+            else:
+                self._tick_size = Decimal("0.01")  # Default fallback
         return self._tick_size or Decimal("0.01")
 
     def _get_best_bid_ask_unlocked(self) -> dict[str, Any]:
@@ -278,9 +280,17 @@ def _get_best_bid_ask_unlocked(self) -> dict[str, Any]:
             }
 
         except Exception as e:
-            self.logger.error(f"Error getting best bid/ask: {e}")
+            self.logger.error(
+                LogMessages.DATA_ERROR,
+                extra={"operation": "get_best_bid_ask", "error": str(e)},
+            )
             return {"bid": None, "ask": None, "spread": None, "timestamp": None}
 
+    @handle_errors(
+        "get best bid/ask",
+        reraise=False,
+        default_return={"bid": None, "ask": None, "spread": None, "timestamp": None},
+    )
     async def get_best_bid_ask(self) -> dict[str, Any]:
         """
         Get current best bid and ask prices with spread calculation.
@@ -313,6 +323,7 @@ async def get_best_bid_ask(self) -> dict[str, Any]:
         async with self.orderbook_lock:
             return self._get_best_bid_ask_unlocked()
 
+    @handle_errors("get bid-ask spread", reraise=False, default_return=None)
     async def get_bid_ask_spread(self) -> float | None:
         """Get the current bid-ask spread."""
         best_prices = await self.get_best_bid_ask()
@@ -338,9 +349,13 @@ def _get_orderbook_bids_unlocked(self, levels: int = 10) -> pl.DataFrame:
                 .head(levels)
             )
         except Exception as e:
-            self.logger.error(f"Error getting orderbook bids: {e}")
+            self.logger.error(
+                LogMessages.DATA_ERROR,
+                extra={"operation": "get_orderbook_bids", "error": str(e)},
+            )
             return pl.DataFrame()
 
+    @handle_errors("get orderbook bids", reraise=False, default_return=pl.DataFrame())
     async def get_orderbook_bids(self, levels: int = 10) -> pl.DataFrame:
         """Get orderbook bids up to specified levels."""
         async with self.orderbook_lock:
@@ -366,14 +381,19 @@ def _get_orderbook_asks_unlocked(self, levels: int = 10) -> pl.DataFrame:
                 .head(levels)
             )
         except Exception as e:
-            self.logger.error(f"Error getting orderbook asks: {e}")
+            self.logger.error(
+                LogMessages.DATA_ERROR,
+                extra={"operation": "get_orderbook_asks", "error": str(e)},
+            )
             return pl.DataFrame()
 
+    @handle_errors("get orderbook asks", reraise=False, default_return=pl.DataFrame())
     async def get_orderbook_asks(self, levels: int = 10) -> pl.DataFrame:
         """Get orderbook asks up to specified levels."""
         async with self.orderbook_lock:
             return self._get_orderbook_asks_unlocked(levels)
 
+    @handle_errors("get orderbook snapshot")
     async def get_orderbook_snapshot(self, levels: int = 10) -> dict[str, Any]:
         """
         Get a complete snapshot of the current orderbook state.
@@ -473,9 +493,13 @@ async def get_orderbook_snapshot(self, levels: int = 10) -> dict[str, Any]:
                 }
 
             except Exception as e:
-                self.logger.error(f"Error getting orderbook snapshot: {e}")
+                self.logger.error(
+                    LogMessages.DATA_ERROR,
+                    extra={"operation": "get_orderbook_snapshot", "error": str(e)},
+                )
                 raise ProjectXError(f"Failed to get orderbook snapshot: {e}") from e
 
+    @handle_errors("get recent trades", reraise=False, default_return=[])
     async def get_recent_trades(self, count: int = 100) -> list[dict[str, Any]]:
         """Get recent trades from the orderbook."""
         async with self.orderbook_lock:
@@ -488,14 +512,19 @@ async def get_recent_trades(self, count: int = 100) -> list[dict[str, Any]]:
                 return recent.to_dicts()
 
             except Exception as e:
-                self.logger.error(f"Error getting recent trades: {e}")
+                self.logger.error(
+                    LogMessages.DATA_ERROR,
+                    extra={"operation": "get_recent_trades", "error": str(e)},
+                )
                 return []
 
+    @handle_errors("get order type statistics", reraise=False, default_return={})
     async def get_order_type_statistics(self) -> dict[str, int]:
         """Get statistics about different order types processed."""
         async with self.orderbook_lock:
             return self.order_type_stats.copy()
 
+    @handle_errors("add callback", reraise=False)
     async def add_callback(self, event_type: str, callback: CallbackType) -> None:
         """
         Register a callback for orderbook events.
@@ -532,14 +561,21 @@ async def add_callback(self, event_type: str, callback: CallbackType) -> None:
         """
         async with self._callback_lock:
             self.callbacks[event_type].append(callback)
-            self.logger.debug(f"Added orderbook callback for {event_type}")
+            logger.debug(
+                LogMessages.CALLBACK_REGISTERED,
+                extra={"event_type": event_type, "component": "orderbook"},
+            )
 
+    @handle_errors("remove callback", reraise=False)
     async def remove_callback(self, event_type: str, callback: CallbackType) -> None:
         """Remove a registered callback."""
         async with self._callback_lock:
             if event_type in self.callbacks and callback in self.callbacks[event_type]:
                 self.callbacks[event_type].remove(callback)
-                self.logger.debug(f"Removed orderbook callback for {event_type}")
+                logger.debug(
+                    LogMessages.CALLBACK_REMOVED,
+                    extra={"event_type": event_type, "component": "orderbook"},
+                )
 
     async def _trigger_callbacks(self, event_type: str, data: dict[str, Any]) -> None:
         """Trigger all callbacks for a specific event type."""
@@ -551,11 +587,18 @@ async def _trigger_callbacks(self, event_type: str, data: dict[str, Any]) -> Non
                 else:
                     callback(data)
             except Exception as e:
-                self.logger.error(f"Error in {event_type} callback: {e}")
+                self.logger.error(
+                    LogMessages.DATA_ERROR,
+                    extra={"operation": f"callback_{event_type}", "error": str(e)},
+                )
 
+    @handle_errors("cleanup", reraise=False)
     async def cleanup(self) -> None:
         """Clean up resources."""
         await self.memory_manager.stop()
         async with self._callback_lock:
             self.callbacks.clear()
-        self.logger.info("OrderBook cleanup completed")
+        logger.info(
+            LogMessages.CLEANUP_COMPLETE,
+            extra={"component": "OrderBook"},
+        )
diff --git a/src/project_x_py/orderbook/detection.py b/src/project_x_py/orderbook/detection.py
index 1bfa472..0d167f9 100644
--- a/src/project_x_py/orderbook/detection.py
+++ b/src/project_x_py/orderbook/detection.py
@@ -32,7 +32,7 @@
 import polars as pl
 
 from project_x_py.orderbook.base import OrderBookBase
-from project_x_py.orderbook.types import IcebergConfig
+from project_x_py.types import IcebergConfig
 
 
 class OrderDetection:
diff --git a/src/project_x_py/orderbook/memory.py b/src/project_x_py/orderbook/memory.py
index 4984772..2bbfebf 100644
--- a/src/project_x_py/orderbook/memory.py
+++ b/src/project_x_py/orderbook/memory.py
@@ -16,7 +16,7 @@
 import contextlib
 import logging
 
-from project_x_py.orderbook.types import MemoryConfig
+from project_x_py.types import MemoryConfig
 
 
 class MemoryManager:
diff --git a/src/project_x_py/orderbook/profile.py b/src/project_x_py/orderbook/profile.py
index 19d5347..2e50317 100644
--- a/src/project_x_py/orderbook/profile.py
+++ b/src/project_x_py/orderbook/profile.py
@@ -426,3 +426,128 @@ async def get_spread_analysis(self, window_minutes: int = 30) -> dict[str, Any]:
             except Exception as e:
                 self.logger.error(f"Error analyzing spread: {e}")
                 return {"error": str(e)}
+
+    @staticmethod
+    def calculate_dataframe_volume_profile(
+        data: pl.DataFrame,
+        price_column: str = "close",
+        volume_column: str = "volume",
+        num_bins: int = 50,
+    ) -> dict[str, Any]:
+        """
+        Calculate volume profile from a DataFrame with price and volume data.
+
+        This static method provides volume profile analysis for any DataFrame,
+        useful for historical analysis or when working with data outside of
+        the orderbook context. It creates a histogram of volume distribution
+        across price levels and identifies key areas of market interest.
+
+        Args:
+            data: DataFrame with price and volume data
+            price_column: Name of the price column (default: "close")
+            volume_column: Name of the volume column (default: "volume")
+            num_bins: Number of price bins for the histogram (default: 50)
+
+        Returns:
+            Dict containing volume profile analysis:
+                - point_of_control: Price level with highest volume
+                - poc_volume: Volume at the point of control
+                - value_area_high: Upper bound of 70% volume area
+                - value_area_low: Lower bound of 70% volume area
+                - total_volume: Total volume analyzed
+                - volume_distribution: Top 10 high-volume price levels
+
+        Example:
+            >>> # Analyze volume distribution in historical data
+            >>> profile = VolumeProfile.calculate_dataframe_volume_profile(ohlcv_data)
+            >>> print(f"POC Price: ${profile['point_of_control']:.2f}")
+            >>> print(
+            ...     f"Value Area: ${profile['value_area_low']:.2f} - ${profile['value_area_high']:.2f}"
+            ... )
+        """
+        required_cols = [price_column, volume_column]
+        for col in required_cols:
+            if col not in data.columns:
+                raise ValueError(f"Column '{col}' not found in data")
+
+        if data.is_empty():
+            return {"error": "No data provided"}
+
+        try:
+            # Get price range
+            min_price = data.select(pl.col(price_column).min()).item()
+            max_price = data.select(pl.col(price_column).max()).item()
+
+            if min_price is None or max_price is None:
+                return {"error": "Invalid price data"}
+
+            price_range = max_price - min_price
+            if price_range == 0:
+                # All prices are the same
+                total_vol = data.select(pl.col(volume_column).sum()).item() or 0
+                return {
+                    "point_of_control": min_price,
+                    "poc_volume": total_vol,
+                    "value_area_high": min_price,
+                    "value_area_low": min_price,
+                    "total_volume": total_vol,
+                    "volume_distribution": [{"price": min_price, "volume": total_vol}],
+                }
+
+            # Create price bins
+            bin_size = price_range / num_bins
+            bins = [min_price + i * bin_size for i in range(num_bins + 1)]
+
+            # Calculate volume per price level
+            volume_by_price = []
+            for i in range(len(bins) - 1):
+                bin_data = data.filter(
+                    (pl.col(price_column) >= bins[i])
+                    & (pl.col(price_column) < bins[i + 1])
+                )
+
+                if not bin_data.is_empty():
+                    total_volume = (
+                        bin_data.select(pl.col(volume_column).sum()).item() or 0
+                    )
+                    avg_price = (bins[i] + bins[i + 1]) / 2
+                    volume_by_price.append(
+                        {
+                            "price": avg_price,
+                            "volume": total_volume,
+                            "price_range": (bins[i], bins[i + 1]),
+                        }
+                    )
+
+            if not volume_by_price:
+                return {"error": "No volume data in bins"}
+
+            # Sort by volume to find key levels
+            volume_by_price.sort(key=lambda x: x["volume"], reverse=True)
+
+            # Point of Control (POC) - price level with highest volume
+            poc = volume_by_price[0]
+
+            # Value Area (70% of volume)
+            total_volume = sum(vp["volume"] for vp in volume_by_price)
+            value_area_volume = total_volume * 0.7
+            cumulative_volume = 0
+            value_area_prices = []
+
+            for vp in volume_by_price:
+                cumulative_volume += vp["volume"]
+                value_area_prices.append(vp["price"])
+                if cumulative_volume >= value_area_volume:
+                    break
+
+            return {
+                "point_of_control": poc["price"],
+                "poc_volume": poc["volume"],
+                "value_area_high": max(value_area_prices),
+                "value_area_low": min(value_area_prices),
+                "total_volume": total_volume,
+                "volume_distribution": volume_by_price[:10],  # Top 10 volume levels
+            }
+
+        except Exception as e:
+            return {"error": str(e)}
diff --git a/src/project_x_py/orderbook/realtime.py b/src/project_x_py/orderbook/realtime.py
index eb6bf10..4659662 100644
--- a/src/project_x_py/orderbook/realtime.py
+++ b/src/project_x_py/orderbook/realtime.py
@@ -16,7 +16,7 @@
 import logging
 
 from project_x_py.orderbook.base import OrderBookBase
-from project_x_py.orderbook.types import DomType
+from project_x_py.types import DomType
 
 
 class RealtimeHandler:
diff --git a/src/project_x_py/position_manager/analytics.py b/src/project_x_py/position_manager/analytics.py
index 9d7952d..dfdfecf 100644
--- a/src/project_x_py/position_manager/analytics.py
+++ b/src/project_x_py/position_manager/analytics.py
@@ -6,7 +6,7 @@
 from project_x_py.models import Position
 
 if TYPE_CHECKING:
-    from project_x_py.position_manager.types import PositionManagerProtocol
+    from project_x_py.types import PositionManagerProtocol
 
 
 class PositionAnalyticsMixin:
diff --git a/src/project_x_py/position_manager/core.py b/src/project_x_py/position_manager/core.py
index caeb5ce..4fc9b8f 100644
--- a/src/project_x_py/position_manager/core.py
+++ b/src/project_x_py/position_manager/core.py
@@ -6,7 +6,6 @@
 """
 
 import asyncio
-import logging
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Optional
 
@@ -18,6 +17,11 @@
 from project_x_py.position_manager.reporting import PositionReportingMixin
 from project_x_py.position_manager.risk import RiskManagementMixin
 from project_x_py.position_manager.tracking import PositionTrackingMixin
+from project_x_py.utils import (
+    LogMessages,
+    ProjectXLogger,
+    handle_errors,
+)
 
 if TYPE_CHECKING:
     from project_x_py.client import ProjectXBase
@@ -103,7 +107,7 @@ def __init__(self, project_x_client: "ProjectXBase"):
         PositionMonitoringMixin.__init__(self)
 
         self.project_x = project_x_client
-        self.logger = logging.getLogger(__name__)
+        self.logger = ProjectXLogger.get_logger(__name__)
 
         # Async lock for thread safety
         self.position_lock = asyncio.Lock()
@@ -136,8 +140,11 @@ def __init__(self, project_x_client: "ProjectXBase"):
             "alert_threshold": 0.005,  # 0.5% threshold for alerts
         }
 
-        self.logger.info("PositionManager initialized")
+        self.logger.info(
+            LogMessages.MANAGER_INITIALIZED, extra={"manager": "PositionManager"}
+        )
 
+    @handle_errors("initialize position manager", reraise=False, default_return=False)
     async def initialize(
         self,
         realtime_client: Optional["ProjectXRealtimeClient"] = None,
@@ -179,39 +186,40 @@ async def initialize(
             - Polling mode refreshes positions periodically (see start_monitoring)
             - Order synchronization helps maintain order/position consistency
         """
-        try:
-            # Set up real-time integration if provided
-            if realtime_client:
-                self.realtime_client = realtime_client
-                await self._setup_realtime_callbacks()
-                self._realtime_enabled = True
-                self.logger.info(
-                    "✅ PositionManager initialized with real-time capabilities"
-                )
-            else:
-                self.logger.info("✅ PositionManager initialized (polling mode)")
-
-            # Set up order management integration if provided
-            if order_manager:
-                self.order_manager = order_manager
-                self._order_sync_enabled = True
-                self.logger.info(
-                    "✅ PositionManager initialized with order synchronization"
-                )
-
-            # Load initial positions
-            await self.refresh_positions()
-
-            return True
-
-        except Exception as e:
-            self.logger.error(f"❌ Failed to initialize PositionManager: {e}")
-            return False
+        # Set up real-time integration if provided
+        if realtime_client:
+            self.realtime_client = realtime_client
+            await self._setup_realtime_callbacks()
+            self._realtime_enabled = True
+            self.logger.info(
+                LogMessages.MANAGER_INITIALIZED,
+                extra={"manager": "PositionManager", "mode": "realtime"},
+            )
+        else:
+            self.logger.info(
+                LogMessages.MANAGER_INITIALIZED,
+                extra={"manager": "PositionManager", "mode": "polling"},
+            )
+
+        # Set up order management integration if provided
+        if order_manager:
+            self.order_manager = order_manager
+            self._order_sync_enabled = True
+            self.logger.info(
+                LogMessages.MANAGER_INITIALIZED,
+                extra={"feature": "order_synchronization", "enabled": True},
+            )
+
+        # Load initial positions
+        await self.refresh_positions()
+
+        return True
 
     # ================================================================================
     # CORE POSITION RETRIEVAL METHODS
     # ================================================================================
 
+    @handle_errors("get all positions", reraise=False, default_return=[])
     async def get_all_positions(self, account_id: int | None = None) -> list[Position]:
         """
         Get all current positions from the API and update tracking.
@@ -246,26 +254,26 @@ async def get_all_positions(self, account_id: int | None = None) -> list[Positio
             In real-time mode, tracked positions are also updated via WebSocket,
             but this method always fetches fresh data from the API.
         """
-        try:
-            positions = await self.project_x.search_open_positions(
-                account_id=account_id
-            )
+        self.logger.info(LogMessages.POSITION_SEARCH, extra={"account_id": account_id})
 
-            # Update tracked positions
-            async with self.position_lock:
-                for position in positions:
-                    self.tracked_positions[position.contractId] = position
+        positions = await self.project_x.search_open_positions(account_id=account_id)
+
+        # Update tracked positions
+        async with self.position_lock:
+            for position in positions:
+                self.tracked_positions[position.contractId] = position
 
-                # Update statistics
-                self.stats["positions_tracked"] = len(positions)
-                self.stats["last_update_time"] = datetime.now()
+            # Update statistics
+            self.stats["positions_tracked"] = len(positions)
+            self.stats["last_update_time"] = datetime.now()
 
-            return positions
+        self.logger.info(
+            LogMessages.POSITION_UPDATE, extra={"position_count": len(positions)}
+        )
 
-        except Exception as e:
-            self.logger.error(f"❌ Failed to retrieve positions: {e}")
-            return []
+        return positions
 
+    @handle_errors("get position", reraise=False, default_return=None)
     async def get_position(
         self, contract_id: str, account_id: int | None = None
     ) -> Position | None:
@@ -316,6 +324,7 @@ async def get_position(
 
         return None
 
+    @handle_errors("refresh positions", reraise=False, default_return=False)
     async def refresh_positions(self, account_id: int | None = None) -> bool:
         """
         Refresh all position data from the API.
@@ -349,13 +358,15 @@ async def refresh_positions(self, account_id: int | None = None) -> bool:
             This method is called automatically during initialization and by
             the monitoring loop in polling mode.
         """
-        try:
-            positions = await self.get_all_positions(account_id=account_id)
-            self.logger.info(f"🔄 Refreshed {len(positions)} positions")
-            return True
-        except Exception as e:
-            self.logger.error(f"❌ Failed to refresh positions: {e}")
-            return False
+        self.logger.info(LogMessages.POSITION_REFRESH, extra={"account_id": account_id})
+
+        positions = await self.get_all_positions(account_id=account_id)
+
+        self.logger.info(
+            LogMessages.POSITION_UPDATE, extra={"refreshed_count": len(positions)}
+        )
+
+        return True
 
     async def is_position_open(
         self, contract_id: str, account_id: int | None = None
diff --git a/src/project_x_py/position_manager/monitoring.py b/src/project_x_py/position_manager/monitoring.py
index 1cdf112..bffdf34 100644
--- a/src/project_x_py/position_manager/monitoring.py
+++ b/src/project_x_py/position_manager/monitoring.py
@@ -8,7 +8,7 @@
 from project_x_py.models import Position
 
 if TYPE_CHECKING:
-    from project_x_py.position_manager.types import PositionManagerProtocol
+    from asyncio import Lock
 
 logger = logging.getLogger(__name__)
 
@@ -16,6 +16,19 @@
 class PositionMonitoringMixin:
     """Mixin for position monitoring and alerts."""
 
+    # Type hints for mypy - these attributes are provided by the main class
+    if TYPE_CHECKING:
+        position_lock: Lock
+        logger: logging.Logger
+        stats: dict[str, Any]
+        _realtime_enabled: bool
+
+        # Methods from other mixins/main class
+        async def _trigger_callbacks(
+            self, event_type: str, data: dict[str, Any]
+        ) -> None: ...
+        async def refresh_positions(self, account_id: int | None = None) -> bool: ...
+
     def __init__(self) -> None:
         """Initialize monitoring attributes."""
         # Monitoring and alerts
@@ -24,7 +37,7 @@ def __init__(self) -> None:
         self.position_alerts: dict[str, dict[str, Any]] = {}
 
     async def add_position_alert(
-        self: "PositionManagerProtocol",
+        self,
         contract_id: str,
         max_loss: float | None = None,
         max_gain: float | None = None,
@@ -56,9 +69,7 @@ async def add_position_alert(
 
         self.logger.info(f"📢 Position alert added for {contract_id}")
 
-    async def remove_position_alert(
-        self: "PositionManagerProtocol", contract_id: str
-    ) -> None:
+    async def remove_position_alert(self, contract_id: str) -> None:
         """
         Remove position alert for a specific contract.
 
@@ -74,7 +85,7 @@ async def remove_position_alert(
                 self.logger.info(f"🔕 Position alert removed for {contract_id}")
 
     async def _check_position_alerts(
-        self: "PositionManagerProtocol",
+        self,
         contract_id: str,
         current_position: Position,
         old_position: Position | None,
@@ -137,9 +148,7 @@ async def _check_position_alerts(
                 },
             )
 
-    async def _monitoring_loop(
-        self: "PositionManagerProtocol", refresh_interval: int
-    ) -> None:
+    async def _monitoring_loop(self, refresh_interval: int) -> None:
         """
         Main monitoring loop for polling mode position updates.
 
@@ -162,9 +171,7 @@ async def _monitoring_loop(
                 self.logger.error(f"Error in monitoring loop: {e}")
                 await asyncio.sleep(refresh_interval)
 
-    async def start_monitoring(
-        self: "PositionManagerProtocol", refresh_interval: int = 30
-    ) -> None:
+    async def start_monitoring(self, refresh_interval: int = 30) -> None:
         """
         Start automated position monitoring for real-time updates and alerts.
 
@@ -200,7 +207,7 @@ async def start_monitoring(
         else:
             self.logger.info("📊 Position monitoring started (real-time mode)")
 
-    async def stop_monitoring(self: "PositionManagerProtocol") -> None:
+    async def stop_monitoring(self) -> None:
         """
         Stop automated position monitoring and clean up monitoring resources.
 
diff --git a/src/project_x_py/position_manager/operations.py b/src/project_x_py/position_manager/operations.py
index ee777c6..ea9d7c9 100644
--- a/src/project_x_py/position_manager/operations.py
+++ b/src/project_x_py/position_manager/operations.py
@@ -1,19 +1,31 @@
 """Direct position operations (close, partial close, etc.)."""
 
-import logging
 from typing import TYPE_CHECKING, Any
 
 from project_x_py.exceptions import ProjectXError
+from project_x_py.utils import (
+    ErrorMessages,
+    LogContext,
+    LogMessages,
+    ProjectXLogger,
+    format_error_message,
+    handle_errors,
+)
 
 if TYPE_CHECKING:
-    from project_x_py.position_manager.types import PositionManagerProtocol
+    from project_x_py.types import PositionManagerProtocol
 
-logger = logging.getLogger(__name__)
+logger = ProjectXLogger.get_logger(__name__)
 
 
 class PositionOperationsMixin:
     """Mixin for direct position operations."""
 
+    @handle_errors(
+        "close position direct",
+        reraise=False,
+        default_return={"success": False, "error": "Operation failed"},
+    )
     async def close_position_direct(
         self: "PositionManagerProtocol",
         contract_id: str,
@@ -67,7 +79,9 @@ async def close_position_direct(
 
         if account_id is None:
             if not self.project_x.account_info:
-                raise ProjectXError("No account information available")
+                raise ProjectXError(
+                    format_error_message(ErrorMessages.ORDER_NO_ACCOUNT)
+                )
             account_id = self.project_x.account_info.id
 
         url = "/Position/closeContract"
@@ -76,14 +90,25 @@ async def close_position_direct(
             "contractId": contract_id,
         }
 
-        try:
+        with LogContext(
+            logger,
+            operation="close_position_direct",
+            contract_id=contract_id,
+            account_id=account_id,
+        ):
             response = await self.project_x._make_request("POST", url, data=payload)
 
             if response:
                 success = response.get("success", False)
 
                 if success:
-                    self.logger.info(f"✅ Position {contract_id} closed successfully")
+                    logger.info(
+                        LogMessages.POSITION_CLOSED,
+                        extra={
+                            "contract_id": contract_id,
+                            "order_id": response.get("orderId"),
+                        },
+                    )
                     # Remove from tracked positions if present
                     async with self.position_lock:
                         positions_to_remove = [
@@ -102,16 +127,20 @@ async def close_position_direct(
                     self.stats["positions_closed"] += 1
                 else:
                     error_msg = response.get("errorMessage", "Unknown error")
-                    self.logger.error(f"❌ Position closure failed: {error_msg}")
+                    logger.error(
+                        LogMessages.POSITION_ERROR,
+                        extra={"operation": "close_position", "error": error_msg},
+                    )
 
                 return dict(response)
 
             return {"success": False, "error": "No response from server"}
 
-        except Exception as e:
-            self.logger.error(f"❌ Position closure request failed: {e}")
-            return {"success": False, "error": str(e)}
-
+    @handle_errors(
+        "partially close position",
+        reraise=False,
+        default_return={"success": False, "error": "Operation failed"},
+    )
     async def partially_close_position(
         self: "PositionManagerProtocol",
         contract_id: str,
@@ -168,12 +197,16 @@ async def partially_close_position(
 
         if account_id is None:
             if not self.project_x.account_info:
-                raise ProjectXError("No account information available")
+                raise ProjectXError(
+                    format_error_message(ErrorMessages.ORDER_NO_ACCOUNT)
+                )
             account_id = self.project_x.account_info.id
 
         # Validate close size
         if close_size <= 0:
-            raise ProjectXError("Close size must be positive")
+            raise ProjectXError(
+                format_error_message(ErrorMessages.ORDER_INVALID_SIZE, size=close_size)
+            )
 
         url = "/Position/partialCloseContract"
         payload = {
@@ -182,15 +215,32 @@ async def partially_close_position(
             "closeSize": close_size,
         }
 
-        try:
+        with LogContext(
+            logger,
+            operation="partial_close_position",
+            contract_id=contract_id,
+            close_size=close_size,
+            account_id=account_id,
+        ):
+            logger.info(
+                LogMessages.POSITION_CLOSE,
+                extra={"contract_id": contract_id, "partial": True, "size": close_size},
+            )
+
             response = await self.project_x._make_request("POST", url, data=payload)
 
             if response:
                 success = response.get("success", False)
 
                 if success:
-                    self.logger.info(
-                        f"✅ Position {contract_id} partially closed: {close_size} contracts"
+                    logger.info(
+                        LogMessages.POSITION_CLOSED,
+                        extra={
+                            "contract_id": contract_id,
+                            "partial": True,
+                            "size": close_size,
+                            "order_id": response.get("orderId"),
+                        },
                     )
                     # Trigger position refresh to get updated sizes
                     await self.refresh_positions(account_id=account_id)
@@ -205,18 +255,20 @@ async def partially_close_position(
                     self.stats["positions_partially_closed"] += 1
                 else:
                     error_msg = response.get("errorMessage", "Unknown error")
-                    self.logger.error(
-                        f"❌ Partial position closure failed: {error_msg}"
+                    logger.error(
+                        LogMessages.POSITION_ERROR,
+                        extra={"operation": "partial_close", "error": error_msg},
                     )
 
                 return dict(response)
 
             return {"success": False, "error": "No response from server"}
 
-        except Exception as e:
-            self.logger.error(f"❌ Partial position closure request failed: {e}")
-            return {"success": False, "error": str(e)}
-
+    @handle_errors(
+        "close all positions",
+        reraise=False,
+        default_return={"total_positions": 0, "closed": 0, "failed": 0, "errors": []},
+    )
     async def close_all_positions(
         self: "PositionManagerProtocol",
         contract_id: str | None = None,
@@ -293,11 +345,22 @@ async def close_all_positions(
                 results["failed"] += 1
                 results["errors"].append(f"Position {position.contractId}: {e!s}")
 
-        self.logger.info(
-            f"✅ Closed {results['closed']}/{results['total_positions']} positions"
+        logger.info(
+            LogMessages.POSITION_CLOSE,
+            extra={
+                "closed": results["closed"],
+                "total": results["total_positions"],
+                "failed": results["failed"],
+                "operation": "close_all",
+            },
         )
         return results
 
+    @handle_errors(
+        "close position by contract",
+        reraise=False,
+        default_return={"success": False, "error": "Operation failed"},
+    )
     async def close_position_by_contract(
         self: "PositionManagerProtocol",
         contract_id: str,
diff --git a/src/project_x_py/position_manager/reporting.py b/src/project_x_py/position_manager/reporting.py
index b09ca95..c7efe9b 100644
--- a/src/project_x_py/position_manager/reporting.py
+++ b/src/project_x_py/position_manager/reporting.py
@@ -4,7 +4,7 @@
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from project_x_py.position_manager.types import PositionManagerProtocol
+    from project_x_py.types import PositionManagerProtocol
 
 
 class PositionReportingMixin:
diff --git a/src/project_x_py/position_manager/risk.py b/src/project_x_py/position_manager/risk.py
index f011ea8..dc81dfc 100644
--- a/src/project_x_py/position_manager/risk.py
+++ b/src/project_x_py/position_manager/risk.py
@@ -5,7 +5,7 @@
 from project_x_py.models import Position
 
 if TYPE_CHECKING:
-    from project_x_py.position_manager.types import PositionManagerProtocol
+    from project_x_py.types import PositionManagerProtocol
 
 
 class RiskManagementMixin:
diff --git a/src/project_x_py/position_manager/tracking.py b/src/project_x_py/position_manager/tracking.py
index 3aeb123..5d7a4c2 100644
--- a/src/project_x_py/position_manager/tracking.py
+++ b/src/project_x_py/position_manager/tracking.py
@@ -10,7 +10,9 @@
 from project_x_py.models import Position
 
 if TYPE_CHECKING:
-    from project_x_py.position_manager.types import PositionManagerProtocol
+    from asyncio import Lock
+
+    from project_x_py.realtime import ProjectXRealtimeClient
 
 logger = logging.getLogger(__name__)
 
@@ -18,6 +20,21 @@
 class PositionTrackingMixin:
     """Mixin for real-time position tracking and callback functionality."""
 
+    # Type hints for mypy - these attributes are provided by the main class
+    if TYPE_CHECKING:
+        realtime_client: ProjectXRealtimeClient | None
+        logger: logging.Logger
+        position_lock: Lock
+        stats: dict[str, Any]
+
+        # Methods from other mixins
+        async def _check_position_alerts(
+            self,
+            contract_id: str,
+            current_position: Position,
+            old_position: Position | None,
+        ) -> None: ...
+
     def __init__(self) -> None:
         """Initialize tracking attributes."""
         # Position tracking (maintains local state for business logic)
@@ -25,7 +42,7 @@ def __init__(self) -> None:
         self.position_history: dict[str, list[dict[str, Any]]] = defaultdict(list)
         self.position_callbacks: dict[str, list[Any]] = defaultdict(list)
 
-    async def _setup_realtime_callbacks(self: "PositionManagerProtocol") -> None:
+    async def _setup_realtime_callbacks(self) -> None:
         """
         Set up callbacks for real-time position monitoring via WebSocket.
 
@@ -54,7 +71,7 @@ async def _setup_realtime_callbacks(self: "PositionManagerProtocol") -> None:
         self.logger.info("🔄 Real-time position callbacks registered")
 
     async def _on_position_update(
-        self: "PositionManagerProtocol", data: dict[str, Any] | list[dict[str, Any]]
+        self, data: dict[str, Any] | list[dict[str, Any]]
     ) -> None:
         """
         Handle real-time position updates and detect position closures.
@@ -84,9 +101,7 @@ async def _on_position_update(
         except Exception as e:
             self.logger.error(f"Error processing position update: {e}")
 
-    async def _on_account_update(
-        self: "PositionManagerProtocol", data: dict[str, Any]
-    ) -> None:
+    async def _on_account_update(self, data: dict[str, Any]) -> None:
         """
         Handle account-level updates that may affect positions.
 
@@ -99,9 +114,7 @@ async def _on_account_update(
         """
         await self._trigger_callbacks("account_update", data)
 
-    def _validate_position_payload(
-        self: "PositionManagerProtocol", position_data: dict[str, Any]
-    ) -> bool:
+    def _validate_position_payload(self, position_data: dict[str, Any]) -> bool:
         """
         Validate that position payload matches ProjectX GatewayUserPosition format.
 
@@ -162,9 +175,7 @@ def _validate_position_payload(
 
         return True
 
-    async def _process_position_data(
-        self: "PositionManagerProtocol", position_data: dict[str, Any]
-    ) -> None:
+    async def _process_position_data(self, position_data: dict[str, Any]) -> None:
         """
         Process individual position data update and detect position closures.
 
@@ -278,9 +289,7 @@ async def _process_position_data(
             self.logger.error(f"Error processing position data: {e}")
             self.logger.debug(f"Position data that caused error: {position_data}")
 
-    async def _trigger_callbacks(
-        self: "PositionManagerProtocol", event_type: str, data: Any
-    ) -> None:
+    async def _trigger_callbacks(self, event_type: str, data: Any) -> None:
         """
         Trigger registered callbacks for position events.
 
@@ -312,7 +321,7 @@ async def _trigger_callbacks(
                 self.logger.error(f"Error in {event_type} callback: {e}")
 
     async def add_callback(
-        self: "PositionManagerProtocol",
+        self,
         event_type: str,
         callback: Callable[[dict[str, Any]], Coroutine[Any, Any, None] | None],
     ) -> None:
diff --git a/src/project_x_py/position_manager/types.py b/src/project_x_py/position_manager/types.py
deleted file mode 100644
index e85cbc4..0000000
--- a/src/project_x_py/position_manager/types.py
+++ /dev/null
@@ -1,97 +0,0 @@
-"""Type definitions and protocols for position management."""
-
-from typing import TYPE_CHECKING, Any, Protocol
-
-if TYPE_CHECKING:
-    import asyncio
-
-    from project_x_py.client import ProjectXBase
-    from project_x_py.models import Position
-    from project_x_py.order_manager import OrderManager
-    from project_x_py.realtime import ProjectXRealtimeClient
-
-
-class PositionManagerProtocol(Protocol):
-    """Protocol defining the interface that mixins expect from PositionManager."""
-
-    project_x: "ProjectXBase"
-    logger: Any
-    position_lock: "asyncio.Lock"
-    realtime_client: "ProjectXRealtimeClient | None"
-    _realtime_enabled: bool
-    order_manager: "OrderManager | None"
-    _order_sync_enabled: bool
-    tracked_positions: dict[str, "Position"]
-    position_history: dict[str, list[dict[str, Any]]]
-    position_callbacks: dict[str, list[Any]]
-    _monitoring_active: bool
-    _monitoring_task: "asyncio.Task[None] | None"
-    position_alerts: dict[str, dict[str, Any]]
-    stats: dict[str, Any]
-    risk_settings: dict[str, float]
-
-    # Methods needed by mixins
-    async def get_all_positions(
-        self, account_id: int | None = None
-    ) -> list["Position"]: ...
-
-    async def get_position(
-        self, contract_id: str, account_id: int | None = None
-    ) -> "Position | None": ...
-
-    async def refresh_positions(self, account_id: int | None = None) -> bool: ...
-
-    async def _trigger_callbacks(self, event_type: str, data: Any) -> None: ...
-
-    async def _process_position_data(self, position_data: dict[str, Any]) -> None: ...
-
-    async def _check_position_alerts(
-        self,
-        contract_id: str,
-        current_position: "Position",
-        old_position: "Position | None",
-    ) -> None: ...
-
-    def _validate_position_payload(self, position_data: dict[str, Any]) -> bool: ...
-
-    def _generate_risk_warnings(
-        self,
-        positions: list["Position"],
-        portfolio_risk: float,
-        largest_position_risk: float,
-    ) -> list[str]: ...
-
-    def _generate_sizing_warnings(
-        self, risk_percentage: float, size: int
-    ) -> list[str]: ...
-
-    async def _on_position_update(
-        self, data: dict[str, Any] | list[dict[str, Any]]
-    ) -> None: ...
-
-    async def _on_account_update(self, data: dict[str, Any]) -> None: ...
-
-    async def _setup_realtime_callbacks(self) -> None: ...
-
-    async def calculate_position_pnl(
-        self,
-        position: "Position",
-        current_price: float,
-        point_value: float | None = None,
-    ) -> dict[str, Any]: ...
-
-    async def _monitoring_loop(self, refresh_interval: int) -> None: ...
-
-    async def close_position_direct(
-        self, contract_id: str, account_id: int | None = None
-    ) -> dict[str, Any]: ...
-
-    async def partially_close_position(
-        self, contract_id: str, close_size: int, account_id: int | None = None
-    ) -> dict[str, Any]: ...
-
-    async def get_portfolio_pnl(self) -> dict[str, Any]: ...
-
-    async def get_risk_metrics(self) -> dict[str, Any]: ...
-
-    def get_position_statistics(self) -> dict[str, Any]: ...
diff --git a/src/project_x_py/realtime/connection_management.py b/src/project_x_py/realtime/connection_management.py
index 3f7bcaf..2a561ae 100644
--- a/src/project_x_py/realtime/connection_management.py
+++ b/src/project_x_py/realtime/connection_management.py
@@ -5,13 +5,22 @@
 from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
+from project_x_py.utils import (
+    LogContext,
+    LogMessages,
+    ProjectXLogger,
+    handle_errors,
+)
+
 try:
     from signalrcore.hub_connection_builder import HubConnectionBuilder
 except ImportError:
     HubConnectionBuilder = None
 
 if TYPE_CHECKING:
-    from project_x_py.realtime.types import ProjectXRealtimeClientProtocol
+    from project_x_py.types import ProjectXRealtimeClientProtocol
+
+logger = ProjectXLogger.get_logger(__name__)
 
 
 class ConnectionManagementMixin:
@@ -22,6 +31,7 @@ def __init__(self) -> None:
         super().__init__()
         self._loop: asyncio.AbstractEventLoop | None = None
 
+    @handle_errors("setup connections")
     async def setup_connections(self: "ProjectXRealtimeClientProtocol") -> None:
         """
         Set up SignalR hub connections with ProjectX Gateway configuration.
@@ -57,7 +67,14 @@ async def setup_connections(self: "ProjectXRealtimeClientProtocol") -> None:
             This method is idempotent - safe to call multiple times.
             Sets self.setup_complete = True when successful.
         """
-        try:
+        with LogContext(
+            logger,
+            operation="setup_connections",
+            user_hub=self.user_hub_url,
+            market_hub=self.market_hub_url,
+        ):
+            logger.info(LogMessages.WS_CONNECT, extra={"phase": "setup"})
+
             if HubConnectionBuilder is None:
                 raise ImportError("signalrcore is required for real-time functionality")
 
@@ -72,9 +89,9 @@ async def setup_connections(self: "ProjectXRealtimeClientProtocol") -> None:
                         },
                     )
                     .configure_logging(
-                        logging.INFO,
+                        logger.level,
                         socket_trace=False,
-                        handler=logging.StreamHandler(),
+                        handler=None,
                     )
                     .with_automatic_reconnect(
                         {
@@ -144,13 +161,10 @@ async def setup_connections(self: "ProjectXRealtimeClientProtocol") -> None:
                 self.market_connection.on("GatewayTrade", self._forward_market_trade)
                 self.market_connection.on("GatewayDepth", self._forward_market_depth)
 
-                self.logger.info("✅ ProjectX Gateway connections configured")
+                logger.info(LogMessages.WS_CONNECTED, extra={"phase": "setup_complete"})
                 self.setup_complete = True
 
-        except Exception as e:
-            self.logger.error(f"❌ Failed to setup ProjectX connections: {e}")
-            raise
-
+    @handle_errors("connect", reraise=False, default_return=False)
     async def connect(self: "ProjectXRealtimeClientProtocol") -> bool:
         """
         Connect to ProjectX Gateway SignalR hubs asynchronously.
@@ -189,27 +203,37 @@ async def connect(self: "ProjectXRealtimeClientProtocol") -> bool:
             - SignalR connections run in thread executor for async compatibility
             - Automatic reconnection is configured but initial connect may fail
         """
-        if not self.setup_complete:
-            await self.setup_connections()
+        with LogContext(
+            logger,
+            operation="connect",
+            account_id=self.account_id,
+        ):
+            if not self.setup_complete:
+                await self.setup_connections()
 
-        # Store the event loop for cross-thread task scheduling
-        self._loop = asyncio.get_event_loop()
+            # Store the event loop for cross-thread task scheduling
+            self._loop = asyncio.get_event_loop()
 
-        self.logger.info("🔌 Connecting to ProjectX Gateway...")
+            logger.info(LogMessages.WS_CONNECT)
 
-        try:
             async with self._connection_lock:
                 # Start both connections
                 if self.user_connection:
                     await self._start_connection_async(self.user_connection, "user")
                 else:
-                    self.logger.error("❌ User connection not available")
+                    logger.error(
+                        LogMessages.WS_ERROR,
+                        extra={"error": "User connection not available"},
+                    )
                     return False
 
                 if self.market_connection:
                     await self._start_connection_async(self.market_connection, "market")
                 else:
-                    self.logger.error("❌ Market connection not available")
+                    logger.error(
+                        LogMessages.WS_ERROR,
+                        extra={"error": "Market connection not available"},
+                    )
                     return False
 
                 # Wait for connections to establish
@@ -217,17 +241,16 @@ async def connect(self: "ProjectXRealtimeClientProtocol") -> bool:
 
                 if self.user_connected and self.market_connected:
                     self.stats["connected_time"] = datetime.now()
-                    self.logger.info("✅ ProjectX Gateway connections established")
+                    logger.info(LogMessages.WS_CONNECTED)
                     return True
                 else:
-                    self.logger.error("❌ Failed to establish all connections")
+                    logger.error(
+                        LogMessages.WS_ERROR,
+                        extra={"error": "Failed to establish all connections"},
+                    )
                     return False
 
-        except Exception as e:
-            self.logger.error(f"❌ Connection error: {e}")
-            self.stats["connection_errors"] += 1
-            return False
-
+    @handle_errors("start connection")
     async def _start_connection_async(
         self: "ProjectXRealtimeClientProtocol", connection: Any, name: str
     ) -> None:
@@ -247,8 +270,9 @@ async def _start_connection_async(
         # SignalR connections are synchronous, so we run them in executor
         loop = asyncio.get_event_loop()
         await loop.run_in_executor(None, connection.start)
-        self.logger.info(f"✅ {name.capitalize()} hub connection started")
+        logger.info(LogMessages.WS_CONNECTED, extra={"hub": name})
 
+    @handle_errors("disconnect")
     async def disconnect(self: "ProjectXRealtimeClientProtocol") -> None:
         """
         Disconnect from ProjectX Gateway hubs.
@@ -276,20 +300,25 @@ async def disconnect(self: "ProjectXRealtimeClientProtocol") -> None:
             Does not clear callbacks or subscription lists, allowing for
             reconnection with the same configuration.
         """
-        self.logger.info("📴 Disconnecting from ProjectX Gateway...")
+        with LogContext(
+            logger,
+            operation="disconnect",
+            account_id=self.account_id,
+        ):
+            logger.info(LogMessages.WS_DISCONNECT)
 
-        async with self._connection_lock:
-            if self.user_connection:
-                loop = asyncio.get_event_loop()
-                await loop.run_in_executor(None, self.user_connection.stop)
-                self.user_connected = False
+            async with self._connection_lock:
+                if self.user_connection:
+                    loop = asyncio.get_event_loop()
+                    await loop.run_in_executor(None, self.user_connection.stop)
+                    self.user_connected = False
 
-            if self.market_connection:
-                loop = asyncio.get_event_loop()
-                await loop.run_in_executor(None, self.market_connection.stop)
-                self.market_connected = False
+                if self.market_connection:
+                    loop = asyncio.get_event_loop()
+                    await loop.run_in_executor(None, self.market_connection.stop)
+                    self.market_connected = False
 
-            self.logger.info("✅ Disconnected from ProjectX Gateway")
+                logger.info(LogMessages.WS_DISCONNECTED)
 
     # Connection event handlers
     def _on_user_hub_open(self: "ProjectXRealtimeClientProtocol") -> None:
@@ -378,13 +407,14 @@ def _on_connection_error(
         error_type = type(error).__name__
         if "CompletionMessage" in error_type:
             # This is a normal SignalR protocol message, not an error
-            self.logger.debug(f"SignalR completion message from {hub} hub: {error}")
+            logger.debug(f"SignalR completion message from {hub} hub: {error}")
             return
 
         # Log actual errors
-        self.logger.error(f"❌ {hub.capitalize()} hub error: {error}")
+        logger.error(LogMessages.WS_ERROR, extra={"hub": hub, "error": str(error)})
         self.stats["connection_errors"] += 1
 
+    @handle_errors("update JWT token", reraise=False, default_return=False)
     async def update_jwt_token(
         self: "ProjectXRealtimeClientProtocol", new_jwt_token: str
     ) -> bool:
@@ -435,31 +465,39 @@ async def update_jwt_token(
             - Market data subscriptions are restored automatically
             - Brief data gap during reconnection process
         """
-        self.logger.info("🔑 Updating JWT token and reconnecting...")
-
-        # Disconnect existing connections
-        await self.disconnect()
-
-        # Update JWT token for header authentication
-        self.jwt_token = new_jwt_token
-
-        # Reset setup flag to force new connection setup
-        self.setup_complete = False
-
-        # Reconnect
-        if await self.connect():
-            # Re-subscribe to user updates
-            await self.subscribe_user_updates()
-
-            # Re-subscribe to market data
-            if self._subscribed_contracts:
-                await self.subscribe_market_data(self._subscribed_contracts)
-
-            self.logger.info("✅ Reconnected with new JWT token")
-            return True
-        else:
-            self.logger.error("❌ Failed to reconnect with new JWT token")
-            return False
+        with LogContext(
+            logger,
+            operation="update_jwt_token",
+            account_id=self.account_id,
+        ):
+            logger.info(LogMessages.AUTH_REFRESH)
+
+            # Disconnect existing connections
+            await self.disconnect()
+
+            # Update JWT token for header authentication
+            self.jwt_token = new_jwt_token
+
+            # Reset setup flag to force new connection setup
+            self.setup_complete = False
+
+            # Reconnect
+            if await self.connect():
+                # Re-subscribe to user updates
+                await self.subscribe_user_updates()
+
+                # Re-subscribe to market data
+                if self._subscribed_contracts:
+                    await self.subscribe_market_data(self._subscribed_contracts)
+
+                logger.info(LogMessages.WS_RECONNECT)
+                return True
+            else:
+                logger.error(
+                    LogMessages.WS_ERROR,
+                    extra={"error": "Failed to reconnect with new JWT token"},
+                )
+                return False
 
     def is_connected(self: "ProjectXRealtimeClientProtocol") -> bool:
         """
diff --git a/src/project_x_py/realtime/core.py b/src/project_x_py/realtime/core.py
index b78ba5a..1f33b89 100644
--- a/src/project_x_py/realtime/core.py
+++ b/src/project_x_py/realtime/core.py
@@ -19,7 +19,6 @@
 from project_x_py.realtime.connection_management import ConnectionManagementMixin
 from project_x_py.realtime.event_handling import EventHandlingMixin
 from project_x_py.realtime.subscriptions import SubscriptionsMixin
-from project_x_py.utils import RateLimiter
 
 if TYPE_CHECKING:
     from project_x_py.models import ProjectXConfig
@@ -199,8 +198,6 @@ def __init__(
         self.logger.info(f"User Hub: {final_user_url}")
         self.logger.info(f"Market Hub: {final_market_url}")
 
-        self.rate_limiter = RateLimiter(requests_per_minute=60)
-
         # Async locks for thread-safe operations
         self._callback_lock = asyncio.Lock()
         self._connection_lock = asyncio.Lock()
diff --git a/src/project_x_py/realtime/event_handling.py b/src/project_x_py/realtime/event_handling.py
index fd3f605..0ce26d3 100644
--- a/src/project_x_py/realtime/event_handling.py
+++ b/src/project_x_py/realtime/event_handling.py
@@ -6,7 +6,7 @@
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from project_x_py.realtime.types import ProjectXRealtimeClientProtocol
+    from project_x_py.types import ProjectXRealtimeClientProtocol
 
 
 class EventHandlingMixin:
diff --git a/src/project_x_py/realtime/subscriptions.py b/src/project_x_py/realtime/subscriptions.py
index d8e3ae4..6e60f21 100644
--- a/src/project_x_py/realtime/subscriptions.py
+++ b/src/project_x_py/realtime/subscriptions.py
@@ -3,13 +3,23 @@
 import asyncio
 from typing import TYPE_CHECKING
 
+from project_x_py.utils import (
+    LogContext,
+    LogMessages,
+    ProjectXLogger,
+    handle_errors,
+)
+
 if TYPE_CHECKING:
-    from project_x_py.realtime.types import ProjectXRealtimeClientProtocol
+    from project_x_py.types import ProjectXRealtimeClientProtocol
+
+logger = ProjectXLogger.get_logger(__name__)
 
 
 class SubscriptionsMixin:
     """Mixin for subscription management functionality."""
 
+    @handle_errors("subscribe user updates", reraise=False, default_return=False)
     async def subscribe_user_updates(self: "ProjectXRealtimeClientProtocol") -> bool:
         """
         Subscribe to all user-specific real-time updates.
@@ -55,14 +65,26 @@ async def subscribe_user_updates(self: "ProjectXRealtimeClientProtocol") -> bool
             - All subscriptions are account-specific
             - Must re-subscribe after reconnection
         """
-        if not self.user_connected:
-            self.logger.error("❌ User hub not connected")
-            return False
+        with LogContext(
+            logger,
+            operation="subscribe_user_updates",
+            account_id=self.account_id,
+        ):
+            if not self.user_connected:
+                logger.error(
+                    LogMessages.WS_ERROR, extra={"error": "User hub not connected"}
+                )
+                return False
 
-        try:
-            self.logger.info(f"📡 Subscribing to user updates for {self.account_id}")
+            logger.info(
+                LogMessages.DATA_SUBSCRIBE,
+                extra={"channel": "user_updates", "account_id": self.account_id},
+            )
             if self.user_connection is None:
-                self.logger.error("❌ User connection not available")
+                logger.error(
+                    LogMessages.WS_ERROR,
+                    extra={"error": "User connection not available"},
+                )
                 return False
             # ProjectX Gateway expects Subscribe method with account ID
             loop = asyncio.get_event_loop()
@@ -99,13 +121,13 @@ async def subscribe_user_updates(self: "ProjectXRealtimeClientProtocol") -> bool
                 [int(self.account_id)],  # List with int account ID
             )
 
-            self.logger.info("✅ Subscribed to user updates")
+            logger.info(
+                LogMessages.DATA_SUBSCRIBE,
+                extra={"status": "success", "channel": "user_updates"},
+            )
             return True
 
-        except Exception as e:
-            self.logger.error(f"❌ Failed to subscribe to user updates: {e}")
-            return False
-
+    @handle_errors("subscribe market data", reraise=False, default_return=False)
     async def subscribe_market_data(
         self: "ProjectXRealtimeClientProtocol", contract_ids: list[str]
     ) -> bool:
@@ -160,13 +182,21 @@ async def subscribe_market_data(
             - Duplicate subscriptions are filtered automatically
             - Contract IDs are case-sensitive
         """
-        if not self.market_connected:
-            self.logger.error("❌ Market hub not connected")
-            return False
+        with LogContext(
+            logger,
+            operation="subscribe_market_data",
+            contract_count=len(contract_ids),
+            contracts=contract_ids[:5],  # Log first 5 contracts
+        ):
+            if not self.market_connected:
+                logger.error(
+                    LogMessages.WS_ERROR, extra={"error": "Market hub not connected"}
+                )
+                return False
 
-        try:
-            self.logger.info(
-                f"📊 Subscribing to market data for {len(contract_ids)} contracts"
+            logger.info(
+                LogMessages.DATA_SUBSCRIBE,
+                extra={"channel": "market_data", "count": len(contract_ids)},
             )
 
             # Store for reconnection (avoid duplicates)
@@ -179,7 +209,10 @@ async def subscribe_market_data(
             for contract_id in contract_ids:
                 # Subscribe to quotes
                 if self.market_connection is None:
-                    self.logger.error("❌ Market connection not available")
+                    logger.error(
+                        LogMessages.WS_ERROR,
+                        extra={"error": "Market connection not available"},
+                    )
                     return False
                 await loop.run_in_executor(
                     None,
@@ -202,13 +235,17 @@ async def subscribe_market_data(
                     [contract_id],
                 )
 
-            self.logger.info(f"✅ Subscribed to {len(contract_ids)} contracts")
+            logger.info(
+                LogMessages.DATA_SUBSCRIBE,
+                extra={
+                    "status": "success",
+                    "channel": "market_data",
+                    "count": len(contract_ids),
+                },
+            )
             return True
 
-        except Exception as e:
-            self.logger.error(f"❌ Failed to subscribe to market data: {e}")
-            return False
-
+    @handle_errors("unsubscribe user updates", reraise=False, default_return=False)
     async def unsubscribe_user_updates(self: "ProjectXRealtimeClientProtocol") -> bool:
         """
         Unsubscribe from all user-specific real-time updates.
@@ -234,15 +271,25 @@ async def unsubscribe_user_updates(self: "ProjectXRealtimeClientProtocol") -> bo
             - Can re-subscribe without re-registering callbacks
             - Stops events for: accounts, positions, orders, trades
         """
-        if not self.user_connected:
-            self.logger.error("❌ User hub not connected")
-            return False
+        with LogContext(
+            logger,
+            operation="unsubscribe_user_updates",
+            account_id=self.account_id,
+        ):
+            if not self.user_connected:
+                logger.error(
+                    LogMessages.WS_ERROR, extra={"error": "User hub not connected"}
+                )
+                return False
 
-        if self.user_connection is None:
-            self.logger.error("❌ User connection not available")
-            return False
+            if self.user_connection is None:
+                logger.error(
+                    LogMessages.WS_ERROR,
+                    extra={"error": "User connection not available"},
+                )
+                return False
 
-        try:
+            logger.info(LogMessages.DATA_UNSUBSCRIBE, extra={"channel": "user_updates"})
             loop = asyncio.get_event_loop()
 
             # Unsubscribe from account updates
@@ -280,13 +327,13 @@ async def unsubscribe_user_updates(self: "ProjectXRealtimeClientProtocol") -> bo
                 self.account_id,
             )
 
-            self.logger.info("✅ Unsubscribed from user updates")
+            logger.info(
+                LogMessages.DATA_UNSUBSCRIBE,
+                extra={"status": "success", "channel": "user_updates"},
+            )
             return True
 
-        except Exception as e:
-            self.logger.error(f"❌ Failed to unsubscribe from user updates: {e}")
-            return False
-
+    @handle_errors("unsubscribe market data", reraise=False, default_return=False)
     async def unsubscribe_market_data(
         self: "ProjectXRealtimeClientProtocol", contract_ids: list[str]
     ) -> bool:
@@ -326,12 +373,22 @@ async def unsubscribe_market_data(
             - Callbacks remain registered for future subscriptions
             - Safe to call with non-subscribed contracts
         """
-        if not self.market_connected:
-            self.logger.error("❌ Market hub not connected")
-            return False
+        with LogContext(
+            logger,
+            operation="unsubscribe_market_data",
+            contract_count=len(contract_ids),
+            contracts=contract_ids[:5],
+        ):
+            if not self.market_connected:
+                logger.error(
+                    LogMessages.WS_ERROR, extra={"error": "Market hub not connected"}
+                )
+                return False
 
-        try:
-            self.logger.info(f"🛑 Unsubscribing from {len(contract_ids)} contracts")
+            logger.info(
+                LogMessages.DATA_UNSUBSCRIBE,
+                extra={"channel": "market_data", "count": len(contract_ids)},
+            )
 
             # Remove from stored contracts
             for contract_id in contract_ids:
@@ -341,7 +398,10 @@ async def unsubscribe_market_data(
             # ProjectX Gateway expects Unsubscribe method
             loop = asyncio.get_event_loop()
             if self.market_connection is None:
-                self.logger.error("❌ Market connection not available")
+                logger.error(
+                    LogMessages.WS_ERROR,
+                    extra={"error": "Market connection not available"},
+                )
                 return False
 
             # Unsubscribe from quotes
@@ -368,9 +428,12 @@ async def unsubscribe_market_data(
                 [contract_ids],
             )
 
-            self.logger.info(f"✅ Unsubscribed from {len(contract_ids)} contracts")
+            logger.info(
+                LogMessages.DATA_UNSUBSCRIBE,
+                extra={
+                    "status": "success",
+                    "channel": "market_data",
+                    "count": len(contract_ids),
+                },
+            )
             return True
-
-        except Exception as e:
-            self.logger.error(f"❌ Failed to unsubscribe from market data: {e}")
-            return False
diff --git a/src/project_x_py/realtime/types.py b/src/project_x_py/realtime/types.py
deleted file mode 100644
index d538177..0000000
--- a/src/project_x_py/realtime/types.py
+++ /dev/null
@@ -1,89 +0,0 @@
-"""Type definitions and protocols for real-time client."""
-
-import asyncio
-from collections import defaultdict
-from collections.abc import Callable, Coroutine
-from typing import TYPE_CHECKING, Any, Protocol
-
-if TYPE_CHECKING:
-    pass
-
-
-class ProjectXRealtimeClientProtocol(Protocol):
-    """Protocol defining the interface for ProjectXRealtimeClient components."""
-
-    # Core attributes
-    jwt_token: str
-    account_id: str
-    user_hub_url: str
-    market_hub_url: str
-    base_user_url: str
-    base_market_url: str
-
-    # Connection objects
-    user_connection: Any | None
-    market_connection: Any | None
-
-    # Connection state
-    user_connected: bool
-    market_connected: bool
-    setup_complete: bool
-
-    # Callbacks and stats
-    callbacks: defaultdict[str, list[Any]]
-    stats: dict[str, Any]
-
-    # Subscriptions
-    _subscribed_contracts: list[str]
-
-    # Logging and rate limiting
-    logger: Any
-    rate_limiter: Any
-
-    # Async locks
-    _callback_lock: asyncio.Lock
-    _connection_lock: asyncio.Lock
-
-    # Event loop
-    _loop: asyncio.AbstractEventLoop | None
-
-    # Methods required by mixins
-    async def setup_connections(self) -> None: ...
-    async def connect(self) -> bool: ...
-    async def disconnect(self) -> None: ...
-    async def _start_connection_async(self, connection: Any, name: str) -> None: ...
-    def _on_user_hub_open(self) -> None: ...
-    def _on_user_hub_close(self) -> None: ...
-    def _on_market_hub_open(self) -> None: ...
-    def _on_market_hub_close(self) -> None: ...
-    def _on_connection_error(self, hub: str, error: Any) -> None: ...
-    async def add_callback(
-        self,
-        event_type: str,
-        callback: Callable[[dict[str, Any]], Coroutine[Any, Any, None] | None],
-    ) -> None: ...
-    async def remove_callback(
-        self,
-        event_type: str,
-        callback: Callable[[dict[str, Any]], Coroutine[Any, Any, None] | None],
-    ) -> None: ...
-    async def _trigger_callbacks(
-        self, event_type: str, data: dict[str, Any]
-    ) -> None: ...
-    def _forward_account_update(self, *args: Any) -> None: ...
-    def _forward_position_update(self, *args: Any) -> None: ...
-    def _forward_order_update(self, *args: Any) -> None: ...
-    def _forward_trade_execution(self, *args: Any) -> None: ...
-    def _forward_quote_update(self, *args: Any) -> None: ...
-    def _forward_market_trade(self, *args: Any) -> None: ...
-    def _forward_market_depth(self, *args: Any) -> None: ...
-    def _schedule_async_task(self, event_type: str, data: Any) -> None: ...
-    async def _forward_event_async(self, event_type: str, args: Any) -> None: ...
-    async def subscribe_user_updates(self) -> bool: ...
-    async def subscribe_market_data(self, contract_ids: list[str]) -> bool: ...
-    async def unsubscribe_user_updates(self) -> bool: ...
-    async def unsubscribe_market_data(self, contract_ids: list[str]) -> bool: ...
-    def is_connected(self) -> bool: ...
-    def get_stats(self) -> dict[str, Any]: ...
-    async def update_jwt_token(self, new_jwt_token: str) -> bool: ...
-    async def cleanup(self) -> None: ...
diff --git a/src/project_x_py/realtime_data_manager/callbacks.py b/src/project_x_py/realtime_data_manager/callbacks.py
index c7fbea1..7f4b7f8 100644
--- a/src/project_x_py/realtime_data_manager/callbacks.py
+++ b/src/project_x_py/realtime_data_manager/callbacks.py
@@ -6,7 +6,7 @@
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from project_x_py.realtime_data_manager.types import RealtimeDataManagerProtocol
+    from project_x_py.types import RealtimeDataManagerProtocol
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/project_x_py/realtime_data_manager/core.py b/src/project_x_py/realtime_data_manager/core.py
index 6e156bb..d9ef7fd 100644
--- a/src/project_x_py/realtime_data_manager/core.py
+++ b/src/project_x_py/realtime_data_manager/core.py
@@ -6,7 +6,6 @@
 """
 
 import asyncio
-import logging
 import time
 from collections import defaultdict
 from datetime import datetime
@@ -17,7 +16,6 @@
 
 from project_x_py.client.base import ProjectXBase
 from project_x_py.exceptions import (
-    ProjectXDataError,
     ProjectXError,
     ProjectXInstrumentError,
 )
@@ -27,6 +25,14 @@
 from project_x_py.realtime_data_manager.data_processing import DataProcessingMixin
 from project_x_py.realtime_data_manager.memory_management import MemoryManagementMixin
 from project_x_py.realtime_data_manager.validation import ValidationMixin
+from project_x_py.utils import (
+    ErrorMessages,
+    LogContext,
+    LogMessages,
+    ProjectXLogger,
+    format_error_message,
+    handle_errors,
+)
 
 if TYPE_CHECKING:
     from project_x_py.client import ProjectXBase
@@ -206,7 +212,7 @@ def __init__(
         self.project_x: ProjectXBase = project_x
         self.realtime_client: ProjectXRealtimeClient = realtime_client
 
-        self.logger = logging.getLogger(__name__)
+        self.logger = ProjectXLogger.get_logger(__name__)
 
         # Set timezone for consistent timestamp handling
         self.timezone: Any = pytz.timezone(timezone)  # CME timezone
@@ -270,8 +276,11 @@ def __init__(
         # Background cleanup task
         self._cleanup_task: asyncio.Task[None] | None = None
 
-        self.logger.info(f"RealtimeDataManager initialized for {instrument}")
+        self.logger.info(
+            "RealtimeDataManager initialized", extra={"instrument": instrument}
+        )
 
+    @handle_errors("initialize", reraise=False, default_return=False)
     async def initialize(self, initial_days: int = 1) -> bool:
         """
         Initialize the real-time data manager by loading historical OHLCV data.
@@ -320,9 +329,15 @@ async def initialize(self, initial_days: int = 1) -> bool:
             - If data for a specific timeframe fails to load, the method will log a warning
               but continue with the other timeframes
         """
-        try:
+        with LogContext(
+            self.logger,
+            operation="initialize",
+            instrument=self.instrument,
+            initial_days=initial_days,
+        ):
             self.logger.info(
-                f"Initializing RealtimeDataManager for {self.instrument}..."
+                LogMessages.DATA_FETCH,
+                extra={"phase": "initialization", "instrument": self.instrument},
             )
 
             # Get the contract ID for the instrument
@@ -330,8 +345,11 @@ async def initialize(self, initial_days: int = 1) -> bool:
                 self.instrument
             )
             if instrument_info is None:
-                self.logger.error(f"❌ Instrument {self.instrument} not found")
-                return False
+                raise ProjectXInstrumentError(
+                    format_error_message(
+                        ErrorMessages.INSTRUMENT_NOT_FOUND, symbol=self.instrument
+                    )
+                )
 
             # Store the exact contract ID for real-time subscriptions
             self.contract_id = instrument_info.id
@@ -349,26 +367,22 @@ async def initialize(self, initial_days: int = 1) -> bool:
                     if bars is not None and not bars.is_empty():
                         self.data[tf_key] = bars
                         self.logger.info(
-                            f"✅ Loaded {len(bars)} bars for {tf_key} timeframe"
+                            LogMessages.DATA_RECEIVED,
+                            extra={"timeframe": tf_key, "bar_count": len(bars)},
                         )
                     else:
-                        self.logger.warning(f"⚠️ No data loaded for {tf_key} timeframe")
+                        self.logger.warning(
+                            LogMessages.DATA_ERROR,
+                            extra={"timeframe": tf_key, "error": "No data loaded"},
+                        )
 
             self.logger.info(
-                f"✅ RealtimeDataManager initialized for {self.instrument}"
+                LogMessages.DATA_RECEIVED,
+                extra={"status": "initialized", "instrument": self.instrument},
             )
             return True
 
-        except ProjectXInstrumentError as e:
-            self.logger.error(f"❌ Failed to initialize - instrument error: {e}")
-            return False
-        except ProjectXDataError as e:
-            self.logger.error(f"❌ Failed to initialize - data error: {e}")
-            return False
-        except ProjectXError as e:
-            self.logger.error(f"❌ Failed to initialize - ProjectX error: {e}")
-            return False
-
+    @handle_errors("start realtime feed", reraise=False, default_return=False)
     async def start_realtime_feed(self) -> bool:
         """
         Start the real-time OHLCV data feed using WebSocket connections.
@@ -422,14 +436,26 @@ async def on_new_bar(data):
             - The method sets up a background task for periodic memory cleanup to prevent
               excessive memory usage
         """
-        try:
+        with LogContext(
+            self.logger,
+            operation="start_realtime_feed",
+            instrument=self.instrument,
+            contract_id=self.contract_id,
+        ):
             if self.is_running:
-                self.logger.warning("⚠️ Real-time feed already running")
+                self.logger.warning(
+                    LogMessages.DATA_ERROR,
+                    extra={"error": "Real-time feed already running"},
+                )
                 return True
 
             if not self.contract_id:
-                self.logger.error("❌ Contract ID not set - call initialize() first")
-                return False
+                raise ProjectXError(
+                    format_error_message(
+                        ErrorMessages.INTERNAL_ERROR,
+                        reason="Contract ID not set - call initialize() first",
+                    )
+                )
 
             # Register callbacks first
             await self.realtime_client.add_callback(
@@ -441,17 +467,25 @@ async def on_new_bar(data):
             )
 
             # Subscribe to market data using the contract ID
-            self.logger.info(f"📡 Subscribing to market data for {self.contract_id}")
+            self.logger.info(
+                LogMessages.DATA_SUBSCRIBE, extra={"contract_id": self.contract_id}
+            )
             subscription_success = await self.realtime_client.subscribe_market_data(
                 [self.contract_id]
             )
 
             if not subscription_success:
-                self.logger.error("❌ Failed to subscribe to market data")
-                return False
+                raise ProjectXError(
+                    format_error_message(
+                        ErrorMessages.WS_SUBSCRIPTION_FAILED,
+                        channel="market data",
+                        reason="Subscription returned False",
+                    )
+                )
 
             self.logger.info(
-                f"✅ Successfully subscribed to market data for {self.contract_id}"
+                LogMessages.DATA_SUBSCRIBE,
+                extra={"status": "success", "contract_id": self.contract_id},
             )
 
             self.is_running = True
@@ -459,16 +493,12 @@ async def on_new_bar(data):
             # Start cleanup task
             self.start_cleanup_task()
 
-            self.logger.info(f"✅ Real-time OHLCV feed started for {self.instrument}")
+            self.logger.info(
+                LogMessages.DATA_SUBSCRIBE,
+                extra={"status": "feed_started", "instrument": self.instrument},
+            )
             return True
 
-        except RuntimeError as e:
-            self.logger.error(f"❌ Failed to start real-time feed - runtime error: {e}")
-            return False
-        except TimeoutError as e:
-            self.logger.error(f"❌ Failed to start real-time feed - timeout: {e}")
-            return False
-
     async def stop_realtime_feed(self) -> None:
         """
         Stop the real-time OHLCV data feed and cleanup resources.
diff --git a/src/project_x_py/realtime_data_manager/data_access.py b/src/project_x_py/realtime_data_manager/data_access.py
index d49dcb8..99af59d 100644
--- a/src/project_x_py/realtime_data_manager/data_access.py
+++ b/src/project_x_py/realtime_data_manager/data_access.py
@@ -6,7 +6,7 @@
 import polars as pl
 
 if TYPE_CHECKING:
-    from project_x_py.realtime_data_manager.types import RealtimeDataManagerProtocol
+    from project_x_py.types import RealtimeDataManagerProtocol
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/project_x_py/realtime_data_manager/data_processing.py b/src/project_x_py/realtime_data_manager/data_processing.py
index b98e692..49b88db 100644
--- a/src/project_x_py/realtime_data_manager/data_processing.py
+++ b/src/project_x_py/realtime_data_manager/data_processing.py
@@ -7,7 +7,9 @@
 import polars as pl
 
 if TYPE_CHECKING:
-    from project_x_py.realtime_data_manager.types import RealtimeDataManagerProtocol
+    from asyncio import Lock
+
+    from pytz import BaseTzInfo
 
 logger = logging.getLogger(__name__)
 
@@ -15,9 +17,32 @@
 class DataProcessingMixin:
     """Mixin for tick processing and OHLCV bar creation."""
 
-    async def _on_quote_update(
-        self: "RealtimeDataManagerProtocol", callback_data: dict[str, Any]
-    ) -> None:
+    # Type hints for mypy - these attributes are provided by the main class
+    if TYPE_CHECKING:
+        logger: logging.Logger
+        timezone: BaseTzInfo
+        data_lock: Lock
+        current_tick_data: list[dict[str, Any]]
+        timeframes: dict[str, dict[str, Any]]
+        data: dict[str, pl.DataFrame]
+        last_bar_times: dict[str, datetime]
+        memory_stats: dict[str, Any]
+        is_running: bool
+
+        # Methods from other mixins/main class
+        def _parse_and_validate_quote_payload(
+            self, data: dict[str, Any]
+        ) -> dict[str, Any] | None: ...
+        def _parse_and_validate_trade_payload(
+            self, data: dict[str, Any]
+        ) -> dict[str, Any] | None: ...
+        def _symbol_matches_instrument(self, symbol: str) -> bool: ...
+        async def _trigger_callbacks(
+            self, event_type: str, data: dict[str, Any]
+        ) -> None: ...
+        async def _cleanup_old_data(self) -> None: ...
+
+    async def _on_quote_update(self, callback_data: dict[str, Any]) -> None:
         """
         Handle real-time quote updates for OHLCV data processing.
 
@@ -91,9 +116,7 @@ async def _on_quote_update(
             self.logger.error(f"Error processing quote update for OHLCV: {e}")
             self.logger.debug(f"Callback data that caused error: {callback_data}")
 
-    async def _on_trade_update(
-        self: "RealtimeDataManagerProtocol", callback_data: dict[str, Any]
-    ) -> None:
+    async def _on_trade_update(self, callback_data: dict[str, Any]) -> None:
         """
         Handle real-time trade updates for OHLCV data processing.
 
@@ -153,9 +176,7 @@ async def _on_trade_update(
             self.logger.error(f"❌ Error processing market trade for OHLCV: {e}")
             self.logger.debug(f"Callback data that caused error: {callback_data}")
 
-    async def _process_tick_data(
-        self: "RealtimeDataManagerProtocol", tick: dict[str, Any]
-    ) -> None:
+    async def _process_tick_data(self, tick: dict[str, Any]) -> None:
         """
         Process incoming tick data and update all OHLCV timeframes.
 
@@ -192,7 +213,7 @@ async def _process_tick_data(
             self.logger.error(f"Error processing tick data: {e}")
 
     async def _update_timeframe_data(
-        self: "RealtimeDataManagerProtocol",
+        self,
         tf_key: str,
         timestamp: datetime,
         price: float,
@@ -325,7 +346,7 @@ async def _update_timeframe_data(
             self.logger.error(f"Error updating {tf_key} timeframe: {e}")
 
     def _calculate_bar_time(
-        self: "RealtimeDataManagerProtocol",
+        self,
         timestamp: datetime,
         interval: int,
         unit: int,
diff --git a/src/project_x_py/realtime_data_manager/memory_management.py b/src/project_x_py/realtime_data_manager/memory_management.py
index 1cdc33f..65dcf6b 100644
--- a/src/project_x_py/realtime_data_manager/memory_management.py
+++ b/src/project_x_py/realtime_data_manager/memory_management.py
@@ -8,7 +8,9 @@
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from project_x_py.realtime_data_manager.types import RealtimeDataManagerProtocol
+    from asyncio import Lock
+
+    import polars as pl
 
 logger = logging.getLogger(__name__)
 
@@ -16,12 +18,26 @@
 class MemoryManagementMixin:
     """Mixin for memory management and optimization."""
 
+    # Type hints for mypy - these attributes are provided by the main class
+    if TYPE_CHECKING:
+        logger: logging.Logger
+        last_cleanup: float
+        cleanup_interval: float
+        data_lock: Lock
+        timeframes: dict[str, dict[str, Any]]
+        data: dict[str, pl.DataFrame]
+        max_bars_per_timeframe: int
+        current_tick_data: list[dict[str, Any]]
+        tick_buffer_size: int
+        memory_stats: dict[str, Any]
+        is_running: bool
+
     def __init__(self) -> None:
         """Initialize memory management attributes."""
         super().__init__()
         self._cleanup_task: asyncio.Task[None] | None = None
 
-    async def _cleanup_old_data(self: "RealtimeDataManagerProtocol") -> None:
+    async def _cleanup_old_data(self) -> None:
         """
         Clean up old OHLCV data to manage memory efficiently using sliding windows.
         """
@@ -71,7 +87,7 @@ async def _cleanup_old_data(self: "RealtimeDataManagerProtocol") -> None:
                 # Force garbage collection after cleanup
                 gc.collect()
 
-    async def _periodic_cleanup(self: "RealtimeDataManagerProtocol") -> None:
+    async def _periodic_cleanup(self) -> None:
         """Background task for periodic cleanup."""
         while self.is_running:
             try:
@@ -91,7 +107,7 @@ async def _periodic_cleanup(self: "RealtimeDataManagerProtocol") -> None:
                 self.logger.error(f"Runtime error in periodic cleanup: {e}")
                 # Don't re-raise runtime errors to keep the cleanup task running
 
-    def get_memory_stats(self: "RealtimeDataManagerProtocol") -> dict[str, Any]:
+    def get_memory_stats(self) -> dict[str, Any]:
         """
         Get comprehensive memory usage statistics for the real-time data manager.
 
@@ -124,7 +140,7 @@ def get_memory_stats(self: "RealtimeDataManagerProtocol") -> dict[str, Any]:
             **self.memory_stats,
         }
 
-    async def stop_cleanup_task(self: "RealtimeDataManagerProtocol") -> None:
+    async def stop_cleanup_task(self) -> None:
         """Stop the background cleanup task."""
         if self._cleanup_task:
             self._cleanup_task.cancel()
@@ -132,7 +148,7 @@ async def stop_cleanup_task(self: "RealtimeDataManagerProtocol") -> None:
                 await self._cleanup_task
             self._cleanup_task = None
 
-    def start_cleanup_task(self: "RealtimeDataManagerProtocol") -> None:
+    def start_cleanup_task(self) -> None:
         """Start the background cleanup task."""
         if not self._cleanup_task:
             self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
diff --git a/src/project_x_py/realtime_data_manager/types.py b/src/project_x_py/realtime_data_manager/types.py
deleted file mode 100644
index 4a6af64..0000000
--- a/src/project_x_py/realtime_data_manager/types.py
+++ /dev/null
@@ -1,94 +0,0 @@
-"""Type definitions and protocols for real-time data management."""
-
-import asyncio
-from collections.abc import Callable, Coroutine
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, Protocol
-
-import polars as pl
-import pytz
-
-if TYPE_CHECKING:
-    from collections import defaultdict
-
-    from project_x_py.client import ProjectXBase
-    from project_x_py.realtime import ProjectXRealtimeClient
-
-
-class RealtimeDataManagerProtocol(Protocol):
-    """Protocol defining the interface for RealtimeDataManager components."""
-
-    # Core attributes
-    instrument: str
-    project_x: "ProjectXBase"
-    realtime_client: "ProjectXRealtimeClient"
-    logger: Any
-    timezone: pytz.tzinfo.BaseTzInfo
-
-    # Timeframe configuration
-    timeframes: dict[str, dict[str, Any]]
-
-    # Data storage
-    data: dict[str, pl.DataFrame]
-    current_tick_data: list[dict[str, Any]]
-    last_bar_times: dict[str, datetime]
-
-    # Synchronization
-    data_lock: asyncio.Lock
-    is_running: bool
-    callbacks: dict[str, list[Any]]
-    indicator_cache: "defaultdict[str, dict[str, Any]]"
-
-    # Contract and subscription
-    contract_id: str | None
-
-    # Memory management settings
-    max_bars_per_timeframe: int
-    tick_buffer_size: int
-    cleanup_interval: float
-    last_cleanup: float
-    memory_stats: dict[str, Any]
-
-    # Background tasks
-    _cleanup_task: asyncio.Task[None] | None
-
-    # Methods required by mixins
-    async def _cleanup_old_data(self) -> None: ...
-    async def _periodic_cleanup(self) -> None: ...
-    async def _trigger_callbacks(
-        self, event_type: str, data: dict[str, Any]
-    ) -> None: ...
-    async def _on_quote_update(self, callback_data: dict[str, Any]) -> None: ...
-    async def _on_trade_update(self, callback_data: dict[str, Any]) -> None: ...
-    async def _process_tick_data(self, tick: dict[str, Any]) -> None: ...
-    async def _update_timeframe_data(
-        self, tf_key: str, timestamp: datetime, price: float, volume: int
-    ) -> None: ...
-    def _calculate_bar_time(
-        self, timestamp: datetime, interval: int, unit: int
-    ) -> datetime: ...
-    def _parse_and_validate_trade_payload(
-        self, trade_data: Any
-    ) -> dict[str, Any] | None: ...
-    def _parse_and_validate_quote_payload(
-        self, quote_data: Any
-    ) -> dict[str, Any] | None: ...
-    def _symbol_matches_instrument(self, symbol: str) -> bool: ...
-
-    # Public interface methods
-    async def initialize(self, initial_days: int = 1) -> bool: ...
-    async def start_realtime_feed(self) -> bool: ...
-    async def stop_realtime_feed(self) -> None: ...
-    async def get_data(
-        self, timeframe: str = "5min", bars: int | None = None
-    ) -> pl.DataFrame | None: ...
-    async def get_current_price(self) -> float | None: ...
-    async def get_mtf_data(self) -> dict[str, pl.DataFrame]: ...
-    async def add_callback(
-        self,
-        event_type: str,
-        callback: Callable[[dict[str, Any]], Coroutine[Any, Any, None] | None],
-    ) -> None: ...
-    def get_memory_stats(self) -> dict[str, Any]: ...
-    def get_realtime_validation_status(self) -> dict[str, Any]: ...
-    async def cleanup(self) -> None: ...
diff --git a/src/project_x_py/realtime_data_manager/validation.py b/src/project_x_py/realtime_data_manager/validation.py
index a94cb90..e742049 100644
--- a/src/project_x_py/realtime_data_manager/validation.py
+++ b/src/project_x_py/realtime_data_manager/validation.py
@@ -5,7 +5,7 @@
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from project_x_py.realtime_data_manager.types import RealtimeDataManagerProtocol
+    from project_x_py.types import RealtimeDataManagerProtocol
 
 logger = logging.getLogger(__name__)
 
diff --git a/src/project_x_py/types/__init__.py b/src/project_x_py/types/__init__.py
new file mode 100644
index 0000000..da8478a
--- /dev/null
+++ b/src/project_x_py/types/__init__.py
@@ -0,0 +1,83 @@
+"""
+Centralized type definitions for ProjectX Python SDK.
+
+This package consolidates all type definitions, protocols, and type aliases
+used throughout the ProjectX SDK to ensure consistency and reduce redundancy.
+
+The types are organized into logical modules:
+- base: Core types used across the SDK
+- trading: Order and position related types
+- market_data: Market data and real-time types
+- protocols: Protocol definitions for type checking
+"""
+
+# Import all types for convenient access
+from project_x_py.types.base import (
+    DEFAULT_TIMEZONE,
+    TICK_SIZE_PRECISION,
+    AccountId,
+    AsyncCallback,
+    CallbackType,
+    ContractId,
+    OrderId,
+    PositionId,
+    SyncCallback,
+)
+from project_x_py.types.market_data import (
+    DomType,
+    IcebergConfig,
+    MarketDataDict,
+    MemoryConfig,
+    OrderbookSide,
+    OrderbookSnapshot,
+    PriceLevelDict,
+    TradeDict,
+)
+from project_x_py.types.protocols import (
+    OrderManagerProtocol,
+    PositionManagerProtocol,
+    ProjectXClientProtocol,
+    ProjectXRealtimeClientProtocol,
+    RealtimeDataManagerProtocol,
+)
+from project_x_py.types.trading import (
+    OrderSide,
+    OrderStats,
+    OrderStatus,
+    OrderType,
+    PositionSide,
+)
+
+__all__ = [
+    "DEFAULT_TIMEZONE",
+    "TICK_SIZE_PRECISION",
+    "AccountId",
+    # From base.py
+    "AsyncCallback",
+    "CallbackType",
+    "ContractId",
+    # From market_data.py
+    "DomType",
+    "IcebergConfig",
+    "MarketDataDict",
+    "MemoryConfig",
+    "OrderId",
+    "OrderManagerProtocol",
+    # From trading.py
+    "OrderSide",
+    "OrderStats",
+    "OrderStatus",
+    "OrderType",
+    "OrderbookSide",
+    "OrderbookSnapshot",
+    "PositionId",
+    "PositionManagerProtocol",
+    "PositionSide",
+    "PriceLevelDict",
+    # From protocols.py
+    "ProjectXClientProtocol",
+    "ProjectXRealtimeClientProtocol",
+    "RealtimeDataManagerProtocol",
+    "SyncCallback",
+    "TradeDict",
+]
diff --git a/src/project_x_py/types/base.py b/src/project_x_py/types/base.py
new file mode 100644
index 0000000..e00cd2a
--- /dev/null
+++ b/src/project_x_py/types/base.py
@@ -0,0 +1,36 @@
+"""
+Core type definitions used across the ProjectX SDK.
+
+This module contains fundamental types that are used throughout the SDK,
+including enums, type aliases, and basic data structures.
+"""
+
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+# Type aliases for callbacks
+AsyncCallback = Callable[[dict[str, Any]], Coroutine[Any, Any, None]]
+SyncCallback = Callable[[dict[str, Any]], None]
+CallbackType = AsyncCallback | SyncCallback
+
+# Common constants
+DEFAULT_TIMEZONE = "America/Chicago"
+TICK_SIZE_PRECISION = 8  # Decimal places for tick size rounding
+
+# Common type aliases
+ContractId = str
+AccountId = str
+OrderId = str
+PositionId = str
+
+__all__ = [
+    "DEFAULT_TIMEZONE",
+    "TICK_SIZE_PRECISION",
+    "AccountId",
+    "AsyncCallback",
+    "CallbackType",
+    "ContractId",
+    "OrderId",
+    "PositionId",
+    "SyncCallback",
+]
diff --git a/src/project_x_py/orderbook/types.py b/src/project_x_py/types/market_data.py
similarity index 79%
rename from src/project_x_py/orderbook/types.py
rename to src/project_x_py/types/market_data.py
index a892cb8..8a488f7 100644
--- a/src/project_x_py/orderbook/types.py
+++ b/src/project_x_py/types/market_data.py
@@ -1,11 +1,10 @@
 """
-Type definitions and constants for the async orderbook module.
+Market data type definitions.
 
-This module contains shared types, enums, and constants used across
-the async orderbook implementation.
+This module contains type definitions for market data structures including
+orderbook data, trades, quotes, and real-time data updates.
 """
 
-from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
 from datetime import datetime
 from enum import IntEnum
@@ -107,12 +106,13 @@ class IcebergConfig:
     confidence_threshold: float = 0.7
 
 
-# Type aliases for async callbacks
-AsyncCallback = Callable[[dict[str, Any]], Coroutine[Any, Any, None]]
-SyncCallback = Callable[[dict[str, Any]], None]
-CallbackType = AsyncCallback | SyncCallback
-
-
-# Constants
-DEFAULT_TIMEZONE = "America/Chicago"
-TICK_SIZE_PRECISION = 8  # Decimal places for tick size rounding
+__all__ = [
+    "DomType",
+    "IcebergConfig",
+    "MarketDataDict",
+    "MemoryConfig",
+    "OrderbookSide",
+    "OrderbookSnapshot",
+    "PriceLevelDict",
+    "TradeDict",
+]
diff --git a/src/project_x_py/types/protocols.py b/src/project_x_py/types/protocols.py
new file mode 100644
index 0000000..51593b8
--- /dev/null
+++ b/src/project_x_py/types/protocols.py
@@ -0,0 +1,489 @@
+"""
+Protocol definitions for type checking across the ProjectX SDK.
+
+This module consolidates all protocol definitions used for type checking
+throughout the SDK, ensuring consistent interfaces between components.
+"""
+
+import asyncio
+import datetime
+import logging
+from collections import defaultdict
+from collections.abc import Callable, Coroutine
+from typing import TYPE_CHECKING, Any, Protocol
+
+import httpx
+import polars as pl
+
+if TYPE_CHECKING:
+    from project_x_py.models import (
+        Account,
+        Instrument,
+        Order,
+        OrderPlaceResponse,
+        Position,
+        ProjectXConfig,
+        Trade,
+    )
+    from project_x_py.realtime import ProjectXRealtimeClient
+    from project_x_py.types import OrderStats
+    from project_x_py.utils.async_rate_limiter import RateLimiter
+
+
+class ProjectXClientProtocol(Protocol):
+    """Protocol defining the interface that client mixins expect."""
+
+    # Authentication attributes
+    session_token: str
+    token_expiry: "datetime.datetime | None"
+    _authenticated: bool
+    username: str
+    api_key: str
+    account_name: str | None
+    account_info: "Account | None"
+    logger: logging.Logger
+
+    # HTTP client attributes
+    _client: "httpx.AsyncClient | None"
+    headers: dict[str, str]
+    base_url: str
+    config: "ProjectXConfig"
+    rate_limiter: "RateLimiter"
+    api_call_count: int
+
+    # Cache attributes
+    cache_hit_count: int
+    cache_ttl: int
+    last_cache_cleanup: float
+    _instrument_cache: dict[str, "Instrument"]
+    _instrument_cache_time: dict[str, float]
+    _market_data_cache: dict[str, pl.DataFrame]
+    _market_data_cache_time: dict[str, float]
+
+    # Authentication methods
+    def _should_refresh_token(self) -> bool: ...
+    async def authenticate(self) -> None: ...
+    async def _refresh_authentication(self) -> None: ...
+    async def _ensure_authenticated(self) -> None: ...
+    async def list_accounts(self) -> list["Account"]: ...
+
+    # HTTP methods
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+        retry_count: int = 0,
+    ) -> Any: ...
+    async def _create_client(self) -> httpx.AsyncClient: ...
+    async def _ensure_client(self) -> httpx.AsyncClient: ...
+    async def get_health_status(self) -> dict[str, Any]: ...
+
+    # Cache methods
+    async def _cleanup_cache(self) -> None: ...
+    def get_cached_instrument(self, symbol: str) -> "Instrument | None": ...
+    def cache_instrument(self, symbol: str, instrument: "Instrument") -> None: ...
+    def get_cached_market_data(self, cache_key: str) -> pl.DataFrame | None: ...
+    def cache_market_data(self, cache_key: str, data: pl.DataFrame) -> None: ...
+    def clear_all_caches(self) -> None: ...
+
+    # Market data methods
+    async def get_instrument(self, symbol: str, live: bool = False) -> "Instrument": ...
+    async def search_instruments(
+        self, query: str, live: bool = False
+    ) -> list["Instrument"]: ...
+    async def get_bars(
+        self,
+        symbol: str,
+        days: int = 8,
+        interval: int = 5,
+        unit: int = 2,
+        limit: int | None = None,
+        partial: bool = True,
+    ) -> pl.DataFrame: ...
+    def _select_best_contract(
+        self, instruments: list[dict[str, Any]], search_symbol: str
+    ) -> dict[str, Any]: ...
+
+    # Trading methods
+    async def get_positions(self) -> list["Position"]: ...
+    async def search_open_positions(
+        self, account_id: int | None = None
+    ) -> list["Position"]: ...
+    async def search_trades(
+        self,
+        start_date: "datetime.datetime | None" = None,
+        end_date: "datetime.datetime | None" = None,
+        contract_id: str | None = None,
+        account_id: int | None = None,
+        limit: int = 100,
+    ) -> list["Trade"]: ...
+
+
+class OrderManagerProtocol(Protocol):
+    """Protocol defining the interface that mixins expect from OrderManager."""
+
+    project_x: ProjectXClientProtocol
+    realtime_client: "ProjectXRealtimeClient | None"
+    order_lock: asyncio.Lock
+    _realtime_enabled: bool
+    stats: "OrderStats"
+
+    # From tracking mixin
+    tracked_orders: dict[str, dict[str, Any]]
+    order_status_cache: dict[str, int]
+    order_callbacks: dict[str, list[Any]]
+    position_orders: dict[str, dict[str, list[int]]]
+    order_to_position: dict[int, str]
+
+    # Methods that mixins need
+    async def place_order(
+        self,
+        contract_id: str,
+        order_type: int,
+        side: int,
+        size: int,
+        limit_price: float | None = None,
+        stop_price: float | None = None,
+        trail_price: float | None = None,
+        custom_tag: str | None = None,
+        linked_order_id: int | None = None,
+        account_id: int | None = None,
+    ) -> "OrderPlaceResponse": ...
+
+    async def place_market_order(
+        self, contract_id: str, side: int, size: int, account_id: int | None = None
+    ) -> "OrderPlaceResponse": ...
+
+    async def place_limit_order(
+        self,
+        contract_id: str,
+        side: int,
+        size: int,
+        limit_price: float,
+        account_id: int | None = None,
+    ) -> "OrderPlaceResponse": ...
+
+    async def place_stop_order(
+        self,
+        contract_id: str,
+        side: int,
+        size: int,
+        stop_price: float,
+        account_id: int | None = None,
+    ) -> "OrderPlaceResponse": ...
+
+    async def get_order_by_id(self, order_id: int) -> "Order | None": ...
+
+    async def cancel_order(
+        self, order_id: int, account_id: int | None = None
+    ) -> bool: ...
+
+    async def modify_order(
+        self,
+        order_id: int,
+        limit_price: float | None = None,
+        stop_price: float | None = None,
+        size: int | None = None,
+    ) -> bool: ...
+
+    async def get_tracked_order_status(
+        self, order_id: str, wait_for_cache: bool = False
+    ) -> dict[str, Any] | None: ...
+
+    async def track_order_for_position(
+        self,
+        contract_id: str,
+        order_id: int,
+        order_type: str = "entry",
+        account_id: int | None = None,
+    ) -> None: ...
+
+    def untrack_order(self, order_id: int) -> None: ...
+
+    def get_position_orders(self, contract_id: str) -> dict[str, list[int]]: ...
+
+    async def _on_order_update(
+        self, order_data: dict[str, Any] | list[Any]
+    ) -> None: ...
+
+    async def _on_trade_execution(
+        self, trade_data: dict[str, Any] | list[Any]
+    ) -> None: ...
+
+    async def cancel_position_orders(
+        self,
+        contract_id: str,
+        order_types: list[str] | None = None,
+        account_id: int | None = None,
+    ) -> dict[str, int]: ...
+
+    async def update_position_order_sizes(
+        self, contract_id: str, new_size: int, account_id: int | None = None
+    ) -> dict[str, Any]: ...
+
+    async def sync_orders_with_position(
+        self,
+        contract_id: str,
+        target_size: int,
+        cancel_orphaned: bool = True,
+        account_id: int | None = None,
+    ) -> dict[str, Any]: ...
+
+    async def on_position_closed(
+        self, contract_id: str, account_id: int | None = None
+    ) -> None: ...
+
+    async def _setup_realtime_callbacks(self) -> None: ...
+
+
+class PositionManagerProtocol(Protocol):
+    """Protocol defining the interface that mixins expect from PositionManager."""
+
+    project_x: ProjectXClientProtocol
+    logger: Any
+    position_lock: asyncio.Lock
+    realtime_client: "ProjectXRealtimeClient | None"
+    _realtime_enabled: bool
+    order_manager: "OrderManagerProtocol | None"
+    _order_sync_enabled: bool
+    tracked_positions: dict[str, "Position"]
+    position_history: dict[str, list[dict[str, Any]]]
+    position_callbacks: dict[str, list[Any]]
+    _monitoring_active: bool
+    _monitoring_task: "asyncio.Task[None] | None"
+    position_alerts: dict[str, dict[str, Any]]
+    stats: dict[str, Any]
+    risk_settings: dict[str, Any]
+
+    # Methods required by mixins
+    async def _setup_realtime_callbacks(self) -> None: ...
+    async def _on_position_update(self, position_data: dict[str, Any]) -> None: ...
+    async def _on_account_update(self, account_data: dict[str, Any]) -> None: ...
+    async def _process_position_data(
+        self, position_data: dict[str, Any]
+    ) -> "Position | None": ...
+    async def _trigger_callbacks(
+        self, event_type: str, data: dict[str, Any]
+    ) -> None: ...
+    def _validate_position_payload(self, position_data: dict[str, Any]) -> bool: ...
+    async def _check_position_alerts(
+        self,
+        contract_id: str,
+        current_position: "Position",
+        old_position: "Position | None",
+    ) -> None: ...
+    async def get_all_positions(
+        self, account_id: int | None = None
+    ) -> list["Position"]: ...
+    async def get_position(
+        self, contract_id: str, account_id: int | None = None
+    ) -> "Position | None": ...
+    async def get_positions(
+        self, account_id: int | None = None
+    ) -> list["Position"]: ...
+    def _generate_risk_warnings(
+        self,
+        positions: list["Position"],
+        portfolio_risk: float,
+        largest_position_risk: float,
+    ) -> list[str]: ...
+    def _generate_sizing_warnings(
+        self, risk_percentage: float, size: int
+    ) -> list[str]: ...
+    async def refresh_positions(self, account_id: int | None = None) -> int: ...
+    async def close_position_direct(
+        self, contract_id: str, account_id: int | None = None
+    ) -> dict[str, Any]: ...
+    async def partially_close_position(
+        self, contract_id: str, reduce_by: int, account_id: int | None = None
+    ) -> dict[str, Any]: ...
+    async def calculate_position_pnl(
+        self, position: "Position", current_price: float, point_value: float = 1.0
+    ) -> dict[str, float]: ...
+    async def get_portfolio_pnl(
+        self,
+        current_prices: dict[str, float] | None = None,
+        account_id: int | None = None,
+    ) -> dict[str, Any]: ...
+    async def get_risk_metrics(
+        self, account_id: int | None = None
+    ) -> dict[str, Any]: ...
+    async def get_position_statistics(
+        self, account_id: int | None = None
+    ) -> dict[str, Any]: ...
+    async def _monitoring_loop(self, check_interval: float = 60.0) -> None: ...
+    async def stop_monitoring(self) -> None: ...
+
+
+class RealtimeDataManagerProtocol(Protocol):
+    """Protocol defining the interface for RealtimeDataManager components."""
+
+    # Core attributes
+    instrument: str
+    project_x: ProjectXClientProtocol
+    realtime_client: "ProjectXRealtimeClient"
+    logger: Any
+    timezone: Any  # pytz.tzinfo.BaseTzInfo
+
+    # Timeframe configuration
+    timeframes: dict[str, dict[str, Any]]
+
+    # Data storage
+    data: dict[str, pl.DataFrame]
+    current_tick_data: list[dict[str, Any]]
+    last_bar_times: dict[str, datetime.datetime]
+
+    # Synchronization
+    data_lock: asyncio.Lock
+    is_running: bool
+    callbacks: dict[str, list[Any]]
+    indicator_cache: defaultdict[str, dict[str, Any]]
+
+    # Contract and subscription
+    contract_id: str | None
+
+    # Memory management settings
+    max_bars_per_timeframe: int
+    tick_buffer_size: int
+    cleanup_interval: float
+    last_cleanup: float
+    memory_stats: dict[str, Any]
+
+    # Background tasks
+    _cleanup_task: "asyncio.Task[None] | None"
+
+    # Methods required by mixins
+    async def _cleanup_old_data(self) -> None: ...
+    async def _periodic_cleanup(self) -> None: ...
+    async def _trigger_callbacks(
+        self, event_type: str, data: dict[str, Any]
+    ) -> None: ...
+    async def _on_quote_update(self, callback_data: dict[str, Any]) -> None: ...
+    async def _on_trade_update(self, callback_data: dict[str, Any]) -> None: ...
+    async def _process_tick_data(self, tick: dict[str, Any]) -> None: ...
+    async def _update_timeframe_data(
+        self, tf_key: str, timestamp: datetime.datetime, price: float, volume: int
+    ) -> None: ...
+    def _calculate_bar_time(
+        self, timestamp: datetime.datetime, interval: int, unit: int
+    ) -> datetime.datetime: ...
+    def _parse_and_validate_trade_payload(
+        self, trade_data: Any
+    ) -> dict[str, Any] | None: ...
+    def _parse_and_validate_quote_payload(
+        self, quote_data: Any
+    ) -> dict[str, Any] | None: ...
+    def _symbol_matches_instrument(self, symbol: str) -> bool: ...
+
+    # Public interface methods
+    async def initialize(self, initial_days: int = 1) -> bool: ...
+    async def start_realtime_feed(self) -> bool: ...
+    async def stop_realtime_feed(self) -> None: ...
+    async def get_data(
+        self, timeframe: str = "5min", bars: int | None = None
+    ) -> pl.DataFrame | None: ...
+    async def get_current_price(self) -> float | None: ...
+    async def get_mtf_data(self) -> dict[str, pl.DataFrame]: ...
+    async def add_callback(
+        self,
+        event_type: str,
+        callback: Callable[[dict[str, Any]], Coroutine[Any, Any, None] | None],
+    ) -> None: ...
+    def get_memory_stats(self) -> dict[str, Any]: ...
+    def get_realtime_validation_status(self) -> dict[str, Any]: ...
+    async def cleanup(self) -> None: ...
+
+    # Memory management methods
+    def start_cleanup_task(self) -> None: ...
+    async def stop_cleanup_task(self) -> None: ...
+
+
+class ProjectXRealtimeClientProtocol(Protocol):
+    """Protocol defining the interface for ProjectXRealtimeClient components."""
+
+    # Core attributes
+    jwt_token: str
+    account_id: str
+    user_hub_url: str
+    market_hub_url: str
+    base_user_url: str
+    base_market_url: str
+
+    # Connection objects
+    user_connection: Any | None
+    market_connection: Any | None
+
+    # Connection state
+    user_connected: bool
+    market_connected: bool
+    setup_complete: bool
+
+    # Callbacks and stats
+    callbacks: defaultdict[str, list[Any]]
+    stats: dict[str, Any]
+
+    # Subscriptions
+    _subscribed_contracts: list[str]
+
+    # Logging
+    logger: Any
+
+    # Async locks
+    _callback_lock: asyncio.Lock
+    _connection_lock: asyncio.Lock
+
+    # Event loop
+    _loop: asyncio.AbstractEventLoop | None
+
+    # Methods required by mixins
+    async def setup_connections(self) -> None: ...
+    async def connect(self) -> bool: ...
+    async def disconnect(self) -> None: ...
+    async def _start_connection_async(self, connection: Any, name: str) -> None: ...
+    def _on_user_hub_open(self) -> None: ...
+    def _on_user_hub_close(self) -> None: ...
+    def _on_market_hub_open(self) -> None: ...
+    def _on_market_hub_close(self) -> None: ...
+    def _on_connection_error(self, hub: str, error: Any) -> None: ...
+    async def add_callback(
+        self,
+        event_type: str,
+        callback: Callable[[dict[str, Any]], Coroutine[Any, Any, None] | None],
+    ) -> None: ...
+    async def remove_callback(
+        self,
+        event_type: str,
+        callback: Callable[[dict[str, Any]], Coroutine[Any, Any, None] | None],
+    ) -> None: ...
+    async def _trigger_callbacks(
+        self, event_type: str, data: dict[str, Any]
+    ) -> None: ...
+    def _forward_account_update(self, *args: Any) -> None: ...
+    def _forward_position_update(self, *args: Any) -> None: ...
+    def _forward_order_update(self, *args: Any) -> None: ...
+    def _forward_trade_execution(self, *args: Any) -> None: ...
+    def _forward_quote_update(self, *args: Any) -> None: ...
+    def _forward_market_trade(self, *args: Any) -> None: ...
+    def _forward_market_depth(self, *args: Any) -> None: ...
+    def _schedule_async_task(self, event_type: str, data: Any) -> None: ...
+    async def _forward_event_async(self, event_type: str, args: Any) -> None: ...
+    async def subscribe_user_updates(self) -> bool: ...
+    async def subscribe_market_data(self, contract_ids: list[str]) -> bool: ...
+    async def unsubscribe_user_updates(self) -> bool: ...
+    async def unsubscribe_market_data(self, contract_ids: list[str]) -> bool: ...
+    def is_connected(self) -> bool: ...
+    def get_stats(self) -> dict[str, Any]: ...
+    async def update_jwt_token(self, new_jwt_token: str) -> bool: ...
+    async def cleanup(self) -> None: ...
+
+
+__all__ = [
+    "OrderManagerProtocol",
+    "PositionManagerProtocol",
+    "ProjectXClientProtocol",
+    "ProjectXRealtimeClientProtocol",
+    "RealtimeDataManagerProtocol",
+]
diff --git a/src/project_x_py/types/trading.py b/src/project_x_py/types/trading.py
new file mode 100644
index 0000000..19fa9b6
--- /dev/null
+++ b/src/project_x_py/types/trading.py
@@ -0,0 +1,65 @@
+"""
+Trading-related type definitions for orders and positions.
+
+This module contains type definitions for trading operations including
+order management, position tracking, and execution statistics.
+"""
+
+from datetime import datetime
+from enum import IntEnum
+from typing import TypedDict
+
+
+class OrderSide(IntEnum):
+    """Order side enumeration."""
+
+    BUY = 0
+    SELL = 1
+
+
+class OrderType(IntEnum):
+    """Order type enumeration."""
+
+    MARKET = 0
+    LIMIT = 1
+    STOP = 2
+    STOP_LIMIT = 3
+    TRAILING_STOP = 4
+
+
+class OrderStatus(IntEnum):
+    """Order status enumeration."""
+
+    PENDING = 0
+    OPEN = 1
+    FILLED = 2
+    CANCELLED = 3
+    REJECTED = 4
+    EXPIRED = 5
+
+
+class OrderStats(TypedDict):
+    """Type definition for order statistics."""
+
+    orders_placed: int
+    orders_cancelled: int
+    orders_modified: int
+    bracket_orders_placed: int
+    last_order_time: datetime | None
+
+
+class PositionSide(IntEnum):
+    """Position side enumeration."""
+
+    LONG = 0
+    SHORT = 1
+    FLAT = 2
+
+
+__all__ = [
+    "OrderSide",
+    "OrderStats",
+    "OrderStatus",
+    "OrderType",
+    "PositionSide",
+]
diff --git a/src/project_x_py/utils/README.md b/src/project_x_py/utils/README.md
new file mode 100644
index 0000000..b871ac5
--- /dev/null
+++ b/src/project_x_py/utils/README.md
@@ -0,0 +1,98 @@
+# Utilities Package
+
+This package contains generic utility functions that provide common functionality across the ProjectX SDK.
+
+## Architecture Principles
+
+### What Belongs in Utils
+
+Utility functions should:
+- Be generic and reusable across different contexts
+- Work with standard data types (DataFrames, numbers, strings)
+- Have no domain-specific knowledge
+- Be stateless and pure functions
+- Not depend on specific ProjectX models or types
+
+Examples:
+- Mathematical calculations (`trading_calculations.py`)
+- Data formatting and display (`formatting.py`)
+- Environment variable handling (`environment.py`)
+- Generic data transformations (`data_utils.py`)
+
+### What Doesn't Belong in Utils
+
+Domain-specific functionality should be in its respective module:
+- Orderbook-specific analysis → `orderbook/` package
+- Position management logic → `position_manager/` package
+- Order handling → `order_manager/` package
+- Real-time data processing → `realtime_data_manager/` package
+
+## Module Overview
+
+### Core Utilities
+
+- **async_rate_limiter.py**: Async-safe rate limiting for API calls
+- **data_utils.py**: DataFrame transformations and data manipulation
+- **environment.py**: Environment variable configuration helpers
+- **formatting.py**: Price, quantity, and display formatting
+- **logging_utils.py**: Logging configuration and helpers
+- **trading_calculations.py**: Generic trading math (tick values, position sizing)
+
+### Analysis Utilities
+
+- **pattern_detection.py**: Technical pattern detection algorithms
+- **portfolio_analytics.py**: Portfolio-level calculations and metrics
+- **market_utils.py**: Market session and trading hour utilities
+
+Note: Market microstructure analysis (bid-ask spread, volume profile) has been moved to the orderbook package:
+- `orderbook.analytics.MarketAnalytics.analyze_dataframe_spread()` - Analyze spread from any DataFrame
+- `orderbook.profile.VolumeProfile.calculate_dataframe_volume_profile()` - Calculate volume distribution
+
+## Usage Guidelines
+
+1. **Keep it Simple**: Utilities should do one thing well
+2. **Type Safety**: Use type hints for all parameters and returns
+3. **Documentation**: Include docstrings with examples
+4. **Testing**: All utilities must have comprehensive unit tests
+5. **No Side Effects**: Utilities should not modify global state
+
+## Examples
+
+### Using Trading Calculations
+```python
+from project_x_py.utils import calculate_tick_value, round_to_tick_size
+
+# Calculate dollar value of price movement
+tick_value = calculate_tick_value(
+    price_change=0.5,  # 5 tick move
+    tick_size=0.1,     # MGC tick size
+    tick_value=1.0     # $1 per tick
+)  # Returns: 5.0
+
+# Round price to valid tick
+price = round_to_tick_size(2050.37, 0.1)  # Returns: 2050.4
+```
+
+### Using Market Analysis
+```python
+from project_x_py.orderbook import MarketAnalytics
+import polars as pl
+
+# Analyze spread from historical data
+data = pl.DataFrame({
+    "bid": [100.0, 100.1, 100.2],
+    "ask": [100.2, 100.3, 100.4]
+})
+
+# Use static method for DataFrame analysis
+spread_stats = MarketAnalytics.analyze_dataframe_spread(data)
+print(f"Average spread: {spread_stats['avg_spread']}")
+```
+
+## Future Development
+
+When adding new utilities:
+1. Ensure they follow the principles above
+2. Add comprehensive tests
+3. Update this documentation
+4. Consider if functionality belongs in a domain module instead
\ No newline at end of file
diff --git a/src/project_x_py/utils/__init__.py b/src/project_x_py/utils/__init__.py
index bbf8db2..90bfc53 100644
--- a/src/project_x_py/utils/__init__.py
+++ b/src/project_x_py/utils/__init__.py
@@ -9,6 +9,8 @@
 """
 
 # Data utilities
+# Rate limiting
+from project_x_py.utils.async_rate_limiter import RateLimiter
 from project_x_py.utils.data_utils import (
     create_data_snapshot,
     get_polars_last_value,
@@ -18,18 +20,33 @@
 # Environment utilities
 from project_x_py.utils.environment import get_env_var
 
+# Error handling utilities
+from project_x_py.utils.error_handler import (
+    ErrorContext,
+    handle_errors,
+    handle_rate_limit,
+    retry_on_network_error,
+    validate_response,
+)
+from project_x_py.utils.error_messages import (
+    ErrorCode,
+    ErrorMessages,
+    format_error_message,
+)
+
 # Formatting utilities
 from project_x_py.utils.formatting import format_price, format_volume
+from project_x_py.utils.logging_config import (
+    LogContext,
+    LogMessages,
+    ProjectXLogger,
+    configure_sdk_logging,
+    log_api_call,
+)
 
 # Logging utilities
 from project_x_py.utils.logging_utils import setup_logging
 
-# Market microstructure utilities
-from project_x_py.utils.market_microstructure import (
-    analyze_bid_ask_spread,
-    calculate_volume_profile,
-)
-
 # Market utilities
 from project_x_py.utils.market_utils import (
     convert_timeframe_to_seconds,
@@ -54,9 +71,6 @@
     calculate_volatility_metrics,
 )
 
-# Rate limiting
-from project_x_py.utils.rate_limiter import RateLimiter
-
 # Trading calculations
 from project_x_py.utils.trading_calculations import (
     calculate_position_sizing,
@@ -67,10 +81,15 @@
 )
 
 __all__ = [
+    # Error handling
+    "ErrorCode",
+    "ErrorContext",
+    "ErrorMessages",
     # Rate limiting
+    "LogContext",
+    "LogMessages",
+    "ProjectXLogger",
     "RateLimiter",
-    # Market microstructure
-    "analyze_bid_ask_spread",
     # Portfolio analytics
     "calculate_correlation_matrix",
     "calculate_max_drawdown",
@@ -82,13 +101,14 @@
     # Trading calculations
     "calculate_tick_value",
     "calculate_volatility_metrics",
-    "calculate_volume_profile",
+    "configure_sdk_logging",
     "convert_timeframe_to_seconds",
     "create_data_snapshot",
     # Pattern detection
     "detect_candlestick_patterns",
     "detect_chart_patterns",
     "extract_symbol_from_contract_id",
+    "format_error_message",
     # Formatting utilities
     "format_price",
     "format_volume",
@@ -98,10 +118,15 @@
     "get_polars_last_value",
     # Data utilities
     "get_polars_rows",
+    "handle_errors",
+    "handle_rate_limit",
     # Market utilities
     "is_market_hours",
+    "log_api_call",
+    "retry_on_network_error",
     "round_to_tick_size",
     # Logging utilities
     "setup_logging",
     "validate_contract_id",
+    "validate_response",
 ]
diff --git a/src/project_x_py/client/rate_limiter.py b/src/project_x_py/utils/async_rate_limiter.py
similarity index 50%
rename from src/project_x_py/client/rate_limiter.py
rename to src/project_x_py/utils/async_rate_limiter.py
index 82646ce..b1af936 100644
--- a/src/project_x_py/client/rate_limiter.py
+++ b/src/project_x_py/utils/async_rate_limiter.py
@@ -1,11 +1,65 @@
-"""Rate limiting for API calls."""
+"""Async rate limiting for API calls.
+
+This module provides a thread-safe, async rate limiter using a sliding window
+algorithm. It ensures that no more than a specified number of requests are
+made within a given time window.
+
+Example:
+    >>> limiter = RateLimiter(
+    ...     max_requests=60, window_seconds=60
+    ... )  # 60 requests per minute
+    >>> async def make_api_call():
+    ...     await limiter.acquire()
+    ...     # Make your API call here
+    ...     response = await client.get("/api/endpoint")
+    ...     return response
+
+The rate limiter is particularly useful for:
+- Respecting API rate limits
+- Preventing server overload
+- Implementing fair usage policies
+- Testing rate-limited scenarios
+"""
 
 import asyncio
 import time
 
 
 class RateLimiter:
-    """Simple async rate limiter using sliding window."""
+    """Async rate limiter using sliding window algorithm.
+
+    This rate limiter implements a sliding window algorithm that tracks
+    the exact timestamp of each request. It ensures that at any point in
+    time, no more than `max_requests` have been made in the past
+    `window_seconds`.
+
+    Features:
+        - Thread-safe using asyncio locks
+        - Accurate sliding window implementation
+        - Automatic cleanup of old request timestamps
+        - Memory-efficient with bounded history
+        - Zero CPU usage while waiting
+
+    Args:
+        max_requests: Maximum number of requests allowed in the window
+        window_seconds: Size of the sliding window in seconds
+
+    Example:
+        >>> # Create a rate limiter for 10 requests per second
+        >>> limiter = RateLimiter(max_requests=10, window_seconds=1)
+        >>>
+        >>> # Use in an async function
+        >>> async def rate_limited_operation():
+        ...     await limiter.acquire()
+        ...     # Perform operation here
+        ...     return "Success"
+        >>>
+        >>> # The limiter will automatically delay if needed
+        >>> async def bulk_operations():
+        ...     tasks = [rate_limited_operation() for _ in range(50)]
+        ...     results = await asyncio.gather(*tasks)
+        ...     # This will take ~5 seconds (50 requests / 10 per second)
+    """
 
     def __init__(self, max_requests: int, window_seconds: int):
         self.max_requests = max_requests
diff --git a/src/project_x_py/utils/error_handler.py b/src/project_x_py/utils/error_handler.py
new file mode 100644
index 0000000..08f7ac0
--- /dev/null
+++ b/src/project_x_py/utils/error_handler.py
@@ -0,0 +1,495 @@
+"""
+Centralized error handling utilities for ProjectX SDK.
+
+This module provides consistent error handling patterns, logging, and retry logic
+across the entire SDK.
+
+Author: TexasCoding
+Date: January 2025
+"""
+
+import asyncio
+import functools
+import logging
+from collections.abc import Callable
+from typing import Any, Literal, TypeVar, cast
+
+import httpx
+
+from project_x_py.exceptions import (
+    ProjectXConnectionError,
+    ProjectXDataError,
+    ProjectXError,
+    ProjectXRateLimitError,
+    ProjectXServerError,
+)
+
+T = TypeVar("T")
+
+
+def handle_errors(
+    operation: str,
+    logger: logging.Logger | None = None,
+    reraise: bool = True,
+    default_return: Any = None,
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """
+    Decorator for consistent error handling across the SDK.
+
+    This decorator catches exceptions, logs them consistently, and optionally
+    re-raises them with additional context.
+
+    Args:
+        operation: Description of the operation being performed
+        logger: Logger instance to use (defaults to module logger)
+        reraise: Whether to re-raise exceptions after logging
+        default_return: Default value to return if exception occurs and reraise=False
+
+    Example:
+        @handle_errors("fetch market data")
+        async def get_bars(self, symbol: str):
+            # Implementation
+            pass
+    """
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @functools.wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> T:
+            nonlocal logger
+            if logger is None:
+                logger = logging.getLogger(func.__module__)
+
+            try:
+                return await func(*args, **kwargs)  # type: ignore[misc,no-any-return]
+            except ProjectXError as e:
+                # Already a ProjectX error, just add context
+                logger.error(
+                    f"ProjectX error during {operation}: {e}",
+                    extra={
+                        "error_type": type(e).__name__,
+                        "error_code": getattr(e, "error_code", None),
+                        "operation": operation,
+                        "function": func.__name__,
+                    },
+                )
+                if reraise:
+                    raise
+                return cast(T, default_return)
+            except httpx.HTTPError as e:
+                # Convert HTTP errors to ProjectX errors
+                logger.error(
+                    f"HTTP error during {operation}: {e}",
+                    extra={
+                        "error_type": type(e).__name__,
+                        "operation": operation,
+                        "function": func.__name__,
+                    },
+                )
+                if reraise:
+                    raise ProjectXConnectionError(
+                        f"HTTP error during {operation}: {e}"
+                    ) from e
+                return cast(T, default_return)
+            except Exception as e:
+                # Unexpected errors
+                logger.exception(
+                    f"Unexpected error during {operation}",
+                    extra={
+                        "error_type": type(e).__name__,
+                        "operation": operation,
+                        "function": func.__name__,
+                    },
+                )
+                if reraise:
+                    raise ProjectXError(
+                        f"Unexpected error during {operation}: {e}"
+                    ) from e
+                return cast(T, default_return)
+
+        @functools.wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> T:
+            nonlocal logger
+            if logger is None:
+                logger = logging.getLogger(func.__module__)
+
+            try:
+                return func(*args, **kwargs)
+            except ProjectXError as e:
+                logger.error(
+                    f"ProjectX error during {operation}: {e}",
+                    extra={
+                        "error_type": type(e).__name__,
+                        "error_code": getattr(e, "error_code", None),
+                        "operation": operation,
+                        "function": func.__name__,
+                    },
+                )
+                if reraise:
+                    raise
+                return cast(T, default_return)
+            except Exception as e:
+                logger.exception(
+                    f"Unexpected error during {operation}",
+                    extra={
+                        "error_type": type(e).__name__,
+                        "operation": operation,
+                        "function": func.__name__,
+                    },
+                )
+                if reraise:
+                    raise ProjectXError(
+                        f"Unexpected error during {operation}: {e}"
+                    ) from e
+                return cast(T, default_return)
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return cast(Callable[..., T], async_wrapper)
+        else:
+            return cast(Callable[..., T], sync_wrapper)
+
+    return decorator
+
+
+def retry_on_network_error(
+    max_attempts: int = 3,
+    backoff_factor: float = 2.0,
+    initial_delay: float = 1.0,
+    max_delay: float = 60.0,
+    retry_on: tuple[type[Exception], ...] = (
+        httpx.ConnectError,
+        httpx.TimeoutException,
+        ProjectXConnectionError,
+        ProjectXServerError,
+    ),
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """
+    Decorator to retry operations on network errors with exponential backoff.
+
+    Args:
+        max_attempts: Maximum number of retry attempts
+        backoff_factor: Multiplier for exponential backoff
+        initial_delay: Initial delay between retries in seconds
+        max_delay: Maximum delay between retries in seconds
+        retry_on: Tuple of exception types to retry on
+
+    Example:
+        @retry_on_network_error(max_attempts=5, initial_delay=0.5)
+        async def api_call(self):
+            # Implementation
+            pass
+    """
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @functools.wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> T:
+            logger = logging.getLogger(func.__module__)
+            last_exception = None
+
+            for attempt in range(max_attempts):
+                try:
+                    return await func(*args, **kwargs)  # type: ignore[misc,no-any-return]
+                except retry_on as e:
+                    last_exception = e
+
+                    if attempt < max_attempts - 1:
+                        delay = min(
+                            initial_delay * (backoff_factor**attempt), max_delay
+                        )
+                        logger.warning(
+                            f"Retry {attempt + 1}/{max_attempts} for {func.__name__} "
+                            f"after {type(e).__name__}, waiting {delay:.1f}s",
+                            extra={
+                                "attempt": attempt + 1,
+                                "max_attempts": max_attempts,
+                                "delay": delay,
+                                "error_type": type(e).__name__,
+                                "function": func.__name__,
+                            },
+                        )
+                        await asyncio.sleep(delay)
+                    else:
+                        logger.error(
+                            f"Max retries ({max_attempts}) exceeded for {func.__name__}",
+                            extra={
+                                "max_attempts": max_attempts,
+                                "error_type": type(e).__name__,
+                                "function": func.__name__,
+                            },
+                        )
+
+            # Re-raise the last exception
+            if last_exception:
+                raise last_exception
+            else:
+                # Should never reach here, but just in case
+                raise RuntimeError(
+                    f"Unexpected state in retry logic for {func.__name__}"
+                )
+
+        @functools.wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> T:
+            logger = logging.getLogger(func.__module__)
+            last_exception = None
+
+            for attempt in range(max_attempts):
+                try:
+                    return func(*args, **kwargs)
+                except retry_on as e:
+                    last_exception = e
+
+                    if attempt < max_attempts - 1:
+                        delay = min(
+                            initial_delay * (backoff_factor**attempt), max_delay
+                        )
+                        logger.warning(
+                            f"Retry {attempt + 1}/{max_attempts} for {func.__name__} "
+                            f"after {type(e).__name__}, waiting {delay:.1f}s"
+                        )
+                        # For sync functions, we can't use asyncio.sleep
+                        import time
+
+                        time.sleep(delay)
+                    else:
+                        logger.error(
+                            f"Max retries ({max_attempts}) exceeded for {func.__name__}"
+                        )
+
+            if last_exception:
+                raise last_exception
+            else:
+                raise RuntimeError(
+                    f"Unexpected state in retry logic for {func.__name__}"
+                )
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return cast(Callable[..., T], async_wrapper)
+        else:
+            return cast(Callable[..., T], sync_wrapper)
+
+    return decorator
+
+
+def handle_rate_limit(
+    logger: logging.Logger | None = None,
+    fallback_delay: float = 60.0,
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """
+    Decorator to handle rate limit errors with automatic retry.
+
+    Args:
+        logger: Logger instance to use
+        fallback_delay: Default delay if rate limit reset time is not available
+
+    Example:
+        @handle_rate_limit(fallback_delay=30.0)
+        async def make_api_call(self):
+            # Implementation
+            pass
+    """
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @functools.wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> T:
+            nonlocal logger
+            if logger is None:
+                logger = logging.getLogger(func.__module__)
+
+            try:
+                return await func(*args, **kwargs)  # type: ignore[misc,no-any-return]
+            except ProjectXRateLimitError as e:
+                # Check if we have a reset time in the response
+                reset_time = None
+                if hasattr(e, "response_data") and e.response_data:
+                    reset_time = e.response_data.get("reset_at")
+
+                if reset_time:
+                    # Calculate delay until reset
+                    from datetime import datetime
+
+                    try:
+                        reset_dt = datetime.fromisoformat(
+                            reset_time.replace("Z", "+00:00")
+                        )
+                        now = datetime.now(reset_dt.tzinfo)
+                        delay = max((reset_dt - now).total_seconds(), 1.0)
+                    except Exception:
+                        delay = fallback_delay
+                else:
+                    delay = fallback_delay
+
+                logger.warning(
+                    f"Rate limit hit in {func.__name__}, waiting {delay:.1f}s",
+                    extra={
+                        "delay": delay,
+                        "function": func.__name__,
+                        "reset_time": reset_time,
+                    },
+                )
+
+                await asyncio.sleep(delay)
+
+                # Retry once after waiting
+                return await func(*args, **kwargs)  # type: ignore[misc,no-any-return]
+
+        @functools.wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> T:
+            # Sync version is simpler - just re-raise
+            # (rate limiting is primarily an async concern)
+            return func(*args, **kwargs)
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return cast(Callable[..., T], async_wrapper)
+        else:
+            return cast(Callable[..., T], sync_wrapper)
+
+    return decorator
+
+
+def validate_response(
+    required_fields: list[str] | None = None,
+    response_type: type | None = None,
+) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """
+    Decorator to validate API response structure.
+
+    Args:
+        required_fields: List of required fields in the response
+        response_type: Expected type of the response
+
+    Example:
+        @validate_response(required_fields=["id", "status"], response_type=dict)
+        async def get_order(self, order_id: str):
+            # Implementation
+            pass
+    """
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @functools.wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> T:
+            result = await func(*args, **kwargs)  # type: ignore[misc]
+
+            # Validate type
+            if response_type is not None and not isinstance(result, response_type):
+                raise ProjectXDataError(
+                    f"Invalid response type from {func.__name__}: "
+                    f"expected {response_type.__name__}, got {type(result).__name__}"
+                )
+
+            # Validate required fields
+            if required_fields and isinstance(result, dict):
+                missing_fields = [f for f in required_fields if f not in result]
+                if missing_fields:
+                    raise ProjectXDataError(
+                        f"Missing required fields in response from {func.__name__}: "
+                        f"{', '.join(missing_fields)}"
+                    )
+
+            return result  # type: ignore[no-any-return]
+
+        @functools.wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> T:
+            result = func(*args, **kwargs)
+
+            # Validate type
+            if response_type is not None and not isinstance(result, response_type):
+                raise ProjectXDataError(
+                    f"Invalid response type from {func.__name__}: "
+                    f"expected {response_type.__name__}, got {type(result).__name__}"
+                )
+
+            # Validate required fields
+            if required_fields and isinstance(result, dict):
+                missing_fields = [f for f in required_fields if f not in result]
+                if missing_fields:
+                    raise ProjectXDataError(
+                        f"Missing required fields in response from {func.__name__}: "
+                        f"{', '.join(missing_fields)}"
+                    )
+
+            return result
+
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return cast(Callable[..., T], async_wrapper)
+        else:
+            return cast(Callable[..., T], sync_wrapper)
+
+    return decorator
+
+
+# Error context manager for batch operations
+class ErrorContext:
+    """
+    Context manager for handling errors in batch operations.
+
+    Collects errors during batch processing and provides summary.
+
+    Example:
+        async with ErrorContext("process orders") as ctx:
+            for order in orders:
+                try:
+                    await process_order(order)
+                except Exception as e:
+                    ctx.add_error(order.id, e)
+
+        if ctx.has_errors:
+            logger.error(f"Failed to process {ctx.error_count} orders")
+    """
+
+    def __init__(self, operation: str, logger: logging.Logger | None = None):
+        self.operation = operation
+        self.logger = logger or logging.getLogger(__name__)
+        self.errors: list[tuple[str, Exception]] = []
+
+    def add_error(self, context: str, error: Exception) -> None:
+        """Add an error to the context."""
+        self.errors.append((context, error))
+
+    @property
+    def has_errors(self) -> bool:
+        """Check if any errors were collected."""
+        return len(self.errors) > 0
+
+    @property
+    def error_count(self) -> int:
+        """Get the number of errors collected."""
+        return len(self.errors)
+
+    def get_summary(self) -> str:
+        """Get a summary of all errors."""
+        if not self.errors:
+            return "No errors"
+
+        error_types: dict[str, int] = {}
+        for _, error in self.errors:
+            error_type = type(error).__name__
+            error_types[error_type] = error_types.get(error_type, 0) + 1
+
+        summary_parts = [f"{count} {etype}" for etype, count in error_types.items()]
+        return f"{self.error_count} errors: {', '.join(summary_parts)}"
+
+    def __enter__(self) -> "ErrorContext":
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Literal[False]:
+        if self.has_errors:
+            self.logger.error(
+                f"Errors during {self.operation}: {self.get_summary()}",
+                extra={
+                    "operation": self.operation,
+                    "error_count": self.error_count,
+                    "errors": [
+                        (ctx, str(e)) for ctx, e in self.errors[:10]
+                    ],  # First 10
+                },
+            )
+        return False  # Don't suppress exceptions
+
+    async def __aenter__(self) -> "ErrorContext":
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> bool:
+        return self.__exit__(exc_type, exc_val, exc_tb)
diff --git a/src/project_x_py/utils/error_messages.py b/src/project_x_py/utils/error_messages.py
new file mode 100644
index 0000000..de67bbb
--- /dev/null
+++ b/src/project_x_py/utils/error_messages.py
@@ -0,0 +1,281 @@
+"""
+Standardized error messages for ProjectX SDK.
+
+This module provides consistent error messages and error formatting
+utilities to ensure uniform error reporting across the SDK.
+
+Author: TexasCoding
+Date: January 2025
+"""
+
+from datetime import UTC
+from typing import Any
+
+
+class ErrorMessages:
+    """Standardized error messages for common scenarios."""
+
+    # Authentication errors
+    AUTH_MISSING_CREDENTIALS = "Missing authentication credentials"
+    AUTH_INVALID_CREDENTIALS = "Invalid authentication credentials"
+    AUTH_TOKEN_EXPIRED = "Authentication token has expired"
+    AUTH_TOKEN_INVALID = "Invalid authentication token"
+    AUTH_SESSION_EXPIRED = "Session has expired, please re-authenticate"
+    AUTH_PERMISSION_DENIED = "Permission denied for this operation"
+    AUTH_FAILED = "Authentication failed"
+    AUTH_NO_ACCOUNTS = "No accounts found for user"
+
+    # Connection errors
+    CONN_FAILED = "Failed to connect to ProjectX API"
+    CONN_TIMEOUT = "Connection timed out"
+    CONN_LOST = "Lost connection to server"
+    CONN_REFUSED = "Connection refused by server"
+    CONN_SSL_ERROR = "SSL/TLS connection error"
+
+    # API errors
+    API_INVALID_ENDPOINT = "Invalid API endpoint: {endpoint}"
+    API_METHOD_NOT_ALLOWED = "HTTP method {method} not allowed for {endpoint}"
+    API_RESOURCE_NOT_FOUND = "Resource not found: {resource}"
+    API_INVALID_REQUEST = "Invalid request: {reason}"
+    API_SERVER_ERROR = "Server error: {status_code} - {message}"
+    API_RATE_LIMITED = "Rate limit exceeded, retry after {retry_after}s"
+    API_REQUEST_FAILED = "API request failed"
+
+    # Data validation errors
+    DATA_MISSING_FIELD = "Missing required field: {field}"
+    DATA_INVALID_TYPE = "Invalid type for {field}: expected {expected}, got {actual}"
+    DATA_INVALID_VALUE = "Invalid value for {field}: {value}"
+    DATA_PARSE_ERROR = "Failed to parse {data_type}: {reason}"
+    DATA_VALIDATION_FAILED = "Data validation failed: {errors}"
+
+    # Order errors
+    ORDER_INVALID_SIDE = "Invalid order side: {side}"
+    ORDER_INVALID_TYPE = "Invalid order type: {order_type}"
+    ORDER_NO_ACCOUNT = "No account information available"
+    ORDER_FAILED = "Order placement failed"
+    ORDER_SEARCH_FAILED = "Order search failed"
+    ORDER_INVALID_SIZE = "Invalid order size: {size}"
+    ORDER_INVALID_PRICE = "Invalid order price: {price}"
+    ORDER_NOT_FOUND = "Order not found: {order_id}"
+    ORDER_ALREADY_FILLED = "Order already filled: {order_id}"
+    ORDER_ALREADY_CANCELLED = "Order already cancelled: {order_id}"
+    ORDER_CANCEL_FAILED = "Failed to cancel order {order_id}: {reason}"
+    ORDER_MODIFY_FAILED = "Failed to modify order {order_id}: {reason}"
+    ORDER_INSUFFICIENT_MARGIN = "Insufficient margin for order"
+    ORDER_MARKET_CLOSED = "Market is closed for {instrument}"
+    ORDER_RISK_EXCEEDED = "Order exceeds risk limits"
+
+    # Position errors
+    POSITION_NOT_FOUND = "Position not found: {position_id}"
+    POSITION_ALREADY_CLOSED = "Position already closed: {position_id}"
+    POSITION_INSUFFICIENT_SIZE = "Insufficient position size for operation"
+    POSITION_WRONG_SIDE = "Operation not allowed for {side} position"
+
+    # Instrument errors
+    INSTRUMENT_NOT_FOUND = "Instrument not found: {symbol}"
+    INSTRUMENT_NOT_TRADEABLE = "Instrument not tradeable: {symbol}"
+    INSTRUMENT_MARKET_CLOSED = "Market closed for {symbol}"
+    INSTRUMENT_INVALID_SYMBOL = "Invalid symbol format: {symbol}"
+
+    # WebSocket errors
+    WS_CONNECTION_FAILED = "WebSocket connection failed: {reason}"
+    WS_AUTHENTICATION_FAILED = "WebSocket authentication failed"
+    WS_SUBSCRIPTION_FAILED = "Failed to subscribe to {channel}: {reason}"
+    WS_MESSAGE_PARSE_ERROR = "Failed to parse WebSocket message"
+    WS_UNEXPECTED_CLOSE = "WebSocket closed unexpectedly: {code} - {reason}"
+
+    # Configuration errors
+    CONFIG_MISSING = "Missing configuration: {key}"
+    CONFIG_INVALID = "Invalid configuration value for {key}: {value}"
+    CONFIG_FILE_NOT_FOUND = "Configuration file not found: {path}"
+    CONFIG_PARSE_ERROR = "Failed to parse configuration: {reason}"
+
+    # Account errors
+    ACCOUNT_NOT_FOUND = (
+        "Account '{account_name}' not found. Available accounts: {available_accounts}"
+    )
+
+    # General errors
+    INTERNAL_ERROR = "Internal error: {reason}"
+    NOT_IMPLEMENTED = "Feature not implemented: {feature}"
+    OPERATION_FAILED = "Operation failed: {operation}"
+    INVALID_STATE = "Invalid state for operation: {state}"
+    TIMEOUT = "Operation timed out after {timeout}s"
+
+
+def format_error_message(template: str, **kwargs: Any) -> str:
+    """
+    Format an error message template with provided values.
+
+    Args:
+        template: Error message template with {placeholders}
+        **kwargs: Values to substitute in template
+
+    Returns:
+        Formatted error message
+
+    Example:
+        >>> format_error_message(
+        ...     ErrorMessages.API_RESOURCE_NOT_FOUND, resource="order/123"
+        ... )
+        "Resource not found: order/123"
+    """
+    try:
+        return template.format(**kwargs)
+    except KeyError as e:
+        # If a placeholder is missing, include it in the error
+        return f"{template} (missing value for: {e})"
+
+
+def create_error_context(
+    operation: str,
+    **details: Any,
+) -> dict[str, Any]:
+    """
+    Create standardized error context dictionary.
+
+    Args:
+        operation: Operation that failed
+        **details: Additional error details
+
+    Returns:
+        Error context dictionary
+    """
+    import time
+    from datetime import datetime
+
+    context = {
+        "operation": operation,
+        "timestamp": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+        "timestamp_unix": time.time(),
+    }
+
+    # Add details, filtering out None values
+    for key, value in details.items():
+        if value is not None:
+            context[key] = value
+
+    return context
+
+
+def enhance_exception(
+    exception: Exception,
+    operation: str,
+    **context: Any,
+) -> Exception:
+    """
+    Enhance an exception with additional context.
+
+    Args:
+        exception: Original exception
+        operation: Operation that failed
+        **context: Additional context
+
+    Returns:
+        Enhanced exception with context
+    """
+    # Import here to avoid circular dependency
+    from project_x_py.exceptions import ProjectXError
+
+    # Create context dict
+    error_context = create_error_context(operation, **context)
+
+    # If it's already a ProjectX exception, enhance it
+    if isinstance(exception, ProjectXError):
+        # Update response data with context
+        if exception.response_data is None:
+            exception.response_data = {}  # type: ignore[unreachable]
+        exception.response_data.update(error_context)
+        return exception
+
+    # Wrap in ProjectXError
+    message = f"{operation} failed: {exception!s}"
+    return ProjectXError(
+        message=message,
+        response_data=error_context,
+    )
+
+
+class ErrorCode:
+    """Standard error codes for categorizing errors."""
+
+    # Authentication (1xxx)
+    AUTH_REQUIRED = 1001
+    AUTH_INVALID = 1002
+    AUTH_EXPIRED = 1003
+    AUTH_PERMISSION = 1004
+
+    # Connection (2xxx)
+    CONN_FAILED = 2001
+    CONN_TIMEOUT = 2002
+    CONN_LOST = 2003
+    CONN_SSL = 2004
+
+    # API (3xxx)
+    API_NOT_FOUND = 3404
+    API_BAD_REQUEST = 3400
+    API_FORBIDDEN = 3403
+    API_RATE_LIMIT = 3429
+    API_SERVER_ERROR = 3500
+
+    # Data (4xxx)
+    DATA_VALIDATION = 4001
+    DATA_PARSING = 4002
+    DATA_MISSING = 4003
+    DATA_INVALID = 4004
+
+    # Trading (5xxx)
+    ORDER_INVALID = 5001
+    ORDER_NOT_FOUND = 5002
+    ORDER_REJECTED = 5003
+    POSITION_INVALID = 5101
+    POSITION_NOT_FOUND = 5102
+
+    # WebSocket (6xxx)
+    WS_CONNECTION = 6001
+    WS_AUTH = 6002
+    WS_SUBSCRIPTION = 6003
+    WS_MESSAGE = 6004
+
+    # Internal (9xxx)
+    INTERNAL_ERROR = 9001
+    NOT_IMPLEMENTED = 9002
+    INVALID_STATE = 9003
+
+
+def get_error_code(exception: Exception) -> int | None:
+    """
+    Get standardized error code for an exception.
+
+    Args:
+        exception: Exception to categorize
+
+    Returns:
+        Error code or None if not categorizable
+    """
+    from project_x_py.exceptions import (
+        ProjectXAuthenticationError,
+        ProjectXConnectionError,
+        ProjectXDataError,
+        ProjectXError,
+        ProjectXRateLimitError,
+        ProjectXServerError,
+    )
+
+    if isinstance(exception, ProjectXAuthenticationError):
+        return ErrorCode.AUTH_INVALID
+    elif isinstance(exception, ProjectXRateLimitError):
+        return ErrorCode.API_RATE_LIMIT
+    elif isinstance(exception, ProjectXServerError):
+        return ErrorCode.API_SERVER_ERROR
+    elif isinstance(exception, ProjectXConnectionError):
+        return ErrorCode.CONN_FAILED
+    elif isinstance(exception, ProjectXDataError):
+        return ErrorCode.DATA_INVALID
+    elif isinstance(exception, ProjectXError):
+        # Check if it has an error code already
+        if hasattr(exception, "error_code") and exception.error_code:
+            return exception.error_code
+        return ErrorCode.INTERNAL_ERROR
+    else:
+        return None
diff --git a/src/project_x_py/utils/logging_config.py b/src/project_x_py/utils/logging_config.py
new file mode 100644
index 0000000..2d6f0fb
--- /dev/null
+++ b/src/project_x_py/utils/logging_config.py
@@ -0,0 +1,368 @@
+"""
+Enhanced logging configuration for ProjectX SDK.
+
+This module provides consistent logging patterns and structured logging
+capabilities across the SDK.
+
+Author: TexasCoding
+Date: January 2025
+"""
+
+import json
+import logging
+import sys
+from datetime import UTC, datetime
+from typing import Any
+
+
+class StructuredFormatter(logging.Formatter):
+    """
+    Custom formatter that outputs structured logs with consistent format.
+
+    Includes timestamp, level, module, function, and structured data.
+    """
+
+    def format(self, record: logging.LogRecord) -> str:
+        # Base log data
+        log_data = {
+            "timestamp": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            "level": record.levelname,
+            "logger": record.name,
+            "module": record.module,
+            "function": record.funcName,
+            "line": record.lineno,
+            "message": record.getMessage(),
+        }
+
+        # Add any extra fields from LogRecord attributes
+        standard_attrs = {
+            "name",
+            "msg",
+            "args",
+            "levelname",
+            "levelno",
+            "pathname",
+            "filename",
+            "module",
+            "exc_info",
+            "exc_text",
+            "stack_info",
+            "lineno",
+            "funcName",
+            "created",
+            "msecs",
+            "relativeCreated",
+            "thread",
+            "threadName",
+            "processName",
+            "process",
+            "getMessage",
+            "message",
+            "asctime",
+        }
+        for key, value in record.__dict__.items():
+            if key not in standard_attrs:
+                log_data[key] = value
+
+        # Add exception info if present
+        if record.exc_info:
+            log_data["exception"] = self.formatException(record.exc_info)
+
+        # For development, use a more readable format
+        if logging.getLogger().level == logging.DEBUG:
+            return (
+                f"{log_data['timestamp']} | {log_data['level']:<8} | "
+                f"{log_data['module']}.{log_data['function']}:{log_data['line']} | "
+                f"{log_data['message']}"
+            )
+        else:
+            # For production, use JSON format
+            return json.dumps(log_data, default=str)
+
+
+class ProjectXLogger:
+    """
+    Factory for creating configured loggers with consistent settings.
+    """
+
+    @staticmethod
+    def get_logger(
+        name: str,
+        level: int | None = None,
+        handler: logging.Handler | None = None,
+    ) -> logging.Logger:
+        """
+        Get a configured logger instance.
+
+        Args:
+            name: Logger name (usually __name__)
+            level: Logging level (defaults to INFO)
+            handler: Custom handler (defaults to console)
+
+        Returns:
+            Configured logger instance
+        """
+        logger = logging.getLogger(name)
+
+        # Only configure if not already configured
+        if not logger.handlers:
+            # Set level
+            if level is None:
+                level = logging.INFO
+            logger.setLevel(level)
+
+            # Add handler
+            if handler is None:
+                handler = logging.StreamHandler(sys.stdout)
+                handler.setFormatter(StructuredFormatter())
+            logger.addHandler(handler)
+
+            # Prevent propagation to avoid duplicate logs
+            logger.propagate = False
+
+        return logger
+
+
+# Logging context for operations
+class LogContext:
+    """
+    Context manager for adding consistent context to log messages.
+
+    Example:
+        with LogContext(logger, operation="fetch_orders", user_id=123):
+            # All log messages in this block will include the context
+            logger.info("Starting order fetch")
+    """
+
+    def __init__(self, logger: logging.Logger, **context: Any):
+        self.logger = logger
+        self.context = context
+        self._old_adapter: logging.Logger | None = None
+
+    def __enter__(self) -> logging.LoggerAdapter[logging.Logger]:
+        # Create adapter with context
+        self._old_adapter = self.logger
+        adapter = logging.LoggerAdapter(self.logger, self.context)
+        # Replace logger methods with adapter methods
+        for method in ["debug", "info", "warning", "error", "critical", "exception"]:
+            setattr(self.logger, method, getattr(adapter, method))
+        return adapter
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        # Restore original logger
+        # Restore original logger
+        for method in [
+            "debug",
+            "info",
+            "warning",
+            "error",
+            "critical",
+            "exception",
+        ]:
+            setattr(self.logger, method, getattr(self._old_adapter, method))
+
+
+# Standard log messages for consistency
+class LogMessages:
+    """Standard log messages for common operations."""
+
+    # API operations
+    API_REQUEST = "Making API request"
+    API_RESPONSE = "Received API response"
+    API_ERROR = "API request failed"
+
+    # Authentication
+    AUTH_START = "Starting authentication"
+    AUTH_SUCCESS = "Authentication successful"
+    AUTH_FAILED = "Authentication failed"
+    AUTH_REFRESH = "Refreshing authentication token"
+    AUTH_TOKEN_PARSE_FAILED = "Failed to parse authentication token expiry"
+
+    # Orders
+    ORDER_PLACE = "Placing order"
+    ORDER_PLACED = "Order placed successfully"
+    ORDER_CANCEL = "Cancelling order"
+    ORDER_CANCELLED = "Order cancelled successfully"
+    ORDER_MODIFY = "Modifying order"
+    ORDER_MODIFIED = "Order modified successfully"
+    ORDER_ERROR = "Order operation failed"
+    ORDER_CANCEL_ALL = "Cancelling all orders"
+    ORDER_CANCEL_ALL_COMPLETE = "Cancel all orders complete"
+
+    # Positions
+    POSITION_OPEN = "Opening position"
+    POSITION_OPENED = "Position opened successfully"
+    POSITION_CLOSE = "Closing position"
+    POSITION_CLOSED = "Position closed successfully"
+    POSITION_ERROR = "Position operation failed"
+
+    # Market data
+    DATA_FETCH = "Fetching market data"
+    DATA_RECEIVED = "Market data received"
+    DATA_ERROR = "Market data fetch failed"
+    DATA_SUBSCRIBE = "Subscribing to market data"
+    DATA_UNSUBSCRIBE = "Unsubscribing from market data"
+
+    # WebSocket
+    WS_CONNECT = "Connecting to WebSocket"
+    WS_CONNECTED = "WebSocket connected"
+    WS_DISCONNECT = "Disconnecting from WebSocket"
+    WS_DISCONNECTED = "WebSocket disconnected"
+    WS_ERROR = "WebSocket error"
+    WS_RECONNECT = "Reconnecting WebSocket"
+
+    # Rate limiting
+    RATE_LIMIT_HIT = "Rate limit reached"
+    RATE_LIMIT_WAIT = "Waiting for rate limit reset"
+    RATE_LIMIT_RESET = "Rate limit reset"
+
+    # Cache
+    CACHE_HIT = "Cache hit"
+    CACHE_MISS = "Cache miss"
+    CACHE_UPDATE = "Updating cache"
+
+    # Managers
+    MANAGER_INITIALIZED = "Manager initialized"
+
+    # Position operations
+    POSITION_REFRESH = "Refreshing positions"
+    POSITION_UPDATE = "Position updated"
+    POSITION_SEARCH = "Searching positions"
+    CACHE_CLEAR = "Clearing cache"
+
+    # Errors
+    ERROR_RETRY = "Retrying after error"
+    ERROR_MAX_RETRY = "Maximum retries exceeded"
+    ERROR_HANDLED = "Error handled"
+    ERROR_UNHANDLED = "Unhandled error"
+
+    # Callbacks
+    CALLBACK_REGISTERED = "Callback registered"
+    CALLBACK_REMOVED = "Callback removed"
+
+    # Cleanup
+    CLEANUP_COMPLETE = "Cleanup completed"
+
+
+def log_performance(
+    logger: logging.Logger,
+    operation: str,
+    start_time: float,
+    end_time: float | None = None,
+    **extra: Any,
+) -> None:
+    """
+    Log performance metrics for an operation.
+
+    Args:
+        logger: Logger instance
+        operation: Operation name
+        start_time: Start time (from time.time())
+        end_time: End time (defaults to now)
+        **extra: Additional context to log
+    """
+    import time
+
+    if end_time is None:
+        end_time = time.time()
+
+    duration = end_time - start_time
+
+    logger.info(
+        f"{operation} completed in {duration:.3f}s",
+        extra={
+            "operation": operation,
+            "duration_seconds": duration,
+            "duration_ms": duration * 1000,
+            **extra,
+        },
+    )
+
+
+def log_api_call(
+    logger: logging.Logger,
+    method: str,
+    endpoint: str,
+    status_code: int | None = None,
+    duration: float | None = None,
+    error: Exception | None = None,
+    **extra: Any,
+) -> None:
+    """
+    Log API call with standard format.
+
+    Args:
+        logger: Logger instance
+        method: HTTP method
+        endpoint: API endpoint
+        status_code: Response status code
+        duration: Request duration in seconds
+        error: Exception if call failed
+        **extra: Additional context
+    """
+    log_data = {
+        "api_method": method,
+        "api_endpoint": endpoint,
+        **extra,
+    }
+
+    if status_code is not None:
+        log_data["status_code"] = status_code
+
+    if duration is not None:
+        log_data["duration_ms"] = duration * 1000
+
+    if error:
+        logger.error(
+            f"{LogMessages.API_ERROR}: {method} {endpoint}",
+            extra={**log_data, "error": str(error)},
+        )
+    else:
+        logger.info(
+            f"{LogMessages.API_RESPONSE}: {method} {endpoint}",
+            extra=log_data,
+        )
+
+
+# Configure root logger for the SDK
+def configure_sdk_logging(
+    level: int = logging.INFO,
+    format_json: bool = False,
+    log_file: str | None = None,
+) -> None:
+    """
+    Configure logging for the entire SDK.
+
+    Args:
+        level: Logging level
+        format_json: Use JSON formatting
+        log_file: Optional log file path
+    """
+    # Get root logger for project_x_py
+    root_logger = logging.getLogger("project_x_py")
+    root_logger.setLevel(level)
+
+    # Remove existing handlers
+    root_logger.handlers.clear()
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    if format_json:
+        console_handler.setFormatter(StructuredFormatter())
+    else:
+        console_handler.setFormatter(
+            logging.Formatter(
+                "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+        )
+    root_logger.addHandler(console_handler)
+
+    # File handler if specified
+    if log_file:
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(StructuredFormatter())
+        root_logger.addHandler(file_handler)
+
+    # Don't propagate to root logger
+    root_logger.propagate = False
diff --git a/src/project_x_py/utils/market_microstructure.py b/src/project_x_py/utils/market_microstructure.py
deleted file mode 100644
index 7f5b44f..0000000
--- a/src/project_x_py/utils/market_microstructure.py
+++ /dev/null
@@ -1,172 +0,0 @@
-"""Market microstructure analysis including bid-ask spread and volume profile."""
-
-from typing import Any
-
-import polars as pl
-
-
-def analyze_bid_ask_spread(
-    data: pl.DataFrame,
-    bid_column: str = "bid",
-    ask_column: str = "ask",
-    mid_column: str | None = None,
-) -> dict[str, Any]:
-    """
-    Analyze bid-ask spread characteristics.
-
-    Args:
-        data: DataFrame with bid/ask data
-        bid_column: Bid price column
-        ask_column: Ask price column
-        mid_column: Mid price column (optional, will calculate if not provided)
-
-    Returns:
-        Dict with spread analysis
-
-    Example:
-        >>> spread_analysis = analyze_bid_ask_spread(market_data)
-        >>> print(f"Average spread: ${spread_analysis['avg_spread']:.4f}")
-    """
-    required_cols = [bid_column, ask_column]
-    for col in required_cols:
-        if col not in data.columns:
-            raise ValueError(f"Column '{col}' not found in data")
-
-    if data.is_empty():
-        return {"error": "No data provided"}
-
-    try:
-        # Calculate mid price if not provided
-        if mid_column is None:
-            data = data.with_columns(
-                ((pl.col(bid_column) + pl.col(ask_column)) / 2).alias("mid_price")
-            )
-            mid_column = "mid_price"
-
-        # Calculate spread metrics
-        analysis_data = (
-            data.with_columns(
-                [
-                    (pl.col(ask_column) - pl.col(bid_column)).alias("spread"),
-                    (
-                        (pl.col(ask_column) - pl.col(bid_column)) / pl.col(mid_column)
-                    ).alias("relative_spread"),
-                ]
-            )
-            .select(["spread", "relative_spread"])
-            .drop_nulls()
-        )
-
-        if analysis_data.is_empty():
-            return {"error": "No valid spread data"}
-
-        return {
-            "avg_spread": analysis_data.select(pl.col("spread").mean()).item() or 0.0,
-            "median_spread": analysis_data.select(pl.col("spread").median()).item()
-            or 0.0,
-            "min_spread": analysis_data.select(pl.col("spread").min()).item() or 0.0,
-            "max_spread": analysis_data.select(pl.col("spread").max()).item() or 0.0,
-            "avg_relative_spread": analysis_data.select(
-                pl.col("relative_spread").mean()
-            ).item()
-            or 0.0,
-            "spread_volatility": analysis_data.select(pl.col("spread").std()).item()
-            or 0.0,
-        }
-
-    except Exception as e:
-        return {"error": str(e)}
-
-
-def calculate_volume_profile(
-    data: pl.DataFrame,
-    price_column: str = "close",
-    volume_column: str = "volume",
-    num_bins: int = 50,
-) -> dict[str, Any]:
-    """
-    Calculate volume profile analysis.
-
-    Args:
-        data: DataFrame with price and volume data
-        price_column: Price column for binning
-        volume_column: Volume column for aggregation
-        num_bins: Number of price bins
-
-    Returns:
-        Dict with volume profile analysis
-
-    Example:
-        >>> vol_profile = calculate_volume_profile(ohlcv_data)
-        >>> print(f"POC Price: ${vol_profile['point_of_control']:.2f}")
-    """
-    required_cols = [price_column, volume_column]
-    for col in required_cols:
-        if col not in data.columns:
-            raise ValueError(f"Column '{col}' not found in data")
-
-    if data.is_empty():
-        return {"error": "No data provided"}
-
-    try:
-        # Get price range
-        min_price = data.select(pl.col(price_column).min()).item()
-        max_price = data.select(pl.col(price_column).max()).item()
-
-        if min_price is None or max_price is None:
-            return {"error": "Invalid price data"}
-
-        # Create price bins
-        bin_size = (max_price - min_price) / num_bins
-        bins = [min_price + i * bin_size for i in range(num_bins + 1)]
-
-        # Calculate volume per price level
-        volume_by_price = []
-        for i in range(len(bins) - 1):
-            bin_data = data.filter(
-                (pl.col(price_column) >= bins[i]) & (pl.col(price_column) < bins[i + 1])
-            )
-
-            if not bin_data.is_empty():
-                total_volume = bin_data.select(pl.col(volume_column).sum()).item() or 0
-                avg_price = (bins[i] + bins[i + 1]) / 2
-                volume_by_price.append(
-                    {
-                        "price": avg_price,
-                        "volume": total_volume,
-                        "price_range": (bins[i], bins[i + 1]),
-                    }
-                )
-
-        if not volume_by_price:
-            return {"error": "No volume data in bins"}
-
-        # Sort by volume to find key levels
-        volume_by_price.sort(key=lambda x: x["volume"], reverse=True)
-
-        # Point of Control (POC) - price level with highest volume
-        poc = volume_by_price[0]
-
-        # Value Area (70% of volume)
-        total_volume = sum(vp["volume"] for vp in volume_by_price)
-        value_area_volume = total_volume * 0.7
-        cumulative_volume = 0
-        value_area_prices = []
-
-        for vp in volume_by_price:
-            cumulative_volume += vp["volume"]
-            value_area_prices.append(vp["price"])
-            if cumulative_volume >= value_area_volume:
-                break
-
-        return {
-            "point_of_control": poc["price"],
-            "poc_volume": poc["volume"],
-            "value_area_high": max(value_area_prices),
-            "value_area_low": min(value_area_prices),
-            "total_volume": total_volume,
-            "volume_distribution": volume_by_price[:10],  # Top 10 volume levels
-        }
-
-    except Exception as e:
-        return {"error": str(e)}
diff --git a/src/project_x_py/utils/rate_limiter.py b/src/project_x_py/utils/rate_limiter.py
deleted file mode 100644
index 636d95c..0000000
--- a/src/project_x_py/utils/rate_limiter.py
+++ /dev/null
@@ -1,42 +0,0 @@
-"""Rate limiting utility for API calls."""
-
-import time
-from typing import Any
-
-
-class RateLimiter:
-    """
-    Simple rate limiter for API calls.
-
-    Example:
-        >>> limiter = RateLimiter(requests_per_minute=60)
-        >>> with limiter:
-        ...     # Make API call
-        ...     response = api_call()
-    """
-
-    def __init__(self, requests_per_minute: int = 60):
-        """Initialize rate limiter."""
-        self.requests_per_minute = requests_per_minute
-        self.min_interval = 60.0 / requests_per_minute
-        self.last_request_time = 0.0
-
-    def __enter__(self) -> "RateLimiter":
-        """Context manager entry - enforce rate limit."""
-        current_time = time.time()
-        time_since_last = current_time - self.last_request_time
-
-        if time_since_last < self.min_interval:
-            sleep_time = self.min_interval - time_since_last
-            time.sleep(sleep_time)
-
-        self.last_request_time = time.time()
-        return self
-
-    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Context manager exit."""
-
-    def wait_if_needed(self) -> None:
-        """Wait if needed to respect rate limit."""
-        with self:
-            pass
diff --git a/tests/client/test_client_auth.py b/tests/client/test_client_auth.py
index fe626b0..403fb1f 100644
--- a/tests/client/test_client_auth.py
+++ b/tests/client/test_client_auth.py
@@ -4,7 +4,7 @@
 
 import pytest
 
-from project_x_py.exceptions import ProjectXAuthenticationError
+from project_x_py.exceptions import ProjectXAuthenticationError, ProjectXError
 
 
 class TestClientAuth:
@@ -94,21 +94,15 @@ async def test_authenticate_with_invalid_account(
 
         auth_response, accounts_response = mock_auth_response
 
-        # Make sure the ValueError message includes the available account name
-        from unittest.mock import patch
-
-        with patch(
-            "project_x_py.client.auth.ValueError", side_effect=ValueError
-        ) as mock_error:
-            client._client.request.side_effect = [auth_response, accounts_response]
+        client._client.request.side_effect = [auth_response, accounts_response]
 
-            with pytest.raises(ValueError):
-                await client.authenticate()
+        with pytest.raises(ProjectXError) as exc_info:
+            await client.authenticate()
 
-            # Verify the error message contains the available account name
-            args, _ = mock_error.call_args
-            error_msg = args[0]
-            assert "Test Account" in error_msg
+        # Verify the error message contains the available account name
+        error_msg = str(exc_info.value)
+        assert "NonExistent" in error_msg
+        assert "Test Account" in error_msg
 
     @pytest.mark.asyncio
     async def test_token_refresh(
diff --git a/tests/client/test_market_data.py b/tests/client/test_market_data.py
index 142e2a8..e693509 100644
--- a/tests/client/test_market_data.py
+++ b/tests/client/test_market_data.py
@@ -7,8 +7,8 @@
 import pytest
 
 from project_x_py import ProjectX
-from project_x_py.client.rate_limiter import RateLimiter
 from project_x_py.exceptions import ProjectXInstrumentError
+from project_x_py.utils.async_rate_limiter import RateLimiter
 
 
 class TestMarketData:
diff --git a/tests/client/test_trading.py b/tests/client/test_trading.py
index fce95fa..6a48467 100644
--- a/tests/client/test_trading.py
+++ b/tests/client/test_trading.py
@@ -7,8 +7,8 @@
 import pytz
 
 from project_x_py import ProjectX
-from project_x_py.client.rate_limiter import RateLimiter
 from project_x_py.exceptions import ProjectXError
+from project_x_py.utils.async_rate_limiter import RateLimiter
 
 
 class TestTrading:
diff --git a/tests/conftest.py b/tests/conftest.py
index e1b9049..7d41920 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -10,8 +10,8 @@
 import pytest
 import pytz
 
-from project_x_py.client.rate_limiter import RateLimiter
 from project_x_py.models import Instrument, ProjectXConfig
+from project_x_py.utils.async_rate_limiter import RateLimiter
 
 
 @pytest.fixture
diff --git a/tests/indicators/__init__.py b/tests/indicators/__init__.py
index b382bfd..5115592 100644
--- a/tests/indicators/__init__.py
+++ b/tests/indicators/__init__.py
@@ -1 +1 @@
-# Marker for indicators test package
\ No newline at end of file
+# Marker for indicators test package
diff --git a/tests/orderbook/__init__.py b/tests/orderbook/__init__.py
new file mode 100644
index 0000000..aafda74
--- /dev/null
+++ b/tests/orderbook/__init__.py
@@ -0,0 +1 @@
+"""Orderbook test module."""
diff --git a/tests/orderbook/test_analytics_static.py b/tests/orderbook/test_analytics_static.py
new file mode 100644
index 0000000..1c53a50
--- /dev/null
+++ b/tests/orderbook/test_analytics_static.py
@@ -0,0 +1,99 @@
+"""Tests for orderbook analytics static methods."""
+
+import polars as pl
+import pytest
+
+from project_x_py.orderbook import MarketAnalytics
+
+
+class TestMarketAnalyticsStaticMethods:
+    """Test static methods in MarketAnalytics class."""
+
+    def test_analyze_dataframe_spread_basic(self):
+        """Test basic spread analysis functionality."""
+        # Create test data
+        data = pl.DataFrame(
+            {
+                "bid": [100.0, 100.1, 100.2, 100.3],
+                "ask": [100.2, 100.3, 100.4, 100.5],
+            }
+        )
+
+        result = MarketAnalytics.analyze_dataframe_spread(data)
+
+        # Check structure
+        assert isinstance(result, dict)
+        assert "avg_spread" in result
+        assert "median_spread" in result
+        assert "min_spread" in result
+        assert "max_spread" in result
+        assert "spread_volatility" in result
+        assert "avg_relative_spread" in result
+
+        # Check values
+        assert pytest.approx(result["avg_spread"], 0.001) == 0.2
+        assert pytest.approx(result["min_spread"], 0.001) == 0.2
+        assert pytest.approx(result["max_spread"], 0.001) == 0.2
+        assert result["spread_volatility"] == 0.0
+
+    def test_analyze_dataframe_spread_with_mid(self):
+        """Test spread analysis with automatic mid price calculation."""
+        data = pl.DataFrame(
+            {
+                "bid": [100.0, 100.1, 100.2],
+                "ask": [100.2, 100.3, 100.4],
+            }
+        )
+
+        result = MarketAnalytics.analyze_dataframe_spread(
+            data,
+            bid_column="bid",
+            ask_column="ask",
+            mid_column=None,  # Let it calculate mid price
+        )
+
+        # Should calculate spread correctly
+        assert pytest.approx(result["avg_spread"], 0.001) == 0.2
+        # Average mid price is (100.1 + 100.2 + 100.3) / 3 = 100.2
+        assert pytest.approx(result["avg_relative_spread"], 0.0001) == 0.2 / 100.2
+
+    def test_analyze_dataframe_spread_empty(self):
+        """Test spread analysis with empty DataFrame."""
+        data = pl.DataFrame(
+            {
+                "bid": [],
+                "ask": [],
+            }
+        )
+
+        result = MarketAnalytics.analyze_dataframe_spread(data)
+
+        # Should return error for empty data
+        assert "error" in result
+        assert result["error"] == "No data provided"
+
+    def test_analyze_dataframe_spread_custom_columns(self):
+        """Test spread analysis with custom column names."""
+        data = pl.DataFrame(
+            {
+                "best_bid": [100.0, 100.1],
+                "best_ask": [100.2, 100.3],
+            }
+        )
+
+        result = MarketAnalytics.analyze_dataframe_spread(
+            data, bid_column="best_bid", ask_column="best_ask"
+        )
+
+        assert pytest.approx(result["avg_spread"], 0.001) == 0.2
+
+    def test_analyze_dataframe_spread_missing_columns(self):
+        """Test spread analysis with missing columns."""
+        data = pl.DataFrame(
+            {
+                "price": [100.0, 100.1],
+            }
+        )
+
+        with pytest.raises(Exception):  # Should raise when columns don't exist
+            MarketAnalytics.analyze_dataframe_spread(data)
diff --git a/tests/orderbook/test_profile_static.py b/tests/orderbook/test_profile_static.py
new file mode 100644
index 0000000..7860423
--- /dev/null
+++ b/tests/orderbook/test_profile_static.py
@@ -0,0 +1,144 @@
+"""Tests for orderbook volume profile static methods."""
+
+import polars as pl
+
+from project_x_py.orderbook import VolumeProfile
+
+
+class TestVolumeProfileStaticMethods:
+    """Test static methods in VolumeProfile class."""
+
+    def test_calculate_dataframe_volume_profile_basic(self):
+        """Test basic volume profile calculation."""
+        # Create test data with price movements
+        data = pl.DataFrame(
+            {
+                "close": [100.0, 100.5, 101.0, 100.5, 100.0, 99.5, 100.0, 100.5, 101.0],
+                "volume": [100, 200, 150, 300, 250, 100, 200, 150, 100],
+            }
+        )
+
+        result = VolumeProfile.calculate_dataframe_volume_profile(
+            data, price_column="close", volume_column="volume", num_bins=5
+        )
+
+        # Check structure
+        assert isinstance(result, dict)
+        assert "point_of_control" in result
+        assert "poc_volume" in result
+        assert "value_area_high" in result
+        assert "value_area_low" in result
+        assert "total_volume" in result
+        assert "volume_distribution" in result
+
+        # Check volume distribution
+        assert isinstance(result["volume_distribution"], list)
+        assert len(result["volume_distribution"]) > 0
+
+        # POC should be at price with highest volume
+        assert result["poc_volume"] > 0
+        # Check that total volume is sum of all volumes (some might be excluded by binning)
+        expected_total = sum([100, 200, 150, 300, 250, 100, 200, 150, 100])  # 1550
+        # But due to binning edge effects, might be slightly less
+        assert result["total_volume"] <= expected_total
+        assert result["total_volume"] > 0
+
+        # Value area should be reasonable
+        assert (
+            result["value_area_low"]
+            <= result["point_of_control"]
+            <= result["value_area_high"]
+        )
+
+    def test_calculate_dataframe_volume_profile_single_price(self):
+        """Test volume profile with single price level."""
+        data = pl.DataFrame(
+            {
+                "close": [100.0] * 5,
+                "volume": [100, 200, 150, 300, 250],
+            }
+        )
+
+        result = VolumeProfile.calculate_dataframe_volume_profile(data)
+
+        # Should have single price level
+        assert result["point_of_control"] == 100.0
+        assert result["poc_volume"] == 1000  # Sum of all volumes
+        assert result["total_volume"] == 1000
+
+    def test_calculate_dataframe_volume_profile_empty(self):
+        """Test volume profile with empty DataFrame."""
+        data = pl.DataFrame(
+            {
+                "close": [],
+                "volume": [],
+            }
+        )
+
+        result = VolumeProfile.calculate_dataframe_volume_profile(data)
+
+        # Should return error for empty data
+        assert "error" in result
+
+    def test_calculate_dataframe_volume_profile_custom_bins(self):
+        """Test volume profile with different bin counts."""
+        data = pl.DataFrame(
+            {
+                "close": list(range(100, 200)),  # 100 different prices
+                "volume": [10] * 100,  # Equal volume at each price
+            }
+        )
+
+        # Test with 10 bins
+        result_10 = VolumeProfile.calculate_dataframe_volume_profile(data, num_bins=10)
+        assert len(result_10["volume_distribution"]) <= 10
+
+        # Test with 20 bins
+        result_20 = VolumeProfile.calculate_dataframe_volume_profile(data, num_bins=20)
+        assert len(result_20["volume_distribution"]) <= 20
+
+        # More bins should give finer granularity
+        assert len(result_20["volume_distribution"]) >= len(
+            result_10["volume_distribution"]
+        )
+
+    def test_calculate_dataframe_volume_profile_distribution(self):
+        """Test that volume distribution is properly formatted."""
+        data = pl.DataFrame(
+            {
+                "close": [100.0, 100.5, 101.0, 100.5, 100.0],
+                "volume": [100, 200, 150, 300, 250],
+            }
+        )
+
+        result = VolumeProfile.calculate_dataframe_volume_profile(data)
+
+        # Check volume distribution structure
+        assert isinstance(result["volume_distribution"], list)
+        for item in result["volume_distribution"]:
+            assert "price" in item
+            assert "volume" in item
+            assert "price_range" in item
+            assert isinstance(item["price_range"], tuple)
+            assert len(item["price_range"]) == 2
+
+    def test_calculate_dataframe_volume_profile_custom_columns(self):
+        """Test volume profile with custom column names."""
+        data = pl.DataFrame(
+            {
+                "price": [100.0, 101.0, 102.0],
+                "size": [100, 200, 300],
+            }
+        )
+
+        result = VolumeProfile.calculate_dataframe_volume_profile(
+            data, price_column="price", volume_column="size"
+        )
+
+        # POC should be a reasonable price within the data range
+        assert 100.0 <= result["point_of_control"] <= 102.0
+        # POC volume should be positive
+        assert result["poc_volume"] > 0
+        # Total volume should be positive (binning might exclude some edge data)
+        assert result["total_volume"] > 0
+        assert result["total_volume"] <= 600
diff --git a/tests/position_manager/__init__.py b/tests/position_manager/__init__.py
index 6b19f51..9e78f98 100644
--- a/tests/position_manager/__init__.py
+++ b/tests/position_manager/__init__.py
@@ -1 +1 @@
-# Mark tests/position_manager as a package for pytest discovery.
\ No newline at end of file
+# Mark tests/position_manager as a package for pytest discovery.
diff --git a/tests/position_manager/conftest.py b/tests/position_manager/conftest.py
index 624d35f..23468e6 100644
--- a/tests/position_manager/conftest.py
+++ b/tests/position_manager/conftest.py
@@ -1,8 +1,10 @@
+from unittest.mock import AsyncMock
+
 import pytest
-from unittest.mock import AsyncMock, patch
 
-from project_x_py.position_manager.core import PositionManager
 from project_x_py.models import Position
+from project_x_py.position_manager.core import PositionManager
+
 
 @pytest.fixture
 async def position_manager(initialized_client, mock_positions_data):
@@ -15,7 +17,8 @@ async def position_manager(initialized_client, mock_positions_data):
     # Optionally patch other APIs as needed for isolation
 
     pm = PositionManager(initialized_client)
-    yield pm
+    return pm
+
 
 @pytest.fixture
 def populate_prices():
@@ -23,4 +26,4 @@ def populate_prices():
     return {
         "MGC": 1910.0,
         "MNQ": 14950.0,
-    }
\ No newline at end of file
+    }
diff --git a/tests/position_manager/test_core.py b/tests/position_manager/test_core.py
index 9be3f4a..8e145df 100644
--- a/tests/position_manager/test_core.py
+++ b/tests/position_manager/test_core.py
@@ -1,5 +1,4 @@
-import asyncio
-from unittest.mock import AsyncMock, patch
+from unittest.mock import patch
 
 import pytest
 
diff --git a/tests/position_manager/test_tracking.py b/tests/position_manager/test_tracking.py
index d959bc7..14bcc36 100644
--- a/tests/position_manager/test_tracking.py
+++ b/tests/position_manager/test_tracking.py
@@ -1,8 +1,12 @@
-import pytest
 from unittest.mock import AsyncMock
 
+import pytest
+
+
 @pytest.mark.asyncio
-async def test_validate_position_payload_valid_invalid(position_manager, mock_positions_data):
+async def test_validate_position_payload_valid_invalid(
+    position_manager, mock_positions_data
+):
     pm = position_manager
     valid = pm._validate_position_payload(mock_positions_data[0])
     assert valid is True
@@ -17,8 +21,11 @@ async def test_validate_position_payload_valid_invalid(position_manager, mock_po
     invalid2["size"] = "not_a_number"
     assert pm._validate_position_payload(invalid2) is False
 
+
 @pytest.mark.asyncio
-async def test_process_position_data_open_and_close(position_manager, mock_positions_data):
+async def test_process_position_data_open_and_close(
+    position_manager, mock_positions_data
+):
     pm = position_manager
     # Patch callback
     pm._trigger_callbacks = AsyncMock()
@@ -35,4 +42,4 @@ async def test_process_position_data_open_and_close(position_manager, mock_posit
     await pm._process_position_data(closure_data)
     assert key not in pm.tracked_positions
     assert pm.stats["positions_closed"] == 1
-    pm._trigger_callbacks.assert_any_call("position_closed", closure_data)
\ No newline at end of file
+    pm._trigger_callbacks.assert_any_call("position_closed", closure_data)
diff --git a/tests/test_types.py b/tests/test_types.py
new file mode 100644
index 0000000..d5c1fb5
--- /dev/null
+++ b/tests/test_types.py
@@ -0,0 +1,88 @@
+"""Tests for centralized type definitions."""
+
+
+class TestTypes:
+    """Tests for type imports and consistency."""
+
+    def test_base_types_import(self):
+        """Test that base types can be imported."""
+        from project_x_py.types import (
+            DEFAULT_TIMEZONE,
+            TICK_SIZE_PRECISION,
+        )
+
+        assert DEFAULT_TIMEZONE == "America/Chicago"
+        assert TICK_SIZE_PRECISION == 8
+
+    def test_trading_types_import(self):
+        """Test that trading types can be imported."""
+        from project_x_py.types import (
+            OrderSide,
+            OrderStatus,
+            OrderType,
+        )
+
+        # Test enums
+        assert OrderSide.BUY.value == 0
+        assert OrderSide.SELL.value == 1
+        assert OrderType.MARKET.value == 0
+        assert OrderStatus.PENDING.value == 0
+
+    def test_market_data_types_import(self):
+        """Test that market data types can be imported."""
+        from project_x_py.types import (
+            DomType,
+            IcebergConfig,
+            MemoryConfig,
+            OrderbookSide,
+        )
+
+        # Test enums
+        assert DomType.ASK.value == 1
+        assert DomType.BID.value == 2
+        assert OrderbookSide.BID.value == 0
+        assert OrderbookSide.ASK.value == 1
+
+        # Test dataclass defaults
+        memory_config = MemoryConfig()
+        assert memory_config.max_trades == 10000
+        assert memory_config.max_depth_entries == 1000
+
+        iceberg_config = IcebergConfig()
+        assert iceberg_config.min_refreshes == 5
+        assert iceberg_config.confidence_threshold == 0.7
+
+    def test_protocol_imports(self):
+        """Test that protocol definitions can be imported."""
+        from project_x_py.types import (
+            OrderManagerProtocol,
+            PositionManagerProtocol,
+            ProjectXClientProtocol,
+            ProjectXRealtimeClientProtocol,
+            RealtimeDataManagerProtocol,
+        )
+
+        # Protocols should be importable
+        assert ProjectXClientProtocol is not None
+        assert OrderManagerProtocol is not None
+        assert PositionManagerProtocol is not None
+        assert ProjectXRealtimeClientProtocol is not None
+        assert RealtimeDataManagerProtocol is not None
+
+    def test_no_duplicate_imports(self):
+        """Test that types are not duplicated across modules."""
+        # Import from centralized location
+        # Import from module that should use centralized types
+        from project_x_py.order_manager import OrderStats as ManagerOrderStats
+        from project_x_py.types import OrderStats as CentralOrderStats
+
+        # They should be the same object
+        assert CentralOrderStats is ManagerOrderStats
+
+    def test_type_consistency_across_modules(self):
+        """Test that types are consistent when used across different modules."""
+        # This test ensures that all modules are using the same type definitions
+
+        # OrderManager should accept and use OrderStats from centralized types
+        # This is a compile-time check that happens when modules are imported
+        assert True  # If we get here, imports are consistent
diff --git a/tests/client/test_rate_limiter.py b/tests/utils/test_async_rate_limiter.py
similarity index 57%
rename from tests/client/test_rate_limiter.py
rename to tests/utils/test_async_rate_limiter.py
index 3b65eac..46b88f6 100644
--- a/tests/client/test_rate_limiter.py
+++ b/tests/utils/test_async_rate_limiter.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from project_x_py.client.rate_limiter import RateLimiter
+from project_x_py.utils.async_rate_limiter import RateLimiter
 
 
 class TestRateLimiter:
@@ -142,3 +142,105 @@ async def test_rate_limiter_clears_old_requests(self):
 
         # Verify internal state
         assert len(limiter.requests) == 2, "Should have 2 requests in tracking"
+
+    @pytest.mark.asyncio
+    async def test_rate_limiter_memory_cleanup(self):
+        """Test that rate limiter doesn't accumulate unlimited request history."""
+        limiter = RateLimiter(max_requests=100, window_seconds=0.1)
+
+        # Make many requests over multiple windows
+        for _ in range(5):
+            # Fill the window
+            for _ in range(100):
+                await limiter.acquire()
+            # Wait for window to expire
+            await asyncio.sleep(0.15)
+
+        # Check that internal state is bounded
+        # Should not keep more than max_requests * 2 entries
+        assert len(limiter.requests) <= 200, "Should limit internal request history"
+
+    @pytest.mark.asyncio
+    async def test_rate_limiter_edge_cases(self):
+        """Test edge cases for rate limiter."""
+        # Test with 1 request per window
+        limiter = RateLimiter(max_requests=1, window_seconds=0.1)
+
+        await limiter.acquire()
+        start = time.time()
+        await limiter.acquire()
+        elapsed = time.time() - start
+
+        assert elapsed >= 0.09, "Should wait for window with single request limit"
+
+        # Test with very large window
+        limiter = RateLimiter(max_requests=1, window_seconds=60)
+        await limiter.acquire()
+
+        # Should still track request
+        assert len(limiter.requests) == 1
+
+    @pytest.mark.asyncio
+    async def test_rate_limiter_stress_test(self):
+        """Stress test the rate limiter with many concurrent requests."""
+        limiter = RateLimiter(max_requests=10, window_seconds=0.5)
+
+        # Create 50 concurrent requests
+        async def make_request():
+            await limiter.acquire()
+            return time.time()
+
+        start_time = time.time()
+        tasks = [make_request() for _ in range(50)]
+        times = await asyncio.gather(*tasks)
+        total_time = time.time() - start_time
+
+        # Should take at least 2 seconds (5 batches of 10 requests, 0.5s window)
+        # But less than 3 seconds (allowing for some overhead)
+        assert 2.0 <= total_time <= 3.0, f"Expected ~2.5s total, got {total_time:.2f}s"
+
+        # Verify requests were properly rate limited
+        times.sort()
+
+        # Check rate limiting - for any 0.5s window, we should have at most 10 requests
+        for i in range(len(times)):
+            # Count requests within 0.5s window starting from this request
+            window_end = times[i] + 0.5
+            requests_in_window = sum(1 for t in times[i:] if t < window_end)
+            assert requests_in_window <= 10, (
+                f"Too many requests ({requests_in_window}) in 0.5s window starting at index {i}"
+            )
+
+    @pytest.mark.asyncio
+    async def test_rate_limiter_accuracy(self):
+        """Test the accuracy of rate limiting calculations."""
+        limiter = RateLimiter(max_requests=5, window_seconds=1.0)
+
+        # Record exact timings
+        timings = []
+
+        for i in range(10):
+            start = time.time()
+            await limiter.acquire()
+            timings.append(time.time())
+
+            # Small delay to spread requests
+            if i < 9:
+                await asyncio.sleep(0.05)
+
+        # Analyze the timings
+        # First 5 should be in the first second
+        assert timings[4] - timings[0] < 1.0, (
+            "First 5 requests should be within 1 second"
+        )
+
+        # 6th request should be delayed
+        assert timings[5] - timings[0] >= 0.9, "6th request should wait for window"
+
+        # Check sliding window behavior
+        for i in range(5, 10):
+            # Each request should maintain the rate limit
+            recent_requests = [t for t in timings[: i + 1] if t > timings[i] - 1.0]
+            assert len(recent_requests) <= 5, (
+                f"Too many requests in window at index {i}"
+            )
diff --git a/tests/utils/test_error_handler.py b/tests/utils/test_error_handler.py
new file mode 100644
index 0000000..5fe2267
--- /dev/null
+++ b/tests/utils/test_error_handler.py
@@ -0,0 +1,395 @@
+"""Tests for error handling decorators and utilities."""
+
+import logging
+from datetime import UTC
+from unittest.mock import Mock, patch
+
+import httpx
+import pytest
+
+from project_x_py.exceptions import (
+    ProjectXConnectionError,
+    ProjectXDataError,
+    ProjectXError,
+    ProjectXRateLimitError,
+    ProjectXServerError,
+)
+from project_x_py.utils.error_handler import (
+    ErrorContext,
+    handle_errors,
+    handle_rate_limit,
+    retry_on_network_error,
+    validate_response,
+)
+
+
+class TestHandleErrors:
+    """Test the handle_errors decorator."""
+
+    def test_handle_errors_sync_success(self):
+        """Test sync function succeeds without errors."""
+
+        @handle_errors("test operation", reraise=True)
+        def test_func(x: int) -> int:
+            return x * 2
+
+        result = test_func(5)
+        assert result == 10
+
+    @pytest.mark.asyncio
+    async def test_handle_errors_async_success(self):
+        """Test async function succeeds without errors."""
+
+        @handle_errors("test operation", reraise=True)
+        async def test_func(x: int) -> int:
+            return x * 2
+
+        result = await test_func(5)
+        assert result == 10
+
+    def test_handle_errors_sync_with_projectx_error(self, caplog):
+        """Test sync function with ProjectX error."""
+
+        @handle_errors("test operation", reraise=True)
+        def test_func():
+            raise ProjectXError("Test error", error_code=123)
+
+        with pytest.raises(ProjectXError) as exc_info:
+            test_func()
+
+        assert str(exc_info.value) == "Test error"
+        assert "ProjectX error during test operation" in caplog.text
+
+    @pytest.mark.asyncio
+    async def test_handle_errors_async_with_http_error(self, caplog):
+        """Test async function with HTTP error."""
+
+        @handle_errors("test operation", reraise=True)
+        async def test_func():
+            raise httpx.ConnectError("Connection failed")
+
+        with pytest.raises(ProjectXConnectionError) as exc_info:
+            await test_func()
+
+        assert "HTTP error during test operation" in str(exc_info.value)
+        assert "HTTP error during test operation" in caplog.text
+
+    def test_handle_errors_no_reraise(self):
+        """Test error handling without re-raising."""
+
+        @handle_errors("test operation", reraise=False, default_return=42)
+        def test_func():
+            raise ValueError("Test error")
+
+        result = test_func()
+        assert result == 42
+
+    @pytest.mark.asyncio
+    async def test_handle_errors_with_custom_logger(self):
+        """Test with custom logger."""
+        mock_logger = Mock(spec=logging.Logger)
+
+        @handle_errors("test operation", logger=mock_logger, reraise=False)
+        async def test_func():
+            raise ProjectXError("Test error")
+
+        await test_func()
+        mock_logger.error.assert_called_once()
+
+
+class TestRetryOnNetworkError:
+    """Test the retry_on_network_error decorator."""
+
+    @pytest.mark.asyncio
+    async def test_retry_async_success_first_try(self):
+        """Test async function succeeds on first try."""
+        call_count = 0
+
+        @retry_on_network_error(max_attempts=3, initial_delay=0.1)
+        async def test_func():
+            nonlocal call_count
+            call_count += 1
+            return "success"
+
+        result = await test_func()
+        assert result == "success"
+        assert call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_retry_async_success_after_retries(self):
+        """Test async function succeeds after retries."""
+        call_count = 0
+
+        @retry_on_network_error(max_attempts=3, initial_delay=0.01)
+        async def test_func():
+            nonlocal call_count
+            call_count += 1
+            if call_count < 3:
+                raise httpx.ConnectError("Connection failed")
+            return "success"
+
+        result = await test_func()
+        assert result == "success"
+        assert call_count == 3
+
+    @pytest.mark.asyncio
+    async def test_retry_async_max_attempts_exceeded(self):
+        """Test async function fails after max attempts."""
+        call_count = 0
+
+        @retry_on_network_error(max_attempts=3, initial_delay=0.01)
+        async def test_func():
+            nonlocal call_count
+            call_count += 1
+            raise httpx.TimeoutException("Timeout")
+
+        with pytest.raises(httpx.TimeoutException):
+            await test_func()
+
+        assert call_count == 3
+
+    def test_retry_sync_success_after_retries(self):
+        """Test sync function succeeds after retries."""
+        call_count = 0
+
+        @retry_on_network_error(max_attempts=3, initial_delay=0.01)
+        def test_func():
+            nonlocal call_count
+            call_count += 1
+            if call_count < 2:
+                raise ProjectXServerError("Server error")
+            return "success"
+
+        result = test_func()
+        assert result == "success"
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_retry_with_custom_exceptions(self):
+        """Test retry with custom exception types."""
+        call_count = 0
+
+        @retry_on_network_error(
+            max_attempts=2, initial_delay=0.01, retry_on=(ValueError,)
+        )
+        async def test_func():
+            nonlocal call_count
+            call_count += 1
+            if call_count == 1:
+                raise ValueError("Custom error")
+            return "success"
+
+        result = await test_func()
+        assert result == "success"
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_retry_exponential_backoff(self):
+        """Test exponential backoff timing."""
+        delays = []
+
+        async def mock_sleep(delay):
+            delays.append(delay)
+
+        @retry_on_network_error(
+            max_attempts=4, initial_delay=0.1, backoff_factor=2.0, max_delay=1.0
+        )
+        async def test_func():
+            raise httpx.ConnectError("Connection failed")
+
+        with patch("asyncio.sleep", mock_sleep):
+            with pytest.raises(httpx.ConnectError):
+                await test_func()
+
+        # Check delays: 0.1, 0.2, 0.4 (capped at max_delay)
+        assert len(delays) == 3
+        assert delays[0] == 0.1
+        assert delays[1] == 0.2
+        assert delays[2] == 0.4
+
+
+class TestHandleRateLimit:
+    """Test the handle_rate_limit decorator."""
+
+    @pytest.mark.asyncio
+    async def test_handle_rate_limit_no_error(self):
+        """Test function without rate limit error."""
+
+        @handle_rate_limit(fallback_delay=1.0)
+        async def test_func():
+            return "success"
+
+        result = await test_func()
+        assert result == "success"
+
+    @pytest.mark.asyncio
+    async def test_handle_rate_limit_with_retry(self):
+        """Test rate limit handling with retry."""
+        call_count = 0
+
+        async def mock_sleep(delay):
+            pass
+
+        @handle_rate_limit(fallback_delay=0.1)
+        async def test_func():
+            nonlocal call_count
+            call_count += 1
+            if call_count == 1:
+                raise ProjectXRateLimitError("Rate limited")
+            return "success"
+
+        with patch("asyncio.sleep", mock_sleep):
+            result = await test_func()
+
+        assert result == "success"
+        assert call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_handle_rate_limit_with_reset_time(self):
+        """Test rate limit handling with reset time in response."""
+        from datetime import datetime, timedelta
+
+        # Future reset time
+        reset_time = datetime.now(UTC) + timedelta(seconds=5)
+
+        call_count = 0
+        actual_delay = None
+
+        async def mock_sleep(delay):
+            nonlocal actual_delay
+            actual_delay = delay
+
+        @handle_rate_limit()
+        async def test_func():
+            nonlocal call_count
+            call_count += 1
+            if call_count == 1:
+                error = ProjectXRateLimitError("Rate limited")
+                error.response_data = {"reset_at": reset_time.isoformat()}
+                raise error
+            return "success"
+
+        with patch("asyncio.sleep", mock_sleep):
+            result = await test_func()
+
+        assert result == "success"
+        assert call_count == 2
+        assert actual_delay is not None
+        assert 4 <= actual_delay <= 6  # Should be close to 5 seconds
+
+
+class TestValidateResponse:
+    """Test the validate_response decorator."""
+
+    @pytest.mark.asyncio
+    async def test_validate_response_async_success(self):
+        """Test async response validation success."""
+
+        @validate_response(required_fields=["id", "status"], response_type=dict)
+        async def test_func():
+            return {"id": 123, "status": "active", "extra": "data"}
+
+        result = await test_func()
+        assert result["id"] == 123
+        assert result["status"] == "active"
+
+    def test_validate_response_sync_success(self):
+        """Test sync response validation success."""
+
+        @validate_response(required_fields=["name"], response_type=dict)
+        def test_func():
+            return {"name": "test", "value": 42}
+
+        result = test_func()
+        assert result["name"] == "test"
+
+    @pytest.mark.asyncio
+    async def test_validate_response_wrong_type(self):
+        """Test validation fails with wrong type."""
+
+        @validate_response(response_type=dict)
+        async def test_func():
+            return ["not", "a", "dict"]
+
+        with pytest.raises(ProjectXDataError) as exc_info:
+            await test_func()
+
+        assert "expected dict, got list" in str(exc_info.value)
+
+    def test_validate_response_missing_fields(self):
+        """Test validation fails with missing fields."""
+
+        @validate_response(required_fields=["id", "name", "status"])
+        def test_func():
+            return {"id": 123, "status": "active"}
+
+        with pytest.raises(ProjectXDataError) as exc_info:
+            test_func()
+
+        assert "Missing required fields" in str(exc_info.value)
+        assert "name" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_validate_response_no_validation(self):
+        """Test decorator with no validation criteria."""
+
+        @validate_response()
+        async def test_func():
+            return "any value"
+
+        result = await test_func()
+        assert result == "any value"
+
+
+class TestErrorContext:
+    """Test the ErrorContext context manager."""
+
+    def test_error_context_no_errors(self):
+        """Test context with no errors."""
+        with ErrorContext("test operation") as ctx:
+            # Do some work without errors
+            pass
+
+        assert not ctx.has_errors
+        assert ctx.error_count == 0
+        assert ctx.get_summary() == "No errors"
+
+    def test_error_context_with_errors(self, caplog):
+        """Test context with collected errors."""
+        with ErrorContext("test operation") as ctx:
+            ctx.add_error("item1", ValueError("Bad value"))
+            ctx.add_error("item2", KeyError("Missing key"))
+            ctx.add_error("item3", ValueError("Another bad value"))
+
+        assert ctx.has_errors
+        assert ctx.error_count == 3
+        assert "2 ValueError" in ctx.get_summary()
+        assert "1 KeyError" in ctx.get_summary()
+        assert "Errors during test operation" in caplog.text
+
+    @pytest.mark.asyncio
+    async def test_error_context_async(self):
+        """Test async context manager."""
+        errors_found = []
+
+        async with ErrorContext("async operation") as ctx:
+            for i in range(5):
+                try:
+                    if i % 2 == 0:
+                        raise ValueError(f"Error {i}")
+                except Exception as e:
+                    ctx.add_error(f"item{i}", e)
+                    errors_found.append(i)
+
+        assert ctx.error_count == 3
+        assert errors_found == [0, 2, 4]
+
+    def test_error_context_with_exception(self):
+        """Test context doesn't suppress exceptions."""
+        with pytest.raises(RuntimeError):
+            with ErrorContext("failing operation") as ctx:
+                ctx.add_error("pre-error", ValueError("Before main error"))
+                raise RuntimeError("Main error")
+
+        # Context should still have the pre-error
+        assert ctx.error_count == 1
diff --git a/tests/utils/test_error_messages.py b/tests/utils/test_error_messages.py
new file mode 100644
index 0000000..0e6e549
--- /dev/null
+++ b/tests/utils/test_error_messages.py
@@ -0,0 +1,202 @@
+"""Tests for error messages and error utilities."""
+
+import pytest
+
+from project_x_py.exceptions import (
+    ProjectXAuthenticationError,
+    ProjectXConnectionError,
+    ProjectXDataError,
+    ProjectXError,
+    ProjectXRateLimitError,
+)
+from project_x_py.utils.error_messages import (
+    ErrorCode,
+    ErrorMessages,
+    create_error_context,
+    enhance_exception,
+    format_error_message,
+    get_error_code,
+)
+
+
+class TestErrorMessages:
+    """Test error message constants and formatting."""
+
+    def test_error_message_constants(self):
+        """Test that error message constants are defined."""
+        assert (
+            ErrorMessages.AUTH_MISSING_CREDENTIALS
+            == "Missing authentication credentials"
+        )
+        assert ErrorMessages.CONN_TIMEOUT == "Connection timed out"
+        assert ErrorMessages.ORDER_NOT_FOUND == "Order not found: {order_id}"
+        assert (
+            ErrorMessages.API_RATE_LIMITED
+            == "Rate limit exceeded, retry after {retry_after}s"
+        )
+
+    def test_format_error_message_success(self):
+        """Test successful error message formatting."""
+        msg = format_error_message(
+            ErrorMessages.API_RESOURCE_NOT_FOUND, resource="order/12345"
+        )
+        assert msg == "Resource not found: order/12345"
+
+        msg = format_error_message(ErrorMessages.ORDER_INVALID_SIZE, size=-5)
+        assert msg == "Invalid order size: -5"
+
+    def test_format_error_message_missing_placeholder(self):
+        """Test formatting with missing placeholder."""
+        msg = format_error_message(
+            ErrorMessages.API_RATE_LIMITED
+            # Missing retry_after parameter
+        )
+        assert "missing value for: 'retry_after'" in msg
+
+    def test_format_error_message_extra_params(self):
+        """Test formatting with extra parameters (should be ignored)."""
+        msg = format_error_message(ErrorMessages.CONN_TIMEOUT, extra_param="ignored")
+        assert msg == "Connection timed out"
+
+
+class TestErrorContext:
+    """Test error context creation."""
+
+    def test_create_error_context_basic(self):
+        """Test basic error context creation."""
+        context = create_error_context("test_operation")
+
+        assert context["operation"] == "test_operation"
+        assert "timestamp" in context
+        assert "timestamp_unix" in context
+        assert context["timestamp"].endswith("Z")
+
+    def test_create_error_context_with_details(self):
+        """Test error context with additional details."""
+        context = create_error_context(
+            "place_order",
+            instrument="ES",
+            size=10,
+            side="BUY",
+            order_id=None,  # Should be filtered out
+        )
+
+        assert context["operation"] == "place_order"
+        assert context["instrument"] == "ES"
+        assert context["size"] == 10
+        assert context["side"] == "BUY"
+        assert "order_id" not in context  # None values filtered
+
+    def test_create_error_context_timestamps(self):
+        """Test timestamp fields are properly formatted."""
+        import time
+
+        before = time.time()
+        context = create_error_context("test")
+        after = time.time()
+
+        # Unix timestamp should be in range
+        assert before <= context["timestamp_unix"] <= after
+
+        # ISO timestamp should parse correctly
+        from datetime import datetime
+
+        dt = datetime.fromisoformat(context["timestamp"].replace("Z", "+00:00"))
+        assert dt.timestamp() == pytest.approx(context["timestamp_unix"], rel=0.01)
+
+
+class TestEnhanceException:
+    """Test exception enhancement."""
+
+    def test_enhance_standard_exception(self):
+        """Test enhancing a standard exception."""
+        original = ValueError("Invalid value")
+        enhanced = enhance_exception(
+            original, "process_data", input_type="string", value="abc123"
+        )
+
+        assert isinstance(enhanced, ProjectXError)
+        assert "process_data failed" in str(enhanced)
+        assert "Invalid value" in str(enhanced)
+        assert enhanced.response_data["operation"] == "process_data"
+        assert enhanced.response_data["input_type"] == "string"
+
+    def test_enhance_projectx_exception(self):
+        """Test enhancing an existing ProjectX exception."""
+        original = ProjectXDataError("Bad data", error_code=4001)
+        original.response_data = {"existing": "data"}
+
+        enhanced = enhance_exception(original, "validate_order", order_type="LIMIT")
+
+        # Should be the same instance
+        assert enhanced is original
+        # Should preserve existing data
+        assert enhanced.response_data["existing"] == "data"
+        # Should add new context
+        assert enhanced.response_data["operation"] == "validate_order"
+        assert enhanced.response_data["order_type"] == "LIMIT"
+
+    def test_enhance_exception_no_response_data(self):
+        """Test enhancing ProjectX exception without response_data."""
+        original = ProjectXError("Test error")
+        enhanced = enhance_exception(original, "test_op", key="value")
+
+        assert enhanced is original
+        assert enhanced.response_data is not None
+        assert enhanced.response_data["key"] == "value"
+
+
+class TestErrorCode:
+    """Test error code constants and utilities."""
+
+    def test_error_code_constants(self):
+        """Test error code constant values."""
+        # Auth codes (1xxx)
+        assert ErrorCode.AUTH_REQUIRED == 1001
+        assert ErrorCode.AUTH_EXPIRED == 1003
+
+        # Connection codes (2xxx)
+        assert ErrorCode.CONN_FAILED == 2001
+        assert ErrorCode.CONN_TIMEOUT == 2002
+
+        # API codes (3xxx)
+        assert ErrorCode.API_NOT_FOUND == 3404
+        assert ErrorCode.API_BAD_REQUEST == 3400
+        assert ErrorCode.API_RATE_LIMIT == 3429
+
+        # Trading codes (5xxx)
+        assert ErrorCode.ORDER_INVALID == 5001
+        assert ErrorCode.POSITION_NOT_FOUND == 5102
+
+    def test_get_error_code_for_exceptions(self):
+        """Test getting error codes for different exception types."""
+        # Authentication error
+        exc = ProjectXAuthenticationError("Auth failed")
+        assert get_error_code(exc) == ErrorCode.AUTH_INVALID
+
+        # Rate limit error
+        exc = ProjectXRateLimitError("Too many requests")
+        assert get_error_code(exc) == ErrorCode.API_RATE_LIMIT
+
+        # Connection error
+        exc = ProjectXConnectionError("Network error")
+        assert get_error_code(exc) == ErrorCode.CONN_FAILED
+
+        # Data error
+        exc = ProjectXDataError("Invalid data")
+        assert get_error_code(exc) == ErrorCode.DATA_INVALID
+
+    def test_get_error_code_with_existing_code(self):
+        """Test getting error code when exception already has one."""
+        exc = ProjectXError("Test error", error_code=9999)
+        assert get_error_code(exc) == 9999
+
+    def test_get_error_code_for_standard_exception(self):
+        """Test getting error code for non-ProjectX exception."""
+        exc = ValueError("Not a ProjectX error")
+        assert get_error_code(exc) is None
+
+    def test_get_error_code_generic_projectx_error(self):
+        """Test getting error code for generic ProjectX error."""
+        exc = ProjectXError("Generic error")
+        assert get_error_code(exc) == ErrorCode.INTERNAL_ERROR
diff --git a/uv.lock b/uv.lock
index cbeb263..f7c27d5 100644
--- a/uv.lock
+++ b/uv.lock
@@ -818,7 +818,7 @@ wheels = [
 
 [[package]]
 name = "project-x-py"
-version = "2.0.4"
+version = "2.0.5"
 source = { editable = "." }
 dependencies = [
     { name = "httpx", extra = ["http2"] },