diff --git a/Cargo.toml b/Cargo.toml
index e0a126b..942d756 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ccxt-rust"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Praying"]
@@ -96,8 +96,8 @@ envy = "0.4"
 
 [dependencies]
 # Workspace members
-ccxt-core = { path = "ccxt-core" , version = "0.1.2"}
-ccxt-exchanges = { path = "ccxt-exchanges" , version = "0.1.2"}
+ccxt-core = { path = "ccxt-core", version = "0.1.3" }
+ccxt-exchanges = { path = "ccxt-exchanges", version = "0.1.3" }
 
 # Async runtime
 tokio = { workspace = true }
diff --git a/README.md b/README.md
index 72bc59d..33cffd6 100644
--- a/README.md
+++ b/README.md
@@ -4,524 +4,122 @@ ___
 [![Rust](https://img.shields.io/badge/rust-1.91%2B-orange.svg)](https://www.rust-lang.org/)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Rust CI](https://github.com/Praying/ccxt-rust/actions/workflows/rust.yml/badge.svg)](https://github.com/Praying/ccxt-rust/actions/workflows/rust.yml)
-[![Security Audit](https://github.com/Praying/ccxt-rust/actions/workflows/rust.yml/badge.svg)](https://github.com/Praying/ccxt-rust/actions/workflows/rust.yml)
 [![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://docs.rs/ccxt-rust)
 
-A professional-grade Rust implementation of the CCXT (CryptoCurrency eXchange Trading) library, providing unified, type-safe access to Major cryptocurrency exchanges with high-performance async operations.
+A professional-grade, type-safe Rust implementation of the CCXT library for cryptocurrency trading, providing unified
+access to major exchanges.
 
 [English](README.md) | [简体中文](README_CN.md)
 
 ## 🎯 Supported Exchanges
 
-| Exchange | Public API (Market Data) | Private API (Trading) | WebSocket |
-|----------|--------------------------|-----------------------|-----------|
-| **Binance** | ✅ | ✅ | ✅ |
-| **Bitget** | ✅ | ✅ | ✅ |
-| **Hyperliquid** | ✅ | ✅ | ✅ |
-| **OKX** | ✅ | ✅ | ✅ |
-| **Bybit** | ✅ | ✅ | ✅ |
-
-> **Legend**: ✅ Supported, 🚧 In Progress, 🔄 Planned
-
-## 🌟 Features
-
-### Core Capabilities
-- **✅ Type-Safe Trading Operations** - Leverage Rust's strong type system for compile-time safety
-- **✅ Async/Await Architecture** - Built on Tokio for efficient, non-blocking I/O operations
-- **✅ Precise Financial Calculations** - Using `rust_decimal` for accurate monetary computations
-- **✅ Comprehensive Error Handling** - Structured error types with full context propagation
-- **✅ REST API Support** - Complete REST API implementation for exchange operations
-- **✅ WebSocket Real-Time Data** - Live market data streaming with automatic reconnection
-- **✅ Multi-Exchange Support** - Unified interface across multiple cryptocurrency exchanges
-
-### Advanced Features
-- **Market Data Operations**
-  - Fetch tickers, order books, and OHLCV data
-  - Real-time market data streaming via WebSocket
-  - Advanced market data with depth and aggregation
-
-- **Order Management**
-  - Create, cancel, and modify orders
-  - Support for market, limit, and conditional orders
-  - OCO (One-Cancels-Other) order support
-  - Batch order operations
-
-- **Account Management**
-  - Balance inquiries and account information
-  - Deposit and withdrawal operations
-  - Transaction history and ledger access
-  - Fee management and calculation
-
-- **Trading Features**
-  - Spot trading
-  - Margin trading (cross and isolated)
-  - Futures trading with position management
-  - Leverage and margin management
-
-- **WebSocket Features**
-  - Real-time order book updates
-  - Live trade streaming
-  - Account balance updates
-  - Order status updates
-  - Position updates for futures
+| Exchange        | Market Data | Trading | WebSocket |
+|-----------------|-------------|---------|-----------|
+| **Binance**     | ✅           | ✅       | ✅         |
+| **Bitget**      | ✅           | ✅       | ✅         |
+| **Hyperliquid** | ✅           | ✅       | ✅         |
+| **OKX**         | ✅           | ✅       | ✅         |
+| **Bybit**       | ✅           | ✅       | ✅         |
 
-## 🏗️ Architecture
-
-The project follows a clean, modular workspace architecture with a unified Exchange trait:
-
-### Project Structure
-
-```
-ccxt-rust/
-├── ccxt-core/              # Core types, traits, and error handling
-│   ├── types/              # Market, Order, Trade, Ticker, etc.
-│   ├── exchange.rs         # Unified Exchange trait
-│   ├── ws_exchange.rs      # WebSocket Exchange trait
-│   ├── error/              # Comprehensive error types
-│   ├── base_exchange/      # Base exchange functionality
-│   ├── http_client/        # HTTP client with retry and circuit breaker
-│   ├── ws_client/          # WebSocket client with auto-reconnect
-│   ├── auth/               # Authentication and signing
-│   └── ...
-├── ccxt-exchanges/         # Exchange-specific implementations
-│   ├── binance/            # Binance exchange implementation
-│   ├── okx/                # OKX exchange implementation
-│   ├── bybit/              # Bybit exchange implementation
-│   ├── bitget/             # Bitget exchange implementation
-│   └── hyperliquid/        # Hyperliquid exchange implementation
-├── examples/               # Comprehensive usage examples
-├── tests/                  # Integration tests
-└── docs/                   # Detailed documentation
-```
-
-### Module Relationships
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                     Application Code                        │
-│  (uses exchanges through unified Exchange trait interface)  │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│                  Unified Exchange Trait                     │
-│  (ccxt-core::exchange::Exchange)                            │
-│  - Provides polymorphic interface for all exchanges        │
-│  - Capability-based feature discovery                       │
-│  - Market data, trading, account management methods        │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│                    Base Exchange Layer                      │
-│  (ccxt-core::base_exchange::BaseExchange)                   │
-│  - Common functionality shared across exchanges             │
-│  - Market caching, precision handling, symbol parsing       │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│              Exchange Implementations                        │
-│  (ccxt-exchanges::binance, okx, bybit, ...)                 │
-│  - Exchange-specific API clients                            │
-│  - REST and WebSocket implementations                       │
-│  - Custom request parsing and authentication                │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### Key Design Principles
-
-1. **Trait-Based Abstraction**: Unified `Exchange` trait allows polymorphic usage
-2. **Capability Discovery**: Runtime feature detection via `ExchangeCapabilities`
-3. **Type Safety**: Strong typing with `rust_decimal` for financial calculations
-4. **Error Handling**: Comprehensive error types with context preservation
-5. **Async First**: Built on Tokio for efficient async operations
-
-### Unified Exchange Trait
-
-The `Exchange` trait in `ccxt-core` provides a unified interface for all exchanges:
-
-```rust
-use ccxt_core::exchange::{Exchange, ExchangeCapabilities, BoxedExchange};
+> **Legend**: ✅ Supported, 🚧 In Progress
 
-// Use any exchange through the unified interface
-async fn fetch_price(exchange: &dyn Exchange, symbol: &str) -> Result<Decimal, Error> {
-    // Check capability before calling
-    if !exchange.capabilities().fetch_ticker() {
-        return Err(Error::not_implemented("fetch_ticker"));
-    }
-    
-    let ticker = exchange.fetch_ticker(symbol).await?;
-    ticker.last.ok_or_else(|| Error::invalid_response("No last price"))
-}
-
-// Use multiple exchanges polymorphically
-async fn compare_prices(exchanges: &[BoxedExchange], symbol: &str) {
-    for exchange in exchanges {
-        println!("{}: {:?}", exchange.name(), fetch_price(exchange.as_ref(), symbol).await);
-    }
-}
-```
-
-### WebSocket Streaming
-
-The `WsExchange` trait provides real-time data streaming:
+## 🌟 Key Features
 
-```rust
-use ccxt_core::ws_exchange::{WsExchange, FullExchange};
-use futures::StreamExt;
-
-async fn watch_market(exchange: &dyn WsExchange, symbol: &str) {
-    exchange.ws_connect().await.unwrap();
-    
-    let mut stream = exchange.watch_ticker(symbol).await.unwrap();
-    while let Some(Ok(ticker)) = stream.next().await {
-        println!("Price: {:?}", ticker.last);
-    }
-}
-```
+- **🛡️ Type-Safe & Async**: Built on `Tokio` and `rust_decimal` for safe, high-performance financial operations.
+- **🔄 Unified Interface**: Consistent `Exchange` trait across all supported exchanges.
+- **⚡ Real-Time**: Robust WebSocket support with automatic reconnection.
+- **📦 Comprehensive Capability**:
+  - **Market Data**: Tickers, Order Books, OHLCV, Trades.
+  - **Trading**: Spot, Margin, Futures, Batched Orders, OCO.
+  - **Account**: Balances, Transactions, Leverage management.
 
 ## 🚀 Quick Start
 
-**New to ccxt-rust?** Start with our [5-minute Quick Start Guide](QUICKSTART.md) 📖
-
-### Prerequisites
-
-- Rust 1.91+ or later
-- Cargo (latest stable)
-
 ### Installation
 
-Add via command line:
-
 ```bash
 cargo add ccxt-rust
 ```
 
-Or add to your `Cargo.toml`:
-
-```toml
-[dependencies]
-ccxt-core = { path = "ccxt-core" }
-ccxt-exchanges = { path = "ccxt-exchanges" }
-tokio = { version = "1.35", features = ["full"] }
-rust_decimal = "1.39"
-futures = "0.3"
-```
-
-### Basic Usage with Builder Pattern
+### Basic Usage
 
 ```rust
 use ccxt_exchanges::binance::Binance;
 use ccxt_core::exchange::Exchange;
+use rust_decimal_macros::dec;
+use ccxt_core::types::{OrderType, OrderSide};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Initialize exchange using the builder pattern (recommended)
+  // 1. Initialize (using env vars recommended)
     let exchange = Binance::builder()
-        .api_key("your_api_key")
-        .secret("your_secret")
-        .sandbox(false)  // Use production API
+            .api_key(std::env::var("BINANCE_API_KEY").ok())
+            .secret(std::env::var("BINANCE_SECRET").ok())
         .build()?;
 
-    // Fetch ticker through the unified Exchange trait
+  // 2. Fetch Market Data
     let ticker = exchange.fetch_ticker("BTC/USDT").await?;
     println!("BTC/USDT Price: {:?}", ticker.last);
 
-    // Fetch order book
-    let orderbook = exchange.fetch_order_book("BTC/USDT", Some(10)).await?;
-    if let Some(best_bid) = orderbook.bids.first() {
-        println!("Best bid: {}", best_bid.price);
-    }
-    if let Some(best_ask) = orderbook.asks.first() {
-        println!("Best ask: {}", best_ask.price);
-    }
-
-    // Place an order (requires API credentials)
-    use ccxt_core::types::{OrderType, OrderSide};
-    use rust_decimal_macros::dec;
-
+  // 3. Place Order (if credentials provided)
+  if exchange.has_private_api() {
     let order = exchange.create_order(
-        "BTC/USDT",
-        OrderType::Limit,
-        OrderSide::Buy,
-        dec!(0.001),
-        Some(dec!(40000)),
+      "BTC/USDT",
+      OrderType::Limit,
+      OrderSide::Buy,
+      dec!(0.001),
+      Some(dec!(50000)),
     ).await?;
     println!("Order placed: {}", order.id);
-
-    Ok(())
-}
-```
-
-### Using Exchanges Polymorphically
-
-```rust
-use ccxt_core::exchange::{Exchange, BoxedExchange};
-use std::sync::Arc;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Create exchange as a trait object
-    let exchange: BoxedExchange = Box::new(
-        ccxt_exchanges::binance::Binance::builder().build()?
-    );
-
-    // Use through the unified interface
-    println!("Exchange: {} ({})", exchange.name(), exchange.id());
-    println!("Capabilities: {:?}", exchange.capabilities());
-
-    // Check capabilities before calling methods
-    if exchange.capabilities().fetch_ticker() {
-        let ticker = exchange.fetch_ticker("BTC/USDT").await?;
-        println!("Price: {:?}", ticker.last);
-    }
-
-    Ok(())
-}
-```
-
-### WebSocket Streaming
-
-```rust
-use ccxt_exchanges::binance::Binance;
-use ccxt_core::ws_exchange::WsExchange;
-use futures::StreamExt;
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Initialize exchange
-    let exchange = Binance::builder().build()?;
-
-    // Watch real-time ticker updates using the WsExchange trait
-    let mut stream = exchange.watch_ticker("BTC/USDT").await?;
-
-    while let Some(result) = stream.next().await {
-        match result {
-            Ok(ticker) => println!("Price: {:?}", ticker.last),
-            Err(e) => eprintln!("Error: {}", e),
-        }
     }
 
     Ok(())
 }
 ```
 
-**More examples**: See the [QUICKSTART.md](QUICKSTART.md) guide for detailed tutorials!
-
-## 📚 Examples
+For WebSocket examples and advanced usage (polymorphism), see the [`examples/`](examples/) directory.
 
-The project includes comprehensive examples covering all major features:
-
-- **`basic_usage.rs`** - Getting started with the library
-- **`binance_market_data_example.rs`** - Market data operations
-- **`binance_order_management_example.rs`** - Order creation and management
-- **`binance_account_example.rs`** - Account operations
-- **`binance_margin_example.rs`** - Margin trading
-- **`binance_futures_example.rs`** - Futures trading
-- **`binance_ws_example.rs`** - WebSocket streaming
-- **`binance_conditional_orders_example.rs`** - Conditional orders
-- **`binance_deposit_withdrawal_example.rs`** - Deposit/withdrawal operations
-
-Run any example:
-
-```bash
-cargo run --example basic_usage
-cargo run --example binance_ws_example
-```
+## 🏗️ Architecture
 
+The project is structured as a workspace:
 
+- **`ccxt-core`**: Defines the unified `Exchange` and `WsExchange` traits, standard types, and error handling logic.
+- **`ccxt-exchanges`**: Contains specific implementations (Binance, OKX, etc.).
 
 ## 🚩 Feature Flags
 
-Optimize your build by selecting only the features you need in `Cargo.toml`:
-
-- **`default`**: Enables `rest`, `websocket`, and `rustls-tls`.
-- **`rest`**: Enables REST API support.
-- **`websocket`**: Enables WebSocket support.
-- **`rustls-tls`**: Uses `rustls` for TLS (default, recommended).
-- **`native-tls`**: Uses platform-native TLS (OpenSSL/Schannel/Secure Transport).
-- **`compression`**: Enables GZIP compression for HTTP requests.
-- **`full`**: Enables all features.
-
-## 🔧 Configuration
-
-### Environment Variables
-
-Create a `.env` file from the template:
-
-```bash
-cp .env.example .env
-```
-
-Key configuration options:
-
-```bash
-# API Credentials
-BINANCE_API_KEY=your_api_key_here
-BINANCE_API_SECRET=your_secret_here
-
-# Testing
-ENABLE_PRIVATE_TESTS=false
-ENABLE_INTEGRATION_TESTS=false
-USE_MOCK_DATA=true
-TEST_SYMBOL=BTC/USDT
-
-# Logging
-RUST_LOG=info
-```
+| Flag         | Description              | Default |
+|--------------|--------------------------|---------|
+| `rest`       | REST API support         | ✅       |
+| `websocket`  | WebSocket support        | ✅       |
+| `rustls-tls` | Use RustLS (recommended) | ✅       |
+| `native-tls` | Use OpenSSL/Native TLS   | ❌       |
 
-## 🧪 Testing
+## 🛠️ Development
 
 ```bash
-# Run all tests
+# Run tests
 cargo test
 
-# Run tests with output
-cargo test -- --nocapture
-
-# Run specific test suite
-cargo test -p ccxt-core
-cargo test -p ccxt-exchanges
-
-# Run integration tests
-cargo test --test binance_integration_test
-
-# Run with live API (requires credentials)
-ENABLE_INTEGRATION_TESTS=true cargo test
-```
-
-## 📖 Documentation
-
-- **[API Documentation](docs/)** - Detailed API reference
-- **[Testing Guide](docs/TESTING.md)** - Comprehensive testing documentation
-- **[Implementation Plans](docs/)** - Feature implementation roadmaps
-- **[Comparison Analysis](docs/GO_RUST_COMPARISON_ANALYSIS.md)** - Go vs Rust implementation
+# Check code quality
+cargo clippy --all-targets -- -D warnings
 
-Generate local documentation:
-
-```bash
+# Build documentation
 cargo doc --open
 ```
 
+## 📝 License & Support
 
-## 🛠️ Development
-
-### Building
-
-```bash
-# Debug build
-cargo build
-
-# Release build (optimized)
-cargo build --release
-
-# Build specific package
-cargo build -p ccxt-core
-cargo build -p ccxt-exchanges
-```
-
-### Code Quality
-
-```bash
-# Format code
-cargo fmt
-
-# Run linter
-cargo clippy --all-targets --all-features
-
-# Strict linting (no warnings)
-cargo clippy --all-targets --all-features -- -D warnings
-
-# Check compilation
-cargo check --all-features
-```
-
-## 🔐 Security
-
-- **Never commit API keys or secrets** - Always use environment variables
-- **Secure credential storage** - Use system keychains or encrypted vaults
-- **Rate limiting** - Built-in rate limiting to prevent API bans
-- **Input validation** - All inputs are validated before API calls
-- **HTTPS only** - All communications use TLS encryption
-
-## 🤝 Contributing
-
-Contributions are welcome! Please follow these guidelines:
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Follow Rust best practices and project conventions
-4. Add tests for new features
-5. Ensure all tests pass (`cargo test`)
-6. Run formatting and linting (`cargo fmt && cargo clippy`)
-7. Commit your changes (`git commit -m 'Add amazing feature'`)
-8. Push to the branch (`git push origin feature/amazing-feature`)
-9. Open a Pull Request
-
-### Development Conventions
-
-- **Code Style**: Rust 2024 edition, 100-character line width
-- **Testing**: Minimum 80% test coverage
-- **Documentation**: All public APIs must have documentation
-- **Error Handling**: Use `thiserror` for custom errors, `anyhow` for context
-
-## 📊 Performance
-
-Built for high performance:
-- **Async I/O**: Non-blocking operations using Tokio
-- **Zero-copy parsing**: Efficient JSON deserialization
-- **Connection pooling**: Reused HTTP connections
-- **Optimized builds**: LTO and single codegen unit for releases
-- **Benchmarks**: Criterion-based performance benchmarks
-
-## 🐛 Troubleshooting
-
-### Common Issues
-
-1. **Compilation errors**
-   - Ensure Rust 1.91+ is installed: `rustc --version`
-   - Update dependencies: `cargo update`
-   - Clean build: `cargo clean && cargo build`
-
-2. **API authentication failures**
-   - Verify API keys in `.env` file
-   - Check API key permissions on exchange
-   - Ensure system clock is synchronized
-
-3. **Rate limiting**
-   - Reduce request frequency
-   - Use WebSocket for real-time data
-   - Check exchange-specific rate limits
-
-For more help, see [documentation](docs/) or open an issue.
-
-## 📝 License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
-
-## 🙏 Acknowledgments
-
-- Inspired by the original [CCXT](https://github.com/ccxt/ccxt) library
-- Built with amazing Rust ecosystem libraries
-- Community contributors and testers
-
-## 📞 Contact & Support
+MIT License. See [LICENSE](LICENSE).
 
 - **Issues**: [GitHub Issues](https://github.com/Praying/ccxt-rust/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/Praying/ccxt-rust/discussions)
-- **Documentation**: [Project Docs](docs/)
+- **Docs**: [docs.rs](https://docs.rs/ccxt-rust)
 
-## ❤️ Donations
+## ⚠️ Disclaimer
 
-If the project is profitable, consider donating as showing gratitude for its development:
-
-**USDT or USDC Binance Smart Chain BEP20**:
-
-`0x8e5d858f92938b028065d39450421d0e080d15f7`
+This project is for educational and research purposes only. The authors and contributors are not responsible for any
+financial losses or damages arising from the use of this software. Cryptocurrency trading involves high risk; please
+trade responsibly.
 
 ---
-
-**Status**: 🚧 Active Development | **Version**: 0.1.2 | **Updated**: 2026-01
-
-⚠️ **Note**: This library is under active development. APIs may change before v1.0. Not recommended for production use yet.
+**Status**: 🚧 Active Development (v0.1.3) | **Donations (BSC)**: `0x8e5d858f92938b028065d39450421d0e080d15f7`
diff --git a/README_CN.md b/README_CN.md
index c0c15fc..9342698 100644
--- a/README_CN.md
+++ b/README_CN.md
@@ -1,394 +1,123 @@
 # <center> CCXT-Rust </center>
 
+___
+
 [![Rust](https://img.shields.io/badge/rust-1.91%2B-orange.svg)](https://www.rust-lang.org/)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Rust CI](https://github.com/Praying/ccxt-rust/actions/workflows/rust.yml/badge.svg)](https://github.com/Praying/ccxt-rust/actions/workflows/rust.yml)
 [![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://docs.rs/ccxt-rust)
 
-CCXT (CryptoCurrency eXchange Trading) 库的专业级 Rust 实现，提供统一、类型安全的接口访问主流的加密货币交易所，具有高性能异步操作特性。
-
-[English](README.md) | 简体中文
+CCXT 库的专业级 Rust 实现，提供统一、类型安全的接口访问主流加密货币交易所。
 
-<!--
-en_version: 0.1.2
-cn_version: 0.1.2
-last_updated: 2025-01-07
--->
+[English](README.md) | [简体中文](README_CN.md)
 
 ## 🎯 支持的交易所
 
-| 交易所 | 公共 API (行情数据) | 私有 API (交易) | WebSocket |
-|----------|--------------------------|-----------------------|-----------|
-| **Binance** | ✅ | ✅ | ✅ |
-| **Bitget** | ✅ | ✅ | ✅ |
-| **Hyperliquid** | ✅ | ✅ | ✅ |
-| **OKX** | ✅ | ✅ | ✅ |
-| **Bybit** | ✅ | ✅ | ✅ |
-
-> **图例**: ✅ 已支持, 🚧 开发中, 🔄 计划中
-
-## 🌟 特性
-
-### 核心能力
-- **✅ 类型安全的交易操作** - 利用 Rust 强大的类型系统实现编译时安全
-- **✅ 异步/等待架构** - 基于 Tokio 构建，实现高效的非阻塞 I/O 操作
-- **✅ 精确的金融计算** - 使用 `rust_decimal` 进行精确的货币计算
-- **✅ 全面的错误处理** - 结构化错误类型，完整的上下文传播
-- **✅ REST API 支持** - 完整的 REST API 实现，支持各种交易所操作
-- **✅ WebSocket 实时数据** - 实时市场数据流，支持自动重连
-- **✅ 多交易所支持** - 跨多个加密货币交易所的统一接口
-
-### 高级功能
-- **市场数据操作**
-  - 获取行情、订单簿和 OHLCV 数据
-  - 通过 WebSocket 实时市场数据流
-  - 高级市场数据，包含深度和聚合功能
-
-- **订单管理**
-  - 创建、取消和修改订单
-  - 支持市价、限价和条件订单
-  - OCO（一单取消另一单）订单支持
-  - 批量订单操作
-
-- **账户管理**
-  - 余额查询和账户信息
-  - 充值和提现操作
-  - 交易历史和账本访问
-  - 手续费管理和计算
-
-- **交易功能**
-  - 现货交易
-  - 保证金交易（全仓和逐仓）
-  - 期货交易及仓位管理
-  - 杠杆和保证金管理
-
-- **WebSocket 功能**
-  - 实时订单簿更新
-  - 实时交易流
-  - 账户余额更新
-  - 订单状态更新
-  - 期货仓位更新
-
-## 🏗️ 架构
-
-项目采用清晰的模块化工作空间架构，并提供统一的 Exchange trait：
+| 交易所             | 市场数据 | 交易 API | WebSocket |
+|-----------------|------|--------|-----------|
+| **Binance**     | ✅    | ✅      | ✅         |
+| **Bitget**      | ✅    | ✅      | ✅         |
+| **Hyperliquid** | ✅    | ✅      | ✅         |
+| **OKX**         | ✅    | ✅      | ✅         |
+| **Bybit**       | ✅    | ✅      | ✅         |
 
-### 项目结构
+> **图例**: ✅ 已支持, 🚧 开发中
 
-```
-ccxt-rust/
-├── ccxt-core/              # 核心类型、trait 和错误处理
-│   ├── types/              # Market、Order、Trade、Ticker 等
-│   ├── exchange.rs         # 统一 Exchange trait
-│   ├── ws_exchange.rs      # WebSocket Exchange trait
-│   ├── error/              # 全面的错误类型
-│   ├── base_exchange/      # 基础交易所功能
-│   ├── http_client/        # HTTP 客户端（重试、熔断器）
-│   ├── ws_client/          # WebSocket 客户端（自动重连）
-│   ├── auth/               # 认证和签名
-│   └── ...
-├── ccxt-exchanges/         # 交易所特定实现
-│   ├── binance/            # Binance 交易所实现
-│   ├── okx/                # OKX 交易所实现
-│   ├── bybit/              # Bybit 交易所实现
-│   ├── bitget/             # Bitget 交易所实现
-│   └── hyperliquid/        # Hyperliquid 交易所实现
-├── examples/               # 全面的使用示例
-├── tests/                  # 集成测试
-└── docs/                   # 详细文档
-```
-
-### 模块关系
+## 🌟 核心特性
 
-```
-┌─────────────────────────────────────────────────────────────┐
-│                     应用程序代码                             │
-│  (通过统一的 Exchange trait 接口使用交易所)                  │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│                  统一 Exchange Trait                        │
-│  - 提供所有交易所的多态接口                                   │
-│  - 基于能力的功能发现                                        │
-│  - 市场数据、交易、账户管理方法                              │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│                    基础交易所层                              │
-│  - 所有交易所共享的通用功能                                  │
-│  - 市场缓存、精度处理、符号解析                              │
-└────────────────────────┬────────────────────────────────────┘
-                         │
-                         ▼
-┌─────────────────────────────────────────────────────────────┐
-│              交易所实现                                      │
-│  - 交易所特定的 API 客户端                                  │
-│  - REST 和 WebSocket 实现                                   │
-│  - 自定义请求解析和认证                                      │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### 核心设计原则
-
-1. **基于 Trait 的抽象**：统一的 `Exchange` trait 支持多态使用
-2. **能力发现**：通过 `ExchangeCapabilities` 进行运行时功能检测
-3. **类型安全**：使用 `rust_decimal` 进行金融计算的强类型保证
-4. **错误处理**：全面的错误类型，保留上下文
-5. **异步优先**：基于 Tokio 构建高效异步操作
+- **🛡️ 类型安全与异步**: 基于 `Tokio` 和 `rust_decimal` 构建，确保高性能与金融计算安全。
+- **🔄 统一接口**: 所有交易所均实现统一的 `Exchange` trait。
+- **⚡ 实时数据**: 强大的 WebSocket 支持，具备自动重连功能。
+- **📦 功能全面**:
+  - **行情**: Ticker, 深度图, K线 (OHLCV), 成交记录。
+  - **交易**: 现货, 杠杆, 合约, 批量下单, OCO。
+  - **账户**: 余额查询, 资金划转, 杠杆管理。
 
 ## 🚀 快速开始
 
-**刚接触 ccxt-rust？** 从我们的 [5分钟快速入门指南](QUICKSTART_CN.md) 开始 📖
-
-### 前置要求
-
-- Rust 1.91+ 或更高版本
-- Cargo（最新稳定版）
-
 ### 安装
 
-使用命令行添加：
-
 ```bash
 cargo add ccxt-rust
 ```
 
-或在 `Cargo.toml` 中添加：
-
-```toml
-[dependencies]
-ccxt-core = { path = "ccxt-core" }
-ccxt-exchanges = { path = "ccxt-exchanges" }
-tokio = { version = "1.35", features = ["full"] }
-rust_decimal = "1.39"
-futures = "0.3"
-```
-
 ### 基本用法
 
 ```rust
 use ccxt_exchanges::binance::Binance;
 use ccxt_core::exchange::Exchange;
+use rust_decimal_macros::dec;
+use ccxt_core::types::{OrderType, OrderSide};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // 使用构建器模式初始化交易所（推荐）
+  // 1. 初始化 (建议使用环境变量)
     let exchange = Binance::builder()
-        .api_key("your_api_key")
-        .secret("your_secret")
-        .sandbox(false)  // 使用生产环境 API
+            .api_key(std::env::var("BINANCE_API_KEY").ok())
+            .secret(std::env::var("BINANCE_SECRET").ok())
         .build()?;
 
-    // 通过统一的 Exchange trait 获取行情
+  // 2. 获取行情
     let ticker = exchange.fetch_ticker("BTC/USDT").await?;
     println!("BTC/USDT 价格: {:?}", ticker.last);
 
-    Ok(())
+  // 3. 下单 (如提供了 API Key)
+  if exchange.has_private_api() {
+    let order = exchange.create_order(
+      "BTC/USDT",
+      OrderType::Limit,
+      OrderSide::Buy,
+      dec!(0.001),
+      Some(dec!(50000)),
+    ).await?;
+    println!("下单成功: {}", order.id);
+  }
+
+  Ok(())
 }
 ```
 
-**更多示例**：查看 [QUICKSTART_CN.md](QUICKSTART_CN.md) 获取详细教程！
+更多 WebSocket 和高级用法示例请查看 [`examples/`](examples/) 目录。
 
-## 📚 示例
-
-项目包含覆盖所有主要功能的全面示例：
-
-- **`basic_usage.rs`** - 库的使用入门
-- **`binance_market_data_example.rs`** - 市场数据操作
-- **`binance_order_management_example.rs`** - 订单创建和管理
-- **`binance_account_example.rs`** - 账户操作
-- **`binance_margin_example.rs`** - 保证金交易
-- **`binance_futures_example.rs`** - 期货交易
-- **`binance_ws_example.rs`** - WebSocket 流
-- **`binance_conditional_orders_example.rs`** - 条件订单
-- **`binance_deposit_withdrawal_example.rs`** - 充值提现操作
-
-运行任何示例：
-
-```bash
-cargo run --example basic_usage
-cargo run --example binance_ws_example
-```
-
-## 🚩 功能标志
-
-通过在 `Cargo.toml` 中选择所需功能来优化构建：
-
-- **`default`**: 启用 `rest`、`websocket` 和 `rustls-tls`
-- **`rest`**: 启用 REST API 支持
-- **`websocket`**: 启用 WebSocket 支持
-- **`rustls-tls`**: 使用 `rustls` 进行 TLS（默认，推荐）
-- **`native-tls`**: 使用平台原生 TLS（OpenSSL/Schannel/Secure Transport）
-- **`compression`**: 启用 HTTP 请求的 GZIP 压缩
-- **`full`**: 启用所有功能
-
-## 🔧 配置
+## 🏗️ 架构
 
-### 环境变量
+项目采用模块化工作空间结构：
 
-从模板创建 `.env` 文件：
+- **`ccxt-core`**: 定义统一的 `Exchange` 和 `WsExchange` trait、标准类型及错误处理逻辑。
+- **`ccxt-exchanges`**: 包含具体交易所的实现 (Binance, OKX 等)。
 
-```bash
-cp .env.example .env
-```
+## 🚩 功能标志 (Feature Flags)
 
-主要配置选项：
+| 标志           | 说明                  | 默认开启 |
+|--------------|---------------------|------|
+| `rest`       | REST API 支持         | ✅    |
+| `websocket`  | WebSocket 支持        | ✅    |
+| `rustls-tls` | 使用 RustLS (推荐)      | ✅    |
+| `native-tls` | 使用 OpenSSL/系统原生 TLS | ❌    |
 
-```bash
-# API 凭证
-BINANCE_API_KEY=your_api_key_here
-BINANCE_API_SECRET=your_secret_here
-
-# 测试
-ENABLE_PRIVATE_TESTS=false
-ENABLE_INTEGRATION_TESTS=false
-USE_MOCK_DATA=true
-TEST_SYMBOL=BTC/USDT
-
-# 日志
-RUST_LOG=info
-```
-
-## 🧪 测试
+## 🛠️ 开发与测试
 
 ```bash
-# 运行所有测试
+# 运行测试
 cargo test
 
-# 运行测试并显示输出
-cargo test -- --nocapture
-
-# 运行特定测试套件
-cargo test -p ccxt-core
-cargo test -p ccxt-exchanges
+# 代码检查
+cargo clippy --all-targets -- -D warnings
 
-# 运行集成测试
-cargo test --test binance_integration_test
-
-# 使用真实 API 运行（需要凭证）
-ENABLE_INTEGRATION_TESTS=true cargo test
-```
-
-## 📖 文档
-
-- **[API 文档](docs/)** - 详细的 API 参考
-- **[快速入门](QUICKSTART_CN.md)** - 5分钟上手指南
-- **[贡献指南](CONTRIBUTING.md)** - 贡献流程
-- **[最佳实践](docs/best-practices.md)** - 使用建议
-
-生成本地文档：
-
-```bash
+# 生成文档
 cargo doc --open
 ```
 
-## 🛠️ 开发
-
-### 构建
-
-```bash
-# Debug 构建
-cargo build
-
-# Release 构建（优化）
-cargo build --release
-
-# 构建特定包
-cargo build -p ccxt-core
-cargo build -p ccxt-exchanges
-```
-
-### 代码质量
-
-```bash
-# 格式化代码
-cargo fmt
-
-# 运行 linter
-cargo clippy --all-targets --all-features
-
-# 严格 linting（无警告）
-cargo clippy --all-targets --all-features -- -D warnings
-
-# 检查编译
-cargo check --all-features
-```
-
-## 🔐 安全
+## 📝 许可证与支持
 
-- **永远不要提交 API 密钥或密钥** - 始终使用环境变量
-- **安全的凭证存储** - 使用系统钥匙串或加密保险库
-- **速率限制** - 内置速率限制以防止 API 封禁
-- **输入验证** - 所有输入在 API 调用前都会被验证
-- **仅 HTTPS** - 所有通信使用 TLS 加密
+MIT License. 详见 [LICENSE](LICENSE).
 
-## 🤝 贡献
+- **问题反馈**: [GitHub Issues](https://github.com/Praying/ccxt-rust/issues)
+- **文档**: [docs.rs](https://docs.rs/ccxt-rust)
 
-欢迎贡献！请遵循以下准则：
+## ⚠️ 免责声明
 
-1. Fork 仓库
-2. 创建特性分支 (`git checkout -b feature/amazing-feature`)
-3. 遵循 Rust 最佳实践和项目约定
-4. 为新功能添加测试
-5. 确保所有测试通过 (`cargo test`)
-6. 运行格式化和 linting (`cargo fmt && cargo clippy`)
-7. 提交更改 (`git commit -m 'Add amazing feature'`)
-8. 推送到分支 (`git push origin feature/amazing-feature`)
-9. 创建 Pull Request
-
-查看 [CONTRIBUTING.md](CONTRIBUTING.md) 了解详情。
-
-## 📊 性能
-
-为高性能而构建：
-
-- **异步 I/O**：使用 Tokio 的非阻塞操作
-- **零拷贝解析**：高效的 JSON 反序列化
-- **连接池**：重用的 HTTP 连接
-- **优化构建**：Release 版本使用 LTO 和单代码生成单元
-- **基准测试**：基于 Criterion 的性能基准
-
-## 🐛 故障排除
-
-### 常见问题
-
-1. **编译错误**
-    - 确保 Rust 1.91+ 已安装：`rustc --version`
-    - 更新依赖：`cargo update`
-    - 清理构建：`cargo clean && cargo build`
-
-2. **API 认证失败**
-   - 验证 `.env` 文件中的 API 密钥
-   - 检查交易所上的 API 密钥权限
-   - 确保系统时钟已同步
-
-3. **速率限制**
-   - 降低请求频率
-   - 使用 WebSocket 获取实时数据
-   - 检查交易所特定的速率限制
-
-更多帮助，请查看 [文档](docs/) 或提交 issue。
-
-## 📝 许可证
-
-本项目采用 MIT 许可证 - 详见 [LICENSE](LICENSE) 文件
-
-## 🙏 致谢
-
-- 受原始 [CCXT](https://github.com/ccxt/ccxt) 库启发
-- 使用了出色的 Rust 生态系统库
-- 社区贡献者和测试者
-
-## 📞 联系与支持
-
-- **问题**: [GitHub Issues](https://github.com/Praying/ccxt-rust/issues)
-- **讨论**: [GitHub Discussions](https://github.com/Praying/ccxt-rust/discussions)
-- **文档**: [项目文档](docs/)
+本项目仅供学习和研究使用。作者和贡献者不对因使用本软件而产生的任何财务损失或损害负责。加密货币交易风险极高，请谨慎交易。
 
 ---
-
-**状态**: 🚧 积极开发中 | **版本**: 0.1.2 | **更新**: 2026-01
-
-⚠️ **注意**: 此库正在积极开发中。在 v1.0 之前 API 可能会变化。暂不推荐生产使用。
+**状态**: 🚧 开发中 (v0.1.3) | **捐赠 (BSC)**: `0x8e5d858f92938b028065d39450421d0e080d15f7`
diff --git a/ccxt-core/Cargo.toml b/ccxt-core/Cargo.toml
index efecc3d..586bfc0 100644
--- a/ccxt-core/Cargo.toml
+++ b/ccxt-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ccxt-core"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Praying"]
diff --git a/ccxt-exchanges/Cargo.toml b/ccxt-exchanges/Cargo.toml
index ddc47f5..3cd77d4 100644
--- a/ccxt-exchanges/Cargo.toml
+++ b/ccxt-exchanges/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ccxt-exchanges"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2024"
 rust-version = "1.91"
 authors = ["Praying"]
@@ -8,7 +8,7 @@ license = "MIT"
 description = "Exchange implementations for CCXT Rust"
 
 [dependencies]
-ccxt-core = { path = "../ccxt-core" , version = "0.1.2"}
+ccxt-core = { path = "../ccxt-core", version = "0.1.3" }
 
 # Async runtime
 tokio = { workspace = true }