using Anubis.Core; using Anubis.Data; using Anubis.Trading; namespace Anubis.Tests; /// The order manager (issues #27, #28, #30, SPEC 7.2): chasing limit, pace, sales, server stops, faults. [TestClass] public sealed class OrderManagerTests { private static readonly CancellationToken _none = CancellationToken.None; private static readonly TimeSpan _minute = TimeSpan.FromSeconds(60); private sealed record Setup(TradingRig Rig, AccountContext Account, Instrument Instrument, PaperBroker Paper, OrderManager Manager) : IAsyncDisposable { public ValueTask DisposeAsync() => Rig.DisposeAsync(); } private static async Task OkxAsync(InstrumentSpec? spec = null, decimal bid = 60000m, decimal ask = 60010m) { var rig = await TradingRig.CreateAsync().ConfigureAwait(false); var account = await rig.AccountAsync(Venues.Okx, TradingEnvironments.Simulation).ConfigureAwait(false); var instrument = await rig.InstrumentAsync(spec ?? TradingRig.Btc).ConfigureAwait(false); var paper = rig.Paper(PaperOptions.Okx(), account.AccountId); await paper.DepositAsync(100_000m, "EUR", _none).ConfigureAwait(false); rig.Quote(instrument.Symbol, bid, ask); return new Setup(rig, account, instrument, paper, rig.Manager(paper, account)); } private static async Task AlpacaAsync(Func>? pendingSplit = null) { var rig = await TradingRig.CreateAsync().ConfigureAwait(false); var account = await rig.AccountAsync(Venues.Alpaca, TradingEnvironments.Simulation).ConfigureAwait(false); var instrument = await rig.InstrumentAsync(TradingRig.Stock("MSFT")).ConfigureAwait(false); var paper = rig.Paper(PaperOptions.Alpaca(), account.AccountId); await paper.DepositAsync(50_000m, "USD", _none).ConfigureAwait(false); rig.Quote(instrument.Symbol, 400m, 400.10m); return new Setup(rig, account, instrument, paper, rig.Manager(paper, account, pendingSplit: pendingSplit)); } private static TradeIntent Buy(Setup s, decimal quantity, decimal? stop = null, bool aggressive = false, string strategy = StrategyNames.CryptoTrend) => new(s.Instrument.Id, strategy, OrderSide.Buy, quantity, OrderPurpose.Entry, Ids.NewId(s.Rig.Clock)) { StopLevel = stop, StartAggressive = aggressive }; private static TradeIntent Sell(Setup s, decimal quantity, string strategy = StrategyNames.CryptoTrend) => new(s.Instrument.Id, strategy, OrderSide.Sell, quantity, OrderPurpose.Exit, Ids.NewId(s.Rig.Clock)); private static Task> OrdersAsync(TradingRig rig) => rig.QueryAsync("SELECT purpose, order_type, status, quantity, limit_price, stop_price, post_only, time_in_force, client_order_id FROM orders ORDER BY created_at, id", r => (r.Text("purpose"), r.Text("order_type"), r.Text("status"), r.Money("quantity"), r.MoneyOrNull("limit_price"), r.MoneyOrNull("stop_price"), r.Bool("post_only"), r.Text("time_in_force"), r.Text("client_order_id"))); private static async Task ExecutionStatusAsync(TradingRig rig, Guid id) => (await rig.QueryAsync("SELECT status, reason FROM executions WHERE id = @id", r => r.Text("status") + "/" + r.TextOrNull("reason"), ("id", id)).ConfigureAwait(false)).Single(); [TestMethod] [TestCategory(Category.Simulation)] public async Task ABuyChasesThePriceThenCrossesWithinToleranceAndGetsItsServerStop() { await using var s = await OkxAsync().ConfigureAwait(false); var (execution, refusal) = await s.Manager.SubmitAsync(Buy(s, 0.01m, stop: 57000m), _none).ConfigureAwait(false); Assert.IsNull(refusal); await s.Rig.TurnsAsync(s.Manager, 6, _minute).ConfigureAwait(false); var orders = await OrdersAsync(s.Rig).ConfigureAwait(false); var entries = orders.Where(o => o.Purpose == "entry").ToList(); Assert.HasCount(4, entries); // Three post-only steps at the best bid, each canceled after a minute, then an aggressive limit at mid + 0.5%. Assert.IsTrue(entries.Take(3).All(o => o.Kind == "limit" && o.PostOnly && o.Limit == 60000m && o.Status == "canceled")); Assert.AreEqual(("limit", false, OrderRules.RoundDown(60005m * 1.005m, 0.1m), "filled"), (entries[3].Kind, entries[3].PostOnly, entries[3].Limit, entries[3].Status)); Assert.AreEqual(4, entries.Select(o => o.ClientId).Distinct().Count(), "Every step is a new id."); Assert.AreEqual("done/filled", await ExecutionStatusAsync(s.Rig, execution!.Value).ConfigureAwait(false)); var events = await s.Rig.QueryAsync("SELECT from_status, to_status FROM order_events e JOIN orders o ON o.id = e.order_id WHERE o.client_order_id = @c ORDER BY e.occurred_at, e.id", r => (r.TextOrNull("from_status") ?? "") + ">" + r.Text("to_status"), ("c", entries[0].ClientId)).ConfigureAwait(false); CollectionAssert.AreEqual(new[] { ">created", "created>submitted", "submitted>canceled" }, events.ToArray(), "Every transition is recorded."); // Held: 0.01 less the taker fee kept in coin. The slippage against the mid of the first order is measured. var position = (await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.CryptoTrend, _none).ConfigureAwait(false))!; Assert.AreEqual((0.00998m, 57000m), (position.Quantity, position.StopPrice)); var slippage = (await s.Rig.QueryAsync("SELECT slippage_bp FROM fills", r => r.Money("slippage_bp")).ConfigureAwait(false)).Single(); Assert.IsTrue(slippage is > 0m and < 10m, slippage.ToString(System.Globalization.CultureInfo.InvariantCulture)); // One trigger order on OKX for the whole quantity, valid until canceled (SPEC 7.2). var stop = orders.Single(o => o.Purpose == "stop"); Assert.AreEqual(("stop", "submitted", 0.00998m, 57000m, "gtc"), (stop.Kind, stop.Status, stop.Quantity, stop.Stop, stop.Tif)); Assert.AreEqual(OrderPurpose.Stop, ClientOrderIds.Parse(stop.ClientId)!.Purpose); Assert.AreEqual(stop.ClientId, (await s.Paper.GetOpenOrdersAsync(_none).ConfigureAwait(false)).Single().ClientOrderId); } [TestMethod] [TestCategory(Category.Simulation)] public async Task ABuyIsGivenUpWhenEvenTheAggressiveLimitDoesNotFill() { await using var s = await OkxAsync(bid: 60000m, ask: 61000m).ConfigureAwait(false); var (execution, _) = await s.Manager.SubmitAsync(Buy(s, 0.01m, stop: 57000m), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 7, _minute).ConfigureAwait(false); Assert.AreEqual("canceled/not_filled", await ExecutionStatusAsync(s.Rig, execution!.Value).ConfigureAwait(false)); var orders = await OrdersAsync(s.Rig).ConfigureAwait(false); Assert.HasCount(4, orders); Assert.IsTrue(orders.All(o => o.Status == "canceled")); Assert.IsNull(await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.CryptoTrend, _none).ConfigureAwait(false)); Assert.IsEmpty(await s.Paper.GetOpenOrdersAsync(_none).ConfigureAwait(false), "Nothing left working."); } [TestMethod] [TestCategory(Category.Simulation)] public async Task ASaleIsNeverGivenUpAndAlertsAfterFiveMinutes() { await using var s = await OkxAsync().ConfigureAwait(false); await s.Manager.SubmitAsync(Buy(s, 0.01m, stop: 40000m, aggressive: true), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 2, _minute).ConfigureAwait(false); var held = (await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.CryptoTrend, _none).ConfigureAwait(false))!.Quantity; // No price at all: the sale waits, and the stops stay on the broker until it can really leave. s.Rig.QuotesDown = true; var (execution, _) = await s.Manager.SubmitAsync(Sell(s, held), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 3, _minute).ConfigureAwait(false); Assert.AreEqual("working/", await ExecutionStatusAsync(s.Rig, execution!.Value).ConfigureAwait(false)); Assert.IsTrue((await OrdersAsync(s.Rig).ConfigureAwait(false)).Any(o => o.Purpose == "stop" && o.Status == "submitted"), "Without a price the stops stay."); s.Rig.QuotesDown = false; // Nobody buys near the price: the sale keeps going with a fresh reference and double tolerance. s.Rig.Quote("BTC-EUR", 50000m, 60000m); await s.Rig.TurnsAsync(s.Manager, 12, _minute).ConfigureAwait(false); Assert.AreEqual("working/", await ExecutionStatusAsync(s.Rig, execution!.Value).ConfigureAwait(false)); var tolerance = (await s.Rig.QueryAsync("SELECT tolerance FROM executions WHERE id = @id", r => r.Money("tolerance"), ("id", execution)).ConfigureAwait(false)).Single(); Assert.AreEqual(0.01m, tolerance); var alerts = await s.Rig.QueryAsync("SELECT kind FROM notifications WHERE kind = 'sell_not_filled'", r => r.Text("kind")).ConfigureAwait(false); Assert.HasCount(1, alerts, "One alert, then it carries on."); Assert.IsFalse((await OrdersAsync(s.Rig).ConfigureAwait(false)).Any(o => o.Purpose == "exit" && o.Kind == "market"), "Never a market order for a strategy's exit."); Assert.IsFalse((await OrdersAsync(s.Rig).ConfigureAwait(false)).Any(o => o.Purpose == "stop" && o.Status == "submitted"), "The stops leave before the sale."); // Buyers come back: sold, the trade closes. s.Rig.Quote("BTC-EUR", 59990m, 60000m); await s.Rig.TurnsAsync(s.Manager, 3, _minute).ConfigureAwait(false); Assert.AreEqual("done/filled", await ExecutionStatusAsync(s.Rig, execution.Value).ConfigureAwait(false)); Assert.AreEqual("closed", (await s.Rig.QueryAsync("SELECT status FROM trades", r => r.Text("status")).ConfigureAwait(false)).Single()); } [TestMethod] [TestCategory(Category.Simulation)] public async Task AtMostSixSendsAMinuteWithSalesAndStepsFirst() { await using var s = await OkxAsync().ConfigureAwait(false); var coins = new List(); for (var i = 1; i <= 9; i++) { var coin = await s.Rig.InstrumentAsync(MarketDataStoreTests.Okx($"C{i}-EUR") with { TickSize = 0.01m, LotSize = 0.0001m, MinSize = 0.001m }).ConfigureAwait(false); s.Rig.Quote(coin.Symbol, 100m, 100.10m); coins.Add(coin); } TradeIntent BuyOf(Instrument coin, bool aggressive = false) => new(coin.Id, StrategyNames.CryptoTrend, OrderSide.Buy, 1m, OrderPurpose.Entry, Ids.NewId(s.Rig.Clock)) { StartAggressive = aggressive, StopLevel = 90m }; // A position to sell later. await s.Manager.SubmitAsync(BuyOf(coins[8], aggressive: true), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 2, TimeSpan.FromMinutes(2)).ConfigureAwait(false); var held = (await s.Rig.Ledger.PositionAsync(s.Account.AccountId, coins[8].Id, StrategyNames.CryptoTrend, _none).ConfigureAwait(false))!.Quantity; var buys = new List(); foreach (var coin in coins.Take(8)) { buys.Add((await s.Manager.SubmitAsync(BuyOf(coin), _none).ConfigureAwait(false)).Execution!.Value); } var sale = (await s.Manager.SubmitAsync(new TradeIntent(coins[8].Id, StrategyNames.CryptoTrend, OrderSide.Sell, held, OrderPurpose.Exit, Ids.NewId(s.Rig.Clock)), _none) .ConfigureAwait(false)).Execution!.Value; await s.Rig.TurnsAsync(s.Manager, 1, TimeSpan.FromSeconds(30)).ConfigureAwait(false); // Six sends: the sale first, then five new buys; three buys wait in line. Stops do not count. var sent = await s.Rig.QueryAsync("SELECT execution_id FROM orders WHERE purpose IN ('entry', 'exit') AND created_at > @t", r => r.Id("execution_id"), ("t", TradingRig.Start.AddMinutes(3))).ConfigureAwait(false); Assert.HasCount(6, sent); Assert.Contains(sale, sent); Assert.AreEqual(5, sent.Count(buys.Contains)); // Within the same minute nothing else goes. await s.Rig.TurnsAsync(s.Manager, 1, TimeSpan.FromSeconds(31)).ConfigureAwait(false); Assert.HasCount(6, await s.Rig.QueryAsync("SELECT id FROM orders WHERE purpose IN ('entry', 'exit') AND created_at > @t", r => r.Id("id"), ("t", TradingRig.Start.AddMinutes(3))).ConfigureAwait(false)); // The next minute: the sale and the five buys already working take their next step; the three new buys still wait. await s.Rig.TurnsAsync(s.Manager, 1, TimeSpan.FromSeconds(30)).ConfigureAwait(false); var started = await s.Rig.QueryAsync("SELECT DISTINCT execution_id FROM orders WHERE purpose = 'entry' AND created_at > @t", r => r.Id("execution_id"), ("t", TradingRig.Start.AddMinutes(3))).ConfigureAwait(false); Assert.HasCount(5, started.Where(buys.Contains).ToList()); Assert.HasCount(12, await s.Rig.QueryAsync("SELECT id FROM orders WHERE purpose IN ('entry', 'exit') AND created_at > @t", r => r.Id("id"), ("t", TradingRig.Start.AddMinutes(3))).ConfigureAwait(false)); Assert.AreEqual(0, s.Manager.Pacer.Available); } [TestMethod] [TestCategory(Category.Simulation)] public async Task AlpacaStopsAreGtcForWholeSharesAndDayForTheFractionAndFollowEveryChange() { await using var s = await AlpacaAsync().ConfigureAwait(false); await s.Manager.SubmitAsync(Buy(s, 10.5m, stop: 380m, aggressive: true, strategy: StrategyNames.EquityMomentum), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 2, _minute).ConfigureAwait(false); var stops = (await OrdersAsync(s.Rig).ConfigureAwait(false)).Where(o => o.Purpose == "stop" && o.Status == "submitted").OrderBy(o => o.Quantity).ToList(); Assert.AreEqual(2, stops.Count); Assert.AreEqual((0.5m, "day"), (stops[0].Quantity, stops[0].Tif)); Assert.AreEqual((10m, "gtc"), (stops[1].Quantity, stops[1].Tif)); Assert.IsTrue(stops.All(o => o.Stop == 380m && o.Kind == "stop")); // Adding to the position: Alpaca refuses a buy with a sell stop open, so the stops leave, the buy goes, they come back. await s.Manager.SubmitAsync(Buy(s, 5m, aggressive: true, strategy: StrategyNames.EquityMomentum), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 2, _minute).ConfigureAwait(false); var all = await OrdersAsync(s.Rig).ConfigureAwait(false); Assert.IsTrue(stops.All(old => all.Single(o => o.ClientId == old.ClientId).Status == "canceled")); var now = all.Where(o => o.Purpose == "stop" && o.Status == "submitted").OrderBy(o => o.Quantity).ToList(); Assert.AreEqual((0.5m, "day", 15m, "gtc"), (now[0].Quantity, now[0].Tif, now[1].Quantity, now[1].Tif)); Assert.IsGreaterThan(ClientOrderIds.Parse(stops[1].ClientId)!.Sequence, ClientOrderIds.Parse(now[0].ClientId)!.Sequence, "A new send, a new progressive."); // At the close the day stop expires; the GTC one fires overnight: the two count as one, the rest is sold at once. await s.Paper.ExpireDayOrdersAsync(_none).ConfigureAwait(false); s.Rig.Quote("MSFT", 379m, 379.20m); await s.Paper.PumpAsync(_none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 3, _minute).ConfigureAwait(false); Assert.IsNull(await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.EquityMomentum, _none).ConfigureAwait(false)); var protective = (await OrdersAsync(s.Rig).ConfigureAwait(false)).Single(o => o.Purpose == "protective"); Assert.AreEqual(("market", 0.5m, "filled"), (protective.Kind, protective.Quantity, protective.Status)); Assert.AreEqual("stop", (await s.Rig.QueryAsync("SELECT exit_reason FROM trades", r => r.Text("exit_reason")).ConfigureAwait(false)).Single()); } [TestMethod] [TestCategory(Category.Simulation)] public async Task AStopAlreadyPassedSellsAtMarketUnlessASplitExplainsIt() { await using (var s = await OkxAsync().ConfigureAwait(false)) { await s.Manager.SubmitAsync(Buy(s, 0.01m, aggressive: true), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 2, _minute).ConfigureAwait(false); // The level to place is already above the price: the stop counts as fired (SPEC 7.2). await s.Rig.Ledger.SetStopAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.CryptoTrend, 61000m, _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 3, _minute).ConfigureAwait(false); Assert.IsNull(await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.CryptoTrend, _none).ConfigureAwait(false)); Assert.AreEqual("market", (await OrdersAsync(s.Rig).ConfigureAwait(false)).Single(o => o.Purpose == "protective").Kind); Assert.AreEqual("stop", (await s.Rig.QueryAsync("SELECT exit_reason FROM trades", r => r.Text("exit_reason")).ConfigureAwait(false)).Single()); Assert.HasCount(1, await s.Rig.QueryAsync("SELECT id FROM notifications WHERE kind = 'stop_already_passed'", r => r.Id("id")).ConfigureAwait(false)); } // The morning of a 4-for-1 split the broker already shows a quarter of the price: a stop at the old level is // not placed and nothing is sold; the split is applied and the stop follows it. var applied = false; await using var a = await AlpacaAsync((instrument, _) => { var first = !applied; applied = true; return Task.FromResult(first ? new CorporateAction(instrument.Symbol, CorporateActionKinds.Split, new DateOnly(2026, 11, 11), "test", "split-msft") { Ratio = 4m } : null); }).ConfigureAwait(false); await a.Manager.SubmitAsync(Buy(a, 10m, aggressive: true, strategy: StrategyNames.EquityMomentum), _none).ConfigureAwait(false); await a.Rig.TurnsAsync(a.Manager, 2, _minute).ConfigureAwait(false); a.Rig.Clock.Advance(TimeSpan.FromDays(1)); a.Rig.Quote("MSFT", 100m, 100.05m); await a.Rig.Ledger.SetStopAsync(a.Account.AccountId, a.Instrument.Id, StrategyNames.EquityMomentum, 380m, _none).ConfigureAwait(false); await a.Rig.TurnsAsync(a.Manager, 2, _minute).ConfigureAwait(false); Assert.IsTrue(applied); var position = (await a.Rig.Ledger.PositionAsync(a.Account.AccountId, a.Instrument.Id, StrategyNames.EquityMomentum, _none).ConfigureAwait(false))!; Assert.AreEqual((40m, 95m), (position.Quantity, position.StopPrice)); Assert.IsFalse((await OrdersAsync(a.Rig).ConfigureAwait(false)).Any(o => o.Purpose == "protective")); var stop = (await OrdersAsync(a.Rig).ConfigureAwait(false)).Single(o => o.Purpose == "stop" && o.Status == "submitted"); Assert.AreEqual((40m, 95m), (stop.Quantity, stop.Stop)); Assert.AreEqual(40m, (await a.Paper.GetPositionsAsync(_none).ConfigureAwait(false)).Single().Quantity, "The simulator's book follows the same split."); } [TestMethod] [TestCategory(Category.Simulation)] public async Task ALostAnswerIsNeverSentTwiceDuplicateFillsCountOnceAndRefusalsEndTheBuy() { await using var s = await OkxAsync().ConfigureAwait(false); var faulty = new FaultyBroker(s.Paper) { LoseNextAnswer = true, DuplicateFills = true }; var manager = s.Rig.Manager(faulty, s.Account); var (execution, _) = await manager.SubmitAsync(Buy(s, 0.01m, stop: 57000m, aggressive: true), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(manager, 1, TimeSpan.FromSeconds(5)).ConfigureAwait(false); var lost = (await OrdersAsync(s.Rig).ConfigureAwait(false)).Single(); Assert.AreEqual("created", lost.Status, "The answer was lost: the bot does not know yet."); // Restart in the middle of the order: a new manager asks the broker before resending and finds it. var restarted = s.Rig.Manager(faulty, s.Account); await s.Rig.TurnsAsync(restarted, 3, TimeSpan.FromSeconds(5)).ConfigureAwait(false); Assert.HasCount(1, faulty.Sent.Where(r => r.ClientOrderId == lost.ClientId).ToList(), "Sent once."); Assert.AreEqual("done/filled", await ExecutionStatusAsync(s.Rig, execution!.Value).ConfigureAwait(false)); Assert.HasCount(1, await s.Rig.QueryAsync("SELECT id FROM fills", r => r.Id("id")).ConfigureAwait(false), "Every fill was reported twice, recorded once."); Assert.AreEqual(0.00998m, (await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.CryptoTrend, _none).ConfigureAwait(false))!.Quantity); // A refused buy ends, with its reason in the diary. faulty.RejectNext = "insufficient"; var (refused, _) = await restarted.SubmitAsync(Buy(s, 0.01m, aggressive: true), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(restarted, 2, TimeSpan.FromSeconds(5)).ConfigureAwait(false); Assert.AreEqual("canceled/rejected_insufficient", await ExecutionStatusAsync(s.Rig, refused!.Value).ConfigureAwait(false)); Assert.HasCount(1, await s.Rig.QueryAsync("SELECT id FROM journal WHERE code = 'order_rejected'", r => r.Id("id")).ConfigureAwait(false)); // A prudent account takes no new entries; exits still go (SPEC 7.4). await s.Rig.Db.WriteAsync(x => x.ExecuteAsync("INSERT INTO account_status (id, account_id, mode, created_at, updated_at) VALUES (@id, @a, 'prudent', @now, @now)", _none, ("id", Ids.NewId(s.Rig.Clock)), ("a", s.Account.AccountId), ("now", s.Rig.Clock.UtcNow)), _none).ConfigureAwait(false); Assert.AreEqual(OrderReasons.PrudentMode, (await restarted.SubmitAsync(Buy(s, 0.01m), _none).ConfigureAwait(false)).Refusal); Assert.IsNull((await restarted.SubmitAsync(Sell(s, 0.005m), _none).ConfigureAwait(false)).Refusal); } [TestMethod] [TestCategory(Category.Simulation)] public async Task WhatCannotBeSoldAfterAnExitIsWrittenOffAndListedApart() { await using var s = await OkxAsync(TradingRig.Pepe, bid: 0.00001m, ask: 0.00001001m).ConfigureAwait(false); await s.Manager.SubmitAsync(Buy(s, 10_000_000m, aggressive: true), _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 2, _minute).ConfigureAwait(false); var held = (await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.CryptoTrend, _none).ConfigureAwait(false))!.Quantity; Assert.AreEqual(9_980_000m, held); s.Rig.Quote("PEPE-EUR", 0.0000099m, 0.00000991m); var (execution, _) = await s.Manager.SubmitAsync(Sell(s, 9_900_000m) with { StartAggressive = true }, _none).ConfigureAwait(false); await s.Rig.TurnsAsync(s.Manager, 3, _minute).ConfigureAwait(false); Assert.AreEqual("done/filled", await ExecutionStatusAsync(s.Rig, execution!.Value).ConfigureAwait(false)); Assert.IsNull(await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Instrument.Id, StrategyNames.CryptoTrend, _none).ConfigureAwait(false)); var residue = (await s.Rig.QueryAsync("SELECT quantity, reason FROM residues", r => (Q: r.Money("quantity"), R: r.Text("reason"))).ConfigureAwait(false)).Single(); Assert.AreEqual((80_000m, "below_minimum"), (residue.Q, residue.R)); Assert.AreEqual(("closed", "residue"), (await s.Rig.QueryAsync("SELECT status, exit_reason FROM trades", r => (r.Text("status"), r.Text("exit_reason"))).ConfigureAwait(false)).Single()); Assert.IsEmpty(await s.Paper.GetOpenOrdersAsync(_none).ConfigureAwait(false), "No stop for a residue the bot no longer owns."); Assert.AreEqual(80_000m, (await s.Paper.GetPositionsAsync(_none).ConfigureAwait(false)).Single().Quantity, "The residue stays on the account."); } }