using Anubis.Core; using Anubis.Data; using Anubis.Db; using Anubis.Platform; using Anubis.Risk; using Anubis.Trading; namespace Anubis.Tests; /// /// The risk engine at work on the database (issues #42, #43; SPEC 9, 12.3, 12.4): the gate of every order, the switch /// of each world, the STOP file, the orders per minute, the day-trade guard, and the only way to real money, tested /// against a fake real account (a simulator that says "live"). /// [TestClass] public sealed class RiskEngineTests { private static readonly CancellationToken _none = CancellationToken.None; private static readonly TimeSpan _minute = TimeSpan.FromSeconds(60); private const string Password = "password-giusta"; private sealed class Setup : IAsyncDisposable { public required TradingRig Rig { get; init; } public required SettingsStore Settings { get; init; } public required StageBook Stages { get; init; } public required RiskEngine Risk { get; init; } public required AccountContext Account { get; init; } public required Instrument Btc { get; init; } public List Owned { get; } = []; public string? Folder { get; init; } public async ValueTask DisposeAsync() { foreach (var owned in Owned) { owned.Dispose(); } if (Folder is not null) { TempFolder.Delete(Folder); } await Rig.DisposeAsync().ConfigureAwait(false); } } /// A real-money consent as the startup configuration would give it: only for the fake real account of these tests. private static TradingConsent Consent() => TradingConsent.From(DockerPlatform.Load(new Dictionary { ["ANUBIS_DB_ENGINE"] = "sqlite", ["ANUBIS_SECRET_KEY"] = new string('k', 40), ["ANUBIS_ADMIN_PASSWORD"] = "initial-pass-1", ["ANUBIS_ALLOW_LIVE"] = "1", })); /// crypto_trend in simulation on the OKX simulator with 10 000 €, BTC at 60 000. private static async Task CreateAsync(TradingConsent? consent = null, bool stopFile = false) { var rig = await TradingRig.CreateAsync().ConfigureAwait(false); var settings = new SettingsStore(rig.Db, rig.Clock, new EventBus()); var stages = new StageBook(rig.Db, rig.Clock, consent ?? TradingConsent.None, (password, _, _) => Task.FromResult(password == Password)); var folder = stopFile ? TempFolder.Create("stop") : null; var risk = new RiskEngine(rig.Db, rig.Clock, rig.Ledger, stages, settings, new FxStore(rig.Db, rig.Clock), rig.FindAsync, rig.QuoteAsync) { StopFile = folder is null ? null : Path.Combine(folder, "STOP"), }; var account = await rig.AccountAsync(Venues.Okx, TradingEnvironments.Simulation).ConfigureAwait(false); var btc = await rig.InstrumentAsync(TradingRig.Btc).ConfigureAwait(false); rig.Quote(btc.Symbol, 60_000m, 60_010m); await rig.Ledger.RecordCapitalAsync(account.AccountId, StrategyNames.CryptoTrend, 10_000m, "EUR", "test", _none).ConfigureAwait(false); await StageRowAsync(rig, StrategyNames.CryptoTrend, account.AccountId, StrategyStages.Simulation, rig.Clock.UtcNow).ConfigureAwait(false); return new Setup { Rig = rig, Settings = settings, Stages = stages, Risk = risk, Account = account, Btc = btc, Folder = folder }; } private static Task StageRowAsync(TradingRig rig, string strategy, Guid account, string stage, DateTimeOffset since) => rig.Db.WriteAsync(s => s.ExecuteAsync( "INSERT INTO strategy_state (id, strategy, account_id, stage, capital, state, created_at, updated_at, share, stage_since) VALUES (@id, @s, @a, @st, 0, @j, @t, @t, 1, @since)", _none, ("id", Ids.NewId(rig.Clock)), ("s", strategy), ("a", account), ("st", stage), ("j", new DbJson("{}")), ("t", rig.Clock.UtcNow), ("since", since)), _none); private static TradeIntent Buy(Setup s, decimal quantity, string strategy = StrategyNames.CryptoTrend, Instrument? instrument = null) => new((instrument ?? s.Btc).Id, strategy, OrderSide.Buy, quantity, OrderPurpose.Entry, Ids.NewId(s.Rig.Clock)) { StopLevel = 57_000m }; private static TradeIntent Sell(Setup s, decimal quantity, string strategy = StrategyNames.CryptoTrend, OrderPurpose purpose = OrderPurpose.Exit, Instrument? instrument = null) => new((instrument ?? s.Btc).Id, strategy, OrderSide.Sell, quantity, purpose, Ids.NewId(s.Rig.Clock)); private static Task HoldAsync(Setup s, AccountContext account, decimal quantity, string strategy = StrategyNames.CryptoTrend, Instrument? instrument = null) => s.Rig.Ledger.RecordFillAsync(s.Rig.Fill(account, instrument ?? s.Btc, strategy, OrderSide.Buy, quantity, 60_000m), _none); private static Task SnapshotAsync(TradingRig rig, string world, DateTimeOffset at, decimal index) => rig.Db.WriteAsync(s => s.ExecuteAsync( "INSERT INTO equity_snapshots (id, taken_at, scope, account_id, strategy, equity, cash, invested, drawdown_pct, created_at, world, currency, flows, twr_index, peak_index) " + "VALUES (@id, @t, 'total', NULL, NULL, @e, @e, 0, 0, @t, @w, 'EUR', 10000, @x, @x)", _none, ("id", Ids.NewId(rig.Clock)), ("t", at), ("e", 10_000m * index), ("w", world), ("x", index)), _none); private static Task> EventsAsync(TradingRig rig, string kind) => rig.QueryAsync("SELECT severity FROM risk_events WHERE kind = @k", r => r.Text("severity"), ("k", kind)); // ---- The gate: stop, pause, ownership, sizes ---- [TestMethod] [TestCategory(Category.Integration)] public async Task PauseStopsEntriesAndStopStopsEverythingButProtection() { await using var s = await CreateAsync(); await HoldAsync(s, s.Account, 0.01m); Assert.AreEqual(0.01m, (await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Quantity); await s.Settings.SetAsync(SettingsStore.BotState.Key, "paused", "test"); Assert.AreEqual(RiskReasons.BotPaused, (await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal); Assert.IsNull((await s.Risk.GateAsync(Sell(s, 0.01m), s.Account, _none)).Refusal, "exits go on in pause"); await s.Settings.SetAsync(SettingsStore.BotState.Key, "stopped", "test"); Assert.AreEqual(RiskReasons.BotStopped, (await s.Risk.GateAsync(Sell(s, 0.01m), s.Account, _none)).Refusal, "no sales on the strategy's initiative"); Assert.IsNull((await s.Risk.GateAsync(Sell(s, 0.01m, purpose: OrderPurpose.Protective), s.Account, _none)).Refusal, "protection always passes"); } [TestMethod] [TestCategory(Category.Integration)] public async Task NoShortSalesAndNothingThatTheStrategyDidNotBuy() { await using var s = await CreateAsync(); Assert.AreEqual(RiskReasons.NotOwned, (await s.Risk.GateAsync(Sell(s, 0.01m), s.Account, _none)).Refusal, "a position the bot did not open is never touched"); await HoldAsync(s, s.Account, 0.01m); Assert.AreEqual(RiskReasons.OwnedByOther, (await s.Risk.GateAsync(Sell(s, 0.01m, StrategyNames.EquityMomentum), s.Account, _none)).Refusal); var more = await s.Risk.GateAsync(Sell(s, 0.05m), s.Account, _none); Assert.AreEqual(0.01m, more.Quantity); CollectionAssert.Contains(more.Reasons.ToList(), RiskReasons.NoShortSelling); Assert.AreEqual(RiskReasons.NoShortSelling, (await s.Risk.GateAsync(Buy(s, 0.01m) with { Purpose = OrderPurpose.Exit }, s.Account, _none)).Refusal); } [TestMethod] [TestCategory(Category.Integration)] public async Task APurchaseIsShrunkAndTheDecisionRecordsWhy() { await using var s = await CreateAsync(); var intent = Buy(s, 0.5m); var result = await s.Risk.GateAsync(intent, s.Account, _none); // 0.5 BTC is three times the equity; 20% of it at 60 010 is 0.0333 BTC; the risk to the stop, 1% of 10 000 over 3 010, a little less. Assert.IsNull(result.Refusal); Assert.AreEqual(Math.Round(100m / 3_010m, 8), Math.Round(result.Quantity, 8)); CollectionAssert.AreEqual(new[] { RiskReasons.InvestedLimit, RiskReasons.PositionLimit, RiskReasons.TradeRiskLimit }, result.Reasons.ToList(), string.Join(",", result.Reasons)); var row = (await new DecisionLog(s.Rig.Db, s.Rig.Clock).OfAsync(intent.DecisionId, _none)).Single(); Assert.AreEqual(DecisionStages.Risk, row.Stage); Assert.AreEqual(DecisionOutcomes.Reduced, row.Outcome); CollectionAssert.Contains(row.Reasons.ToList(), RiskReasons.TradeRiskLimit); Assert.IsTrue(row.Data!.ContainsKey("reference")); // No leverage: with the rest of the bot ten times larger the limits allow more, the strategy's own cash does not. // The purchase counts at the highest price its limit may chase to. await s.Rig.Ledger.RecordCapitalAsync(s.Account.AccountId, "sma_cross", 90_000m, "EUR", "test", _none); var poor = await s.Risk.GateAsync(Buy(s, 0.5m), s.Account, _none); Assert.AreEqual(Math.Round(10_000m / (60_010m * (1m + RiskLimits.Default.MaxPriceGap)), 8), Math.Round(poor.Quantity, 8)); Assert.AreEqual(RiskReasons.NoLeverage, poor.Reasons[^1]); } [TestMethod] [TestCategory(Category.Integration)] public async Task OldPricesStopEntriesButNotExits() { await using var s = await CreateAsync(); await HoldAsync(s, s.Account, 0.01m); s.Rig.Clock.Advance(TimeSpan.FromSeconds(61)); Assert.AreEqual(RiskReasons.StalePrice, (await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal); Assert.IsNull((await s.Risk.GateAsync(Sell(s, 0.01m), s.Account, _none)).Refusal); s.Rig.Refresh(); var skewed = new RiskEngine(s.Rig.Db, s.Rig.Clock, s.Rig.Ledger, s.Stages, s.Settings, new FxStore(s.Rig.Db, s.Rig.Clock), s.Rig.FindAsync, s.Rig.QuoteAsync) { ClockSkew = _ => TimeSpan.FromSeconds(3), }; Assert.AreEqual(RiskReasons.ClockSkew, (await skewed.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal); } [TestMethod] [TestCategory(Category.Integration)] public async Task AStrategyInObservationNeverBuys() { await using var s = await CreateAsync(); await s.Rig.Db.WriteAsync(x => x.ExecuteAsync("UPDATE strategy_state SET stage = 'observation'", _none), _none); Assert.AreEqual(RiskReasons.Observation, (await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal); } // ---- 9.2: the limits of each world ---- [TestMethod] [TestCategory(Category.Integration)] public async Task ADayOfLossesBlocksEntriesOfThatWorldOnly() { await using var s = await CreateAsync(); var now = s.Rig.Clock.UtcNow; await SnapshotAsync(s.Rig, Worlds.Simulated, now - TimeSpan.FromHours(10), 1.00m); await SnapshotAsync(s.Rig, Worlds.Simulated, now, 0.975m); await SnapshotAsync(s.Rig, Worlds.Real, now - TimeSpan.FromHours(10), 1.00m); await SnapshotAsync(s.Rig, Worlds.Real, now, 1.01m); var alerts = await s.Risk.CheckAsync([], _none); Assert.IsTrue(alerts.Any(a => a.Kind == RiskAlertKinds.DailyLoss)); Assert.AreEqual(RiskSeverities.High, (await EventsAsync(s.Rig, RiskAlertKinds.DailyLoss)).Single()); Assert.AreEqual(RiskReasons.DailyLossBlock, (await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal); Assert.IsFalse((await s.Risk.WorldAsync(Worlds.Real, _none)).EntriesBlocked, "the real world goes on"); Assert.IsNotEmpty(await s.Rig.QueryAsync("SELECT code FROM journal WHERE code = @c", r => r.Text("code"), ("c", RiskAlertKinds.DailyLoss)), "the diary says it"); // A second check does not repeat the alert; after 24 hours entries are back. await s.Risk.CheckAsync([], _none); Assert.HasCount(1, await EventsAsync(s.Rig, RiskAlertKinds.DailyLoss)); s.Rig.Clock.Advance(TimeSpan.FromHours(24) + _minute); s.Rig.Refresh(); Assert.IsNull((await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal); } [TestMethod] [TestCategory(Category.Integration)] public async Task TheSwitchTripsAtFifteenPercentAndOnlyTheUserRestartsIt() { await using var s = await CreateAsync(); await HoldAsync(s, s.Account, 0.01m); await SnapshotAsync(s.Rig, Worlds.Simulated, s.Rig.Clock.UtcNow, 1.00m); await s.Risk.CheckAsync([], _none); s.Rig.Clock.Advance(TimeSpan.FromDays(5)); await SnapshotAsync(s.Rig, Worlds.Simulated, s.Rig.Clock.UtcNow, 1.20m); await s.Risk.CheckAsync([], _none); // The high of ten days ago is outside the series read now, but remembered. s.Rig.Clock.Advance(TimeSpan.FromDays(10)); s.Rig.Refresh(); await SnapshotAsync(s.Rig, Worlds.Simulated, s.Rig.Clock.UtcNow, 1.00m); await s.Risk.CheckAsync([], _none); var world = await s.Risk.WorldAsync(Worlds.Simulated, _none); Assert.IsTrue(world.State.Tripped); Assert.AreEqual(RiskSeverities.Critical, (await EventsAsync(s.Rig, RiskAlertKinds.DrawdownStop)).Single()); Assert.AreEqual(RiskReasons.SwitchTripped, (await s.Risk.GateAsync(Sell(s, 0.01m), s.Account, _none)).Refusal); Assert.IsFalse((await s.Risk.WorldAsync(Worlds.Real, _none)).State.Tripped); // Days pass: nothing rearms by itself. s.Rig.Clock.Advance(TimeSpan.FromDays(3)); await s.Risk.CheckAsync([], _none); Assert.IsTrue((await s.Risk.WorldAsync(Worlds.Simulated, _none)).State.Tripped); await s.Risk.RestartAsync("utente", _none); world = await s.Risk.WorldAsync(Worlds.Simulated, _none); Assert.IsFalse(world.State.Tripped); Assert.AreEqual(0m, world.Measures.Drawdown, "the high starts again from now"); Assert.AreEqual("active", (await s.Settings.GetAsync(SettingsStore.BotState.Key)).Value); Assert.AreEqual(RiskSeverities.Info, (await EventsAsync(s.Rig, "restart")).Single(), "the restart is recorded with who confirmed it"); } [TestMethod] [TestCategory(Category.Integration)] public async Task TenOrdersInAMinuteStopTheBot() { await using var s = await CreateAsync(); async Task OrdersAsync(int count, string purpose) { for (var i = 0; i < count; i++) { await s.Rig.Db.WriteAsync(x => x.ExecuteAsync( "INSERT INTO orders (id, account_id, instrument_id, strategy, client_order_id, side, order_type, quantity, status, created_at, updated_at, purpose, submitted_at) " + "VALUES (@id, @a, @i, 'crypto_trend', @c, 'buy', 'limit', 1, 'submitted', @t, @t, @p, @t)", _none, ("id", Ids.NewId(s.Rig.Clock)), ("a", s.Account.AccountId), ("i", s.Btc.Id), ("c", "T" + Ids.NewId(s.Rig.Clock).ToString("N")), ("t", s.Rig.Clock.UtcNow), ("p", purpose)), _none); } } await OrdersAsync(9, "entry"); await OrdersAsync(5, "stop"); await s.Risk.CheckAsync([], _none); Assert.AreEqual("active", (await s.Settings.GetAsync(SettingsStore.BotState.Key)).Value, "stops do not count"); await OrdersAsync(1, "exit"); await s.Risk.CheckAsync([], _none); Assert.AreEqual("stopped", (await s.Settings.GetAsync(SettingsStore.BotState.Key)).Value); // A stop is not a critical incident of SPEC 12.3: it must not hold back a promotion for 30 days. Assert.AreEqual(RiskSeverities.High, (await EventsAsync(s.Rig, RiskReasons.OrdersPerMinute)).Single()); } [TestMethod] [TestCategory(Category.Integration)] public async Task TheStopFileStopsEverythingAndBlocksTheRestart() { await using var s = await CreateAsync(stopFile: true); await File.WriteAllTextAsync(s.Risk.StopFile!, ""); Assert.AreEqual(RiskReasons.BotStopped, (await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal, "at once, before the check"); await s.Risk.CheckAsync([], _none); Assert.AreEqual("stopped", (await s.Settings.GetAsync(SettingsStore.BotState.Key)).Value); await Assert.ThrowsExactlyAsync(() => s.Risk.RestartAsync("utente", _none)); File.Delete(s.Risk.StopFile!); Assert.AreEqual(RiskReasons.BotStopped, (await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal, "removing the file does not restart"); await s.Risk.RestartAsync("utente", _none); Assert.IsNull((await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal); } [TestMethod] [TestCategory(Category.Integration)] public async Task StopEverythingCancelsWorkOrdersButKeepsTheStops() { await using var s = await CreateAsync(); var paper = s.Rig.Paper(PaperOptions.Okx(), s.Account.AccountId); await paper.DepositAsync(100_000m, "EUR", _none); var manager = s.Rig.Manager(paper, s.Account); await manager.SubmitAsync(Buy(s, 0.01m) with { StartAggressive = true }, _none); await s.Rig.TurnsAsync(manager, 2, _minute); var stops = await paper.GetOpenOrdersAsync(_none); Assert.HasCount(1, stops, "the stop of the position"); // A sale far from the price stays working; "Ferma tutto" cancels it and puts the stop back. s.Rig.Quote(s.Btc.Symbol, 60_000m, 60_010m); var held = (await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Btc.Id, StrategyNames.CryptoTrend, _none))!.Quantity; await manager.SubmitAsync(Sell(s, held), _none); await s.Risk.StopAllAsync([manager], "utente", "stop_all", "Fermo tutto.", _none); await s.Rig.TurnsAsync(manager, 1, _minute); Assert.AreEqual("stopped", (await s.Settings.GetAsync(SettingsStore.BotState.Key)).Value); Assert.AreEqual(held, (await s.Rig.Ledger.PositionAsync(s.Account.AccountId, s.Btc.Id, StrategyNames.CryptoTrend, _none))?.Quantity, "the position stays"); var open = await paper.GetOpenOrdersAsync(_none); Assert.IsTrue(open.Any(o => o.Kind == OrderKind.Stop || o.StopPrice is not null), "the stop is there"); Assert.IsEmpty(await s.Rig.QueryAsync("SELECT id FROM executions WHERE status = 'working'", r => r.Id("id"))); } // ---- 9.2: the day-trade guard ---- [TestMethod] [TestCategory(Category.Integration)] public async Task TheDayTradeGuardKeepsMeanReversionInAndCountsTheDay() { await using var s = await CreateAsync(); var alpaca = await s.Rig.AccountAsync(Venues.Alpaca, TradingEnvironments.Simulation); var stocks = new List(); foreach (var symbol in new[] { "AAA", "BBB", "CCC", "DDD" }) { var stock = await s.Rig.InstrumentAsync(TradingRig.Stock(symbol)); s.Rig.Quote(symbol, 99.99m, 100m); stocks.Add(stock); } await new FxStore(s.Rig.Db, s.Rig.Clock).UpsertAsync([new FxRate("EUR", "USD", DateOnly.FromDateTime(s.Rig.Clock.UtcNow.UtcDateTime), 1.10m, "test")], _none); await s.Rig.Ledger.RecordCapitalAsync(alpaca.AccountId, StrategyNames.EquityMeanrev, 5_000m, "USD", "test", _none); await s.Rig.Ledger.RecordCapitalAsync(alpaca.AccountId, StrategyNames.EquityMomentum, 5_000m, "USD", "test", _none); await s.Rig.Ledger.RecordFillAsync(s.Rig.Fill(alpaca, stocks[0], StrategyNames.EquityMeanrev, OrderSide.Buy, 1m, 100m), _none); await s.Rig.Ledger.RecordFillAsync(s.Rig.Fill(alpaca, stocks[1], StrategyNames.EquityMomentum, OrderSide.Buy, 1m, 100m), _none); // Off by default: mean reversion may leave on the day it entered. Assert.IsNull((await s.Risk.GateAsync(Sell(s, 1m, StrategyNames.EquityMeanrev, instrument: stocks[0]), alpaca, _none)).Refusal); await s.Settings.SetAsync(RiskSettings.PdtGuard.Key, "on", "test"); Assert.AreEqual(RiskEngine.PdtReason, (await s.Risk.GateAsync(Sell(s, 1m, StrategyNames.EquityMeanrev, instrument: stocks[0]), alpaca, _none)).Refusal); Assert.IsNull((await s.Risk.GateAsync(Sell(s, 1m, StrategyNames.EquityMomentum, instrument: stocks[1]), alpaca, _none)).Refusal); // Two positions opened today: one more allowed, then none. Assert.AreEqual(1, await s.Risk.PdtRoomAsync(alpaca.AccountId, _none)); Assert.IsNull((await s.Risk.GateAsync(Buy(s, 1m, StrategyNames.EquityMomentum, stocks[2]) with { StopLevel = 99m }, alpaca, _none)).Refusal); await s.Rig.Ledger.RecordFillAsync(s.Rig.Fill(alpaca, stocks[2], StrategyNames.EquityMomentum, OrderSide.Buy, 1m, 100m), _none); Assert.AreEqual(RiskEngine.PdtReason, (await s.Risk.GateAsync(Buy(s, 1m, StrategyNames.EquityMomentum, stocks[3]) with { StopLevel = 99m }, alpaca, _none)).Refusal); // Crypto is not touched by it. Assert.IsNull((await s.Risk.GateAsync(Buy(s, 0.001m), s.Account, _none)).Refusal); } // ---- 12.4: real money only with the procedure ---- private sealed record Live(FaultyBroker Broker, PaperBroker Paper, AccountContext Account, OrderManager Manager); /// A fake real account: the simulator behind a broker that says "live", and its order manager wired as in the service. private static async Task FakeRealAccountAsync(Setup s, bool permit = true) { var account = await s.Rig.AccountAsync(Venues.Okx, TradingEnvironments.Live, "OKX reale (finto)"); var paper = s.Rig.Paper(PaperOptions.Okx(), account.AccountId); await paper.DepositAsync(100_000m, "EUR", _none); var broker = new FaultyBroker(paper, TradingEnvironments.Live); var manager = new OrderManager(s.Rig.Db, s.Rig.Clock, s.Rig.Ledger, broker, account, TradingRig.Installation, s.Rig.FindAsync, s.Rig.QuoteAsync) { ConfirmPrice = s.Rig.QuoteAsync, MarketOpen = (_, _) => Task.FromResult(true), Gate = s.Risk.GateAsync, LivePermit = permit ? s.Stages.LiveRefusalAsync : null, }; s.Owned.Add(manager); return new Live(broker, paper, account, manager); } /// Everything SPEC 12.3 asks before reduced real: 60 days, 8 closed trades, the one-step comparison, the backtest passed. private static async Task RequirementsMetAsync(Setup s) { var since = s.Rig.Clock.UtcNow - TimeSpan.FromDays(61); await s.Rig.Db.WriteAsync(x => x.ExecuteAsync("UPDATE strategy_state SET stage_since = @t", _none, ("t", since)), _none); await s.Stages.ApplyQualificationAsync(StrategyNames.CryptoTrend, new Qualification { Passed = true, Verdict = "superato", Report = "docs/backtests/crypto_trend.md", MaxDrawdown = 0.20m, ExpectedSlippageBp = 5m, RoundTripCost = 0.004m, }, _none); for (var i = 0; i < 8; i++) { var closed = since + TimeSpan.FromDays(5 + (i * 6)); await s.Rig.Db.WriteAsync(x => x.ExecuteAsync( "INSERT INTO trades (id, account_id, instrument_id, strategy, status, opened_at, closed_at, bought_quantity, bought_value, sold_quantity, sold_value, fees, realized, created_at, updated_at) " + "VALUES (@id, @a, @i, 'crypto_trend', 'closed', @o, @c, 0.01, 600, 0.01, 620, 1, 19, @c, @c)", _none, ("id", Ids.NewId(s.Rig.Clock)), ("a", s.Account.AccountId), ("i", s.Btc.Id), ("o", closed - TimeSpan.FromDays(3)), ("c", closed)), _none); await new DecisionLog(s.Rig.Db, s.Rig.Clock).WriteAsync(new DecisionRow(Ids.NewId(s.Rig.Clock), StrategyNames.CryptoTrend, s.Account.AccountId, null, DecisionStages.OneStep, DecisionOutcomes.Same, [], null, closed), _none); } } [TestMethod] [TestCategory(Category.Simulation)] public async Task NoOrderReachesARealAccountWithoutTheProcedure() { // Without the startup consent: nothing, however the strategy stands. await using (var s = await CreateAsync()) { var live = await FakeRealAccountAsync(s); var (id, refusal) = await live.Manager.SubmitAsync(Buy(s, 0.001m), _none); Assert.IsNull(id); Assert.AreEqual(RiskReasons.NoConsent, refusal); await RequirementsMetAsync(s); var refused = await Assert.ThrowsExactlyAsync(() => s.Stages.ConfirmLiveAsync( new LiveConfirmation(StrategyNames.CryptoTrend, live.Account.AccountId, StageBook.Phrase(StrategyNames.CryptoTrend, StrategyStages.Reduced), Password, null, "utente"), _none)); Assert.AreEqual(RiskReasons.NoConsent, refused.Code); await s.Rig.TurnsAsync(live.Manager, 3, _minute); Assert.IsEmpty(live.Broker.Sent); } // An order manager without the permission check sends nothing on a real account: it fails closed. await using (var s = await CreateAsync(Consent())) { var bare = await FakeRealAccountAsync(s, permit: false); Assert.AreEqual(RiskReasons.LiveNotConfirmed, (await bare.Manager.SubmitAsync(Buy(s, 0.001m), _none)).Refusal); Assert.IsEmpty(bare.Broker.Sent); } // With the consent, step by step: every part of the procedure is needed. await using (var s = await CreateAsync(Consent())) { var live = await FakeRealAccountAsync(s); await s.Rig.Ledger.RecordCapitalAsync(live.Account.AccountId, StrategyNames.CryptoTrend, 2_500m, "EUR", "test", _none); Assert.AreEqual(RiskReasons.LiveNotConfirmed, (await live.Manager.SubmitAsync(Buy(s, 0.001m), _none)).Refusal, "simulation is not real money"); await Assert.ThrowsExactlyAsync(() => s.Stages.MoveAsync(StrategyNames.CryptoTrend, StrategyStages.Reduced, "test", "utente", _none), "no shortcut to real money"); var phrase = StageBook.Phrase(StrategyNames.CryptoTrend, StrategyStages.Reduced); LiveConfirmation Ask(string text, string password) => new(StrategyNames.CryptoTrend, live.Account.AccountId, text, password, null, "utente"); Assert.AreEqual("requirements", (await Assert.ThrowsExactlyAsync(() => s.Stages.ConfirmLiveAsync(Ask(phrase, Password), _none))).Code); await RequirementsMetAsync(s); Assert.IsTrue((await s.Stages.RequirementsAsync(StrategyNames.CryptoTrend, _none)).All(r => r.Met)); Assert.AreEqual("phrase", (await Assert.ThrowsExactlyAsync(() => s.Stages.ConfirmLiveAsync(Ask("confermo", Password), _none))).Code); Assert.AreEqual("password", (await Assert.ThrowsExactlyAsync(() => s.Stages.ConfirmLiveAsync(Ask(phrase, "sbagliata"), _none))).Code); await s.Rig.TurnsAsync(live.Manager, 2, _minute); Assert.IsEmpty(live.Broker.Sent, "nothing reached the real account before the confirmation"); s.Rig.Refresh(); await s.Stages.ConfirmLiveAsync(Ask(phrase, Password), _none); var stage = (await s.Stages.GetAsync(StrategyNames.CryptoTrend, _none))!; Assert.AreEqual(StrategyStages.Reduced, stage.Stage); Assert.AreEqual(live.Account.AccountId, stage.LiveAccountId); Assert.IsNotNull(stage.LiveConfirmedAt); Assert.IsNotEmpty(await s.Rig.QueryAsync("SELECT key FROM config_history WHERE key = @k", r => r.Text("key"), ("k", "strategy.crypto_trend.stage"))); Assert.IsNotEmpty(await s.Rig.QueryAsync("SELECT to_stage FROM strategy_stage_history WHERE to_stage = 'reduced'", r => r.Text("to_stage"))); var (id, refusal) = await live.Manager.SubmitAsync(Buy(s, 0.001m) with { StartAggressive = true }, _none); Assert.IsNull(refusal); Assert.IsNotNull(id); await s.Rig.TurnsAsync(live.Manager, 2, _minute); Assert.IsNotEmpty(live.Broker.Sent, "after the procedure the order reaches the account"); // Another strategy on the same account is still refused: the confirmation is for one strategy and one account. Assert.AreEqual(RiskReasons.LiveNotConfirmed, (await live.Manager.SubmitAsync(Buy(s, 0.001m, StrategyNames.EquityMomentum), _none)).Refusal); } } [TestMethod] [TestCategory(Category.Simulation)] public async Task ADemotedStrategyKeepsManagingItsRealPositionsDownToZero() { await using var s = await CreateAsync(Consent()); var live = await FakeRealAccountAsync(s); await s.Rig.Ledger.RecordCapitalAsync(live.Account.AccountId, StrategyNames.CryptoTrend, 2_500m, "EUR", "test", _none); await RequirementsMetAsync(s); await s.Stages.ConfirmLiveAsync(new LiveConfirmation(StrategyNames.CryptoTrend, live.Account.AccountId, StageBook.Phrase(StrategyNames.CryptoTrend, StrategyStages.Reduced), Password, null, "utente"), _none); s.Rig.Refresh(); await live.Manager.SubmitAsync(Buy(s, 0.002m) with { StartAggressive = true }, _none); await s.Rig.TurnsAsync(live.Manager, 3, _minute); var held = (await s.Rig.Ledger.PositionAsync(live.Account.AccountId, s.Btc.Id, StrategyNames.CryptoTrend, _none))!.Quantity; Assert.IsTrue(held is > 0.0019m and <= 0.002m, "bought, less the fee in bitcoin"); Assert.HasCount(1, await live.Paper.GetOpenOrdersAsync(_none), "the stop on the real account"); await s.Stages.DemoteAsync(StrategyNames.CryptoTrend, "drawdown", _none); var stage = (await s.Stages.GetAsync(StrategyNames.CryptoTrend, _none))!; Assert.AreEqual(StrategyStages.Simulation, stage.Stage); Assert.IsTrue(stage.ExitOnly); Assert.IsNull(stage.LiveConfirmedAt); Assert.AreEqual(RiskSeverities.High, (await EventsAsync(s.Rig, "demotion")).Single()); // Nothing new, nothing bigger. var sent = live.Broker.Sent.Count; Assert.AreEqual(RiskReasons.ExitOnly, (await live.Manager.SubmitAsync(Buy(s, 0.001m), _none)).Refusal); // The stops are kept and put back every day: one moved by hand comes back. foreach (var order in await live.Paper.GetOpenOrdersAsync(_none)) { await live.Paper.CancelOrderAsync(order.ClientOrderId, order.Symbol, _none); } await s.Rig.TurnsAsync(live.Manager, 2, _minute); Assert.HasCount(1, await live.Paper.GetOpenOrdersAsync(_none), "the stop is put back on the real account"); // The exit goes: half, then the rest. Assert.IsNull((await live.Manager.SubmitAsync(Sell(s, 0.001m) with { StartAggressive = true }, _none)).Refusal); await s.Rig.TurnsAsync(live.Manager, 3, _minute); var rest = (await s.Rig.Ledger.PositionAsync(live.Account.AccountId, s.Btc.Id, StrategyNames.CryptoTrend, _none))!.Quantity; Assert.AreEqual(held - 0.001m, rest); Assert.AreEqual(0, await s.Stages.ReleaseExitOnlyAsync(s.Rig.Ledger, _none), "a real position is still open"); Assert.IsNull((await live.Manager.SubmitAsync(Sell(s, rest) with { StartAggressive = true }, _none)).Refusal); await s.Rig.TurnsAsync(live.Manager, 3, _minute); Assert.IsNull(await s.Rig.Ledger.PositionAsync(live.Account.AccountId, s.Btc.Id, StrategyNames.CryptoTrend, _none) is { Quantity: > 0m } p ? p : null); Assert.IsTrue(live.Broker.Sent.Count > sent); // At zero the exit only ends, and the real account is closed to it again. Assert.AreEqual(1, await s.Stages.ReleaseExitOnlyAsync(s.Rig.Ledger, _none)); Assert.IsFalse((await s.Stages.GetAsync(StrategyNames.CryptoTrend, _none))!.ExitOnly); Assert.AreEqual(RiskReasons.LiveNotConfirmed, (await live.Manager.SubmitAsync(Buy(s, 0.001m), _none)).Refusal); } [TestMethod] [TestCategory(Category.Integration)] public async Task TheTwinIsPhotographedButLeftOutOfTheTotals() { await using var s = await CreateAsync(Consent()); var live = await s.Rig.AccountAsync(Venues.Okx, TradingEnvironments.Live, "OKX reale (finto)"); await s.Rig.Ledger.RecordCapitalAsync(live.AccountId, StrategyNames.CryptoTrend, 2_500m, "EUR", "test", _none); await s.Rig.Db.WriteAsync(x => x.ExecuteAsync("UPDATE strategy_state SET stage = 'reduced', live_account_id = @a, live_confirmed_at = @t", _none, ("a", live.AccountId), ("t", s.Rig.Clock.UtcNow)), _none); await new EquityBook(s.Rig.Db, s.Rig.Clock, s.Rig.Ledger, new FxStore(s.Rig.Db, s.Rig.Clock)).TakeAsync(_none); var totals = await s.Rig.QueryAsync("SELECT world, equity FROM equity_snapshots WHERE scope = 'total'", r => (World: r.Text("world"), Equity: r.Money("equity"))); Assert.AreEqual(2_500m, totals.Single(t => t.World == Worlds.Real).Equity); Assert.IsFalse(totals.Any(t => t.World == Worlds.Simulated), "the twin is the only simulated ledger"); Assert.HasCount(2, await s.Rig.QueryAsync("SELECT id FROM equity_snapshots WHERE scope = 'strategy'", r => r.Id("id"))); // In the risk engine too: the twin's ten thousand are not exposure, and the reference counts the quarter four times. var exposure = await s.Risk.ExposureAsync(_none); Assert.AreEqual(0m, exposure.SimulatedEquity); Assert.AreEqual(2_500m, exposure.RealEquity); Assert.AreEqual(10_000m, await s.Risk.ReferenceAsync(_none)); } [TestMethod] [TestCategory(Category.Integration)] public async Task TheReferenceCountsEachResultOnceAcrossStageChanges() { await using var s = await CreateAsync(Consent()); var live = await s.Rig.AccountAsync(Venues.Okx, TradingEnvironments.Live, "OKX reale (finto)"); async Task TradeAsync(AccountContext account, decimal quantity, decimal sold) { await s.Rig.Ledger.RecordFillAsync(s.Rig.Fill(account, s.Btc, StrategyNames.CryptoTrend, OrderSide.Buy, quantity, 60_000m), _none); await s.Rig.Ledger.RecordFillAsync(s.Rig.Fill(account, s.Btc, StrategyNames.CryptoTrend, OrderSide.Sell, quantity, sold), _none); } Task ResultsAsync(AccountContext account) => s.Rig.Db.ReadAsync(x => StageBook.LedgerResultsAsync(x, account.AccountId, StrategyNames.CryptoTrend), _none); // In simulation: the capital and what the simulation made. await TradeAsync(s.Account, 0.1m, 70_000m); var simulated = await ResultsAsync(s.Account); Assert.AreEqual(10_000m + simulated, await s.Risk.ReferenceAsync(_none)); // Reduced real: the simulation's results stay, the quarter on the real account counts four times. await RequirementsMetAsync(s); await s.Rig.Ledger.RecordCapitalAsync(live.AccountId, StrategyNames.CryptoTrend, 2_500m, "EUR", "test", _none); await s.Stages.ConfirmLiveAsync(new LiveConfirmation(StrategyNames.CryptoTrend, live.AccountId, StageBook.Phrase(StrategyNames.CryptoTrend, StrategyStages.Reduced), Password, null, "utente"), _none); await TradeAsync(live, 0.01m, 66_000m); var reduced = await ResultsAsync(live); await TradeAsync(s.Account, 0.05m, 50_000m); // the twin's results are not part of the reference Assert.AreEqual(10_000m + simulated + (4m * reduced), await s.Risk.ReferenceAsync(_none)); // Real, on the same ledger: what was made in reduced is counted once, four times, not five. s.Rig.Clock.Advance(TimeSpan.FromDays(31)); await s.Rig.Ledger.RecordCapitalAsync(live.AccountId, StrategyNames.CryptoTrend, 7_500m, "EUR", "test", _none); await s.Stages.ConfirmLiveAsync(new LiveConfirmation(StrategyNames.CryptoTrend, live.AccountId, StageBook.Phrase(StrategyNames.CryptoTrend, StrategyStages.Real), Password, null, "utente"), _none); Assert.AreEqual(10_000m + simulated + (4m * reduced), await s.Risk.ReferenceAsync(_none)); // Back to simulation: the simulation's old results are not counted again, nor the twin's. await s.Stages.RevokeAsync(StrategyNames.CryptoTrend, "utente", "user", _none); Assert.AreEqual(10_000m + simulated + (4m * reduced), await s.Risk.ReferenceAsync(_none)); } [TestMethod] [TestCategory(Category.Integration)] public async Task AnInstrumentBelongsToOneStrategyPerAccountAndPurchasesUnderWayHoldTheirCash() { await using var s = await CreateAsync(); // SPEC 8.6: another strategy holds BTC in this account, crypto_trend skips the entry. await s.Rig.Ledger.RecordCapitalAsync(s.Account.AccountId, "sma_cross", 10_000m, "EUR", "test", _none); await HoldAsync(s, s.Account, 0.01m, "sma_cross"); Assert.AreEqual(RiskReasons.OwnedByOther, (await s.Risk.GateAsync(Buy(s, 0.01m), s.Account, _none)).Refusal); await s.Rig.Ledger.RecordFillAsync(s.Rig.Fill(s.Account, s.Btc, "sma_cross", OrderSide.Sell, 0.01m, 60_000m), _none); Assert.IsNull((await s.Risk.GateAsync(Buy(s, 0.001m), s.Account, _none)).Refusal); // A purchase of 9 600 € still under way holds its cash: only what is left can be bought, at the highest price. await s.Rig.Db.WriteAsync(x => x.ExecuteAsync( "INSERT INTO executions (id, account_id, instrument_id, strategy, side, purpose, quantity, filled, order_key, sequence, step, reference_price, status, started_at, created_at, updated_at) " + "VALUES (@id, @a, @i, @s, 'buy', 'entry', 0.16, 0, 'K1', 1, 0, 60000, @w, @t, @t, @t)", _none, ("id", Ids.NewId(s.Rig.Clock)), ("a", s.Account.AccountId), ("i", s.Btc.Id), ("s", StrategyNames.CryptoTrend), ("w", ExecutionStates.Working), ("t", s.Rig.Clock.UtcNow)), _none); var highest = 1m + RiskLimits.Default.MaxPriceGap; var result = await s.Risk.GateAsync(Buy(s, 0.5m), s.Account, _none); Assert.AreEqual(RiskReasons.NoLeverage, result.Reasons[^1]); Assert.IsLessThanOrEqualTo(10_000m - (9_600m * highest) + 0.01m, result.Quantity * 60_010m * highest); } [TestMethod] [TestCategory(Category.Integration)] public async Task ObservationLastsNinetyDaysBeforeTheSimulation() { await using var s = await CreateAsync(); await s.Rig.Db.WriteAsync(x => x.ExecuteAsync("UPDATE strategy_state SET stage = 'observation', stage_since = @t", _none, ("t", s.Rig.Clock.UtcNow)), _none); var passed = new Qualification { Passed = true, Verdict = "superato", Report = "docs/backtests/crypto_trend.md" }; await s.Stages.ApplyQualificationAsync(StrategyNames.CryptoTrend, passed with { Passed = false, Verdict = "non superato" }, _none); // SPEC 12.3: the protocol passed and 90 days of signals collected live. var refused = await Assert.ThrowsExactlyAsync(() => s.Stages.MoveAsync(StrategyNames.CryptoTrend, StrategyStages.Simulation, "user", "utente", _none)); Assert.AreEqual("backtest", refused.Code); // A new outcome after the first start: written as the first start would, without its automatic move. await s.Rig.Db.WriteAsync(x => x.ExecuteAsync("UPDATE strategy_state SET qualification = @q", _none, ("q", new DbJson(System.Text.Json.JsonSerializer.Serialize(passed, Qualification.Json)))), _none); s.Rig.Clock.Advance(TimeSpan.FromDays(89)); refused = await Assert.ThrowsExactlyAsync(() => s.Stages.MoveAsync(StrategyNames.CryptoTrend, StrategyStages.Simulation, "user", "utente", _none)); Assert.AreEqual("observation", refused.Code); var requirement = (await s.Stages.RequirementsAsync(StrategyNames.CryptoTrend, _none)).Single(r => r.Key == "observation"); Assert.IsFalse(requirement.Met); s.Rig.Clock.Advance(TimeSpan.FromDays(1)); await s.Stages.MoveAsync(StrategyNames.CryptoTrend, StrategyStages.Simulation, "user", "utente", _none); Assert.AreEqual(StrategyStages.Simulation, (await s.Stages.GetAsync(StrategyNames.CryptoTrend, _none))!.Stage); } [TestMethod] [TestCategory(Category.Integration)] public async Task WithRealMoneyTheQualificationDoesNotMove() { await using var s = await CreateAsync(Consent()); var live = await s.Rig.AccountAsync(Venues.Okx, TradingEnvironments.Live, "OKX reale (finto)"); await RequirementsMetAsync(s); await s.Stages.ConfirmLiveAsync(new LiveConfirmation(StrategyNames.CryptoTrend, live.AccountId, StageBook.Phrase(StrategyNames.CryptoTrend, StrategyStages.Reduced), Password, null, "utente"), _none); // SPEC 12.3: a new build cannot move the figures a strategy with real money is compared with. await s.Stages.ApplyQualificationAsync(StrategyNames.CryptoTrend, new Qualification { Passed = true, Verdict = "altro", Report = "altro.md", MaxDrawdown = 0.50m }, _none); Assert.AreEqual(0.20m, (await s.Stages.GetAsync(StrategyNames.CryptoTrend, _none))!.Qualification!.MaxDrawdown); } }