Neue Binance-API-Methoden in sgcWebSockets

24. Februar 2026 · Funktionen

Die sgcWebSockets-Bibliothek erweitert ihre Binance-Integration mit einem umfangreichen Satz neuer Methoden für Spot-REST-API, Futures-REST-API und WebSocket-Streams. Dieser Artikel liefert einen technischen Überblick über jede neue Methode, ihre Parameter und praktische Delphi-Code-Beispiele für den schnellen Einstieg.

Inhaltsverzeichnis

Neue Spot-REST-API-Methoden
Spot-Marktdaten: UI-KLines, Rolling Window & Trading Day Tickers
Spot-Order-Management: OCO, OTO, OTOCO & SOR Orders
Spot-Konto: Commission, Allocations, Rate Limits & Prevented Matches
Neue Futures-REST-API-Methoden
Futures-Marktdaten: Continuous KLines, Premium Index & mehr
Futures-Order-Management: Modify, Batch & Force Orders
Futures-Konto: V3-Endpoints, Config & Fee Burn
Neue Spot-WebSocket-Streams
Neue Futures-WebSocket-Streams
Vollständige funktionierende Beispiele

1. Neue Spot-REST-API-Methoden

Die Klasse TsgcHTTP_API_Binance_Rest wurde um neue Marktdaten-Endpoints, erweiterte Order-Typen und Kontoabfrage-Methoden erweitert. Alle Methoden sind entweder direkt über die REST-Komponente oder über die Property REST_API von TsgcWS_API_Binance erreichbar.

Marktdaten-Endpoints

Methode	Beschreibung	Binance-Endpoint
`GetUIKLines`	Für UI-Darstellung optimierte Kline-/Candlestick-Daten. Liefert Daten im gleichen Format wie `GetKLines`, aber für Chart-Rendering abgestimmt.	`/api/v3/uiKlines`
`GetRollingWindowTicker`	Preisänderungsstatistiken im Rolling-Window-Verfahren. Unterstützt konfigurierbare Fenstergrößen (z. B. 1h, 4h, 1d), anders als der feste 24h-Ticker.	`/api/v3/ticker`
`GetTradingDayTicker`	Preisänderungsstatistiken über den Handelstag berechnet (UTC 00:00 bis aktuell). Unterstützt einzelne oder mehrere Symbole.	`/api/v3/ticker/tradingDay`
`GetPriceTickers`	Preisticker für mehrere Symbole in einer einzigen Anfrage abrufen, über ein JSON-Array von Symbolnamen.	`/api/v3/ticker/price`

GetUIKLines

function GetUIKLines(const aSymbol: String;
  aInterval: TsgcHTTPBinanceChartIntervals; aStartTime: Int64 = 0;
  aEndTime: Int64 = 0; aLimit: Integer = 500): String;

Der Unterschied zwischen GetKLines und GetUIKLines ist subtil: Die UI-Variante ist vom Binance-Backend für Chart-Rendering optimiert und kann modifizierte Kline-Grenzen für bessere visuelle Darstellung liefern. Das Antwortformat ist identisch — also ein Drop-in-Ersatz für jeden Charting-Use-Case.

var
  vJSON: string;
begin
  // 1-Stunden-UI-optimierte Klines für BTCUSDT abrufen
  vJSON := sgcBinanceREST.GetUIKLines('BTCUSDT', bcih1h, 0, 0, 100);
  Memo1.Lines.Add(vJSON);
end;

GetRollingWindowTicker

function GetRollingWindowTicker(const aSymbol: String = '';
  const aSymbols: String = ''; const aWindowSize: String = ''): String;

Diese Methode erweitert den klassischen Get24hrTicker, indem sie benutzerdefinierte Fenstergrößen erlaubt. Akzeptierte Werte für aWindowSize sind '1h', '4h' und '1d'. Bei Auslassung wird das Standardfenster verwendet.

var
  vJSON: string;
begin
  // 4-Stunden-Rolling-Window-Statistiken für ETHUSDT abrufen
  vJSON := sgcBinanceREST.GetRollingWindowTicker('ETHUSDT', '', '4h');
  Memo1.Lines.Add(vJSON);
  // Rolling Window für mehrere Symbole abrufen
  vJSON := sgcBinanceREST.GetRollingWindowTicker('',
    '["BTCUSDT","ETHUSDT"]', '1h');
  Memo1.Lines.Add(vJSON);
end;

GetTradingDayTicker

function GetTradingDayTicker(const aSymbol: String = '';
  const aSymbols: String = ''; const aType: String = ''): String;

var
  vJSON: string;
begin
  // Trading-Day-Statistiken für BTCUSDT (FULL-Response) abrufen
  vJSON := sgcBinanceREST.GetTradingDayTicker('BTCUSDT', '', 'FULL');
  Memo1.Lines.Add(vJSON);
end;

Erweiterte Order-Typen

Binance hat mehrere neue Order-List-Typen eingeführt, die über das ursprüngliche OCO hinausgehen. Die sgcWebSockets-Bibliothek unterstützt sie jetzt alle nativ.

NewOrderListOCO (neues OCO-Format)

Das neue OCO-Format ersetzt das alte NewOCO und führt flexiblere Above-/Below-Preiskonfigurationen ein. Jeder Schenkel der OCO lässt sich unabhängig mit eigenem Order-Typ, Stop-Preis, Trailing-Delta und Time-in-Force konfigurieren.

function NewOrderListOCO(const aSymbol, aSide: String;
  aQuantity: Double; const aAboveType: String;
  const aBelowType: String;
  aAboveClientOrderId: String = '';
  aAboveIcebergQty: Double = 0; aAbovePrice: Double = 0;
  aAboveStopPrice: Double = 0; aAboveTrailingDelta: Int64 = 0;
  aAboveTimeInForce: String = '';
  aBelowClientOrderId: String = '';
  aBelowIcebergQty: Double = 0; aBelowPrice: Double = 0;
  aBelowStopPrice: Double = 0; aBelowTrailingDelta: Int64 = 0;
  aBelowTimeInForce: String = '';
  aListClientOrderId: String = '';
  aNewOrderRespType: String = '';
  aSelfTradePreventionMode: String = ''): String;

var
  vJSON: string;
begin
  // Neue OCO platzieren: Take-Profit oberhalb + Stop-Loss unterhalb
  vJSON := sgcBinanceREST.NewOrderListOCO(
    'BTCUSDT',          // symbol
    'SELL',              // side
    0.001,              // quantity
    'LIMIT_MAKER',      // above type (take-profit)
    'STOP_LOSS_LIMIT',  // below type (stop-loss)
    '',                 // aboveClientOrderId
    0,                  // aboveIcebergQty
    72000.0,            // abovePrice (take-profit price)
    0,                  // aboveStopPrice
    0,                  // aboveTrailingDelta
    '',                 // aboveTimeInForce
    '',                 // belowClientOrderId
    0,                  // belowIcebergQty
    62000.0,            // belowPrice (limit price for stop)
    62500.0,            // belowStopPrice (trigger price)
    0,                  // belowTrailingDelta
    'GTC'               // belowTimeInForce
  );
  Memo1.Lines.Add(vJSON);
end;

NewOrderListOTO (One-Triggers-the-Other)

Eine OTO-Order-Liste besteht aus einer Working-Order und einer Pending-Order. Wenn die Working-Order ausgeführt wird, wird die Pending-Order automatisch platziert. Nützlich für Entry-Orders mit automatischen Folge-Orders.

function NewOrderListOTO(const aSymbol: String;
  const aWorkingType, aWorkingSide: String;
  aWorkingQuantity: Double; aWorkingPrice: Double;
  const aPendingType, aPendingSide: String;
  aPendingQuantity: Double;
  { ... additional optional parameters ... }
  ): String;

var
  vJSON: string;
begin
  // BTCUSDT per Limit kaufen, dann automatisch einen Stop-Loss-Sell platzieren
  vJSON := sgcBinanceREST.NewOrderListOTO(
    'BTCUSDT',
    'LIMIT', 'BUY',       // working order: limit buy
    0.001, 65000.0,        // working quantity and price
    'STOP_LOSS_LIMIT', 'SELL',  // pending: stop-loss sell
    0.001,                 // pending quantity
    '',                    // workingClientOrderId
    'GTC',                 // workingTimeInForce
    0,                     // workingIcebergQty
    '',                    // pendingClientOrderId
    62000.0,               // pendingPrice (limit)
    62500.0                // pendingStopPrice (trigger)
  );
  Memo1.Lines.Add(vJSON);
end;

NewOrderListOTOCO (One-Triggers-an-OCO)

Kombiniert OTO- und OCO-Logik: Eine Working-Order löst beim Fill ein OCO-Paar (Take-Profit + Stop-Loss) aus. Das ermöglicht vollautomatische Entry-with-Exit-Plan-Strategien in einem einzigen API-Aufruf.

var
  vJSON: string;
begin
  // Entry: Limit-Buy bei 65000
  // Bei Fill: platziert OCO mit Take-Profit bei 72000 und Stop-Loss bei 62000
  vJSON := sgcBinanceREST.NewOrderListOTOCO(
    'BTCUSDT',
    'LIMIT', 'BUY',          // working order
    0.001, 65000.0,           // working qty & price
    'SELL',                   // pending side
    'LIMIT_MAKER',            // pending above type
    'STOP_LOSS_LIMIT',        // pending below type
    0.001,                   // pending quantity
    '',                      // workingClientOrderId
    'GTC',                   // workingTimeInForce
    0,                       // workingIcebergQty
    '',                      // pendingAboveClientOrderId
    72000.0,                 // pendingAbovePrice (take-profit)
    0,                       // pendingAboveStopPrice
    0,                       // pendingAboveTrailingDelta
    '',                      // pendingAboveTimeInForce
    0,                       // pendingAboveIcebergQty
    '',                      // pendingBelowClientOrderId
    62000.0,                 // pendingBelowPrice
    62500.0                  // pendingBelowStopPrice
  );
  Memo1.Lines.Add(vJSON);
end;

Smart Order Routing (SOR)

SOR-Orders erlauben Binance, die Ausführung durch Routing über mehrere Liquiditätspools zu optimieren. Es gibt zwei neue Methoden: NewSOROrder für Live-Ausführung und TestSOROrder zur Validierung ohne tatsächliche Platzierung.

function NewSOROrder(const aSymbol, aSide, aType: String;
  aQuantity: Double; aTimeInForce: String = '';
  aPrice: Double = 0; aNewClientOrderId: String = '';
  aNewOrderRespType: String = '';
  aIcebergQty: Double = 0;
  aSelfTradePreventionMode: String = '';
  aStrategyId: Int64 = 0; aStrategyType: Integer = 0): String;

var
  vJSON: string;
begin
  // SOR-Limit-Order platzieren
  vJSON := sgcBinanceREST.NewSOROrder(
    'BTCUSDT', 'BUY', 'LIMIT',
    0.001,             // quantity
    'GTC',             // timeInForce
    65000.0            // price
  );
  Memo1.Lines.Add(vJSON);
  // SOR-Order ohne Ausführung testen
  vJSON := sgcBinanceREST.TestSOROrder('BTCUSDT', 'BUY', 'LIMIT',
    0.001, 'GTC', 65000.0);
  Memo1.Lines.Add(vJSON);
end;

CancelReplaceOrder

Storniert atomar eine bestehende Order und platziert eine neue. Entscheidend für Strategien, die Orders ändern müssen, ohne zwischen zwei getrennten Cancel-+-Place-Aufrufen ohne Position dazustehen.

var
  vJSON: string;
begin
  // Order 123456 stornieren und durch neuen Limit-Buy ersetzen
  vJSON := sgcBinanceREST.CancelReplaceOrder(
    'BTCUSDT', 'BUY', 'LIMIT',
    'STOP_ON_FAILURE',   // mode: only place new if cancel succeeds
    'GTC',               // timeInForce
    0.001,               // quantity
    0,                   // quoteOrderQty
    64500.0,             // new price
    '',                  // cancelNewClientOrderId
    '',                  // cancelOrigClientOrderId
    123456               // cancelOrderId
  );
  Memo1.Lines.Add(vJSON);
end;

Konto- und Abfrage-Endpoints

Methode	Beschreibung
`GetAccountInformation(aOmitZeroBalances)`	Erweitert um den Parameter `aOmitZeroBalances`. Bei `True` werden Assets mit Saldo null aus der Antwort ausgeschlossen.
`GetOrderRateLimitUsage`	Liefert die aktuelle Order-Anzahl und Rate-Limit-Nutzung — essentiell, um in Hochfrequenz-Szenarien innerhalb der API-Limits zu bleiben.
`GetPreventedMatches`	Fragt verhinderte Self-Trade-Matches ab. Unterstützt Filterung nach Symbol, Order-ID oder Prevented-Match-ID mit Paginierung.
`GetAllocations`	Ruft SOR-Order-Allocations ab und zeigt, wie eine Order auf Pools verteilt wurde.
`GetAccountCommission`	Liefert die Maker-/Taker-Kommissionsrate für ein bestimmtes Symbol.

var
  vJSON: string;
begin
  // Kontoinformationen abrufen, Salden null auslassen
  vJSON := sgcBinanceREST.GetAccountInformation(True);
  Memo1.Lines.Add(vJSON);
  // Order-Rate-Limit-Nutzung prüfen
  vJSON := sgcBinanceREST.GetOrderRateLimitUsage;
  Memo1.Lines.Add(vJSON);
  // Kommissionsraten für BTCUSDT abrufen
  vJSON := sgcBinanceREST.GetAccountCommission('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Prevented Matches für ein Symbol abrufen
  vJSON := sgcBinanceREST.GetPreventedMatches('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // SOR-Allocations für ein Symbol abrufen
  vJSON := sgcBinanceREST.GetAllocations('BTCUSDT');
  Memo1.Lines.Add(vJSON);
end;

Hinweis: Die Methoden NewOrder und TestNewOrder wurden ebenfalls mit neuen optionalen Parametern erweitert: aSelfTradePreventionMode, aStrategyId und aStrategyType. Die Methode CancelOrder akzeptiert nun einen Parameter aCancelRestrictions für bedingtes Cancel. Diese Ergänzungen sind rückwärtskompatibel — bestehender Code funktioniert unverändert.

2. Neue Futures-REST-API-Methoden

Die Klasse TsgcHTTP_API_Binance_Futures_Rest hat den größten Satz neuer Methoden erhalten — abgedeckt sind Marktdaten, Order-Management, Kontokonfiguration und Stream-Management. Alle Methoden arbeiten mit USDT-M- und COIN-M-Futures, gesteuert über die Property FuturesContracts.

Futures-Marktdaten

Methode	Beschreibung
`GetContinuousKLines`	Kline-/Candlestick-Daten für einen Continuous-Kontrakt. Erfordert Pair, Kontrakttyp (z. B. `'PERPETUAL'`, `'CURRENT_QUARTER'`) und Intervall.
`GetIndexPriceKLines`	Kline-Daten basierend auf dem Index-Preis eines Handelspaares.
`GetMarkPriceKLines`	Kline-Daten basierend auf dem Mark-Preis eines Symbols.
`GetPremiumIndexKLines`	Premium-Index-Kline-Daten zur Basis-Berechnung und Funding-Rate-Analyse.
`GetFundingInfo`	Liefert Funding-Rate-Infos für alle Symbole inklusive Funding-Intervall und Cap-/Floor-Raten.
`GetPriceTickerV2`	V2-Preisticker mit verbessertem Antwortformat.
`GetIndexInfo`	Liefert Indexpreis und Bestandteildaten für ein Composite-Index-Symbol.
`GetAssetIndex`	Asset-Indexpreise für Margin-Berechnungen im Multi-Asset-Modus.
`GetConstituents`	Bestandteile und ihre Gewichtungen für einen Composite-Index abfragen.
`GetDeliveryPrice`	Historische Delivery-Preise für Quartals-/Halbjahres-Kontrakte.
`GetBasis`	Basis-Daten (Spread zwischen Futures- und Spot-Preis) für ein Paar und Kontrakttyp.

var
  vJSON: string;
begin
  // Continuous Klines für BTCUSDT Perpetual, 1h-Intervall
  vJSON := sgcBinanceFutREST.GetContinuousKLines(
    'BTCUSDT', 'PERPETUAL', bcih1h, 0, 0, 100);
  Memo1.Lines.Add(vJSON);
  // Mark-Price-Klines für ETHUSDT, 15m-Intervall
  vJSON := sgcBinanceFutREST.GetMarkPriceKLines('ETHUSDT', bcih15m);
  Memo1.Lines.Add(vJSON);
  // Index-Price-Klines
  vJSON := sgcBinanceFutREST.GetIndexPriceKLines('BTCUSDT', bcih4h);
  Memo1.Lines.Add(vJSON);
  // Premium-Index-Klines für Funding-Analyse
  vJSON := sgcBinanceFutREST.GetPremiumIndexKLines('BTCUSDT', bcih1h);
  Memo1.Lines.Add(vJSON);
  // Funding-Info für alle Symbole abrufen
  vJSON := sgcBinanceFutREST.GetFundingInfo;
  Memo1.Lines.Add(vJSON);
  // V2-Preisticker
  vJSON := sgcBinanceFutREST.GetPriceTickerV2('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Basis-Daten
  vJSON := sgcBinanceFutREST.GetBasis('BTCUSDT', 'PERPETUAL', oip1h, 30);
  Memo1.Lines.Add(vJSON);
  // Delivery-Preishistorie
  vJSON := sgcBinanceFutREST.GetDeliveryPrice('BTCUSD');
  Memo1.Lines.Add(vJSON);
end;

Futures-Order-Management

Die neuen Futures-Order-Methoden bieten Test-Orders, Order-Modifikation, Batch-Verarbeitung und Liquidations-Abfragen.

Methode	Beschreibung
`TestNewOrder`	Validiert eine neue Futures-Order, ohne sie zu platzieren. Spiegelt die Signatur von `NewOrder`.
`ModifyOrder`	Ändert Preis, Menge oder Price-Matching-Modus einer bestehenden offenen Order.
`NewBatchOrders`	Platziert bis zu 5 Orders in einer einzigen Anfrage über ein JSON-Array von Order-Objekten.
`ModifyBatchOrders`	Modifiziert bis zu 5 bestehende Orders in einer einzigen Anfrage.
`CancelBatchOrders`	Storniert mehrere Orders über eine Order-ID-Liste oder Client-Order-ID-Liste.
`GetOrderAmendment`	Ruft die Änderungs-(Amendment-)Historie einer Order ab.
`CountdownCancelAll`	Setzt einen Countdown-Timer (in Millisekunden), nach dem alle offenen Orders für ein Symbol storniert werden.
`GetForceOrders`	Fragt erzwungene Liquidations-Orders mit optionaler Filterung ab.
`GetADLQuantile`	Ruft die ADL- (Auto-Deleveraging-)Quantilschätzung für Positionen ab.

Die Signatur von NewOrder für Futures wurde ebenfalls um neue Parameter erweitert: aPriceMatch, aSelfTradePreventionMode, aGoodTillDate und aPriceProtect.

var
  vJSON: string;
begin
  // Futures-Order ohne Ausführung testen
  vJSON := sgcBinanceFutREST.TestNewOrder(
    'BTCUSDT', 'BUY', '', 'LIMIT',
    'GTC', 0.001, 'false', 65000.0);
  Memo1.Lines.Add('TestNewOrder: ' + vJSON);
  // Preis einer bestehenden Order ändern
  vJSON := sgcBinanceFutREST.ModifyOrder('BTCUSDT', 123456, '',
    'BUY', 0.001, 64800.0);
  Memo1.Lines.Add('ModifyOrder: ' + vJSON);
  // Mehrere Orders auf einmal stornieren
  vJSON := sgcBinanceFutREST.CancelBatchOrders('BTCUSDT',
    '[123456,123457,123458]');
  Memo1.Lines.Add('CancelBatch: ' + vJSON);
  // Countdown-Cancel setzen: alle BTCUSDT-Orders in 30 Sekunden stornieren
  vJSON := sgcBinanceFutREST.CountdownCancelAll('BTCUSDT', 30000);
  Memo1.Lines.Add('Countdown: ' + vJSON);
  // Erzwungene Liquidations-Orders abfragen
  vJSON := sgcBinanceFutREST.GetForceOrders('BTCUSDT');
  Memo1.Lines.Add('ForceOrders: ' + vJSON);
  // ADL-Quantilschätzung
  vJSON := sgcBinanceFutREST.GetADLQuantile('BTCUSDT');
  Memo1.Lines.Add('ADL: ' + vJSON);
end;

Futures-Konto und Konfiguration

Mehrere V3-Konto-Endpoints wurden zusätzlich zu Konfigurations- und Fee-Management-Methoden hinzugefügt.

Methode	Beschreibung
`GetAccountBalanceV3`	V3-Kontostand mit verbesserter Multi-Asset-Margin-Unterstützung.
`GetAccountInformationV3`	V3-Kontodetails inklusive Multi-Asset-Margin-Modus und aktualisierten Fee-Tiers.
`GetPositionInformationV3`	V3-Positionsdaten mit zusätzlichen Präzisions-Feldern.
`GetCommissionRate`	Liefert die aktuelle Maker-/Taker-Kommissionsrate für ein bestimmtes Futures-Symbol.
`GetAccountConfig`	Kontoweite Konfiguration: Fee-Tier, Positions-Modus, Multi-Asset-Margin-Modus.
`GetSymbolConfig`	Symbolweite Konfiguration: Hebel, Margin-Typ und Positions-Modus.
`GetOrderRateLimit`	Aktueller Order-Rate-Limit-Status pro Symbol.
`GetApiTradingStatus`	API-Trading-Status und Indikatoren, die Trading-Einschränkungen auslösen können.
`ChangeMultiAssetsMode`	Multi-Asset-Margin-Modus für USDT-M-Futures aktivieren oder deaktivieren.
`GetMultiAssetsMode`	Aktuelle Einstellung des Multi-Asset-Margin-Modus abfragen.
`SetFeeBurn`	BNB-Fee-Burn aktivieren oder deaktivieren (Gebühren mit BNB rabattiert bezahlen).
`GetFeeBurn`	Aktuelle Fee-Burn-Einstellung abfragen.

Listen-Key-Verwaltung

Drei dedizierte Methoden verwalten nun den Listen-Key-Lebenszyklus des Futures-User-Data-Streams direkt über REST, unabhängig von der WebSocket-Komponente:

Methode	Beschreibung
`CreateListenKey`	Erzeugt einen neuen Listen-Key für den User-Data-Stream (POST).
`KeepAliveListenKey`	Verlängert die Gültigkeit eines Listen-Keys (PUT). Muss alle 60 Minuten aufgerufen werden.
`CloseListenKey`	Macht einen Listen-Key ungültig und schließt ihn (DELETE).

var
  vJSON: string;
begin
  // V3-Saldo und Kontoinfo
  vJSON := sgcBinanceFutREST.GetAccountBalanceV3;
  Memo1.Lines.Add('V3 Balance: ' + vJSON);
  vJSON := sgcBinanceFutREST.GetAccountInformationV3;
  Memo1.Lines.Add('V3 Account: ' + vJSON);
  vJSON := sgcBinanceFutREST.GetPositionInformationV3('BTCUSDT');
  Memo1.Lines.Add('V3 Position: ' + vJSON);
  // Kommissionsrate
  vJSON := sgcBinanceFutREST.GetCommissionRate('BTCUSDT');
  Memo1.Lines.Add('Commission: ' + vJSON);
  // Konto- und Symbolkonfiguration
  vJSON := sgcBinanceFutREST.GetAccountConfig;
  Memo1.Lines.Add('AccountConfig: ' + vJSON);
  vJSON := sgcBinanceFutREST.GetSymbolConfig('BTCUSDT');
  Memo1.Lines.Add('SymbolConfig: ' + vJSON);
  // Multi-Asset-Margin-Modus aktivieren
  vJSON := sgcBinanceFutREST.ChangeMultiAssetsMode(True);
  Memo1.Lines.Add('MultiAssets: ' + vJSON);
  // BNB-Fee-Burn aktivieren
  vJSON := sgcBinanceFutREST.SetFeeBurn(True);
  Memo1.Lines.Add('FeeBurn: ' + vJSON);
  // API-Trading-Status prüfen
  vJSON := sgcBinanceFutREST.GetApiTradingStatus('BTCUSDT');
  Memo1.Lines.Add('TradingStatus: ' + vJSON);
  // Listen-Key-Lebenszyklus (Nur-REST-Ansatz)
  vJSON := sgcBinanceFutREST.CreateListenKey;
  Memo1.Lines.Add('ListenKey: ' + vJSON);
end;

3. Neue Spot-WebSocket-Streams

Die Klasse TsgcWS_API_Binance wurde um drei neue Stream-Typen erweitert, jeweils mit Subscribe- und Unsubscribe-Methoden.

Methode	Stream	Beschreibung
`SubscribeAvgPrice / UnSubscribeAvgPrice`	`<symbol>@avgPrice`	Echtzeit-Durchschnittspreis-Stream für ein Symbol.
`SubscribeRollingWindowTicker`	`<symbol>@ticker_<window>`	Rolling-Window-Statistiken mit konfigurierbarer Fenstergröße (1h, 4h, 1d).
`SubscribeAllRollingWindowTickers`	`!ticker_<window>@arr`	Rolling-Window-Statistiken für alle gehandelten Symbole bei einer bestimmten Fenstergröße.

Ein neuer Aufzählungstyp TsgcWSBinanceRollingWindowSize ermöglicht eine typsichere Angabe der Fenstergröße:

TsgcWSBinanceRollingWindowSize = (brw1h, brw4h, brw1d);

procedure TForm1.btnSubscribeClick(Sender: TObject);
begin
  if not sgcWebSocketClient1.Active then
    sgcWebSocketClient1.Active := True;
  // Durchschnittspreis-Updates für BTCUSDT abonnieren
  sgcBinance.SubscribeAvgPrice('btcusdt');
  // 1-Stunden-Rolling-Window-Ticker für ETHUSDT abonnieren
  sgcBinance.SubscribeRollingWindowTicker('ethusdt', brw1h);
  // Alle Ticker mit 4-Stunden-Rolling-Window abonnieren
  sgcBinance.SubscribeAllRollingWindowTickers(brw4h);
end;
procedure TForm1.btnUnsubscribeClick(Sender: TObject);
begin
  sgcBinance.UnSubscribeAvgPrice('btcusdt');
  sgcBinance.UnSubscribeRollingWindowTicker('ethusdt', brw1h);
  sgcBinance.UnSubscribeAllRollingWindowTickers(brw4h);
end;

4. Neue Futures-WebSocket-Streams

Die Klasse TsgcWS_API_Binance_Futures erhält den größten Satz neuer WebSocket- Stream-Subscriptions. Sie decken Continuous-Kontrakte, Composite-Indizes, Asset-Indizes, Index-Preise und Mark-Price-Klines ab.

Methode	Stream	Beschreibung
`SubscribeContinuousKLine`	`<pair>_<contract>@continuousKline_<interval>`	Kline-Stream für Continuous-Kontrakte. Erfordert Pair, Kontrakttyp und Intervall.
`SubscribeCompositeIndex`	`<symbol>@compositeIndex`	Composite-Index-Preis-Stream mit Komponenten-Aufschlüsselung.
`SubscribeContractInfo`	`!contractInfo`	Kontraktinformations-Stream. Liefert Updates zu Listing, Delisting und Bracket-Änderungen.
`SubscribeAssetIndex / SubscribeAllAssetIndex`	`<symbol>@assetIndex` / `!assetIndex@arr`	Asset-Index-Preise für Multi-Asset-Margin-Berechnungen. Pro Symbol oder gesamter Markt.
`SubscribeIndexPrice`	`<pair>@indexPrice`	Index-Preis-Stream für ein Handelspaar. Unterstützt optionalen Update-Speed-Parameter.
`SubscribeIndexPriceKLine`	`<pair>@indexPriceKline_<interval>`	Index-Preis-Kline-/Candlestick-Stream mit konfigurierbaren Intervallen.
`SubscribeMarkPriceKLine`	`<symbol>@markPriceKline_<interval>`	Mark-Price-Kline-Stream zur Nachverfolgung des Mark-Preises in Liquidationsberechnungen.

procedure TForm1.SubscribeFuturesStreams;
begin
  if not sgcWebSocketClient1.Active then
    sgcWebSocketClient1.Active := True;
  // Continuous Kline für BTCUSDT-Perpetual-Kontrakt, 1h-Intervall
  sgcBinanceFutures.SubscribeContinuousKLine('btcusdt',
    'perpetual', bci1h);
  // Composite-Index-Stream
  sgcBinanceFutures.SubscribeCompositeIndex('defiusdt');
  // Kontraktinfo-Updates (kein Symbol nötig)
  sgcBinanceFutures.SubscribeContractInfo;
  // Asset-Index für ein einzelnes Symbol
  sgcBinanceFutures.SubscribeAssetIndex('btcusd');
  // Alle Asset-Index-Preise
  sgcBinanceFutures.SubscribeAllAssetIndex;
  // Indexpreis mit Standard-Update-Speed
  sgcBinanceFutures.SubscribeIndexPrice('btcusdt');
  // Index-Preis-Kline, 15m-Intervall
  sgcBinanceFutures.SubscribeIndexPriceKLine('btcusdt', bci15m);
  // Mark-Price-Kline, 5m-Intervall
  sgcBinanceFutures.SubscribeMarkPriceKLine('btcusdt', bci5m);
end;

5. Vollständige funktionierende Beispiele

Beispiel 1: Spot REST + WebSocket kombiniert (VCL-Anwendung)

Ein typisches Muster: Die REST-API für das Platzieren von Orders und die WebSocket-API für Echtzeit-Marktdaten nutzen. Das folgende Beispiel zeigt das Setup beider über die Komponente TsgcWS_API_Binance.

unit MainForm;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  StdCtrls, sgcWebSocket_Classes, sgcWebSocket_API_Binance,
  sgcWebSocket_APIs, sgcBase_Classes, sgcWebSocket_Client, sgcWebSocket;
type
  TForm1 = class(TForm)
    sgcWebSocketClient1: TsgcWebSocketClient;
    sgcBinance: TsgcWSAPI_Binance;
    btnConnect: TButton;
    btnGetTicker: TButton;
    btnPlaceSOROrder: TButton;
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure btnConnectClick(Sender: TObject);
    procedure btnGetTickerClick(Sender: TObject);
    procedure btnPlaceSOROrderClick(Sender: TObject);
    procedure sgcWebSocketClient1Message(Connection: TsgcWSConnection;
      const Text: string);
  end;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
begin
  // API-Zugangsdaten konfigurieren
  sgcBinance.Binance.ApiKey := 'dein-api-key';
  sgcBinance.Binance.ApiSecret := 'dein-api-secret';
  sgcBinance.Binance.TestNet := True;  // im Development das Testnet nutzen
  sgcBinance.Binance.UserStream := False;
end;
procedure TForm1.btnConnectClick(Sender: TObject);
begin
  sgcWebSocketClient1.Active := True;
  // Neue Streams abonnieren
  sgcBinance.SubscribeAvgPrice('btcusdt');
  sgcBinance.SubscribeRollingWindowTicker('btcusdt', brw1h);
end;
procedure TForm1.btnGetTickerClick(Sender: TObject);
begin
  // Neue REST-Endpoints über die integrierte REST_API-Property nutzen
  Memo1.Lines.Add(sgcBinance.REST_API.GetTradingDayTicker('BTCUSDT'));
  Memo1.Lines.Add(sgcBinance.REST_API.GetRollingWindowTicker('BTCUSDT',
    '', '4h'));
  Memo1.Lines.Add(sgcBinance.REST_API.GetAccountCommission('BTCUSDT'));
end;
procedure TForm1.btnPlaceSOROrderClick(Sender: TObject);
begin
  // Smart-Order-Routing-Order testen
  Memo1.Lines.Add(sgcBinance.REST_API.TestSOROrder(
    'BTCUSDT', 'BUY', 'LIMIT', 0.001, 'GTC', 65000.0));
end;
procedure TForm1.sgcWebSocketClient1Message(Connection: TsgcWSConnection;
  const Text: string);
begin
  Memo1.Lines.Add(Text);
end;
end.

Beispiel 2: Futures REST + WebSocket (Konsolenanwendung)

Konsolenanwendungen sind ideal für Headless-Bots und Hintergrunddienste. Das folgende Beispiel zeigt die Nutzung der neuen Futures-Methoden im Konsolenkontext.

program BinanceFuturesConsole;
{$APPTYPE CONSOLE}
{$R *.res}
uses
  Classes, SysUtils,
  sgcWebSocket, sgcWebSocket_APIs, sgcWebSocket_Types,
  sgcWebSocket_Classes, sgcHTTP_API_Binance;
var
  FutREST: TsgcHTTP_API_Binance_Futures_Rest;
  vJSON: string;
begin
  try
    FutREST := TsgcHTTP_API_Binance_Futures_Rest.Create(nil);
    try
      FutREST.BinanceOptions.ApiKey := 'dein-api-key';
      FutREST.BinanceOptions.ApiSecret := 'dein-api-secret';
      FutREST.BinanceOptions.TestNet := True;
      FutREST.FuturesContracts := bfchUSDT;
      // Neue Marktdaten-Methoden
      vJSON := FutREST.GetFundingInfo;
      WriteLn('Funding Info: ', Copy(vJSON, 1, 200), '...');
      vJSON := FutREST.GetPriceTickerV2('BTCUSDT');
      WriteLn('PriceV2: ', vJSON);
      vJSON := FutREST.GetContinuousKLines('BTCUSDT',
        'PERPETUAL', bcih1h, 0, 0, 5);
      WriteLn('ContinuousKLines: ', Copy(vJSON, 1, 200), '...');
      // V3-Konto-Endpoints
      vJSON := FutREST.GetAccountBalanceV3;
      WriteLn('V3 Balance: ', Copy(vJSON, 1, 200), '...');
      // Kontokonfiguration
      vJSON := FutREST.GetAccountConfig;
      WriteLn('Config: ', vJSON);
      vJSON := FutREST.GetSymbolConfig('BTCUSDT');
      WriteLn('SymbolConfig: ', vJSON);
      // Kommission und Gebührenverwaltung
      vJSON := FutREST.GetCommissionRate('BTCUSDT');
      WriteLn('Commission: ', vJSON);
      vJSON := FutREST.GetFeeBurn;
      WriteLn('FeeBurn: ', vJSON);
      // Listen-Key-Verwaltung
      vJSON := FutREST.CreateListenKey;
      WriteLn('ListenKey: ', vJSON);
    finally
      FutREST.Free;
    end;
  except
    on E: Exception do
      WriteLn(E.ClassName, ': ', E.Message);
  end;
end.

Beispiel 3: OTOCO-Order-Strategie

Der OTOCO-Order-Typ steht für den komplettesten automatisierten Trade-Lebenszyklus: Ein einziger Aufruf platziert eine Entry-Order, die nach dem Fill automatisch sowohl Take-Profit als auch Stop-Loss aufsetzt.

procedure TForm1.PlaceOTOCOStrategy;
var
  vResult: string;
begin
  // Strategie: ETHUSDT bei 3400 kaufen, Take-Profit bei 3600, Stop-Loss bei 3300
  vResult := sgcBinance.REST_API.NewOrderListOTOCO(
    'ETHUSDT',
    // Working-Order: Limit-Buy-Entry
    'LIMIT',              // workingType
    'BUY',                // workingSide
    0.1,                  // workingQuantity
    3400.0,               // workingPrice
    // Pending OCO (ausgelöst nach Entry-Fill)
    'SELL',                // pendingSide
    'LIMIT_MAKER',         // pendingAboveType (take-profit)
    'STOP_LOSS_LIMIT',     // pendingBelowType (stop-loss)
    0.1,                  // pendingQuantity
    '',                   // workingClientOrderId
    'GTC',                // workingTimeInForce
    0,                    // workingIcebergQty
    '',                   // pendingAboveClientOrderId
    3600.0,               // pendingAbovePrice (take-profit target)
    0,                    // pendingAboveStopPrice
    0,                    // pendingAboveTrailingDelta
    '',                   // pendingAboveTimeInForce
    0,                    // pendingAboveIcebergQty
    '',                   // pendingBelowClientOrderId
    3250.0,               // pendingBelowPrice (stop-loss limit)
    3300.0                // pendingBelowStopPrice (trigger)
  );
  if Pos('"orderListId"', vResult) > 0 then
    Memo1.Lines.Add('OTOCO erfolgreich platziert')
  else
    Memo1.Lines.Add('OTOCO-Fehler: ' + vResult);
end;

Zusammenfassung

Die folgende Tabelle fasst die Anzahl der neu hinzugefügten Methoden pro Klasse zusammen:

Komponente	Klasse	Neue Methoden
Spot-REST-API	`TsgcHTTP_API_Binance_Rest`	GetUIKLines, GetRollingWindowTicker, GetTradingDayTicker, NewOrderListOCO, NewOrderListOTO, NewOrderListOTOCO, NewSOROrder, TestSOROrder, CancelReplaceOrder, GetOrderRateLimitUsage, GetPreventedMatches, GetAllocations, GetAccountCommission
Futures-REST-API	`TsgcHTTP_API_Binance_Futures_Rest`	TestNewOrder, ModifyOrder, NewBatchOrders, ModifyBatchOrders, CancelBatchOrders, GetOrderAmendment, CountdownCancelAll, GetForceOrders, GetADLQuantile, GetAccountBalanceV3, GetAccountInformationV3, GetPositionInformationV3, GetCommissionRate, GetAccountConfig, GetSymbolConfig, GetOrderRateLimit, GetApiTradingStatus, ChangeMultiAssetsMode, GetMultiAssetsMode, SetFeeBurn, GetFeeBurn, GetContinuousKLines, GetIndexPriceKLines, GetMarkPriceKLines, GetPremiumIndexKLines, GetFundingInfo, GetPriceTickerV2, GetIndexInfo, GetAssetIndex, GetConstituents, GetDeliveryPrice, GetBasis, CreateListenKey, KeepAliveListenKey, CloseListenKey
Spot-WebSocket	`TsgcWS_API_Binance`	SubscribeAvgPrice, SubscribeRollingWindowTicker, SubscribeAllRollingWindowTickers (+ passende UnSubscribe-Methoden)
Futures-WebSocket	`TsgcWS_API_Binance_Futures`	SubscribeContinuousKLine, SubscribeCompositeIndex, SubscribeContractInfo, SubscribeAssetIndex, SubscribeAllAssetIndex, SubscribeIndexPrice, SubscribeIndexPriceKLine, SubscribeMarkPriceKLine (+ passende UnSubscribe-Methoden)

Wichtig: Alle Trading-Methoden, die Orders platzieren, ändern oder stornieren, erfordern gültige ApiKey- und ApiSecret-Zugangsdaten. Es wird dringend empfohlen, vor dem Produktiveinsatz mit TestNet := True gegen das Binance-TestNet zu entwickeln und zu testen. Stelle außerdem sicher, dass die API-Key-Berechtigungen (Trading, Margin, Futures) zu den geplanten Operationen passen. Rückwärtskompatibilität: Alle Ergänzungen sind rückwärtskompatibel. Bestehende Methodensignaturen wurden mit Standard-Parameterwerten erweitert, sodass bereits kompilierter Code unverändert weiterläuft. Die neuen Parameter (aSelfTradePreventionMode, aStrategyId, aPriceMatch usw.) sind standardmäßig leer oder null, was die API zum Standardverhalten veranlasst.