Candles: bound volume-profile levels by snapping prices to the instrument price step

A volume profile keyed each level by the exact level price. Built from a
near-continuous source (e.g. a Level1 SpreadMiddle feed on a wide-range
instrument), every distinct fractional price spawned its own level, so an hour
candle accumulated thousands of levels and could no longer be stored or
transmitted as deep history.

VolumeProfileBuilder gains an optional price-step constructor: when set, each
level price is snapped to the instrument grid (ShrinkPrice) before it keys a
level, so the count stays bounded; volumes for prices in the same bucket merge
through the existing Join path. The parameterless constructor keeps the old
per-price behaviour. CandleBuilder now passes Message.PriceStep at all three
profile-creation sites (the value/time-frame path, the PnF CreateCandle path and
the Renko path). Tests cover both the bucketed and the back-compat no-step modes.

Author: mikasoukhov

Algo/Candles/Compression/CandleBuilder.cs

@@ -137,7 +137,7 @@ protected virtual IEnumerable<TCandleMessage> OnProcess(ICandleBuilderSubscripti
 
 			if (subscription.Message.IsCalcVolumeProfile)
 			{
-				subscription.VolumeProfile = volumeProfile = new();
+				subscription.VolumeProfile = volumeProfile = new(subscription.Message.PriceStep);
 				volumeProfile.Update(transform);
 
 				candle.PriceLevels = subscription.VolumeProfile.PriceLevels;
@@ -768,7 +768,7 @@ private PnFCandleMessage CreateCandle(ICandleBuilderSubscription subscription, D
 
 		if (subscription.Message.IsCalcVolumeProfile)
 		{
-			subscription.VolumeProfile = new();
+			subscription.VolumeProfile = new(subscription.Message.PriceStep);
 			candle.PriceLevels = subscription.VolumeProfile.PriceLevels;
 		}
 
@@ -818,7 +818,7 @@ RenkoCandleMessage GenerateNewCandle(decimal openPrice, decimal closePrice)
 
 			if (subscription.Message.IsCalcVolumeProfile)
 			{
-				subscription.VolumeProfile = new();
+				subscription.VolumeProfile = new(subscription.Message.PriceStep);
 				candle.PriceLevels = subscription.VolumeProfile.PriceLevels;
 			}
 

Algo/Candles/Compression/VolumeProfileBuilder.cs

@@ -7,6 +7,13 @@ public class VolumeProfileBuilder
 {
 	private readonly Dictionary<decimal, int> _volumeProfileInfo = [];
 
+	// Optional price-step bucketing for the level price. When set (> 0), every level price is
+	// snapped to the instrument price step before it keys a profile level. Without it a profile
+	// built from a near-continuous source (e.g. Level1 SpreadMiddle on a wide-range instrument
+	// such as a crypto/RUB pair) accumulates an unbounded number of distinct levels, bloating the
+	// candle so much that it can no longer be stored/transmitted as deep history.
+	private readonly decimal? _priceStep;
+
 	/// <summary>
 	/// The upper price level.
 	/// </summary>
@@ -46,6 +53,16 @@ public VolumeProfileBuilder()
 	{
 	}
 
+	/// <summary>
+	/// Initializes a new instance of the <see cref="VolumeProfileBuilder"/> that snaps every level
+	/// price to <paramref name="priceStep"/> so the number of distinct levels stays bounded.
+	/// </summary>
+	/// <param name="priceStep">Instrument price step used to bucket level prices; <see langword="null"/> or non-positive disables bucketing.</param>
+	public VolumeProfileBuilder(decimal? priceStep)
+	{
+		_priceStep = priceStep;
+	}
+
 	private readonly List<CandlePriceLevel> _levels = [];
 
 	/// <summary>
@@ -93,6 +110,15 @@ public void Update(CandlePriceLevel level)
 		if (price == 0)
 			throw new ArgumentOutOfRangeException(nameof(level));
 
+		if (_priceStep is decimal step && step > 0m)
+		{
+			// Snap the level price to the instrument grid so a near-continuous source cannot
+			// spawn a new level per tick. Volumes for prices that fall into the same bucket are
+			// merged by the existing Join path below.
+			price = price.ShrinkPrice(step, step.GetCachedDecimals());
+			level.Price = price;
+		}
+
 		if (!_volumeProfileInfo.TryGetValue(price, out var idx))
 		{
 			idx = _levels.Count;

Tests/VolumeProfileBuilderTests.cs

@@ -0,0 +1,44 @@
+namespace StockSharp.Tests;
+
+using StockSharp.Algo.Candles.Compression;
+using StockSharp.Messages;
+
+[TestClass]
+public class VolumeProfileBuilderTests : BaseTestClass
+{
+	[TestMethod]
+	public void PriceStepBucketsLevels()
+	{
+		// Regression: a profile built from a near-continuous source (Level1 SpreadMiddle on a
+		// wide-range instrument) used to spawn one level per distinct fractional price, so an
+		// hour candle ballooned to thousands of levels and could no longer be served as deep
+		// history. With a price step every level must snap to the grid, keeping the count bounded.
+		const decimal step = 1m;
+		var builder = new VolumeProfileBuilder(step);
+
+		for (var i = 0; i < 1000; i++)
+		{
+			// 100.000, 100.001 ... 100.999 — all collapse onto the integer grid.
+			var price = 100m + i / 1000m;
+			builder.Update(price, 1m, Sides.Buy);
+		}
+
+		var levels = builder.PriceLevels.ToArray();
+
+		(levels.Length <= 2).AssertTrue($"Expected <=2 grid-bucketed levels, got {levels.Length}");
+		levels.All(l => l.Price == decimal.Round(l.Price / step) * step).AssertTrue("Every level price must be snapped to the step grid");
+		AreEqual(1000m, levels.Sum(l => l.TotalVolume), "All volume must be preserved across buckets");
+	}
+
+	[TestMethod]
+	public void NoPriceStepKeepsRawLevels()
+	{
+		// Back-compat: without a step each distinct price stays its own level.
+		var builder = new VolumeProfileBuilder();
+
+		for (var i = 0; i < 100; i++)
+			builder.Update(100m + i / 1000m, 1m, Sides.Buy);
+
+		AreEqual(100, builder.PriceLevels.Count(), "Without bucketing each distinct price is its own level");
+	}
+}