Forem: Whale's Secret

Trading Bot in C# — Part 8 — Account Balance

Whale's Secret — Wed, 06 Aug 2025 18:31:48 +0000

In the previous blog post, we explained how to retrieve past trades and orders. This article will focus on account asset balances.

Introduction

When you sign up for an account on Binance, KuCoin, or any other exchange, you usually gain access to an asset overview page that displays your asset holdings.

The overview is valuable for tracking your holdings and their overall value.

In this series, we have emphasized that trading requires some discipline and effort. Similarly, your exchange account settings require your attention. Specifically, it's important to take account security measures seriously to avoid needless risk of losing funds. Better safe than sorry!

Account Security

Today, exchanges provide many security features, including:

Password strength — Exchanges tell you how strong your password is. A password manager can generate a random password of arbitrary length that you don’t have to remember. Go for it.
Withdrawals whitelist — With this feature on, your funds can be withdrawn from your exchange account but only to pre-selected wallet addresses which are owned by you.
API key permissions — An API key can be typically assigned multiple permissions like the ability to create an order, cancel an order, etc. There are two important settings. First, do not allow your API keys to withdraw funds from your exchange account unless you plan to use it. Secondly, do allow your API key to be restricted to only your IP addresses, if possible. The following screenshot shows the feature on the KuCoin exchange:

API keys IP address restrictions on KuCoin

Two-factor authentication (2FA) — Accessing an account used to be a combination of username and password in the old days. Today, with 2FA, you can sign in in the same way but an additional piece of information is required — a code you can obtain from your phone or hardware token. In a nutshell, your account cannot be accessed without your phone or hardware token. That’s the second factor.

Is 2FA all I need? For the most part, yes. However, no measure is bullet proof and multi-factor authentication is the same. For instance, there is the nefarious SIM swapping attack where fraudsters target wealthy individuals and convince their phone providers to port their phone numbers to their own devices in order to access bank accounts or cryptocurrency exchange accounts by receiving SMS codes required for accessing the accounts. These incidents can result in significant losses. Recently, a sentencing was issued in a case involving Michael Terpin who lost $20 million.

There's no need to worry; the intention is to encourage you to think about your account security. Exchanges have made significant advancements over the last few years, and their security measures are often comparable to those of traditional bank accounts.

This leads us to the main focus of this article: automated monitoring of your assets holdings. This approach can be viewed as an additional security measure or, more commonly, as a means to track the performance of your portfolio.

API

ScriptApiLib allows to retrieve up-to-date account asset balances using the GetLatestExchangeAccountInformation method:

ExchangeAccountInformation info = client.GetLatestExchangeAccountInformation();
Print("Assets:");

foreach ((string symbol, AccountSymbolInformation asi) in info.SymbolsInformation)
{
    Print($"* {symbol}: {asi.AvailableBalance} / {asi.TotalBalance}");
}

The sample output of the snippet may be like this:

[2025-07-15 10:20:35] Assets (available balance / total balance):
[2025-07-15 10:20:35] * BTC: 0.01 / 0.01
[2025-07-15 10:20:35] * LTC: 0.5 / 0.5
[2025-07-15 10:20:35] * USD: 25 / 30

You may notice that only 25 USD s available from the total of 30 USD. That's because 5 USD is, so called, frozen because an order with the value of 5 USD was placed but the order was not yet executed.

While having balance for each asset is useful, many people like to know the total value in a specific currency, such as dollars, to get similar output as KuCoin provides on their asset overview page. Public CoinGecko API can help us compute such value:

decimal totalValue = await ConvertAsync(info);
Print($"Total value is {totalValue} USD.");

/// <summary>
/// Compute value of assets in USD using CoinGecko's simple price API.
/// </summary>
/// <seealso href="https://docs.coingecko.com/v3.0.1/reference/simple-price"/>
/// <example>https://api.coingecko.com/api/v3/simple/price?symbols=btc,ltc&vs_currencies=usd</example>
static async Task<decimal> ConvertAsync(ExchangeAccountInformation info)
{
  string symbols = string.Join(',', info.SymbolsInformation.Keys);

  using HttpClient httpClient = new();
  using HttpResponseMessage response = await httpClient
    .GetAsync($"https://api.coingecko.com/api/v3/simple/price?symbols={symbols}&vs_currencies=usd");
  var data = await response.Content.ReadFromJsonAsync<Dictionary<string, Dictionary<string, decimal>>>();
  if (data is null)
  {
    Print("Failed to retrieve exchange-rate data from CoinGecko.");
    return -1;
  }

  decimal usdValue = 0;

  foreach (string coin in info.SymbolsInformation.Keys)
  {
    if (data.TryGetValue(coin.ToLowerInvariant(), out var dict) && dict.TryGetValue("usd", out decimal rate))
    {
        usdValue += rate * info.SymbolsInformation[coin].TotalBalance;
    }
    else Print($"No USD value found for '{coin}' asset.");
  }

  return usdValue;
}

With this method, the output of our sample now contains one more line:

[2025-07-15 10:20:35] Total value is 1247 USD.

Depending on your needs, account monitoring can be strictly time-based (check account every N hours) or more detailed, tracking every single change. GetNewerExchangeAccountInformationAsync comes to the rescue:

int i = 0;
while (true)
{
    i++;
    ExchangeAccountInformation info = await client.GetNewerExchangeAccountInformationAsync();
    Print($"Report #{i} (available balance / total balance):");

    foreach ((string symbol, AccountSymbolInformation asi) in info.SymbolsInformation)
    {
        Print($"* {symbol}: {asi.AvailableBalance} / {asi.TotalBalance}");
    }
}

Now it's easy to demonstrate the concept of a frozen balance. You can just place an order and observe the outcome.

[2025-07-17 10:00:00] Connected to KuCoin.
[2025-07-17 10:00:00] Report #1 (available balance / total balance):
[2025-07-17 10:00:00] * BTC: 0.001 / 0.001
[2025-07-17 10:00:00] * USDT: 50 / 50

// At this point, a new order to buy 5 USDT worth of bitcoin was placed.

[2025-07-17 10:00:15] Report #2 (available balance / total balance):
[2025-07-17 10:00:15] * BTC: 0.001 / 0.001
[2025-07-17 10:00:15] * USDT: 45 / 50

Conclusion

In this blog post, we presented API for retrieving and monitoring of account asset balances in ScriptApiLib, allowing users to understand how their portfolios change value over time. Next time, we will discuss budgeting for your trading strategies.

Disclaimer: The information provided in this blog post should not be considered financial advice. Always conduct your own research and consider your personal circumstances before acting on any financial information.

Trading Bot in C# — Part 7— Getting Trade History

Whale's Secret — Wed, 06 Aug 2025 08:53:10 +0000

In the previous blog post, we discussed reconnecting strategies to deal with network issues. This article will offer an opportunity to take a look at your past orders trades.

First, let’s clarify what we mean by “trade.” A trade refers to an event in which the order book matching engine pairs your order with another one. In other words, a trade represents either a partial or a full fill of an order.

Motivation

It’s easy to get caught up in current or upcoming trading opportunities for profit. However, failing to reflect on past experiences can lead to repeated mistakes. Just like in other areas, learning from previous errors is crucial in trading as well.

What insights can your past trades reveal? More frequently than one might expect, they reveal a tendency to deviate from one’s trading strategy due to a lack of discipline. An effective trading strategy minimizes the risk of losing capital; therefore, if your trading data suggests that you do not adhere to it, the risk increases, leading to additional stress. For example, traders might place both a take-profit order and a stop-loss order simultaneously to ensure they either secure a profit or incur only a small loss. However, even institutional traders occasionally overlook risk management rules. A notable example occurred at the French bank Société Générale in 2007 and 2008, when Mr. Jérôme Kerviel incurred a loss of €4.9 billion for the bank by taking on large unauthorized directional positions without the necessary hedging that was required by the company.

Time and time again, many individuals — even very intelligent and experienced ones — slowly start believing that they finally fully grasp the market’s behavior and can accurately predict future price movements. They deviate from their strategy by making high-risk trades, often resulting in swift consequences.

“My biggest losses have always followed my largest profits.” (Martin Schwartz)

Certain aspects of “being human” can be addressed by implementing the trading strategy in Whale’s Secret ScriptApiLib. Each such strategy runs on a machine, thus it is not prone to experiencing fatigue, becoming emotional, or diverting from strategy rules.

While learning from the past is important, there are more practical reasons for retrieving one’s past trades: taxes. Governments worldwide have intensified their regulations regarding cryptocurrencies, and one key aspect of this is how cryptocurrencies should be taxed. At first glance, this may seem unusual, as currencies are not typically subject to taxation. However, tax authorities do not view cryptocurrencies, such as Bitcoin, as traditional fiat currencies. Instead, crypto currencies are typically classified as either property or commodities. Additionally, tokens offered in an Initial Coin Offering (ICO), or similar schemes, may be categorized as securities.

Why do we bring up this seemingly dull information? The answer is straightforward. Depending on your tax residency, each trade could be considered a taxable event. Therefore, it’s important to keep track of all your trades to accurately calculate your taxes.

API

ScriptApiLib allows to retrieve historical trades using the GetTradesAsync method. We might want to retrieve yesterday’s trades:

ITradeApiClient client = await scriptApi.ConnectAsync(ExchangeMarket.KucoinSpot);
Print("Connected to KuCoin.");

// Suppose, we are interested in trades that were executed yesterday.
DateOnly yesterdayDate = DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-1);

IReadOnlyList<ITrade> trades = await client.GetTradesAsync(yesterdayDate);
Print($"For {yesterdayDate}, there were {trades.Count} trades:");

foreach (ITrade trade in trades)
{
    Print($"* {trade}");
}

The sample output is:

[09:00:11] Connected to KuCoin.
[09:00:11] For 2025-06-10, there were 2 trades:
[09:00:11] #1: [SymbolPair=`BTC/USDT`,Side=Sell,ExchangeOrderId=`o-6847ffb88c21700007fc1510`,TradeId=`15542552101404673`,Timestamp=06/10/2025 09:49:44,Price=109355.5,BaseQuantity=0.00004686,QuoteQuantity=5.12439873,CommissionAmount=0.00512439873,CommissionAsset=`USDT`,IsMaker=False]
[09:00:11] #2: [SymbolPair=`BTC/USDT`,Side=Buy,ExchangeOrderId=`o-6848003f759520000728a118`,TradeId=`15542582918397953`,Timestamp=06/10/2025 09:51:59,Price=109376.7,BaseQuantity=0.00004571,QuoteQuantity=4.999608957,CommissionAmount=0.004999608957,CommissionAsset=`USDT`,IsMaker=False]

The GetTradesAsync method retrieves trades for a specific date, as exchanges generally offer API to handle it with just one exchange API request. Additionally, GetTradesAsync method caches the data, making subsequent calls to the method more efficient.

In the earlier code example, we retrieved KuCoin’s trades. Unsurprisingly, ScriptApiLib offers the same API for Binance as well. However, there’s a significant caveat to consider. Typically, one wants to get trades for a certain time period. Generally, when getting trades for a specific time frame, Binance allows you to retrieve them, but only for one symbol at a time (e.g., BTC/USDT). This limitation makes obtaining a comprehensive trading history from Binance quite challenging. ScriptApiLib handles the limitation by introducing a set of heuristics to mitigate the issue.

Filtering Options

ScriptApiLib also provides a basic filtering API. For example, you might want to fetch only buy-limit orders for a specific date:

TradeFilterOptions options = new() 
{ 
    TradeSide = OrderSide.Buy,
    OrderTypes = new HashSet<OrderType>() { OrderType.Limit }
};

IReadOnlyList<ITrade> trades = await client.GetTradesAsync(date, options);

Please note that for purposes of data mining, we recommend to download trades and feed them into a database. This approach gives you full expressive power to analyze your trades, calculate statistics, etc.

Historical Orders

If you take a closer look at the ITrade type, you may notice that the properties of the corresponding order are not directly included; instead, they are accessed through the ITrade.Order property. It is worthwhile to take a moment to understand the relationship between historical orders and historical trades.

A typical exchange offers an API endpoint to access historical trades for a specific time period, as well as another endpoint for historical orders within the same time frame. But there is a caveat that makes things harder: An order can be created at a certain day and filled on the following day or any subsequent day. In practice, we cannot determine when an order was created based on a trade, so we need to rely on heuristics to provide data quickly and to save API requests as well.

As ScriptApiLib does the heavy-lifting, you can achieve your task by writing a few lines of code:

IReadOnlyList<ITrade> trades = await client.GetTradesAsync(yesterdayDate);
Print($"For {yesterdayDate}, there were {trades.Count} orders:");

foreach (ITrade trade in trades)
{
    Print($"Trade {trade.TradeId} belongs to order '{trade.Order}'.");
}

However, if you need just to retrieve historical orders, the API is straightforward again:

DateOnly yesterdayDate = DateOnly.FromDateTime(DateTime.UtcNow).AddDays(-1);
IReadOnlyList<IOrder> orders = await client.GetOrdersAsync(yesterdayDate);
Print($"For {yesterdayDate}, there were {orders.Count} orders:");

foreach (IOrder order in orders)
{
    Print($"* {order}");
}

Conclusion

In this blog post, we presented API for retrieving historical orders and trades in ScriptApiLib, allowing users to reflect on past successes or failures, as well as to prepare data for tax reporting purposes. Next time, we will discuss how to access and work with account balance data.

Trading Bot in C# — Part 6— Reconnecting Strategies

Whale's Secret — Sun, 13 Jul 2025 11:52:04 +0000

The previous blog post covered order canceling and how to retrieve active orders. This time, we will discuss how to react to exchange service disruptions.

Motivation

If you are serious about algorithmic trading, you need to think about various outages as they are inevitable in practice. Even if your trading strategy appears solid on paper, it’s common for a strategy that seems profitable in theory to underperform in real-world conditions.

Failing to take into account that each exchange can sometimes enter a maintenance mode — to release new features, resolve bugs, upgrade systems, etc. — can lead to significant financial consequences. Under this circumstance, trading is halted on the exchange while participants on other exchanges continue to trade, impacting asset prices. For instance, if you hold a position, you might face a loss if you cannot close the position in a timely manner.

In our experience, however, network issues are more prevalent than exchange issues. Networks typically do not provide stability guarantees, and your connection to an exchange can potentially be disrupted literally at any moment. So you may encounter the following scenarios:

Your API request won’t reach its target exchange server. Thus, for example, you may fail to cancel an existing order.
Your API request reaches the target server but the response won’t be received. In this case, you can create an order but not know about it.
Your API request can reach the target sever much later than expected. For a market order, this typically means that your order execution price may differ from your expectation.

These issues are not to be taken lightly. ScriptApiLib does its best to recover from such situations, and it is certainly not trivial to do so.

Controlling Internet Access

To demonstrate the connection strategies provided by ScriptApiLib, you need to be able to disconnect your Internet connection. This can be done manually through your operating system or by using a command-line command. On Windows, one can turn off and turn on Wi-Fi using these simple commands in PowerShell or using the command prompt (i.e. cmd.exe):

// sudo requires Windows 11, version 24H2 or higher. See https://learn.microsoft.com/en-us/windows/sudo/.
// Check out "netsh interface show interface" if your Wi-Fi is called "Wi-Fi".
sudo netsh interface set interface name="Wi-Fi" admin=DISABLED
sudo netsh interface set interface name="Wi-Fi" admin=ENABLED

Monitoring Connection Status

Having learned how to manage Internet access, we can effortlessly simulate our trading bot experiencing disconnections and subsequent reconnections. ScriptApiLib provides the ability to specify callbacks in ConnectionOptions that are called whenever we lose connection to the exchange or successfully reconnect. These callbacks are OnConnectedDelegateAsync and OnDisconnectedDelegateAsync:

ConnectionOptions connectionOptions = new(ConnectionType.FullTrading, 
    onConnectedAsync: OnConnectedAsync,        // <-- IMPORTANT.
    onDisconnectedAsync: OnDisconnectedAsync); // <-- IMPORTANT.
ITradeApiClient client = await scriptApi.ConnectAsync(ExchangeMarket.BinanceSpot, connectionOptions);
Print("Connected to Binance sandbox.");

// Use: sudo netsh interface set interface name="Wi-Fi" admin=DISABLED
Print("Waiting 60 seconds for you to make sure your machine is offline.");
await Task.Delay(60_000);

// Use: sudo netsh interface set interface name="Wi-Fi" admin=ENABLE
Print("Waiting 120 seconds for you to make sure your machine is online.");
await Task.Delay(120_000);

Task OnConnectedAsync(ITradeApiClient tradeApiClient)
{
    Print("Connected again.");
    return Task.CompletedTask;
}

Task OnDisconnectedAsync(ITradeApiClient tradeApiClient)
{
    Print("Disconnected.");
    return Task.CompletedTask;
}

The output of the sample is as follows:

[08:20:15.907] Connected to Binance sandbox.
[08:20:15.908] Waiting 60 seconds for you to make sure your machine is offline.
[08:20:18.295] Disconnected.
[08:21:15.919] Waiting 120 seconds for you to make sure your machine is online.
[08:22:22.267] Connected again.

Please note that “Connected again.” is not printed right after we get connected for the first time, only on subsequent re-connections. This is a feature, not a bug.

You might observe that disconnections and re-connections are not detected right away. This is a typical characteristic of networking protocols, such as TCP/IP, and it is a consequence of the inherent unreliability of networks as a fundamental design principle.

Disconnection Handling Strategies

ScriptApiLib currently provides two connection strategies that influence its behavior when it is directed to execute an action that requires exchange data or API access. Let’s explore these strategies in detail.

Strategy: Fail Instantly If Not Connected

The first strategy is FailInstantlyIfNotConnected and it behaves in the following fashion:

When the connection to the exchange is active, all exchange API requests are handled as usual.
If the connection to the exchange is lost and a new API request is sent to the exchange, the request will fail immediately, resulting in a NotConnectedException being thrown.

Instead of NotConnectedException, you may get OperationFailedException which is thrown when the connection is lost, but the library has not yet recognized it as disconnected.

The following sample demonstrates the connection strategy by intentionally causing the connection to be lost and then attempting to place a market order:

// Use the FailInstantlyIfNotConnected connection strategy.
ConnectionOptions connectionOptions = new(FailInstantlyIfNotConnected.Instance, 
    onConnectedAsync: OnConnectedAsync, 
    onDisconnectedAsync: OnDisconnectedAsync);
ITradeApiClient client = await scriptApi.ConnectAsync(ExchangeMarket.BinanceSpot, connectionOptions);
Print("Connected to Binance sandbox.");

// Use: sudo netsh interface set interface name="Wi-Fi" admin=DISABLED
Print("Waiting 60 seconds for you to make sure your machine is offline.");
await Task.Delay(60_000);

try
{
    Print("Attempt to create a market order while disconnected.");
    await client.CreateMarketOrderAsync(SymbolPair.BTC_EUR, OrderSide.Buy, size: 0.0001m);

    throw new SanityCheckException("Should not be called.");
}
catch (NotConnectedException)
{
    Print($"{nameof(NotConnectedException)} was thrown as expected!");
}

try
{
    // Similarly, getting open orders will throw the same exception, even
    // though the method is querying a local storage and does not send an
    // explicit API request to Binance. The issue is that "not being online
    // could lead to returning wrong data".
    Print("Attempt to retrieve all open orders while disconnected.");
    IReadOnlyList<ILiveOrder> openOrders = await client.GetOpenOrdersAsync();

    throw new SanityCheckException("Should not be called.");
}
catch (NotConnectedException)
{
    Print($"{nameof(NotConnectedException)} was thrown as expected!");
}

Task OnConnectedAsync(ITradeApiClient tradeApiClient)
{
    Print("Connected again.");
    return Task.CompletedTask;
}

Task OnDisconnectedAsync(ITradeApiClient tradeApiClient)
{
    Print("Disconnected.");
    return Task.CompletedTask;
}

// Use: sudo netsh interface set interface name="Wi-Fi" admin=ENABLED
Print("The demonstration is over. You can re-enable your Internet access.");

The sample output is:

[08:06:10.926] Connected to Binance sandbox.

[08:06:10.927] Waiting 60 seconds for you to make sure your machine is offline.
[08:06:58.606] Disconnected.
[08:07:10.936] Attempt to create a market order while disconnected.
[08:07:10.946] NotConnectedException was thrown as expected!

[08:07:10.946] Attempt to retrieve all open orders while disconnected.
[08:07:10.949] NotConnectedException was thrown as expected!

Please note that NotConnectedException is intentionally thrown even when one queries the local storage of open orders by calling GetOpenOrdersAsync. This is a precautionary measure to prevent retrieving an active order set that may have changed since we lost our connection.

Strategy: Block Until Reconnected Or Timeout

Now, let’s discuss the BlockUntilReconnectedOrTimeout strategy, which requires a parameter known as PreRequestTimeout and operates as follows:

When there is an active connection to the exchange, then all exchange API requests are processed normally.
If the connection to the exchange is lost and a new API request is sent to the exchange, NotConnectedException is thrown only if the PreRequestTimeout elapses without establishing a new exchange connection to the exchange. If a new connection is established before PreRequestTimeout elapses, the API request will be sent at that time.

Tip: If you can tolerate arbitrary long disconnections, you can use BlockUntilReconnectedOrTimeout.InfinityTimeoutInstance and thus avoid NotConnectedException exceptions.

The following sample simulates a straightforward scenario:

Connect to Binance,
disconnect from the Internet,
ask to place a limit order and quickly make sure to re-connect.

Utilizing BlockUntilReconnectedOrTimeout makes sure that such a limit order is actually placed:

// Use the BlockUntilReconnectedOrTimeout connection strategy.
BlockUntilReconnectedOrTimeout connectionStrategy = new(
    preRequestTimeout: TimeSpan.FromSeconds(60)); // <-- IMPORTANT.
ConnectionOptions connectionOptions = new(connectionStrategy, 
    onConnectedAsync: OnConnectedAsync, 
    onDisconnectedAsync: OnDisconnectedAsync);
ITradeApiClient client = await scriptApi.ConnectAsync(ExchangeMarket.BinanceSpot, connectionOptions);
Print("Connected to Binance sandbox.");

// Subscribe BTC/EUR order book data.
IOrderBookSubscription subscription = await client.CreateOrderBookSubscriptionAsync(SymbolPair.BTC_EUR);

// Use: sudo netsh interface set interface name="Wi-Fi" admin=DISABLED
Print("Waiting 40 seconds for you to make sure your machine is offline.");
await Task.Delay(40_000);

Task<ILiveLimitOrder> createOrderTask = client.CreateLimitOrderAsync(SymbolPair.BTC_EUR, OrderSide.Buy, price: 90_000m, size: 0.0001m);
Task<OrderBook> orderBookTask = subscription.GetOrderBookAsync(CancellationToken.None);

// Use: sudo netsh interface set interface name="Wi-Fi" admin=ENABLE
Print("Make sure your machine is online. Waiting 60 seconds.");
await Task.Delay(60_000);

// The assumption is that we are connected again.
ILiveLimitOrder limitOrder = await createOrderTask;
Print($"Limit order '{limitOrder}' was placed!");

OrderBook orderBook = await orderBookTask;
Print("Received order book:");
Print(orderBook.ToFullString());

The sample output is:

[10:29:42] Connected to Binance sandbox.
[10:29:43] Waiting 10 seconds for you to make sure your machine is offline.
[10:30:23] Waiting 60 seconds for you to make sure your machine is online.
[10:31:23] Limit order '[ExchangeMarket=BinanceSpot,ClientOrderId=`FyWZLbhFUd`,ExchangeOrderId=`BTC/EUR-1101075`,OrderStatus=Accepted,CreateTime=05/15/2025 10:30:34,LastUpdateTime=05/15/2025 10:30:34,Size=0.0001,latestFillData=`[CumulativeSize=0,CumulativeAveragePrice=,LastSize=0,LastAveragePrice=,ImpliedFill=False,LastFee=,LastFeeSymbol=``]`,terminalEvent.IsSet=False]' was placed!
[10:31:23] Received order book:
[10:31:23] [ExchangeSymbolPair=`BinanceSpot@BTC/EUR`,LastUpdateId=2,LastUpdate=05/15/2025 10:30:15,Bids=[[Price=90994.70000000,Quantity=0.09902000],[Price=90985.31000000,Quantity=0.08991000],[Price=90985.30000000,Quantity=0.09183000],[Price=90978.57000000,Quantity=0.06123000],[Price=90978.46000000,Quantity=0.10355000],[Price=90975.01000000,Quantity=0.07717000],[Price=90974.43000000,Quantity=0.08717000],[Price=90974.42000000,Quantity=0.10047000],[Price=90974.34000000,Quantity=0.08948000],[Price=90971.16000000,Quantity=0.08569000],[Price=90971.15000000,Quantity=0.10537000],[Price=90970.49000000,Quantity=0.09229000],[Price=90969.47000000,Quantity=0.08283000],[Price=90967.79000000,Quantity=0.08828000],[Price=90966.18000000,Quantity=0.08025000],[Price=90966.17000000,Quantity=0.07701000],[Price=90957.02000000,Quantity=0.08911000],[Price=89838.84000000,Quantity=0.00107000],[Price=88800.24000000,Quantity=0.00107000]],Asks=[[Price=90994.72000000,Quantity=0.05684000],[Price=90996.12000000,Quantity=0.08177000],[Price=90996.13000000,Quantity=0.07831000],[Price=90996.88000000,Quantity=0.08913000],[Price=90997.92000000,Quantity=0.10721000],[Price=90997.93000000,Quantity=0.08913000],[Price=90998.73000000,Quantity=0.08841000],[Price=90999.35000000,Quantity=0.07852000],[Price=91000.04000000,Quantity=0.09995000],[Price=91009.58000000,Quantity=0.08472000],[Price=91009.59000000,Quantity=0.08983000],[Price=91009.62000000,Quantity=0.08181000],[Price=91009.65000000,Quantity=0.08055000],[Price=91010.16000000,Quantity=0.07703000],[Price=91010.64000000,Quantity=0.10356000],[Price=91012.50000000,Quantity=0.08906000],[Price=91014.96000000,Quantity=0.09482000],[Price=91029.94000000,Quantity=0.08355000],[Price=91085.89000000,Quantity=0.07762000],[Price=91226.00000000,Quantity=0.08238000],[Price=93055.27000000,Quantity=0.00538000],[Price=93091.91000000,Quantity=0.00269000],[Price=93113.84000000,Quantity=0.00538000],[Price=93135.84000000,Quantity=0.00269000],[Price=93137.97000000,Quantity=0.00269000],[Price=93137.99000000,Quantity=0.00269000],[Price=93204.52000000,Quantity=0.00268000],[Price=93218.30000000,Quantity=0.00268000],[Price=93305.45000000,Quantity=0.00268000],[Price=93311.94000000,Quantity=0.00804000],[Price=93314.06000000,Quantity=0.00268000],[Price=93332.73000000,Quantity=0.00268000],[Price=93376.75000000,Quantity=0.00268000],[Price=93377.20000000,Quantity=0.00268000],[Price=93378.17000000,Quantity=0.00268000],[Price=93380.97000000,Quantity=0.00268000],[Price=93382.44000000,Quantity=0.00268000],[Price=93385.24000000,Quantity=0.00268000],[Price=93388.57000000,Quantity=0.00268000],[Price=93391.98000000,Quantity=0.00268000],[Price=93402.55000000,Quantity=0.00268000],[Price=93408.69000000,Quantity=0.00268000],[Price=93409.37000000,Quantity=0.00268000],[Price=93420.39000000,Quantity=0.00268000],[Price=93451.37000000,Quantity=0.00268000],[Price=93452.12000000,Quantity=0.00268000],[Price=93454.88000000,Quantity=0.00268000],[Price=93458.53000000,Quantity=0.00268000],[Price=93461.76000000,Quantity=0.00268000],[Price=93539.44000000,Quantity=0.00268000],[Price=93551.87000000,Quantity=0.00536000],[Price=93551.90000000,Quantity=0.00268000],[Price=93589.42000000,Quantity=0.00267000],[Price=93671.22000000,Quantity=0.00267000],[Price=93672.06000000,Quantity=0.00267000],[Price=93687.08000000,Quantity=0.00801000],[Price=93697.54000000,Quantity=0.00267000],[Price=93703.35000000,Quantity=0.00267000],[Price=93707.05000000,Quantity=0.00267000],[Price=93733.08000000,Quantity=0.00267000],[Price=93993.24000000,Quantity=0.00107000],[Price=94018.57000000,Quantity=0.00263000],[Price=94058.12000000,Quantity=0.00263000],[Price=94286.39000000,Quantity=0.00019000],[Price=94784.11000000,Quantity=0.00264000],[Price=94818.67000000,Quantity=0.00264000],[Price=94826.79000000,Quantity=0.00264000],[Price=95031.84000000,Quantity=0.00107000],[Price=96070.44000000,Quantity=0.00107000],[Price=97109.04000000,Quantity=0.00107000],[Price=98147.64000000,Quantity=0.00107000],[Price=99025.82000000,Quantity=0.00109000],[Price=103055.02000000,Quantity=0.01070000]]]

So even though our connection was disconnected, ScriptApiLib waited for a re-connection and then it sent the order request. Moreover, BTC/EUR subscription was lost during the first disconnection, but it was re-subscribed and an order book snapshot was returned as expected. One word. Resiliency.

BlockUntilReconnectedOrTimeout is a connection strategy that requires special considerations. PreRequestTimeout can be set to, say, 60 seconds, and it is possible that during that 60 seconds, you may get re-connected multiple times. There is no danger in subscribing market data multiple times during one minute. However, we are very cautious with respect to creating orders and so we attempt to send a request to place an order always just once when BlockUntilReconnectedOrTimeout is utilized to avoid placing an order multiple times which could lead easily to financial losses.

Conclusion

In this blog post, we demonstrated two connection strategies which can help tune trading experience based on Internet connectivity. Next time, we will discuss retrieving of historical trades.

Trading Bot in C# — Part 5— Order Cancelling

Whale's Secret — Mon, 07 Jul 2025 00:55:13 +0000

In the previous blog post, we covered monitoring of order (partial) fills. In this article, we will expand our toolbox by discussing how to cancel orders and outlining the common issues one may face in the process.

Introduction

In trading, there is only a limited number of actions one can take. Actually, one typically just ask an exchange to create an order, or to cancel an existing order. So, when do people decide to cancel orders?

When a trading opportunity is missed, it makes sense to cancel an existing order and create a new one when another opportunity arises. A good example of this is a missed arbitrage opportunity, which typically exists only for a brief period of time before being taken advantage of by other traders.
People who execute orders manually often cancel orders that were placed due to fat-finger errors — that is when one mistypes the price or order size before submitting the order request.
… and of course when you feel like you are rich enough. :-)

Note that some exchanges attempt to help people avoid unwanted mistakes by allowing people to trade only in a band of prices, meaning you can buy and sell an asset but with a price that is, e.g., up to 10% higher or lower than the last price. This avoids you to buy bitcoin for $950,000 instead of intended $95,000. However, it can limit you, for instance, in profiting from a serious market crash.

While it is possible to cancel any type of order, in practice, canceling, e.g., market orders can be challenging since such orders can get filled right away. Therefore, this blog post will focus solely on cancelling of limit orders.

API for Order Cancelling

In line with the reasons for canceling an order, we can demonstrate the API by placing a limit order and then canceling it after two seconds:

// Make sure the price is greater than the current market price.
Print("Place a limit sell order to sell 0.00015 BTC @ 120,000 EUR.");
ILiveLimitOrder order = await client.CreateLimitOrderAsync(SymbolPair.BTC_EUR, 
    OrderSide.Sell, price: 120_000m, size: 0.00015m);

Print("Wait 2 seconds.");
await Task.Delay(2_000);

Print($"Cancel the order '{order.ExchangeOrderId}'.");
try 
{
    await client.CancelOrderAsync(order); // <--- Actually cancels the order.
}
catch (NotFoundException e)
{
    Print($"[!] {nameof(NotFoundException)}: {e.Message}");
}

Print($"Attempt to cancel the order '{order.ExchangeOrderId}' again.");
try
{    
    await client.CancelOrderAsync(order);
    throw new SanityCheckException("No, no, no. This exception should not be thrown.");
}
catch (NotFoundException e)
{
    Print($"[!] {nameof(NotFoundException)}: {e.Message}");
}

The sample output is as follows:

[2025-04-04 10:24:35.701] Ready to trade!
[2025-04-04 10:24:35.705] Place a limit sell order to sell 0.00015 BTC @ 120,000 EUR.
[2025-04-04 10:24:36.548] Wait 2 seconds.
[2025-04-04 10:24:38.549] Cancel the order 'BTC/EUR-205382'.
[2025-04-04 10:24:38.876] Attempt to cancel the order 'BTC/EUR-205382' again.
[2025-04-04 10:24:38.935] [!] NotFoundException: Order 'BTC/EUR-205382'

You may be curious as to why the code listing consistently includes a try-catch block when calling ITradeApiClient.CancelOrderAsync(ILiveOrder order, /* ... */). The explanation is quite simple: in trading, factors like network delays and exchange processing times introduce latencies. Consequently, you may try to cancel an order only to discover that it has already been filled in the meantime. This situation occurs frequently in practice, making it essential to account for it.

Fortunately, we considered this scenario, so our app won’t crash, right? Unfortunately, that’s it’s not so easy. Another frequent source of business bugs arises from neglecting to check whether a canceled order was partially filled or not. The following sample demonstrates how to do it:

Print($"Cancel the order '{order.ExchangeOrderId}'.");
try 
{
    await client.CancelOrderAsync(order);
}
catch (NotFoundException e)
{
    Print($"[!] {nameof(NotFoundException)}: {e.Message}");
}

// At this stage, the possible outcomes for the order are:
// * The order is canceled.
// * The order is canceled and partially filled
// * The order is fully filled.
decimal filledSize = order.LatestFillData.CumulativeSize;

if (filledSize > 0)
    Print($"The order '{order.ExchangeOrderId}' was partially filled {filledSize}.");

Always check the filled size of your orders!

Existing Orders

There are situations where you might need to cancel an order that was placed prior to launching your trading application. In these instances, you first need to obtain an instance of ILiveLimitOrder. The ITradeApiClient interface includes a method for retrieving all open orders:

IReadOnlyList<ILiveOrder> orders = await client.GetOpenOrdersAsync(OrderFilterOptions.AllOrders);
Print($"There are {orders.Count} open order(s).");

// Now we can, for example, print when the orders were created, or we can 
// cancel the orders one by one, etc.
foreach (ILiveOrder o in orders)
    Print($"Order '{o.ExchangeOrderId}' was created at {o.CreateTime} UTC.");

Please note that ScriptApiLib utilizes Coordinated Universal Time (UTC) for reporting dates and times to eliminate any confusion caused by time zones.

You might be reluctant to call client.GetOpenOrdersAsync(..) multiple times in order to manage your API rate limits effectively, but there’s no need for that concern. The method is designed to be efficient, as ScriptApiLib locally stores open orders and monitors any changes. Therefore, you can call the method as often as you wish without affecting your ability to create new orders, etc.

Bulk Order Cancellation

Cancelling orders one by one is not efficient if you want to cancel all orders quickly. Naturally, ITradeApiClientprovides a method for this exact use case — CancelAllOrdersAsync.

await client.CancelAllOrdersAsync();

// The behavior can be verified in the following manner:
IReadOnlyList<ILiveOrder> orders = await client.GetOpenOrdersAsync(OrderFilterOptions.AllOrders);
Print($"There are {orders.Count} open order(s).");

Create an Order, Cancel an Order, and …?

In fact, there is a third action that exchanges frequently provide for order management via their APIs: the ability to modify an existing order.

It’s important to note that while exchanges typically provide some form of API for order modifications, these capabilities are often limited. The reason for this is order execution performance and fairness. Exchanges aim to deliver peak performance for their users, which involves minimizing latency in order processing. Consequently, it can be understood that the more fixed or immutable the orders are, the easier and quicker it becomes for the matching engine to maintain faster processing.

It is worth looking at the problem from a different angle: modifying an existing order can be effectively simulated by canceling the current order and placing a new one. This may seem unusual, but for instance, the KuCoin exchange utilizes this method by providing a single API endpoint that internally performs exactly this — cancels the existing order and creates a new one. The advantage for users is that this approach reduces network latency compared to making two separate API requests.

Is it fair to modify an existing order? For instance, allowing increases in order sizes may not be fair. This is because order matching engines typically operate on a “first come, first served” basis. A trader aiming to have their orders at the top of the book might place numerous small orders and later inflate them as necessary, potentially securing better execution prices than they would achieve by canceling and re-entering orders.

Conclusion

In this blog post, we described how orders can be canceled using Whale’s Secret ScriptApiLib API. Moreover, we demonstrated API for listing currently open orders. Next time, we will discuss reconnecting strategies and their behavior.

Trading Bot in C# — Part 4— Order Fills

Whale's Secret — Sun, 29 Jun 2025 09:53:37 +0000

The previous blog post covered how to place orders on the Binance Testnet. Additionally, we enhanced our trading bot to execute orders based on RSI signals. In this article, we will take a deeper dive into the topic of orders by showcasing how to monitor the individual fills of our trades.

How are Exchange Orders Processed Behind The Scenes?

If you are familiar with exchange order processing, you can skip this section.

We have previously discussed order books and noted that they generally offer some form of aggregated data regarding the bids and asks from other trading participants. However, how do exchanges handle order requests behind the scenes? The fundamental process for managing order requests by exchanges is as follows:

**Validate common order limits. **Each exchange aims to create a level playing field where participants can trade while also generating profit for the exchange. To achieve this, various limits and rules are implemented (as seen in Binance’s filters). If an order request does not satisfy all exchange rules and limits, the exchange will reject the order request, preventing it from being added to the actual order book. For instance, a request to buy 1 satoshi (0.00000001 BTC) would be rejected by Binance and many other exchanges. Exchanges depend on fees for their revenue, and the profit from a 1-satoshi order is so minimal that there is no economic incentive to accommodate such small amounts.
**Specific order restrictions. **Recently, European Union (EU) introduced a new policy regarding stable coins that requires greater transparency, and as a consequence Binance removed some stablecoins for European customers. So if you are a resident of the EU and try to place an order request with the BTC/USDT symbol, the request will be rejected. This example illustrates that exchange accounts may have different limitations, especially due to jurisdictions. Another example is that submitting an excessive number of bids or asks to an order book is not permitted, as this would create an unfair advantage over other participants and increase the operational costs for the exchange. Unfortunately, there are many reasons why your order request can be rejected and the requirements change in time. However, if your intentions are good, you are mostly fine.
**The order is accepted into the order book. **After the order request is fully validated, the order is placed in the order book where the order waits until the order matching engine can pair the order with another order (or orders) to execute the order and thus produce a trade or a set of trades.
**The order is either filled or canceled. **The lifetime of each order ends when the order is either fully filled (i.e. when the order matching engine finds a sufficient number of orders to pair it with to fully execute the order), or when the order is canceled by the person who placed it.

Order matching engine

The most exciting moment is when “The order is accepted into the order book.” which occurs after an order request is fully validated and it enters the order book. Let’s demonstrate it on a new market order to buy 0.02 BTC when the BTC/EUR order book is in this state:

The order matching engine takes your buy order and searches for asks with which your order can be matched with. The best ask offers 0.00001 BTC @ 75743.23 EUR, which is insufficient to fulfill the size of your market order — i.e. 0.02 BTC. The matching engine then finds another ask 0.01200 BTC @ 75752.28 EUR. Together, these two asks cover only 0.01201 out of 0.02 BTC needed. Therefore, the third-best ask (0.01170 BTC @ 75752.35 EUR) must also be considered.

In short, the first two asks are completely taken while the third one only partially because: 0.00001 + 0.01200 + 0.00799 = 0.02 BTC. Now how much will you pay for your 0.02 BTC? One can calculate it using weighted arithmetic mean and the result is about 75752.30 EUR.

By the way, did you notice the “trap” presented by the best ask? The idea is: Put a minuscule order before a real order in hopes of achieving a more favorable outcome. In this instance, there is a tiny order for 0.00001 BTC, and whoever decides to buy with a market order will consume this small order but more costly ones as well! While it is not always an actual trap, the effect remains the same for you — your trade might be executed for a worse average price than it appears at first sight.

Watching Order (Partial) Fills

As described, an order matching engine pairs orders together to generate trades. When an order is completely executed by matching it with another order, we refer to it as being filled. Each order execution smaller than the order size, we call a partial fill. However, it’s common for people to overlook this distinction.

If the concept is not entirely clear, code is worth a thousand words:

ILiveMarketOrder order = await client.CreateMarketOrderAsync(SymbolPair.BTC_EUR,
    OrderSide.Sell, size: 0.00015m);
Print($"Order '{order.ExchangeOrderId}' was created.");

// Wait until the order is fully filled.
IReadOnlyList<FillData> fills = await order.WaitForFillAsync();
Print($"Order '{order.ExchangeOrderId}' was fully filled.");

// Note that small orders are typically executed in just one fill.
foreach (FillData fill in fills)
    Print($"Fill: {fill}");

static void Print(string msg)
    => Console.WriteLine($"[{DateTime.UtcNow:yyyy-MM-dd HH:mm:ss.fff}] {msg}");

And sample output is

[2025-04-04 07:14:57.249] Order 'BTC/EUR-187593' was created.
[2025-04-04 07:14:57.250] Waiting for fills.
[2025-04-04 07:14:57.345] Fill: [CumulativeSize=0.00015,CumulativeAveragePrice=75430.51,LastSize=0.00015,LastAveragePrice=75430.51,ImpliedFill=False,LastFee=0,LastFeeSymbol=`BTC`]
[2025-04-04 07:14:57.346] Order 'BTC/EUR-187593' was FILLED'.

We can see that the order was executed immediately in a single full fill. The average price was 75430.51 EUR. It is noteworthy that the cumulative price and the last size are the same. However, that’s not always the case as the following listing for a buy market order of 0.1 BTC illustrates:

[2025-04-14 14:30:09.722] Ready to trade!
[2025-04-14 14:30:10.103] Order 'BTC/EUR-1556875' was created.
[2025-04-14 14:30:10.218] Fill: [CumulativeSize=0.04708,CumulativeAveragePrice=74952.93,LastSize=0.04708,LastAveragePrice=74952.93,ImpliedFill=False,LastFee=0,LastFeeSymbol=`BTC`]
[2025-04-14 14:30:10.218] Fill: [CumulativeSize=0.1,CumulativeAveragePrice=74958.465432,LastSize=0.05292,LastAveragePrice=74963.39,ImpliedFill=False,LastFee=0,LastFeeSymbol=`BTC`]

The FillData structure includes cumulative and last values for convenience. The last size indicates the most recent size reported by the exchange in the latest trade report for the order, while the cumulative size represents the total filled size of the order to date. The same applies to the last average price and cumulative average price. We believe it’s better to focus on actual trading strategy rather than on details like storing last fill sizes to compute cumulative sizes.

Finally, let’s take a look at monitoring order fills for limit orders. While market orders are typically filled instantly, limit orders can take a long time to be filled, and we need to adjust the code accordingly:

ILiveLimitOrder order = await client.CreateLimitOrderAsync(SymbolPair.BTC_EUR,
    OrderSide.Buy, size: 0.00015m, price: 75_000m);
Print($"Order '{order.ExchangeOrderId}' was created.");

// The number of partial fills an order is not known beforehand.
while (true)
{
    Print("Waiting for fills.");
    IReadOnlyList<FillData> fills = await order.WaitForPartialFillOrCloseAsync();

    if (fills.Count > 0)
    {
        foreach (FillData fill in fills)
            Print($"Fill: {fill}");
    }

    // If the order is either filled or canceled, there won't be any new fills.
    if (order.OrderStatus.IsTerminated())
    {
        string status = order.OrderStatus.ToString().ToUpperInvariant();
        Print($"Order '{order.ExchangeOrderId}' was {status}'.");
        break;
    }
}

Note that ILiveOrder.WaitForFillAsync() is not a great fit for limit orders because:

Limit orders can be canceled, in which case the method would throw.
All (partial) fills would be returned by the method once the order is fully filled. However, consider an order that is filled 0.999 / 1.0 BTC immediately and the remaining size is executed after three days.

Conclusion

In this blog post, we outlined the process by which exchanges handle orders, starting from the moment an order request is submitted until the order is completed. We also demonstrated how to monitor individual partial fills. Next time, we will discuss monitoring of active orders and how to cancel orders.

Trading Bot in C# — Part 3— Orders

Whale's Secret — Sat, 21 Jun 2025 07:36:29 +0000

The previous blog posts explored subscribing to market data and how to get notified on Telegram when an interesting trading opportunity comes. The next step is to actually trade based on the signals we receive.

In this blog post, we will use a form of paper trading — Binance Testnet environment. The idea is simple. The Testnet gives you access to the Binance exchange but all order books, all trades, and your account balance sheet are simulated in this platform environment to mimic the real trading environment.

People use testnets to familiarize themselves with the platform before they feel confident risking their hard earned assets on a live exchange. By using the testnet, you will save some time as Binance does not need to verify your identity through their Know Your Customer process (KYC).

Introduction to Exchange Orders

Binance and other major exchanges allow you to create several different types of orders. The most commonly used order types are market orders and limit orders. A market order allows you to buy or sell a certain quantity of an asset at the best available price at that moment. In contrast, a limit order requires you to specify not only a quantity but also the price for which you are willing to buy (or sell) the asset.

It’s very important to realize why professional traders often prefer limit orders, and why using market orders can be dangerous. Consider the following scenario:

You intend to sell 1 BTC, and the order book indicates a favorable price of 75,000 EUR. However, upon selecting the “sell” button with the market order type, an unfortunate turn of events occurs — before your request is processed by the Binance platform, a significant investor decides to liquidate her holdings, causing the price to temporarily drop to 70,000 EUR. Consequently, your order is executed at this lower price, resulting in a loss of 5,000 EUR!

It’s very easy to lose hard-earned profit this way. That said, it’s also worth noting that the price could rise up just as easily. This is mentioned to emphasize the importance of understanding your risks when trading.

How to Place Orders in Whale’s Secret ScriptApiLib

Whale’s Secret ScriptApiLib offers API for creating and cancelling of orders. First, before an order can be placed, we need to establish an authenticated connection:

using WhalesSecret.ScriptApiLib;
using WhalesSecret.ScriptApiLib.Exchanges;
using WhalesSecret.TradeScriptLib.API.TradingV1;
using WhalesSecret.TradeScriptLib.Entities;

// Use the Binance Testnet.
CreateOptions createOptions = new(connectToBinanceSandbox: true);
await using ScriptApi scriptApi = await ScriptApi.CreateAsync(createOptions);

// Specify your Binance Testnet API credentials.
using IApiIdentity apiIdentity = BinanceApiIdentity.CreateHmac(name: "MyApiKey", 
  key: "<KEY>", secret: Convert.FromBase64String("<SECRET>"));
scriptApi.SetCredentials(apiIdentity);

// Connect.
ITradeApiClient client = await scriptApi.ConnectAsync(ExchangeMarket.BinanceSpot);
Console.WriteLine("Ready to trade!");

And then we might want to buy 0.00015 BTC using a market order:

// Ask Binance to place a market order to buy 0.00015 BTC.
ILiveMarketOrder order = await client.CreateMarketOrderAsync(SymbolPair.BTC_EUR, 
    OrderSide.Buy, size: 0.00015m);

Success! However, if you are not familiar with bitcoin exchange rates, you might be curious about the value of 0.00015 BTC (spoiler: it is approximately 11 EUR at the time of writing). In this case, we can specify the quantity directly in euros for your convenience:

MarketOrderRequest request = new(SymbolPair.BTC_EUR, OrderSide.Buy, 
    size: 11m, sizeInBaseSymbol: false);
ILiveMarketOrder order = await client.CreateOrderAsync(request);

Note the difference between the two approaches. When the size is specified in the base symbol, you are saying “buy 0.00015 BTC for the best possible price” and it may cost you 11 EUR, or it may cost you 12 EUR, or 10 EUR, depending on the current market situation. In the second case, when the size is specified in the quote symbol, you are saying “buy 11 EUR worth of BTC”. Here you will never spend 10 EUR nor 12 EUR, you will spend 11 EUR and for that you may obtain 0.00015 BTC or maybe just 0.00013 BTC.

We mentioned that market orders can lead to losses, so let’s move on to limit orders where your risk is much easier to assess:

ILiveLimitOrder order = await client.CreateLimitOrderAsync(SymbolPair.BTC_EUR, 
    OrderSide.Sell, price: 75_000m, size: 1.0m);

The sample shows how to create a limit order to sell one bitcoin with the limit price of 75,000 EUR. Notably, you cannot incur a loss in this case as your order might be filled with the minimum price of 75,000 EUR. Yes, you may achieve a higher selling price, if you are fortunate. However, a drawback is that your order might not be fully executed. So while market orders give you reasonable confidence that your trade will be finished “immediately”, limit orders does not offer the same level of certainty.

Note that the previous code sample works only if you decide to buy ScriptApiLib subscription. That’s because ScriptApiLib can be used for free only with limited order sizes. Paying customers can just specify their license key and enjoy unlimited order sizes:

CreateOptions createOptions = new(connectToBinanceSandbox: true, 
    license: "<YOUR-WHALESSECRET-LICENSE>");
await using ScriptApi scriptApi = await ScriptApi.CreateAsync(createOptions);

// [..]

// License string is specified. No exception is thrown!
ILiveLimitOrder order = await client.CreateLimitOrderAsync(SymbolPair.BTC_EUR, 
    OrderSide.Sell, price: 75_000m, size: 1.0m);

Without a license, you will be informed about the maximum allowed order size by an exception:

Bot That Trades

In the previous blog posts, we have significantly enhanced our market-watching bot. Now, we can modify it further by trading based on received RSI signals. The idea is simple: Buy when the market is oversold, sell when the market is overbought. Note that this is not an endorsement of this trading strategy, we demonstrate order placing for education purposes. That’s why we use the Testnet to avoid any financial losses.

In C#, this can be implemented as follows:

// Store if we did buy or sell the last time. We do not want the bot to
// do multiple consecutive buys. After each buy, only a sell can follow
// and vice versa.
OrderSide? lastAction = null;

// [..]

OrderSide? action = null;

if ((rsiValue < 30) && (lastAction != OrderSide.Buy)) action = OrderSide.Buy;
else if ((rsiValue > 70) && (lastAction != OrderSide.Sell)) action = OrderSide.Sell;

if (action is not null)
{
    lastAction = action;

    ILiveMarketOrder order = await tradeClient.CreateMarketOrderAsync(SymbolPair.BTC_EUR, action.Value, size: 0.00015m);
    await order.WaitForFillAsync();

    // Notify us on Telegram that an order was placed.
    string message = $"Bot says: Based on the RSI signal <b>{rsiStr}{interpretation}</b> for BTC/EUR on Binance, a {action.Value} market order with size " +
        $"{order.Size} was <b>placed</b>!";

    await SendTelegramMessageAsync(message);
}
else
{
    string message = interpretation != string.Empty
        ? $"Bot says: RSI signals <b>{rsiStr}{interpretation}</b> for BTC/EUR on Binance! Current price is {priceStr} EUR."
        : $"Bot says: RSI does <b>not</b> provide a clear signal for BTC/EUR on Binance! Current price is {priceStr} EUR. RSI value is {rsiStr}.";

    await SendTelegramMessageAsync(message);
}

The following image demonstrates how the bot behaves in practice:

Buy order was placed based on an RSI signal

Conclusion

In this blog post, we demonstrated how to create orders in Whale’s Secret ScriptApiLib and we improved our trading bot to actually trade based on the RSI signals it gets. Next time, we will talk about how to monitor order fills.

Trading Bot in C# — Part 2— Notifications

Whale's Secret — Sat, 14 Jun 2025 07:47:26 +0000

In the previous post, we implemented a market-watching bot that continuously monitors the BTC/USDT market on Binance exchange and provides updates on the relative-strength indicator (RSI) values.

With this system in place, we may wish to be notified when noteworthy trading opportunities arise. This blog post will dive into that topic.

Get Notified!

A simple approach would be to send an email whenever RSI crosses a significant threshold. While this approach is valid, we believe that messaging apps could be more advantageous for our intended purpose. Messaging apps typically offer various notification settings, and the ease of joining or leaving a group chat. Although email can provide similar functionalities, it tends to be more complicated, and carries the risk of being perceived as spam.

Nowadays, messaging apps are ubiquitous. It’s quite possible that at least one message from such a service just buzzed in your pocket a moment ago. So why not to send a message to a chat group where your friends or customers can act on your trading tips! We chose Telegram because we are the most familiar with that particular service. The concept is straightforward: create a Telegram bot and utilize it to send messages to a public Telegram group. Let’s dive in!

Create a New Bot

Follow these steps to create a new Telegram bot:

Open your Telegram app on your phone, or on your laptop.
Send the message /newbot to @BotFather in your Telegram app.
Specify a name of the bot. For example, MyTradingBot.
Specify a bot’s username: <YOUR_BOT_NAME>_bot. Note that the name has to end with _bot or Bot.
Now a summary is displayed:

_Done! Congratulations on your new bot. You will find it at t.me/_bot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you’ve finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.

Use this token to access the HTTP API:

XXXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Keep your [API] token secure and store it safely, it can be used by anyone to control your bot.

For a description of the Bot API, see this page:_ https://core.telegram.org/bots/api
Search for <YOUR_BOT_NAME>_bot user in your Telegram app and press Start button.
Create a new public Telegram group <YOUR_GROUP_NAME> — i.e. set public link to be: https://t.me/<YOUR_GROUP_NAME>. An example of the group name is trading_signal_group_123456. It’s certainly possible to send messages to private Telegram groups, it’s just harder to get its group ID.

Send a Message

Once your Telegram bot is set up, sending a message using Telegram API is just a matter of using its REST API:

using System.Diagnostics;
using System.Web;

// Telegram API token to authorize message sending.
string apiToken = "XXXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";

// Telegram group where to send a message to.
string groupId = "@your_group";

// Messages can be formatted using HTML syntax (e.g. <b>bold</b>, <i>italics</i>, etc.).
await SendTelegramMessageAsync("First test message from <b>the robot</b>!");

async Task SendTelegramMessageAsync(string message, bool htmlSyntax = true)
{
    string chatId = HttpUtility.UrlEncode(groupId);
    message = HttpUtility.UrlEncode(message);

    using HttpClient client = new();
    string uri = htmlSyntax
        ? $"https://api.telegram.org/bot{apiToken}/sendMessage?chat_id={chatId}&parse_mode=html&text={message}"
        : $"https://api.telegram.org/bot{apiToken}/sendMessage?chat_id={chatId}&text={message}";

    using HttpRequestMessage request = new(HttpMethod.Get, uri);
    HttpResponseMessage response = await client.SendAsync(request).ConfigureAwait(false);

    string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
    Debug.Assert(response.IsSuccessStatusCode, content);
}

Voilà! Now we know how to send a nicely formatted message to a Telegram group.

Bot Sending Notifications

Unsurprisingly, we might want to enhance our market-watching bot to send a notification whenever the RSI indicator signals that the market is oversold or overbought.

RSI can be computed with respect to various time frames (we call them candle widths)— 1 day, 6 hours, 2 hours, 5 minutes, and many more. We chose the 1-minute interval. Nobody wants to sit idle for such a long time, so we will also print last ticker prices as we get them. The following sample shows the main parts of our bot:

    // [...]

// The Telegram API token should be in form "XXXXXXXXXX:YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY".
string? apiToken = null;

if (apiToken is null)
    throw new SanityCheckException("Please provide your Telegram API token.");

// The Telegram group identifier is in form "@my_group".
string? groupId = null;

if (groupId is null)
    throw new SanityCheckException("Please provide a Telegram group identifier.");

await using ScriptApi scriptApi = await ScriptApi.CreateAsync();

// [...]

await using ICandlestickSubscription candlestickSubscription = await tradeClient.CreateCandlestickSubscriptionAsync(SymbolPair.BTC_USDT);
await using ITickerSubscription tickerSubscription = await tradeClient.CreateTickerSubscriptionAsync(SymbolPair.BTC_USDT);

// Get historical candlestick data for the last three days for 1-minute candles.
DateTime endTime = DateTime.Now;
DateTime startTime = endTime.AddDays(-3);

CandlestickData candlestickData = await tradeClient.GetCandlesticksAsync(SymbolPair.BTC_USDT, CandleWidth.Minute1, startTime, endTime);

// Compute RSI using Skender.Stock.Indicators.
// Add the package to the project using "dotnet add package Skender.Stock.Indicators".
// Add "using Skender.Stock.Indicators;" to the source file.
List<Quote> quotes = new();
foreach (Candle candle in candlestickData.Candles)
    quotes.Add(QuoteFromCandle(candle));

Task<Candle>? lastClosedCandleTask = null;

// Loop until the program is terminated using CTRL+C.
while (true)
{
    // Wait for a new ticker.
    Ticker lastTicker = await tickerSubscription.GetNewerTickerAsync();

    // If there is no task to get the latest closed candle, create one.
    lastClosedCandleTask ??= candlestickSubscription.WaitNextClosedCandlestickAsync(CandleWidth.Minute1);

    string priceStr = ToInvariantString(Math.Round(lastTicker.LastPrice!.Value, 2));
    Console.WriteLine($"The latest price is: {priceStr} USDT.");

    if (lastClosedCandleTask.IsCompleted)
    {
        Candle lastClosedCandle = await lastClosedCandleTask;
        quotes.Add(QuoteFromCandle(lastClosedCandle));
        lastClosedCandleTask = null;

        // Compute RSI.
        RsiResult lastRsi = quotes.GetRsi().Last();
        double rsiValue = Math.Round(lastRsi.Rsi!.Value, 2);

        string interpretation = rsiValue switch
        {
            < 30 => " (oversold!)",
            > 70 => " (overbought!)",
            _ => string.Empty
        };

        string rsiStr = ToInvariantString(rsiValue);

        Console.WriteLine();
        Console.WriteLine($"RSI was recomputed: {rsiStr}{interpretation}");
        Console.WriteLine();

        string message = interpretation != string.Empty
            ? $"Bot says: RSI signals <b>{rsiStr}{interpretation}</b> for BTC/USDT on Binance! Current price is {priceStr} USDT."
            : $"Bot says: RSI does <b>not</b> provide a clear signal for BTC/USDT on Binance! Current price is {priceStr} USDT. RSI value is {rsiStr}.";

        await SendTelegramMessageAsync(message);
    }
}

// In certain cultures, the decimal separator can be comma. We prefer full stops.
static string ToInvariantString(object o)
    => string.Format(CultureInfo.InvariantCulture, $"{o}");

// [...]

The code snippet synchronously waits for a new ticker and prints the current price as the new ticker is received. New closed 1-minute candles are awaited in the background and whenever a new candle arrives, RSI is re-computed. Based on the RSI value, we send a message using the Telegram API.

In practice, it would be preferable to notify only when RSI gives an interesting signal but for demonstration purposes we send a Telegram message every minute.

Traders often watch charts closely. For those passionate out there, we show a bot’s run with the corresponding chart:

Conclusion

In this blog post, we enhanced the market-watching bot to communicate with the outside world to share its trading signals with others using Telegram API. Next time, we will discuss how to trade based on signals received from the RSI indicator, as well as signals in general.

Trading Bot in C# — Part 1 — Basic Market Watching on Binance

Whale's Secret — Tue, 10 Jun 2025 16:27:53 +0000

This blog post is part of a series on building a simple trading bot. In this blog post, we’ll cover how to connect to an exchange, get price data, and use a trading indicator to interpret that data. The next blog post will focus on adding a notification system, followed by a guide on executing trades based on the trading indicator.

Introduction

There are many forms of trading, each presenting unique opportunities and challenges. One question can be “What to trade?”. Here we have, for example, equities, commodities, currencies and crypto currencies. Then we may ask “How frequently?” and come out with scalping, day-trading, swing trading, positional trading. Another decision is to be made about the type of analysis to help us make decisions. Here we have technical analysis vs. fundamental analysis.

In this blog post and upcoming parts of the series, we will focus on automated crypto currency day-trading based on technical analysis. Today our bot we will just watch the market on the Binance exchange. Let’s get started!

Prerequisites

This blog post requires basic knowledge of .NET and the trading bot is written in C#. To communicate with Binance, we will use Whale’s Secret ScriptApiLib which translates exchanges’ APIs into nice and simple API for you.

Create New Console Application

Using command-line interface, a new console application can be set up using:

dotnet new console --name MarketWatcher
cd MarketWatcher
dotnet add package WhalesSecret.ScriptApiLib

Alternatively, you can do the same in your IDE. In Visual Studio, you can create a console application like this:

Open Visual Studio, and select Create a new project in the start window.
In the Create a new project window, select C# from the language drop-down list. Choose Console App from the project types list.
In the Configure your new project window, type or enter MarketWatcher in the Project name box, and then select Next.
On the next screen with Additional information, you can leave everything as is and just hit Create.
Install WhalesSecret.ScriptApiLib NuGet package by clicking Tools → NuGet Package Manager → Manage NuGet Packages for Solution and then searching for WhalesSecret.ScriptApiLib.

Connect to Binance

To make it simple, we start working only with market data in this blog post. This means that for now, you don’t need any account on Binance as the data is publicly available. If we were to create, for example, a new order, we would need an exchange account. However, our first aim is to simply connect to a Binance exchange server. In your Program.cs file, add the following code:

using WhalesSecret.ScriptApiLib;
using WhalesSecret.TradeScriptLib.API.TradingV1;
using WhalesSecret.TradeScriptLib.API.TradingV1.MarketData;
using WhalesSecret.TradeScriptLib.Entities;
using WhalesSecret.TradeScriptLib.Entities.MarketData;

await using ScriptApi scriptApi = await ScriptApi.CreateAsync();

Console.WriteLine("Initializing Binance exchange.");

// Initialize information about various exchange assets and coins.
await scriptApi.InitializeMarketAsync(ExchangeMarket.BinanceSpot);

Console.WriteLine("Connecting...");

// Connect to the exchange without API credentials to work with market data.
ConnectionOptions options = new(ConnectionType.MarketData);
await using ITradeApiClient tradeClient = await scriptApi.ConnectAsync(ExchangeMarket.BinanceSpot, options);
Console.WriteLine("Connection succeeded!");

The program terminates immediately after connecting to a Binance server.

Get Historical Price Data

At every moment, a list of bids and a list of asks together represent an order book snapshot. In other words, an order book snapshot is a list of buy and sell orders and a trade occurs when an existing buy order is matched with a sell order or vice versa.

If we were to store all order book snapshots in full, we would need a lot of disk space as order books get changed every time a new order is added to the order book, or removed, or modified, or when orders are matched and a trade occurs.

However, this section is about historical prices, so why are order book snapshots important? We wanted to make it clear that while price is generally a very simple concept, in trading, it might be less clear. Suppose that somebody tells you that the price of BTC/USDT is $80,000. What does it actually signify? There are at least three possible interpretations:

the top order book bid, or
the top order book ask, or
the last trade’s execution price.

In trading, when we talk about price we always mean the last trade’s execution price. It is also beneficial to think in terms of price ranges. Candlestick charts effectively illustrate this concept by visually representing the price range of an asset over specific time frames. For example, on March 2nd 2025, a candlestick chart with the 1-day granularity reveals that:

The price of the asset at the beginning of the trading period was $86,064. This is called opening price.
The price of the asset at the end of the trading period was $94,270. This is called closing price.
The highest price reached during the trading period was $95,000. This is called high price.
The lowest price reached during the trading period was $85,050. This is called low price.

It was a day with great price volatility. Remember that you cannot predict the future with certainty — i.e. probability is in play.

While candlestick charts are useful by giving better understanding of price changes, they do not account for order sizes. Suppose that the BTC/USDT order book contains the top bid price $80,000 but the top bidder wants to buy just 0.0001 BTC, and the next best bid is for $79,000. If you are a seller and you intend to sell 1 BTC, then you would not receive $80,000 but only about $79,000 or less. Costly detail!

However, since candlesticks only reflect the actual price that was reached on the market (i.e. not only price of bids and asks but actual executed trades), they are, in a sense, more real than prices taken from order books. Moreover, each candle comes with a volume information, that is the amount that was traded within the candle’s period.

Candlestick Subscription with RSI

We want to monitor the price data and compute an indicator, such as the relative-strength index (RSI), on top of it.

To do this, we will create a candlestick subscription, get historical candles, and consume new candlestick updates.

await using ICandlestickSubscription subscription = await tradeClient.CreateCandlestickSubscriptionAsync(SymbolPair.BTC_USDT);

// Get historical candlestick data for the last three days for 1-minute candles.
DateTime endTime = DateTime.Now;
DateTime startTime = endTime.AddDays(-3);

CandlestickData candlestickData = await tradeClient.GetCandlesticksAsync(SymbolPair.BTC_USDT, CandleWidth.Minute1, startTime, endTime);

Afterwards, one can use the data to compute the RSI values which tell you if the market is overbought, oversold, or whether you should wait patiently on. We will use Skender.Stock.Indicators library for calculating the indicator.

// Compute RSI using Skender.Stock.Indicators.
// Add the package to the project using "dotnet add package Skender.Stock.Indicators".
// Add "using Skender.Stock.Indicators;" to the source file.
List<Quote> quotes = new();
foreach (Candle candle in candlestickData.Candles)
    quotes.Add(QuoteFromCandle(candle));

Candle lastClosedCandle = subscription.GetLatestClosedCandlestick(CandleWidth.Minute1);

Console.WriteLine();
Console.WriteLine($"Last closed candle: {lastClosedCandle}");

ReportRsi(quotes);

// Loop until the program is terminated using CTRL+C.
while (true)
{
    Console.WriteLine();
    Console.WriteLine("Waiting for the next closed candle...");

    try
    {
        lastClosedCandle = await subscription.WaitNextClosedCandlestickAsync(CandleWidth.Minute1);
    }
    catch (OperationCanceledException)
    {
        break;
    }

    Console.WriteLine($"New closed candle arrived: {lastClosedCandle}");
    quotes.Add(QuoteFromCandle(lastClosedCandle));
    ReportRsi(quotes);
}

static void ReportRsi(IEnumerable<Quote> quotes)
{
    IEnumerable<RsiResult> results = quotes.GetRsi();
    RsiResult lastRsi = results.Last();

    string interpretation = lastRsi.Rsi switch
    {
        < 30 => " (oversold!)",
        > 70 => " (overbought!)",
        _ => string.Empty
    };

    Console.WriteLine($"Current RSI: {lastRsi.Date} -> {lastRsi.Rsi}{interpretation}");
}

static Quote QuoteFromCandle(Candle candle)
{
    Quote quote = new()
    {
        Date = candle.Timestamp,
        Open = candle.OpenPrice,
        High = candle.HighPrice,
        Low = candle.LowPrice,
        Close = candle.ClosePrice,
        Volume = candle.BaseVolume,
    };

    return quote;
}

Output can then look like this:

Last closed candle: [Timestamp=2025-03-15 09:36:00,OpenPrice=83821.35000000,HighPrice=83821.35000000,LowPrice=83811.74000000,ClosePrice=83811.74000000,BaseVolume=3.45983000,QuoteVolume=289993.96687040,IsClosed=True]
Current RSI: 15.03.2025 9:36:00 -> 52.24205443879027

Waiting for the next closed candle...
New closed candle arrived: [Timestamp=2025-03-15 09:37:00,OpenPrice=83811.75000000,HighPrice=83854.53000000,LowPrice=83811.74000000,ClosePrice=83851.98000000,BaseVolume=26.12462000,QuoteVolume=2190256.94452210,IsClosed=True]
Current RSI: 15.03.2025 9:37:00 -> 58.320544966728924

The code listing is a bit more complicated as it requires a conversion from Whale’s Secret data format to Skender.Stock.Indicators. Alternatively, one can compute it in C# without a new dependency. Be it as it may, the code simply waits for a new closed candle, computes RSI value and presents an RSI verdict. If the market is overbought, you might consider decreasing your position and similarly you might want to increase your position if the market is oversold.

Conclusion

In this blog post, a simple trading bot in C# was implemented and it can connect to Binance for you. Then the bot can fetch historical price data which can drive your trading strategies. An example of computing RSI signal values was shown to consider a buy or sell when market conditions seem right.