From 98ee504dab346dfea6b67d9aac890172c2d897fc Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Wed, 11 Nov 2026 17:46:28 +0100 Subject: [PATCH] Write the diary from fixed templates and add the "senza bot" comparison (refs #50) The diary needs sentences in the tone of appendix B, built only from what happened. DiaryText holds the templates the live engine will use: fills with the result of the trade they close, raised stops, the daily crypto close, the stock signals, observation signals, recovery and absence. The reason-code sentences move from the server into the library (ReasonCatalog) so the engine and the screens share them; a test checks that every reason constant has its sentence. The diary gets the kinds of the Diario screen: Ordini, Decisioni, Sistema, Notizie, Apprendimento. The comparison of SPEC 7.5 invests each capital flow on its day, 40% in BTC/EUR and 60% in SPY adjusted and converted at the ECB rate, and never touches it; a withdrawal sells both in the proportion they reached. Prices are the closes of the day before, so a deposit is never a gain. Without the SPY history (no Alpaca keys) the photograph leaves it empty rather than show half a comparison. The Panoramica now takes the flows out of the "Senza bot" result, as it already did for the bot. Co-Authored-By: Claude Opus 5.5 --- src/Anubis.Server/Overview.cs | 8 +- src/Anubis.Server/ReasonTexts.cs | 59 +------ src/Anubis/Trading/Diary.cs | 5 + src/Anubis/Trading/DiaryText.cs | 237 ++++++++++++++++++++++++++++ src/Anubis/Trading/Equity.cs | 44 +++++- src/Anubis/Trading/NoBot.cs | 113 +++++++++++++ src/Anubis/Trading/OrderManager.cs | 23 ++- src/Anubis/Trading/ReasonCatalog.cs | 83 ++++++++++ tests/Anubis.Tests/DiaryTests.cs | 136 ++++++++++++++++ 9 files changed, 636 insertions(+), 72 deletions(-) create mode 100644 src/Anubis/Trading/DiaryText.cs create mode 100644 src/Anubis/Trading/NoBot.cs create mode 100644 src/Anubis/Trading/ReasonCatalog.cs create mode 100644 tests/Anubis.Tests/DiaryTests.cs diff --git a/src/Anubis.Server/Overview.cs b/src/Anubis.Server/Overview.cs index 8a0f0fc..d0943f3 100644 --- a/src/Anubis.Server/Overview.cs +++ b/src/Anubis.Server/Overview.cs @@ -95,9 +95,13 @@ internal sealed record Overview( }; var series = daily.Where(p => p.Day >= start.Day).ToList(); var cells = new List { Between("Oggi", Since(1)), Between("Ultimi 7 giorni", Since(7)), Between("Ultimi 30 giorni", Since(30)) }; - if (daily[0].Benchmark is { } firstBenchmark && latest.Benchmark is { } lastBenchmark && firstBenchmark != 0) + // "Senza bot" since the first day it is known, with the same flows taken out as for the bot (SPEC 7.5). + if (daily.FirstOrDefault(p => p.Benchmark is not null) is { Benchmark: { } firstBenchmark } first && latest.Benchmark is { } lastBenchmark) { - cells.Add(new PeriodResult("Senza bot", lastBenchmark - firstBenchmark, (lastBenchmark - firstBenchmark) / firstBenchmark * 100m)); + var flows = latest.Flows - first.Flows; + var amount = lastBenchmark - firstBenchmark - flows; + var basis = firstBenchmark + flows; + cells.Add(new PeriodResult("Senza bot", amount, basis == 0m ? 0m : amount / basis * 100m)); } return new Overview(daily, series, Between("", start), start.Day, start.Equity, cells, (int)positions, (int)withoutStop, (int)orders, next, last, capitalSet); diff --git a/src/Anubis.Server/ReasonTexts.cs b/src/Anubis.Server/ReasonTexts.cs index 8f4fbd5..2b5fd40 100644 --- a/src/Anubis.Server/ReasonTexts.cs +++ b/src/Anubis.Server/ReasonTexts.cs @@ -12,63 +12,6 @@ namespace Anubis.Server; /// internal static class ReasonTexts { - private static readonly Dictionary Texts = new(StringComparer.Ordinal) - { - // Strategies. - ["trend_entry"] = "La chiusura ha superato i massimi recenti su almeno un orizzonte: è iniziata una tendenza al rialzo.", - ["trend_increase"] = "Più orizzonti erano d'accordo sulla tendenza: il peso è salito.", - ["trend_reduce"] = "La tendenza si è indebolita, o la moneta è diventata più agitata: il peso è sceso.", - ["trend_exit"] = "La tendenza si è interrotta: il prezzo è finito sotto lo stop mobile.", - ["trend_stop"] = "Lo stop mobile è salito con il prezzo.", - ["momentum_entry"] = "Era tra i titoli più forti degli ultimi mesi, con il mercato in salita.", - ["momentum_increase"] = "Il peso obiettivo è salito alla revisione settimanale.", - ["momentum_reduce"] = "Il peso obiettivo è sceso alla revisione settimanale.", - ["momentum_exit_rank"] = "Non era più tra i 30 titoli più forti.", - ["momentum_exit_trend"] = "Il mercato nel suo insieme è girato al ribasso: niente più azioni.", - ["momentum_stop"] = "Lo stop di protezione è stato aggiornato.", - ["meanrev_entry"] = "Era sceso per qualche seduta di fila ma restava sopra la sua media a 200 giorni: un ribasso breve di un titolo che nel lungo periodo sale.", - ["meanrev_exit_average"] = "Il prezzo è tornato sopra la media a 5 giorni: il rimbalzo cercato è arrivato.", - ["meanrev_exit_rsi"] = "L'indicatore di forza è tornato alto: il rimbalzo è avvenuto.", - ["meanrev_exit_earnings"] = "Uscita prima della trimestrale.", - ["meanrev_exit_time"] = "Tempo scaduto: nessun rimbalzo in 5 sedute.", - // Exits recorded on the trade. - ["stop"] = "Stop di protezione raggiunto.", - ["exit"] = "Uscita decisa dalla strategia.", - ["signal"] = "Uscita sul segnale della strategia.", - ["residue"] = "Resto troppo piccolo per essere venduto, tolto dal registro.", - ["adjustment"] = "Rettifica dopo l'allineamento con il conto.", - // Correctives. - ["crypto_regime_below_average"] = "Il mercato crypto era sotto la sua media: acquisti ridotti.", - ["crypto_regime_high_volatility"] = "Il mercato crypto era molto agitato: acquisti ridotti.", - ["calendar_event"] = "Un dato economico importante era vicino: niente nuove posizioni in quell'ora.", - // Risk. - ["risk_reduction"] = "Ordine rimpicciolito dai limiti di rischio.", - ["daily_loss_block"] = "Perdita del giorno oltre il limite: niente nuovi ingressi per 24 ore.", - ["switch_tripped"] = "Interruttore scattato: il bot aspetta la tua conferma.", - ["bot_paused"] = "Bot in pausa: niente nuovi ingressi.", - ["bot_stopped"] = "Bot fermato con \"Ferma tutto\".", - ["invested_limit"] = "Capitale investito al limite: niente soldi presi in prestito.", - ["position_limit"] = "Ridotto al peso massimo di una posizione.", - ["crypto_limit"] = "Quota delle crypto sul totale al limite.", - ["trade_risk_limit"] = "Ridotto perché il rischio dell'operazione restasse entro il limite.", - ["stop_above_price"] = "Stop sopra il prezzo: ordine rifiutato.", - ["stale_price"] = "Prezzo troppo vecchio: niente acquisti finché i dati non tornano freschi.", - ["price_gap"] = "Prezzo dell'ordine troppo lontano dall'ultimo prezzo.", - ["clock_skew"] = "Orologio non allineato con quello del broker.", - ["owned_by_other_strategy"] = "La posizione appartiene a un'altra strategia.", - ["no_short_selling"] = "Niente vendite allo scoperto: venduto solo quanto posseduto.", - ["no_leverage"] = "Niente leva: l'ordine sta nella liquidità disponibile.", - ["not_owned_by_bot"] = "La posizione non è del bot: non la tocca.", - ["live_not_confirmed"] = "Soldi veri non confermati per questa strategia.", - ["exit_only"] = "Strategia in sola uscita: niente nuovi acquisti.", - ["live_not_allowed"] = "Soldi veri non permessi dalla configurazione d'avvio.", - ["observation"] = "Strategia in osservazione: produce segnali, nessun ordine.", - ["orders_per_minute"] = "Troppi ordini in un minuto: il bot si è fermato.", - ["pdt_guard"] = "Guardia sulle operazioni in giornata: niente posizioni in più oggi.", - ["no_fx_rate"] = "Manca il cambio euro-dollaro: niente acquisti in dollari.", - ["unknown_instrument"] = "Strumento sconosciuto.", - }; - // The exits in the few words of a table column; the full sentence stays for the "why" card. private static readonly Dictionary ShortExits = new(StringComparer.Ordinal) { @@ -85,7 +28,7 @@ internal static class ReasonTexts /// Why a trade was closed, in a short sentence. public static string Exit(string? code) => code is null ? "Chiusa" : ShortExits.TryGetValue(code, out var text) ? text : Text(code).TrimEnd('.'); - public static string Text(string code) => Texts.TryGetValue(code, out var text) ? text : code; + public static string Text(string code) => ReasonCatalog.Text(code); /// The lines of one stage of a decision. is the JSON of the numbers the stage used. public static IEnumerable Stage(string stage, string outcome, IReadOnlyList reasons, string? data) diff --git a/src/Anubis/Trading/Diary.cs b/src/Anubis/Trading/Diary.cs index 451d8db..39e9f7c 100644 --- a/src/Anubis/Trading/Diary.cs +++ b/src/Anubis/Trading/Diary.cs @@ -8,7 +8,12 @@ namespace Anubis.Trading; public static class DiaryKinds { public const string Orders = "Ordini"; + public const string Decisions = "Decisioni"; public const string System = "Sistema"; + public const string News = "Notizie"; + public const string Learning = "Apprendimento"; + + public static readonly IReadOnlyList All = [Orders, Decisions, System, News, Learning]; } /// diff --git a/src/Anubis/Trading/DiaryText.cs b/src/Anubis/Trading/DiaryText.cs new file mode 100644 index 0000000..eea8cbd --- /dev/null +++ b/src/Anubis/Trading/DiaryText.cs @@ -0,0 +1,237 @@ +using Anubis.Core; +using Anubis.Data; + +namespace Anubis.Trading; + +/// +/// The fixed templates of the diary (SPEC 5.2, 13.3, appendix B): one main sentence and, when it helps, a second +/// one with the reason. Short form without a subject for what was done ("Alzato lo stop di BTC/EUR"), first person +/// for what the bot does or did ("Sono stato fermo"). Never free text written at decision time. +/// +public static class DiaryText +{ + /// A symbol as the user reads it: BTC/EUR for the pair BTC-EUR, AAPL as it is. + public static string Shown(string symbol) + { + ArgumentNullException.ThrowIfNull(symbol); + return symbol.Replace('-', '/'); + } + + /// The coin of a pair: BTC for BTC-EUR. + public static string Coin(string symbol) + { + ArgumentNullException.ThrowIfNull(symbol); + var dash = symbol.IndexOf('-', StringComparison.Ordinal); + return dash > 0 ? symbol[..dash] : symbol; + } + + /// "BTC, ETH e SOL". + public static string List(IEnumerable items) + { + ArgumentNullException.ThrowIfNull(items); + var list = items.ToList(); + return list.Count switch + { + 0 => "", + 1 => list[0], + _ => string.Join(", ", list.Take(list.Count - 1)) + " e " + list[^1], + }; + } + + /// A stop or a price level in a sentence: no decimals from 1,000 up (65.400 €), the price's own below. + public static string Level(decimal value, string currency) => + Math.Abs(value) >= 1000m ? Format.Money(value, currency, decimals: 0) : Format.Number(value, Math.Abs(value) >= 1m ? 2 : 4) + " " + Format.CurrencySymbol(currency); + + /// + /// A fill: "Comprate 2 AAPL a 259,80 $." and, for a sale that closes the trade, its result: "Venduta 1 MSFT a + /// 522,14 $: +9,84 $ in 3 giorni." is the second sentence, from a reason code. + /// + public static string Fill(OrderSide side, decimal quantity, string symbol, bool crypto, decimal price, string currency, string? reason = null, ClosedTrade? closed = null) + { + var buy = side == OrderSide.Buy; + var one = quantity == 1m; + var verb = (buy, crypto, one) switch + { + (true, true, true) => "Comprato", + (true, true, false) => "Comprati", + (true, false, true) => "Comprata", + (true, false, false) => "Comprate", + (false, true, true) => "Venduto", + (false, true, false) => "Venduti", + (false, false, true) => "Venduta", + (false, false, false) => "Vendute", + }; + var text = $"{verb} {Format.Quantity(quantity)} {Shown(symbol)} a {Format.Price(price)} {Format.CurrencySymbol(currency)}"; + if (closed is not null) + { + text += $": {Format.Money(closed.Result, currency, withSign: true)} {Days(closed.Days)}"; + } + + return text + "." + (string.IsNullOrWhiteSpace(reason) ? "" : " " + reason.Trim()); + } + + /// "in 3 giorni", "in 1 giorno", "in giornata". + public static string Days(int days) => days switch + { + <= 0 => "in giornata", + 1 => "in 1 giorno", + _ => $"in {days} giorni", + }; + + public static string StopRaised(string symbol, decimal from, decimal to, string currency) => + $"Alzato lo stop di {Shown(symbol)} da {Level(from, currency)} a {Level(to, currency)}. Lo stop segue il prezzo quando sale."; + + public static string StopsReplaced(int count) => count == 1 + ? "Rimesso 1 stop giornaliero sulle frazioni di azione." + : $"Rimessi {count} stop giornalieri sulle frazioni di azione."; + + /// + /// The daily crypto close (SPEC 5.5): what changes, what stays in trend, what stays out. "Chiusura giornaliera + /// crypto: nessun cambio. BTC, ETH e SOL restano in tendenza. Le altre 7 monete restano fuori: nessuna ha segnato + /// nuovi massimi." + /// + public static string CryptoClose(DecisionSummary summary) + { + ArgumentNullException.ThrowIfNull(summary); + var head = "Chiusura giornaliera crypto: " + Changes(summary, Coin) + "."; + var staying = summary.Held.Select(Coin).ToList(); + if (staying.Count > 0) + { + head += staying.Count == 1 ? $" {staying[0]} resta in tendenza." : $" {List(staying)} restano in tendenza."; + } + + if (summary.Outside > 0) + { + head += summary.Outside == 1 + ? " L'altra moneta resta fuori: non ha segnato nuovi massimi." + : $" {(staying.Count + summary.Bought.Count > 0 ? "Le altre" : "Le")} {summary.Outside} monete restano fuori: nessuna ha segnato nuovi massimi."; + } + + return head; + } + + /// + /// The stock signals after the close: "Azioni: nessun nuovo acquisto. AAPL resta aperta." or "Azioni: domani + /// compro AAPL e MSFT, vendo JPM." + /// + public static string StockSignals(DecisionSummary summary) + { + ArgumentNullException.ThrowIfNull(summary); + var head = summary.HasChanges ? "Azioni: domani " + Changes(summary, s => s) + "." : "Azioni: nessun nuovo acquisto."; + if (summary.Held.Count > 0) + { + head += summary.Held.Count == 1 ? $" {summary.Held[0]} resta aperta." : $" {List(summary.Held)} restano aperte."; + } + + return head; + } + + /// A strategy in observation: the signal is recorded, no order leaves (SPEC 12.3). + public static string Observed(string strategy, DecisionSummary summary) + { + ArgumentNullException.ThrowIfNull(summary); + var label = StrategyNames.Label(strategy, withMarket: true); + return summary.HasChanges + ? $"{label}, in osservazione: avrei {Conditional(summary)}. Nessun ordine: registro solo il segnale." + : $"{label}, in osservazione: nessun cambio. Registro solo il segnale."; + } + + /// A strategy whose decision could not be made: the data was missing, nothing was bought. + public static string NoData(string strategy, string what) => + $"{StrategyNames.Label(strategy, withMarket: true)}: nessuna decisione oggi. Mancano {what}: non apro nuove posizioni."; + + /// A missed job done at the restart (SPEC 5.6). + public static string Recovered(string what, DateTimeOffset due, TimeZoneInfo zone) => + $"Recuperato un lavoro saltato: {what} (previsto alle {TimeZoneInfo.ConvertTime(due, zone):HH:mm})."; + + /// A missed job left out at the restart, with its reason (SPEC 5.6). + public static string Skipped(string what, string reason) => $"Saltato: {what}. {reason}"; + + /// An entry left out because the price moved too far from the planned one (SPEC 5.6). + public static string EntryDropped(string symbol, decimal movedPercent, decimal limitPercent) => + $"Scartato l'acquisto di {Shown(symbol)}: il prezzo si è mosso del {Format.Percent(movedPercent, 1)} dall'orario previsto, oltre il limite del {Format.Percent(limitPercent, 0)}."; + + /// The restart after an absence (SPEC 5.6, 9.4). + public static string Absence(TimeSpan absence) => $"Sono stato fermo per {Duration(absence)}. Ho ripreso i lavori saltati con le regole del recupero."; + + /// "3 ore e 5 minuti", "2 giorni e 4 ore", "12 minuti". + public static string Duration(TimeSpan span) + { + static string Unit(int n, string one, string many) => n == 1 ? $"1 {one}" : $"{n} {many}"; + if (span.TotalDays >= 1) + { + var days = (int)span.TotalDays; + return span.Hours > 0 ? $"{Unit(days, "giorno", "giorni")} e {Unit(span.Hours, "ora", "ore")}" : Unit(days, "giorno", "giorni"); + } + + if (span.TotalHours >= 1) + { + var hours = (int)span.TotalHours; + return span.Minutes > 0 ? $"{Unit(hours, "ora", "ore")} e {Unit(span.Minutes, "minuto", "minuti")}" : Unit(hours, "ora", "ore"); + } + + return Unit(Math.Max(1, (int)Math.Round(span.TotalMinutes)), "minuto", "minuti"); + } + + private static string Changes(DecisionSummary s, Func name) + { + var parts = new List(); + if (s.Bought.Count > 0) + { + parts.Add("compro " + List(s.Bought.Select(name))); + } + + if (s.Increased.Count > 0) + { + parts.Add("aumento " + List(s.Increased.Select(name))); + } + + if (s.Reduced.Count > 0) + { + parts.Add("riduco " + List(s.Reduced.Select(name))); + } + + if (s.Sold.Count > 0) + { + parts.Add("vendo " + List(s.Sold.Select(name))); + } + + return parts.Count == 0 ? "nessun cambio" : string.Join(", ", parts); + } + + private static string Conditional(DecisionSummary s) + { + var parts = new List(); + if (s.Bought.Count > 0) + { + parts.Add("comprato " + List(s.Bought.Select(Shown))); + } + + if (s.Increased.Count > 0) + { + parts.Add("aumentato " + List(s.Increased.Select(Shown))); + } + + if (s.Reduced.Count > 0) + { + parts.Add("ridotto " + List(s.Reduced.Select(Shown))); + } + + if (s.Sold.Count > 0) + { + parts.Add("venduto " + List(s.Sold.Select(Shown))); + } + + return string.Join(", ", parts); + } +} + +/// The result of a trade a sale has just closed: for the diary line of the fill. +public sealed record ClosedTrade(decimal Result, int Days); + +/// What one decision changes, by symbol: the material of the diary's decision lines. +public sealed record DecisionSummary(IReadOnlyList Bought, IReadOnlyList Increased, IReadOnlyList Reduced, IReadOnlyList Sold, + IReadOnlyList Held, int Outside) +{ + public bool HasChanges => Bought.Count + Increased.Count + Reduced.Count + Sold.Count > 0; +} diff --git a/src/Anubis/Trading/Equity.cs b/src/Anubis/Trading/Equity.cs index 768dbbf..a7a8945 100644 --- a/src/Anubis/Trading/Equity.cs +++ b/src/Anubis/Trading/Equity.cs @@ -55,7 +55,10 @@ public static class Returns public sealed class EquityBook(Database db, IClock clock, Ledger ledger, FxStore fx) { private sealed record Shot(string Scope, string World, Guid? AccountId, string? Strategy, string Currency, decimal Equity, decimal Cash, decimal Invested, decimal Flows, - decimal? FxEffect); + decimal? FxEffect) + { + public decimal? Benchmark { get; init; } + } public async Task TakeAsync(CancellationToken cancellationToken) { @@ -84,10 +87,13 @@ public sealed class EquityBook(Database db, IClock clock, Ledger ledger, FxStore } var rate = await UsdRateAsync(DateOnly.FromDateTime(now.UtcDateTime), cancellationToken).ConfigureAwait(false); - var flowRows = await db.ReadAsync(s => s.QueryAsync("SELECT account_id, kind, amount, currency, created_at FROM cash_ledger WHERE strategy IS NOT NULL", - r => (Account: r.Id("account_id"), Kind: r.Text("kind"), Amount: r.Money("amount"), Currency: r.Text("currency"), At: r.Moment("created_at"))), cancellationToken) + var flowRows = await db.ReadAsync(s => s.QueryAsync("SELECT account_id, strategy, kind, amount, currency, created_at FROM cash_ledger WHERE strategy IS NOT NULL", + r => (Account: r.Id("account_id"), Strategy: r.Text("strategy"), Kind: r.Text("kind"), Amount: r.Money("amount"), Currency: r.Text("currency"), At: r.Moment("created_at"))), cancellationToken) .ConfigureAwait(false); - foreach (var world in shots.Where(s => s.Scope == "account").GroupBy(s => s.World)) + Func? prices = null; + var pricesLoaded = false; + var today = DateOnly.FromDateTime(now.UtcDateTime); + foreach (var world in shots.Where(s => s.Scope == "account").GroupBy(s => s.World).ToList()) { var usd = world.Where(s => s.Currency == "USD").ToList(); if (usd.Count > 0 && rate is null) @@ -102,11 +108,33 @@ public sealed class EquityBook(Database db, IClock clock, Ledger ledger, FxStore usdFlows.Add((row.Amount, await UsdRateAsync(DateOnly.FromDateTime(row.At.UtcDateTime), cancellationToken).ConfigureAwait(false) ?? rate!.Value)); } + // The "senza bot" comparison gets the same flows, each on its day and in euro at that day's rate (SPEC 7.5). + var included = shots.Where(s => s.Scope == "strategy" && s.World == world.Key && !twins.Contains((s.Strategy!, s.AccountId!.Value))) + .Select(s => (s.AccountId!.Value, s.Strategy!)).ToHashSet(); + var dated = new List<(DateOnly Day, decimal AmountEur)>(); + foreach (var row in flowRows.Where(f => LedgerKinds.IsFlow(f.Kind) && included.Contains((f.Account, f.Strategy)))) + { + var day = DateOnly.FromDateTime(row.At.UtcDateTime); + var amount = row.Currency == "USD" + ? row.Amount / (await UsdRateAsync(day, cancellationToken).ConfigureAwait(false) ?? rate!.Value) + : row.Amount; + dated.Add((day, amount)); + } + + if (!pricesLoaded && dated.Count > 0) + { + pricesLoaded = true; + prices = await NoBot.PricesAsync(db, clock, dated.Min(d => d.Day), today, cancellationToken).ConfigureAwait(false); + } + + var benchmark = prices is null ? null : NoBot.Value(dated, prices, today); + decimal ToEur(Shot s, decimal value) => s.Currency == "USD" ? value / rate!.Value : value; var eurFlows = world.Where(s => s.Currency != "USD").Sum(s => s.Flows) + usdFlows.Sum(f => f.AmountUsd / f.Rate); shots.Add(new Shot("total", world.Key, null, null, "EUR", DbValues.Money(world.Sum(s => ToEur(s, s.Equity))), DbValues.Money(world.Sum(s => ToEur(s, s.Cash))), DbValues.Money(world.Sum(s => ToEur(s, s.Invested))), - DbValues.Money(eurFlows), usd.Count > 0 ? DbValues.Money(Returns.FxEffect(usdFlows, rate!.Value)) : null)); + DbValues.Money(eurFlows), usd.Count > 0 ? DbValues.Money(Returns.FxEffect(usdFlows, rate!.Value)) : null) + { Benchmark = benchmark }); } await db.WriteAsync(async s => @@ -119,10 +147,10 @@ public sealed class EquityBook(Database db, IClock clock, Ledger ledger, FxStore var peak = Math.Max(previous?.Peak ?? index, index); var drawdown = peak <= 0m ? 0m : Math.Round((index / peak - 1m) * 100m, 4, MidpointRounding.AwayFromZero); await 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, fx_effect) " + - "VALUES (@id, @now, @sc, @a, @st, @e, @c, @i, @d, @now, @w, @cur, @f, @x, @p, @fx)", cancellationToken, + "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, fx_effect, benchmark) " + + "VALUES (@id, @now, @sc, @a, @st, @e, @c, @i, @d, @now, @w, @cur, @f, @x, @p, @fx, @b)", cancellationToken, ("id", Ids.NewId(clock)), ("now", now), ("sc", shot.Scope), ("a", shot.AccountId), ("st", shot.Strategy), ("e", shot.Equity), ("c", shot.Cash), ("i", shot.Invested), - ("d", drawdown), ("w", shot.World), ("cur", shot.Currency), ("f", shot.Flows), ("x", index), ("p", peak), ("fx", shot.FxEffect)).ConfigureAwait(false); + ("d", drawdown), ("w", shot.World), ("cur", shot.Currency), ("f", shot.Flows), ("x", index), ("p", peak), ("fx", shot.FxEffect), ("b", shot.Benchmark)).ConfigureAwait(false); } }, cancellationToken).ConfigureAwait(false); return shots.Count; diff --git a/src/Anubis/Trading/NoBot.cs b/src/Anubis/Trading/NoBot.cs new file mode 100644 index 0000000..1bfe8b2 --- /dev/null +++ b/src/Anubis/Trading/NoBot.cs @@ -0,0 +1,113 @@ +using Anubis.Core; +using Anubis.Data; +using Anubis.Db; + +namespace Anubis.Trading; + +/// +/// The "senza bot" comparison (SPEC 7.5): the same capital, with the same flows, put 40% in Bitcoin (BTC/EUR) and +/// 60% in the S&P 500 (SPY adjusted for dividends and splits, in euro at the ECB rate) and never touched. Every +/// deposit buys the two in that proportion on its day; a withdrawal sells both in the proportion they have reached. +/// Prices are the daily closes of the days before: a deposit on Tuesday buys at Monday's close, and the value on +/// Wednesday uses Tuesday's. A close is final only when its day is over, so the comparison moves once a day. +/// +public static class NoBot +{ + public const decimal BitcoinShare = 0.40m; + + public const decimal StockShare = 0.60m; + + public const string BitcoinSymbol = "BTC-EUR"; + + public const string StockSymbol = "SPY"; + + /// + /// The value in euro on of the untouched portfolio. Null when there are no flows or a + /// price is missing on a day that needs it: a comparison with a hole would not be honest. + /// + public static decimal? Value(IEnumerable<(DateOnly Day, decimal AmountEur)> flows, Func prices, DateOnly today) + { + ArgumentNullException.ThrowIfNull(flows); + ArgumentNullException.ThrowIfNull(prices); + decimal bitcoin = 0m, stock = 0m; + var any = false; + foreach (var (day, amount) in flows.Where(f => f.AmountEur != 0m).OrderBy(f => f.Day)) + { + if (prices(day) is not { Bitcoin: > 0m, Stock: > 0m } p) + { + return null; + } + + any = true; + if (amount > 0m) + { + bitcoin += BitcoinShare * amount / p.Bitcoin; + stock += StockShare * amount / p.Stock; + continue; + } + + var value = bitcoin * p.Bitcoin + stock * p.Stock; + var keep = value <= 0m ? 0m : Math.Max(0m, 1m + amount / value); + bitcoin *= keep; + stock *= keep; + } + + return any && prices(today) is { Bitcoin: > 0m, Stock: > 0m } now ? DbValues.Money(bitcoin * now.Bitcoin + stock * now.Stock) : null; + } + + /// + /// The daily closes the comparison needs, from the database: BTC-EUR on OKX, SPY on Alpaca with its corporate + /// actions, the ECB rate. Null when one of the series is missing (no Alpaca keys means no SPY history). + /// + public static async Task?> PricesAsync(Database db, IClock clock, DateOnly from, DateOnly to, CancellationToken cancellationToken) + { + ArgumentNullException.ThrowIfNull(db); + var catalog = new InstrumentCatalog(db, clock); + var bars = new BarStore(db, clock); + var btc = await catalog.FindAsync(Venues.Okx, BitcoinSymbol, cancellationToken).ConfigureAwait(false); + var spy = await catalog.FindAsync(Venues.Alpaca, StockSymbol, cancellationToken).ConfigureAwait(false); + if (btc is null || spy is null) + { + return null; + } + + // A week before the first flow: a deposit on a Monday uses Friday's close. + var start = from.AddDays(-10); + var bitcoin = (await bars.DailyAsync(btc.Id, start, to, cancellationToken).ConfigureAwait(false)).Select(b => (b.Day, Close: (decimal)b.Close)).ToList(); + var rawStock = await bars.DailyAsync(spy.Id, start, to, cancellationToken).ConfigureAwait(false); + var actions = await new CorporateActionStore(db, clock).ForSymbolAsync(StockSymbol, cancellationToken).ConfigureAwait(false); + var stock = rawStock.Count == 0 ? [] : Adjustments.Anchored(rawStock, actions, rawStock[^1].Day).Select(b => (b.Day, Close: (decimal)(b.Adjusted?.Close ?? b.Close))).ToList(); + var rates = await db.ReadAsync(s => s.QueryAsync("SELECT rate_date, rate FROM fx_rates WHERE base = 'EUR' AND quote = 'USD' AND rate_date >= @f AND rate_date <= @t ORDER BY rate_date", + r => (Day: BarStore.ParseDay(r.Text("rate_date")), Rate: r.Money("rate")), ("f", BarStore.DayText(start.AddDays(-10))), ("t", BarStore.DayText(to))), cancellationToken).ConfigureAwait(false); + if (bitcoin.Count == 0 || stock.Count == 0 || rates.Count == 0) + { + return null; + } + + var rateSeries = rates.Select(x => (x.Day, x.Rate)).ToList(); + return day => + { + var known = day.AddDays(-1); + var b = OnOrBefore(bitcoin, known); + var s = OnOrBefore(stock, known); + var r = OnOrBefore(rateSeries, known); + return b is null || s is null || r is not > 0m ? null : (b.Value, s.Value / r.Value); + }; + } + + private static decimal? OnOrBefore(List<(DateOnly Day, decimal Value)> series, DateOnly day) + { + decimal? found = null; + foreach (var (d, v) in series) + { + if (d > day) + { + break; + } + + found = v; + } + + return found; + } +} diff --git a/src/Anubis/Trading/OrderManager.cs b/src/Anubis/Trading/OrderManager.cs index ae01c7f..8c68e48 100644 --- a/src/Anubis/Trading/OrderManager.cs +++ b/src/Anubis/Trading/OrderManager.cs @@ -766,10 +766,25 @@ public sealed partial class OrderManager : IDisposable recorded++; var instrument = await _instruments(row.InstrumentId, cancellationToken).ConfigureAwait(false); - await _db.WriteAsync(s => Diary.WriteAsync(s, _clock, DiaryKinds.Orders, "fill", - string.Create(CultureInfo.InvariantCulture, - $"{(fill.Side == OrderSide.Buy ? "Comprati" : "Venduti")} {Format.Quantity(fill.Quantity)} {instrument?.Symbol} a {Format.Price(fill.Price)} su {_account.Name}."), - new { fill.ExecutionId, row.ClientOrderId, outcome.SlippageBp }, cancellationToken), cancellationToken).ConfigureAwait(false); + await _db.WriteAsync(async s => + { + // A sale that closes the trade says its result (appendix F.10: "Venduta 1 MSFT a 522,14 $: +9,84 $ in 3 giorni"). + ClosedTrade? closed = null; + if (outcome.TradeClosed && outcome.TradeId is { } tradeId) + { + var trade = await s.FirstOrDefaultAsync("SELECT realized, opened_at, closed_at FROM trades WHERE id = @id", + r => (Realized: r.Money("realized"), Opened: r.Moment("opened_at"), Closed: r.MomentOrNull("closed_at")), ("id", tradeId)).ConfigureAwait(false); + if (trade.Closed is { } closedAt) + { + closed = new ClosedTrade(trade.Realized, (DateOnly.FromDateTime(closedAt.UtcDateTime).DayNumber - DateOnly.FromDateTime(trade.Opened.UtcDateTime).DayNumber)); + } + } + + var reason = fill.Side == OrderSide.Sell && row.Purpose is OrderPurpose.Stop or OrderPurpose.Protective ? ReasonCatalog.Text("stop") : null; + await Diary.WriteAsync(s, _clock, DiaryKinds.Orders, "fill", + DiaryText.Fill(fill.Side, fill.Quantity, instrument?.Symbol ?? "?", instrument?.IsCrypto ?? false, fill.Price, _account.Currency, reason, closed), + new { fill.ExecutionId, row.ClientOrderId, outcome.SlippageBp, outcome.TradeId, Account = _account.Name }, cancellationToken).ConfigureAwait(false); + }, cancellationToken).ConfigureAwait(false); if (row.Purpose == OrderPurpose.Stop && outcome.Quantity > 0m && instrument is not null) { // A stop that fired only in part, or one of Alpaca's two stops: the rest is sold at once (SPEC 7.2). diff --git a/src/Anubis/Trading/ReasonCatalog.cs b/src/Anubis/Trading/ReasonCatalog.cs new file mode 100644 index 0000000..d1227bd --- /dev/null +++ b/src/Anubis/Trading/ReasonCatalog.cs @@ -0,0 +1,83 @@ +namespace Anubis.Trading; + +/// +/// The fixed sentences of the reason codes of the decisions table (SPEC 5.2): the "why" card of a trade and the +/// diary use these, never free text written at decision time. An unknown code is shown as it is, so nothing is ever +/// hidden. +/// +public static class ReasonCatalog +{ + private static readonly Dictionary Texts = new(StringComparer.Ordinal) + { + // Strategies. + ["trend_entry"] = "La chiusura ha superato i massimi recenti su almeno un orizzonte: è iniziata una tendenza al rialzo.", + ["trend_increase"] = "Più orizzonti erano d'accordo sulla tendenza: il peso è salito.", + ["trend_reduce"] = "La tendenza si è indebolita, o la moneta è diventata più agitata: il peso è sceso.", + ["trend_exit"] = "La tendenza si è interrotta: il prezzo è finito sotto lo stop mobile.", + ["trend_stop"] = "Lo stop mobile è salito con il prezzo.", + ["momentum_entry"] = "Era tra i titoli più forti degli ultimi mesi, con il mercato in salita.", + ["momentum_increase"] = "Il peso obiettivo è salito alla revisione settimanale.", + ["momentum_reduce"] = "Il peso obiettivo è sceso alla revisione settimanale.", + ["momentum_exit_rank"] = "Non era più tra i 30 titoli più forti.", + ["momentum_exit_trend"] = "Il mercato nel suo insieme è girato al ribasso: niente più azioni.", + ["momentum_stop"] = "Lo stop di protezione è stato aggiornato.", + ["meanrev_entry"] = "Era sceso per qualche seduta di fila ma restava sopra la sua media a 200 giorni: un ribasso breve di un titolo che nel lungo periodo sale.", + ["meanrev_exit_average"] = "Il prezzo è tornato sopra la media a 5 giorni: il rimbalzo cercato è arrivato.", + ["meanrev_exit_rsi"] = "L'indicatore di forza è tornato alto: il rimbalzo è avvenuto.", + ["meanrev_exit_earnings"] = "Uscita prima della trimestrale.", + ["meanrev_exit_time"] = "Tempo scaduto: nessun rimbalzo in 5 sedute.", + // Exits recorded on the trade. + ["stop"] = "Stop di protezione raggiunto.", + ["exit"] = "Uscita decisa dalla strategia.", + ["signal"] = "Uscita sul segnale della strategia.", + ["residue"] = "Resto troppo piccolo per essere venduto, tolto dal registro.", + ["adjustment"] = "Rettifica dopo l'allineamento con il conto.", + // Correctives. + ["crypto_regime_below_average"] = "Il mercato crypto era sotto la sua media: acquisti ridotti.", + ["crypto_regime_high_volatility"] = "Il mercato crypto era molto agitato: acquisti ridotti.", + ["calendar_event"] = "Un dato economico importante era vicino: niente nuove posizioni in quell'ora.", + // Risk. + ["risk_reduction"] = "Ordine rimpicciolito dai limiti di rischio.", + ["daily_loss_block"] = "Perdita del giorno oltre il limite: niente nuovi ingressi per 24 ore.", + ["switch_tripped"] = "Interruttore scattato: il bot aspetta la tua conferma.", + ["bot_paused"] = "Bot in pausa: niente nuovi ingressi.", + ["bot_stopped"] = "Bot fermato con \"Ferma tutto\".", + ["invested_limit"] = "Capitale investito al limite: niente soldi presi in prestito.", + ["position_limit"] = "Ridotto al peso massimo di una posizione.", + ["crypto_limit"] = "Quota delle crypto sul totale al limite.", + ["trade_risk_limit"] = "Ridotto perché il rischio dell'operazione restasse entro il limite.", + ["stop_above_price"] = "Stop sopra il prezzo: ordine rifiutato.", + ["stale_price"] = "Prezzo troppo vecchio: niente acquisti finché i dati non tornano freschi.", + ["price_gap"] = "Prezzo dell'ordine troppo lontano dall'ultimo prezzo.", + ["clock_skew"] = "Orologio non allineato con quello del broker.", + ["owned_by_other_strategy"] = "La posizione appartiene a un'altra strategia.", + ["no_short_selling"] = "Niente vendite allo scoperto: venduto solo quanto posseduto.", + ["no_leverage"] = "Niente leva: l'ordine sta nella liquidità disponibile.", + ["not_owned_by_bot"] = "La posizione non è del bot: non la tocca.", + ["live_not_confirmed"] = "Soldi veri non confermati per questa strategia.", + ["exit_only"] = "Strategia in sola uscita: niente nuovi acquisti.", + ["live_not_allowed"] = "Soldi veri non permessi dalla configurazione d'avvio.", + ["observation"] = "Strategia in osservazione: produce segnali, nessun ordine.", + ["orders_per_minute"] = "Troppi ordini in un minuto: il bot si è fermato.", + ["pdt_guard"] = "Guardia sulle operazioni in giornata: niente posizioni in più oggi.", + ["no_fx_rate"] = "Manca il cambio euro-dollaro: niente acquisti in dollari.", + ["unknown_instrument"] = "Strumento sconosciuto.", + ["unknown_symbol"] = "Strumento sconosciuto.", + // Orders. + ["zero_quantity"] = "Quantità troppo piccola: nessun ordine.", + ["below_min_size"] = "Sotto la quantità minima del broker: nessun ordine.", + ["below_min_notional"] = "Sotto l'importo minimo del broker: nessun ordine.", + ["no_price"] = "Nessun prezzo recente: nessun ordine.", + ["instrument_not_live"] = "Lo strumento non si può negoziare in questo momento.", + ["account_prudent"] = "Conto in modalità prudente: niente nuovi ingressi.", + ["not_ours"] = "L'ordine non è del bot: non lo tocca.", + ["no_cash"] = "Liquidità insufficiente per l'acquisto.", + ["stop_gap"] = "Il prezzo ha aperto sotto lo stop: venduto all'apertura.", + ["residue_written_off"] = "Resto troppo piccolo per essere venduto, tolto dal registro.", + ["dividend"] = "Dividendo accreditato.", + }; + + public static string Text(string code) => Texts.TryGetValue(code, out var text) ? text : code; + + public static bool Has(string code) => Texts.ContainsKey(code); +} diff --git a/tests/Anubis.Tests/DiaryTests.cs b/tests/Anubis.Tests/DiaryTests.cs new file mode 100644 index 0000000..a7256c3 --- /dev/null +++ b/tests/Anubis.Tests/DiaryTests.cs @@ -0,0 +1,136 @@ +using System.Reflection; +using Anubis.Core; +using Anubis.Data; +using Anubis.Trading; + +namespace Anubis.Tests; + +/// The diary from reason codes and the "senza bot" comparison (issue #50, SPEC 5.2, 7.5, appendix B and F.10). +[TestClass] +public sealed class DiaryTests +{ + private static readonly CancellationToken _none = CancellationToken.None; + + // The appendix writes plain spaces; the bot puts a non-breaking one between a number and its currency. + private static string Plain(string text) => text.Replace(' ', ' '); + + [TestMethod] + public void TheTemplatesWriteTheSentencesOfTheAppendix() + { + Assert.AreEqual("Alzato lo stop di BTC/EUR da 65.400 € a 66.180 €. Lo stop segue il prezzo quando sale.", + Plain(DiaryText.StopRaised("BTC-EUR", 65400m, 66180m, "EUR"))); + Assert.AreEqual( + "Chiusura giornaliera crypto: nessun cambio. BTC, ETH e SOL restano in tendenza. Le altre 7 monete restano fuori: nessuna ha segnato nuovi massimi.", + DiaryText.CryptoClose(new DecisionSummary([], [], [], [], ["BTC-EUR", "ETH-EUR", "SOL-EUR"], 7))); + Assert.AreEqual("Venduta 1 MSFT a 522,14 $: +9,84 $ in 3 giorni.", + Plain(DiaryText.Fill(OrderSide.Sell, 1m, "MSFT", crypto: false, 522.14m, "USD", closed: new ClosedTrade(9.84m, 3)))); + Assert.AreEqual("Comprate 2 AAPL a 259,80 $. Mean reversion: tre sedute di ribasso, titolo sopra la media a 200 giorni.", + Plain(DiaryText.Fill(OrderSide.Buy, 2m, "AAPL", crypto: false, 259.80m, "USD", "Mean reversion: tre sedute di ribasso, titolo sopra la media a 200 giorni."))); + Assert.AreEqual("Rimessi 6 stop giornalieri sulle frazioni di azione.", DiaryText.StopsReplaced(6)); + Assert.AreEqual("Azioni: nessun nuovo acquisto. AAPL resta aperta.", DiaryText.StockSignals(new DecisionSummary([], [], [], [], ["AAPL"], 0))); + + // Changes, coins and agreement. + Assert.AreEqual("Chiusura giornaliera crypto: compro ETH, vendo SOL. BTC resta in tendenza. Le altre 7 monete restano fuori: nessuna ha segnato nuovi massimi.", + DiaryText.CryptoClose(new DecisionSummary(["ETH-EUR"], [], [], ["SOL-EUR"], ["BTC-EUR"], 7))); + Assert.AreEqual("Azioni: domani compro AAPL e MSFT, vendo JPM.", DiaryText.StockSignals(new DecisionSummary(["AAPL", "MSFT"], [], [], ["JPM"], [], 0))); + Assert.AreEqual("Comprati 0,0512 BTC/EUR a 66.180,00 €.", Plain(DiaryText.Fill(OrderSide.Buy, 0.0512m, "BTC-EUR", crypto: true, 66180m, "EUR"))); + Assert.AreEqual("Venduto 1 ETH/EUR a 3.010,50 €: −42,10 € in giornata. Stop di protezione raggiunto.", + Plain(DiaryText.Fill(OrderSide.Sell, 1m, "ETH-EUR", crypto: true, 3010.50m, "EUR", ReasonCatalog.Text("stop"), new ClosedTrade(-42.10m, 0)))); + Assert.AreEqual("Trend crypto, in osservazione: avrei comprato BTC/EUR. Nessun ordine: registro solo il segnale.", + DiaryText.Observed(StrategyNames.CryptoTrend, new DecisionSummary(["BTC-EUR"], [], [], [], [], 0))); + Assert.AreEqual("3 ore", DiaryText.Duration(TimeSpan.FromHours(3))); + Assert.AreEqual("20 ore e 5 minuti", DiaryText.Duration(new TimeSpan(20, 5, 0))); + Assert.AreEqual("3 giorni", DiaryText.Duration(TimeSpan.FromDays(3))); + Assert.AreEqual("1 giorno e 1 ora", DiaryText.Duration(TimeSpan.FromHours(25))); + + // No jargon and no exclamation marks (appendix B). + foreach (var sentence in new[] { DiaryText.Absence(TimeSpan.FromHours(20)), DiaryText.EntryDropped("AAPL", 1.4m, 1m), DiaryText.NoData(StrategyNames.EquityMomentum, "le barre di chiusura") }) + { + Assert.DoesNotContain("!", sentence); + Assert.DoesNotContain("stop loss", sentence, StringComparison.OrdinalIgnoreCase); + } + } + + [TestMethod] + public void EveryReasonCodeHasItsSentence() + { + // Every code a strategy, a corrective, the risk engine or the order rules can write: the diary never shows a bare code. + var holders = typeof(DiaryText).Assembly.GetTypes().Where(t => t.Name == "Reasons" || (t.Name.EndsWith("Reasons", StringComparison.Ordinal) && t.IsAbstract && t.IsSealed)); + var codes = holders.SelectMany(t => t.GetFields(BindingFlags.Public | BindingFlags.Static)) + .Where(f => f.IsLiteral && f.FieldType == typeof(string) && !f.Name.EndsWith("Prefix", StringComparison.Ordinal)) + .Select(f => (string)f.GetRawConstantValue()!) + .ToList(); + Assert.IsGreaterThan(40, codes.Count, "The reason classes were found."); + var missing = codes.Where(c => !ReasonCatalog.Has(c)).ToList(); + Assert.IsEmpty(missing, "Codes without a sentence: " + string.Join(", ", missing)); + Assert.IsTrue(codes.All(c => !ReasonCatalog.Text(c).Contains('!', StringComparison.Ordinal))); + } + + [TestMethod] + public void TheComparisonInvestsEveryFlowOnItsDayAndNeverTouchesIt() + { + var d1 = new DateOnly(2026, 1, 5); + var d2 = new DateOnly(2026, 2, 2); + var d3 = new DateOnly(2026, 3, 2); + var prices = new Dictionary + { + [d1] = (50000m, 500m), + [d2] = (60000m, 500m), + [d3] = (60000m, 550m), + }; + (decimal Bitcoin, decimal Stock)? At(DateOnly day) => prices.TryGetValue(day, out var p) ? p : null; + + // 10,000 € on day 1: 4,000 in Bitcoin, 6,000 in the S&P 500. Bitcoin +20%: 4,800 + 6,000. + Assert.AreEqual(10800m, NoBot.Value([(d1, 10000m)], At, d2)); + + // A deposit of 1,000 € on day 2 buys at day 2's prices: it is not a gain. S&P +10% on day 3. + // Units: 0.08 + 0.0066667 BTC = 0.0866667 × 60,000 = 5,200; 12 + 1.2 SPY = 13.2 × 550 = 7,260. + Assert.AreEqual(12460m, NoBot.Value([(d1, 10000m), (d2, 1000m)], At, d3)); + + // A withdrawal sells both in the proportion they reached: half of 10,800 out leaves 5,400, then S&P +10%. + Assert.AreEqual(5700m, NoBot.Value([(d1, 10000m), (d2, -5400m)], At, d3)); + + // No flows, or a missing price: no comparison rather than a wrong one. + Assert.IsNull(NoBot.Value([], At, d3)); + Assert.IsNull(NoBot.Value([(new DateOnly(2025, 12, 1), 10000m)], At, d3)); + } + + [TestMethod] + [TestCategory(Category.Integration)] + public async Task ThePhotographOfTheTotalCarriesTheComparisonOnlyWithBothSeries() + { + await using var rig = await TradingRig.CreateAsync().ConfigureAwait(false); + var fx = new FxStore(rig.Db, rig.Clock); + var okx = await rig.AccountAsync(Venues.Okx, TradingEnvironments.Simulation).ConfigureAwait(false); + await rig.Db.WriteAsync(s => s.ExecuteAsync("INSERT INTO strategy_state (id, strategy, account_id, stage, capital, state, created_at, updated_at, share) VALUES (@id, @s, @a, 'observation', 0, @j, @now, @now, 1)", + _none, ("id", Ids.NewId(rig.Clock)), ("s", StrategyNames.CryptoTrend), ("a", okx.AccountId), ("j", new Anubis.Db.DbJson("{}")), ("now", rig.Clock.UtcNow)), _none).ConfigureAwait(false); + var today = DateOnly.FromDateTime(rig.Clock.UtcNow.UtcDateTime); + var capital = new Capital(rig.Db, rig.Clock, rig.Ledger, fx); + await fx.UpsertAsync([new FxRate("EUR", "USD", today.AddDays(-3), 1.10m, "ecb")], _none).ConfigureAwait(false); + await capital.SetAsync(Venues.Okx, 10000m, "test", _none).ConfigureAwait(false); + var book = new EquityBook(rig.Db, rig.Clock, rig.Ledger, fx); + + // Without the SPY history (no Alpaca keys) there is no comparison: null, never a half one. + await book.TakeAsync(_none).ConfigureAwait(false); + Assert.IsNull(await BenchmarkAsync(rig).ConfigureAwait(false)); + + // With both: BTC-EUR on OKX, SPY on Alpaca in dollars at 1.10 $/€. + var btc = await rig.InstrumentAsync(TradingRig.Btc).ConfigureAwait(false); + var spy = await rig.InstrumentAsync(TradingRig.Stock("SPY")).ConfigureAwait(false); + var bars = new BarStore(rig.Db, rig.Clock); + await bars.UpsertDailyAsync(btc.Id, [new DailyBar(today.AddDays(-1), 50000, 50000, 50000, 50000, 1)], "test", _none).ConfigureAwait(false); + await bars.UpsertDailyAsync(spy.Id, [new DailyBar(today.AddDays(-1), 550, 550, 550, 550, 1)], "test", _none).ConfigureAwait(false); + rig.Clock.Advance(TimeSpan.FromMinutes(5)); + await book.TakeAsync(_none).ConfigureAwait(false); + Assert.AreEqual(10000m, await BenchmarkAsync(rig).ConfigureAwait(false), "Invested today at today's prices: worth what was put in."); + + // The next day Bitcoin is up 10%: 4,000 € become 4,400 €. + rig.Clock.Advance(TimeSpan.FromDays(1)); + await bars.UpsertDailyAsync(btc.Id, [new DailyBar(today, 55000, 55000, 55000, 55000, 1)], "test", _none).ConfigureAwait(false); + await book.TakeAsync(_none).ConfigureAwait(false); + Assert.AreEqual(10400m, await BenchmarkAsync(rig).ConfigureAwait(false)); + } + + private static async Task BenchmarkAsync(TradingRig rig) => + (await rig.QueryAsync("SELECT benchmark FROM equity_snapshots WHERE scope = 'total' ORDER BY taken_at DESC, id DESC LIMIT 1", r => r.MoneyOrNull("benchmark")).ConfigureAwait(false))[0]; +}