BI.PersianCryotoExchange.Wallex.Net 1.0.0

Wallex API Wrapper for .NET

A comprehensive .NET library for interacting with the Wallex cryptocurrency exchange API. This library provides a strongly-typed, async/await-based interface for all Wallex API endpoints including market data, account management, order execution, and real-time WebSocket connections.

Features

• ✅ Complete API Coverage: All public and authenticated endpoints
• ✅ Strongly Typed Models: Full IntelliSense support with strongly-typed DTOs
• ✅ Async/Await: Modern asynchronous programming patterns
• ✅ WebSocket Support: Real-time market data via Socket.IO
• ✅ Error Handling: Comprehensive error handling with detailed error messages
• ✅ Pagination Support: Built-in support for paged API responses
• ✅ Flexible JSON Deserialization: Handles various JSON formats (string/number conversions)
• ✅ IDisposable Pattern: Proper resource cleanup

Installation

Using NuGet Package Manager

Install-Package BI.PersianCryotoExchange.Wallex.Net

Using .NET CLI

dotnet add package BI.PersianCryotoExchange.Wallex.Net

Manual Installation

1. Clone this repository
2. Add the project to your solution
3. Reference the project in your application

Quick Start

Basic Usage (Public Endpoints)

using BI.PersianCryotoExchange.Wallex.Net;

// Create client (no API key needed for public endpoints)
var client = new WallexApiClient();

// Get market list
var markets = await client.Markets.GetMarketsAsync();
if (markets.Success && markets.Result != null)
{
    foreach (var market in markets.Result.Symbols)
    {
        Console.WriteLine($"{market.Key}: {market.Value.Symbol}");
    }
}

// Get order book
var orderBook = await client.Markets.GetOrderBookAsync("BTCUSDT");
if (orderBook.Success && orderBook.Result != null)
{
    Console.WriteLine($"Bids: {orderBook.Result.Bids.Count}");
    Console.WriteLine($"Asks: {orderBook.Result.Asks.Count}");
}

// Get latest trades
var trades = await client.Markets.GetLatestTradesAsync("BTCUSDT");
if (trades.Success && trades.Result != null)
{
    foreach (var trade in trades.Result.LatestTrades.Take(10))
    {
        Console.WriteLine($"Price: {trade.Price}, Quantity: {trade.Quantity}");
    }
}

Authenticated Endpoints

using BI.PersianCryotoExchange.Wallex.Net;

// Create client with API key
var client = new WallexApiClient("your-api-key-here");

// Get account profile
var profile = await client.Account.GetProfileAsync();
if (profile.Success && profile.Result != null)
{
    Console.WriteLine($"Email: {profile.Result.Email}");
    Console.WriteLine($"Phone: {profile.Result.Phone}");
}

// Get balances
var balances = await client.Account.GetBalancesAsync();
if (balances.Success && balances.Result != null)
{
    foreach (var balance in balances.Result.Balances)
    {
        Console.WriteLine($"{balance.Key}: {balance.Value.Value}");
    }
}

// Place an order
var orderRequest = new PlaceOrderRequest
{
    Symbol = "BTCUSDT",
    Side = "BUY",
    Type = "LIMIT",
    Quantity = "0.001",
    Price = "50000",
    ClientId = Guid.NewGuid().ToString()
};

var order = await client.Orders.PlaceOrderAsync(orderRequest);
if (order.Success && order.Result != null)
{
    Console.WriteLine($"Order placed: {order.Result.ClientOrderId}");
}

// Get active orders
var activeOrders = await client.Orders.GetActiveOrdersAsync();
if (activeOrders.Success && activeOrders.Result != null)
{
    foreach (var order in activeOrders.Result.Orders)
    {
        Console.WriteLine($"Order: {order.Symbol} - {order.Side} - {order.Status}");
    }
}

WebSocket Real-Time Data

using BI.PersianCryotoExchange.Wallex.Net;

var client = new WallexApiClient();
var webSocket = client.WebSocket;

// Subscribe to connection events
webSocket.OnConnected += () => Console.WriteLine("Connected to WebSocket");
webSocket.OnDisconnected += (reason) => Console.WriteLine($"Disconnected: {reason}");
webSocket.OnError += (error) => Console.WriteLine($"Error: {error}");

// Connect
await webSocket.ConnectAsync();

// Subscribe to trade updates
await webSocket.SubscribeTradeAsync("BTCUSDT", trade =>
{
    Console.WriteLine($"Trade: {trade.Price} x {trade.Quantity}");
});

// Subscribe to buy depth
await webSocket.SubscribeBuyDepthAsync("BTCUSDT", depth =>
{
    Console.WriteLine($"Buy Depth: {depth.Entries.Count} entries");
});

// Subscribe to sell depth
await webSocket.SubscribeSellDepthAsync("BTCUSDT", depth =>
{
    Console.WriteLine($"Sell Depth: {depth.Entries.Count} entries");
});

// Cleanup
client.Dispose();

API Reference

Market Service

Account Service

Order Service

OTC Service

WebSocket Service

Error Handling

All API methods return an ApiResponse<T> object with the following structure:

public class ApiResponse<T>
{
    public bool Success { get; set; }
    public string? Message { get; set; }
    public T? Result { get; set; }
    public int? ErrorCode { get; set; }
}

Example error handling:

var response = await client.Markets.GetMarketsAsync();
if (!response.Success)
{
    Console.WriteLine($"Error: {response.Message}");
    Console.WriteLine($"Error Code: {response.ErrorCode}");
}
else if (response.Result != null)
{
    // Process successful response
}

Requirements

• .NET 9.0 or higher
• SocketIOClient 3.1.0 (for WebSocket support)

Support

For issues, questions, or contributions, please open an issue on GitHub.

Disclaimer

This library is not officially affiliated with Wallex. Use at your own risk. Always test thoroughly before using in production.