CCXT.NET Cryptocurrency Exchange Trading Library

CCXT.NET is a unified API library for cryptocurrency exchange trading in .NET. Key features include:

• Unified API: Consistent method signatures across different exchanges.
• Market Data: Access to public data like tickers, order books, trades, and OHLCV.
• Account Management: Private access to balances, orders, and trades.
• Security: Built-in secure authentication handling for each exchange.
• Developer Experience: Strong typing with full IntelliSense support and async/await throughout.

When calling API methods, use the following standard parameter names to ensure consistency across different exchanges:

• base_name: Base currency (e.g., "BTC")
• quote_name: Quote currency (e.g., "USDT")
• currency_name: Single currency (e.g., "ETH")
• timeframe: Time period (e.g., "1h", "1d")
• since: Unix timestamp in milliseconds (long)
• limits: Number of results to return (int)
• sideType: Buy or Sell enum
• args: Dictionary<string, object> for exchange-specific parameters

To avoid being banned by exchanges, you must respect rate limits by calling ApiCallWait before making API requests. Use the appropriate TradeType based on the API category you are accessing:

• TradeType.Public: For public market data endpoints.
• TradeType.Private: For account management and transfer endpoints.
• TradeType.Trade: For order placement and management endpoints.

// Respect exchange rate limits
await ApiCallWait(TradeType.Public);  // For public API
await ApiCallWait(TradeType.Private); // For private API
await ApiCallWait(TradeType.Trade);   // For trade API

The repository is organized into source code, tests, samples, and documentation:

• src/: Main library source code.
  • exchanges/: Contains exchange implementations organized by {country_code}/{exchange}/.
    • {exchange}.cs: The main exchange client class.
    • private/: Private API implementations (e.g., balance.cs, transfer.cs).
    • public/: Public API implementations (e.g., ticker.cs, orderBook.cs).
    • trade/: Trading API implementations (e.g., order.cs, place.cs).
  • shared/: Shared components.
    • standard/: Standard interfaces (IXApiClient) and base classes (XApiClient).
    • types/: Type definitions.
• tests/: Test projects for private, public, and trade APIs.
• samples/: Sample applications for demonstrating usage.
• docs/: Documentation files.
• scripts/: Build and deployment scripts.

The library supports 120 exchanges. Exchanges are categorized into two implementation states:

• Fully Implemented (🟢): Complete API implementation with full testing (e.g., Binance, Bitfinex, Kraken, OKEX).
• Basic Implementation (🟡): Basic structure is implemented, but full API integration is pending (e.g., Coinbase, OKX, KuCoin, Bybit).

All API methods in CCXT.NET must follow a specific return pattern. They must return ValueTask<ApiResult<T>>, where ApiResult<T> wraps the actual result T with success or error information. This allows for consistent error handling across all exchange implementations.

// Example of the expected return pattern
public async ValueTask<ApiResult<Ticker>> FetchTickerAsync(string base_name, string quote_name)
{
    var _result = new Ticker(base_name, quote_name);
    
    try
    {
        // ... API logic ...
        return _result.SetResult(_parsedResponse);
    }
    catch (Exception ex)
    {
        return _result.SetError(ex.Message);
    }
}

To publish the CCXT.NET package to NuGet.org, you must first ensure you have the .NET SDK installed and a valid NuGet API key with 'Push' permissions. You can use several methods to trigger the publication process from the project root.

### Method 1: Using Batch File (Simplest)
1. Navigate to the `scripts` folder
2. Double-click `publish-nuget.bat`
3. Enter your NuGet API key when prompted
4. Confirm publication

To contribute to CCXT.NET, you need to set up a local development environment.

Prerequisites

• .NET SDK 8.0 or 9.0
• Visual Studio 2022 or VS Code (with C# extension)
• Git
• PowerShell (Windows) or bash (Linux/Mac)

Initial Setup Steps

1. Fork the repository to your GitHub account.
2. Clone your fork and navigate to the directory.
3. Add the original repository as an upstream remote to keep your fork in sync.
4. Restore dependencies, build the project, and run tests to ensure a clean state.

# Clone your fork
git clone https://github.com/YOUR_USERNAME/ccxt.net.git
cd ccxt.net

# Add upstream remote
git remote add upstream https://github.com/odinsoft-lab/ccxt.net.git

# Install dependencies and build
dotnet restore
dotnet build

# Run tests
dotnet test

Instead of passing the API key as a parameter, you can set the NUGET_API_KEY environment variable in your PowerShell session and then run the script without arguments.

# Set API key in environment
$env:NUGET_API_KEY = "YOUR_API_KEY_HERE"

# Run without parameters (from project root)
.\scripts\publish-nuget.ps1

To use CCXT.NET, import the specific exchange namespace (e.g., CCXT.NET.Binance). You can create a client for public market data or a private client for account management using API keys. All operations are asynchronous and support await.

using CCXT.NET.Binance;

// Create client for public API
var publicClient = new BinanceClient("public");

// Get ticker
var ticker = await publicClient.FetchTickerAsync("BTC/USDT");
Console.WriteLine($"BTC/USDT Price: ${ticker.result.close}");

// Create client for private API (requires API keys)
var privateClient = new BinanceClient("private", "YOUR_API_KEY", "YOUR_SECRET_KEY");

// Get account balance
var balance = await privateClient.FetchBalanceAsync();

You can install CCXT.NET using NuGet, the .NET CLI, or by cloning the repository. The library is compatible with .NET 8.0 and 9.0.

# Package Manager Console
Install-Package CCXT.NET -Version 1.5.3

# .NET CLI
dotnet add package CCXT.NET --version 1.5.3

# PackageReference
<PackageReference Include="CCXT.NET" Version="1.5.3" />