PROJEKT: C# Copytrader Windows Forms App (Umwandlung aus bestehendem Python-Projekt)Ziel: Maximale Performance & niedrigste Latenz beim Kopieren von Master-Signalen auf nur 5–10 Follower-Accounts (max. 50–100 Master-Trader).
App-Typ: Windows Forms Application (.NET 8 oder .NET 9) in Visual Studio 2022 – muss unbedingt so bleiben! Der User möchte Live- und Demo-Trading-Accounts direkt in der GUI konfigurieren, Einstellungen ändern und überwachen können.
Wichtigste Anforderung: Alles kritische im RAM (Hot-Path), nur finalized Daten asynchron persistieren. Skalierung ist bewusst klein → Architektur darf deutlich einfacher und wartbarer sein als bei 1000 Accounts.Kern-Architektur für maximale Performance (angepasst an WinForms + kleine Skalierung)In-Memory Hot-Path (alles kritische im RAM)Zentrale Klasse TradingState mit:ConcurrentDictionary<string, AccountState> (Key: AccountId)
Jeder AccountState enthält: Balance, ConcurrentDictionary<string, Position> (Open Positions), Pending Orders, Risk-Parameter etc.

Keine DB-Zugriffe im Live-Copy-Pfad!

Asynchrone Signal-VerarbeitungCopyTradingEngine als BackgroundService oder IHostedService (über Microsoft.Extensions.Hosting in der WinForms-App integriert)
Eingehende Master-Signale kommen in System.Threading.Channel<CopySignal>
Einfacher Consumer (1–2 Tasks reichen völlig aus bei max. 10 Accounts)
Innerhalb des Consumers: asynchron über alle Accounts iterieren (kein schweres Parallel.ForEachAsync nötig)

Persistence (nur finalized Daten)Separate PersistenceService (BackgroundService)
Channel<ClosedTrade> für Fire-and-Forget Logging
Nur geschlossene Trades, Performance-Logs und Audit-Daten asynchron schreiben
Empfohlene DB: LiteDB (embedded, 100 % C#, super schnell & einfach) oder Microsoft.Data.Sqlite (EF Core / Dapper)

Crash-Recovery & Snapshot-MechanismusBeim Form-Load / App-Start:Polymarket-API abfragen → alle offenen Positionen, Orders, Balances laden
In TradingState einspielen
Letzten JSON-Snapshot laden und Reconciliation durchführen

Alle 30–60 Sekunden: Snapshot des gesamten TradingState als JSON auf Festplatte (Background-Task)

Multithreading – Moderner .NET-Standard (2026)Kein BackgroundWorker (veraltet!)
Nur: BackgroundService / IHostedService (sauber in WinForms integriert via HostBuilder)
System.Threading.Channels, ConcurrentDictionary, async/await überall
UI-Updates immer thread-sicher (InvokeRequired + Invoke oder BindingSource)
Graceful Shutdown mit CancellationToken

API-Integration (aktueller Stand)Primär Polymarket API nutzen (bleiben, weil günstiger)
Antigravity hat bereits die Option für wss Blockchainstream der Polygon Chain (über Alchemy.com) implementiert → diese Option soll vorhanden bleiben (als Toggle in der GUI), aber nicht aktiv genutzt werden, solange die Polymarket API ausreicht.
Wir werden früher oder später wahrscheinlich an das Polymarket-Ratelimit stoßen – die Architektur soll später leicht auf Alchemy umschaltbar sein.

Gewünschtes Projekt-Gerüst (was Antigravity generieren soll)WinForms-Projekt (.NET 8/9) mit Program.cs + HostBuilder (Microsoft.Extensions.Hosting)
MainForm.cs (Einstellungen für Live-/Demo-Accounts, Start/Stop-Buttons, Monitoring)
TradingState.cs (Records + ConcurrentDictionary)
CopyTradingEngine.cs (Channel + Signal-Verarbeitung)
PersistenceService.cs (Channel + LiteDB/SQLite)
SnapshotService.cs (periodische JSON-Snapshots)
PolymarketApiService.cs (bzw. WebSocket/REST-Stub – Alchemy-Option als alternativer Service)
Models/ Ordner (CopySignal, Position, ClosedTrade, AccountState etc.)
Services/ Ordner für alle BackgroundServices
appsettings.json + Konfiguration
README mit benötigten NuGet-Paketen (LiteDB, System.Threading.Channels, Microsoft.Extensions.Hosting.WindowsForms, Newtonsoft.Json oder System.Text.Json etc.)

Ziel: Das fertige Gerüst soll bei 5–10 Accounts + 50–100 Mastern eine Copy-Latenz unter 5 ms erreichen und extrem einfach zu warten sein. Die bestehende Python-Logik (Signal-Erkennung, Risk-Management, Order-Generierung) soll schrittweise in diese Architektur übertragen werden.