SubscriptionOnlineManager: skip TryAddOrderTransaction when statusInfo is a linked view

Reproducer: client subscribes to OrderStatus(Tx=N), registers an order(Tx=R),
broker replies with an Active execution carrying OrigTxId=R, TxId=R+1.
The execution-side lookup hits the per-order TxId entry created by the prior
register and returns a linked SubscriptionInfo whose Linked/State accessors
throw via CheckOnLinked. TryAddOrderTransaction then called statusInfo.Linked.Add
and threw — the connector logged the CheckOnLinked exception and the order
flow then surfaced a phantom Cancel.

Add ISubscriptionOnlineInfo.IsLinked and bail out of TryAddOrderTransaction
when the resolved info is already a linked view: the order is tracked through
the main subscription, the message is forwarded by the caller, no extra alias
state is needed. Test reproduces the exact stack and asserts the execution
passes through.

Author: mikasoukhov

Algo/ISubscriptionOnlineManagerState.cs

@@ -130,4 +130,14 @@ public interface ISubscriptionOnlineInfo
 	/// Linked subscription IDs.
 	/// </summary>
 	List<long> Linked { get; }
+
+	/// <summary>
+	/// True when this info is a linked view onto a main subscription
+	/// (created via <see cref="ISubscriptionOnlineManagerState.CreateLinkedSubscriptionInfo"/>),
+	/// not the main subscription itself. Mutating <see cref="State"/> or
+	/// reading <see cref="Linked"/> on a linked view throws — callers that
+	/// reach an info through a per-order TxId lookup must check this flag
+	/// before treating the info as a main subscription.
+	/// </summary>
+	bool IsLinked { get; }
 }

Algo/SubscriptionOnlineManager.cs

@@ -300,6 +300,15 @@ private bool ChangeState(ISubscriptionOnlineInfo info, long transId, Subscriptio
 
 	private void TryAddOrderTransaction(ISubscriptionOnlineInfo statusInfo, long transactionId, bool warnOnDuplicate = true)
 	{
+		// statusInfo can arrive as a linked view (looked up via an existing
+		// per-order TxId entry in _subscriptionsById). The order is then
+		// already tracked through the main OrderStatus subscription — adding
+		// another linked alias keyed by another TxId duplicates state, and
+		// statusInfo.Linked.Add below would throw CheckOnLinked anyway. Bail
+		// silently — the message will still be forwarded by the caller.
+		if (statusInfo.IsLinked)
+			return;
+
 		if (!_state.ContainsSubscriptionById(transactionId))
 		{
 			var orderSubscription = _state.CreateLinkedSubscriptionInfo(statusInfo);

Algo/SubscriptionOnlineManagerState.cs

@@ -60,6 +60,8 @@ public List<long> Linked
 			}
 		}
 
+		public bool IsLinked => _main != null;
+
 		public override string ToString() => (_main != null ? "Linked: " : string.Empty) + Subscription.ToString();
 	}
 

Tests/SubscriptionOnlineManagerTests.cs

@@ -1022,6 +1022,77 @@ public async Task OrderStatus_CreatesSubscriptionWithDefaultSecurityId()
 		AreEqual(100, info.Subscription.TransactionId, "Subscription TransactionId should match");
 	}
 
+	/// <summary>
+	/// Reproducer for the linkage break observed in MultiConnect/client1 logs:
+	///   Subscribe OrderStatus(Tx=N) → RegisterOrder(Tx=R) → broker sends Active
+	///   ExecutionMessage{ OrigTxId=R, TxId!=0, DataType=Transactions }.
+	///
+	/// On the outgoing OrderRegister, ProcessInMessageAsync calls
+	/// TryAddOrderSubscription → TryAddOrderTransaction(MAIN, R), which adds a
+	/// LINKED copy at <c>_subscriptionsById[R]</c>.
+	///
+	/// Then the incoming Active is looked up by OrigTxId=R and returns the
+	/// LINKED copy (not MAIN). Inside the existing TryAddOrderTransaction call
+	/// at ProcessOutMessageAsync (line 223), <c>statusInfo.Linked.Add</c> is
+	/// called — and SubscriptionInfo.CheckOnLinked() throws because info has
+	/// _main != null.
+	///
+	/// Symptom in MultiConnect log: Order stays Pending despite broker
+	/// confirming Active. After cancel, Order shows as new Done — the user
+	/// reads it as "filled".
+	/// </summary>
+	[TestMethod]
+	public async Task OrderRegister_FollowedByActive_OrigTxIdEqualsRegisterTxId_DoesNotThrow()
+	{
+		var logReceiver = new TestReceiver();
+		var manager = new SubscriptionOnlineManager(logReceiver, _ => true, new SubscriptionOnlineManagerState());
+		var token = CancellationToken;
+
+		// 1. Subscribe to OrderStatus.
+		await manager.ProcessInMessageAsync(new OrderStatusMessage
+		{
+			IsSubscribe = true,
+			TransactionId = 100,
+		}, token);
+		await manager.ProcessOutMessageAsync(new SubscriptionResponseMessage { OriginalTransactionId = 100 }, token);
+		await manager.ProcessOutMessageAsync(new SubscriptionOnlineMessage { OriginalTransactionId = 100 }, token);
+
+		// 2. Send OrderRegister with TxId=R. ProcessInMessageAsync's switch on
+		// MessageTypes.OrderRegister calls TryAddOrderSubscription → adds a
+		// LINKED entry at _subscriptionsById[R].
+		const long R = 27738195;
+		await manager.ProcessInMessageAsync(new OrderRegisterMessage
+		{
+			TransactionId = R,
+			SecurityId = Helper.CreateSecurityId(),
+			Side = Sides.Buy,
+			Volume = 200m,
+			Price = 0.4m,
+			OrderType = OrderTypes.Limit,
+		}, token);
+
+		// 3. Broker responds Active. With OrigTxId=R the lookup at line 216 in
+		// ProcessOutMessageAsync returns the LINKED copy. With TxId!=0, the
+		// branch at line 223 calls TryAddOrderTransaction(LINKED, X), which
+		// then hits statusInfo.Linked.Add → CheckOnLinked → throws.
+		var active = new ExecutionMessage
+		{
+			DataTypeEx = DataType.Transactions,
+			HasOrderInfo = true,
+			OrderState = OrderStates.Active,
+			OrderId = 4991775493L,
+			OriginalTransactionId = R,
+			TransactionId = R + 1, // upstream-translated id, anything non-zero
+			SecurityId = Helper.CreateSecurityId(),
+			ServerTime = logReceiver.CurrentTime,
+		};
+
+		// Currently throws InvalidOperationException via CheckOnLinked.
+		// After the fix it must pass through and forward the message.
+		var (forward, _) = await manager.ProcessOutMessageAsync(active, token);
+		forward.AssertNotNull("Active execution must pass through, not be dropped or throw.");
+	}
+
 	#endregion
 
 	#region History+Live Subscription Tests