Nowe metody API Binance w sgcWebSockets

24 lutego 2026 · Funkcje

Biblioteka sgcWebSockets rozszerza integrację z Binance o znaczącą partię nowych metod obejmujących Spot REST API, Futures REST API i strumienie WebSocket. Artykuł zawiera techniczny opis każdej nowej metody, jej parametrów oraz praktyczne przykłady kodu Delphi, które pozwolą ci szybko zacząć.

Spis treści

Nowe metody Spot REST API
Dane rynkowe Spot: UI KLines, Rolling Window i Trading Day Tickers
Zarządzanie zleceniami Spot: OCO, OTO, OTOCO i SOR
Konto Spot: prowizje, alokacje, limity i zapobieganie transakcjom
Nowe metody Futures REST API
Dane rynkowe Futures: ciągłe KLines, Premium Index i więcej
Zarządzanie zleceniami Futures: modyfikacja, partia i zlecenia wymuszone
Konto Futures: endpointy V3, konfiguracja i spalanie opłat
Nowe strumienie Spot WebSocket
Nowe strumienie Futures WebSocket
Pełne przykłady robocze

1. Nowe metody Spot REST API

Klasa TsgcHTTP_API_Binance_Rest została rozszerzona o nowe endpointy danych rynkowych, zaawansowane typy zleceń i metody zapytań o konto. Wszystkie metody są dostępne bezpośrednio przez komponent REST lub przez właściwość REST_API klasy TsgcWS_API_Binance.

Endpointy danych rynkowych

Metoda	Opis	Endpoint Binance
`GetUIKLines`	Zoptymalizowane dane kline/świeczki do prezentacji w interfejsie. Zwraca dane w formacie identycznym do `GetKLines`, ale dostosowanym do renderowania wykresów.	`/api/v3/uiKlines`
`GetRollingWindowTicker`	Statystyki zmian ceny w ruchomym oknie. Obsługuje konfigurowalne rozmiary okna (np. 1h, 4h, 1d) w odróżnieniu od stałego tickera 24h.	`/api/v3/ticker`
`GetTradingDayTicker`	Statystyki zmian ceny obliczone dla dnia tradingowego (UTC 00:00 do bieżącej chwili). Obsługuje jeden lub wiele symboli.	`/api/v3/ticker/tradingDay`
`GetPriceTickers`	Pobiera tickery cen dla wielu symboli w jednym żądaniu, używając tablicy JSON nazw symboli.	`/api/v3/ticker/price`

GetUIKLines

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

Różnica między GetKLines a GetUIKLines jest subtelna: wariant UI jest optymalizowany przez backend Binance do renderowania wykresów i może zwracać zmodyfikowane granice kline dla lepszej prezentacji wizualnej. Format odpowiedzi jest identyczny, dzięki czemu jest to zamienne zastępstwo dla każdego przypadku użycia wykresów.

var
  vJSON: string;
begin
  // Retrieve 1-hour UI-optimized klines for BTCUSDT
  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;

Ta metoda rozszerza tradycyjny Get24hrTicker, umożliwiając niestandardowe rozmiary okna. Dopuszczalne wartości aWindowSize to '1h', '4h' i '1d'. Jeśli pominięty, używane jest domyślne okno.

var
  vJSON: string;
begin
  // Get 4-hour rolling window stats for ETHUSDT
  vJSON := sgcBinanceREST.GetRollingWindowTicker('ETHUSDT', '', '4h');
  Memo1.Lines.Add(vJSON);
  // Get rolling window for multiple symbols
  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
  // Get trading day statistics for BTCUSDT (FULL response)
  vJSON := sgcBinanceREST.GetTradingDayTicker('BTCUSDT', '', 'FULL');
  Memo1.Lines.Add(vJSON);
end;

Zaawansowane typy zleceń

Binance wprowadził kilka nowych typów list zleceń wykraczających poza pierwotny OCO. Biblioteka sgcWebSockets obsługuje teraz wszystkie z nich natywnie.

NewOrderListOCO (New OCO Format)

Nowy format OCO zastępuje starszy NewOCO i wprowadza bardziej elastyczne konfiguracje cen powyżej/poniżej. Każda noga OCO może być niezależnie skonfigurowana z własnym typem zlecenia, ceną stop, trailing delta i time-in-force.

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
  // Place a new-format OCO: take-profit above + stop-loss below
  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)

Lista zleceń OTO składa się ze zlecenia roboczego i oczekującego. Gdy zlecenie robocze zostanie zrealizowane, zlecenie oczekujące jest automatycznie składane. Jest to przydatne do konfigurowania zleceń wejścia z automatycznymi zleceniami kontynuacyjnymi.

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
  // Buy BTCUSDT at limit, then automatically place a stop-loss sell
  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)

Łączy logikę OTO i OCO: zlecenie robocze uruchamia parę OCO (take-profit + stop-loss) po zrealizowaniu. Umożliwia to w pełni zautomatyzowane strategie wejście-z-planem-wyjścia w jednym wywołaniu API.

var
  vJSON: string;
begin
  // Entry: limit buy at 65000
  // On fill: places OCO with take-profit at 72000 and stop-loss at 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)

Zlecenia SOR pozwalają Binance zoptymalizować realizację przez routing przez wiele pul płynności. Dostarczone są dwie nowe metody: NewSOROrder do realizacji na żywo i TestSOROrder do walidacji bez faktycznego składania.

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
  // Place a SOR limit order
  vJSON := sgcBinanceREST.NewSOROrder(
    'BTCUSDT', 'BUY', 'LIMIT',
    0.001,             // quantity
    'GTC',             // timeInForce
    65000.0            // price
  );
  Memo1.Lines.Add(vJSON);
  // Test a SOR order without execution
  vJSON := sgcBinanceREST.TestSOROrder('BTCUSDT', 'BUY', 'LIMIT',
    0.001, 'GTC', 65000.0);
  Memo1.Lines.Add(vJSON);
end;

CancelReplaceOrder

Atomowo anuluje istniejące zlecenie i składa nowe. Jest to kluczowe dla strategii wymagających modyfikacji zleceń bez ryzyka pozostania bez pozycji między dwoma oddzielnymi wywołaniami anulowania i składania.

var
  vJSON: string;
begin
  // Cancel order 123456 and replace it with a new limit buy
  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;

Endpointy konta i zapytań

Metoda	Opis
`GetAccountInformation(aOmitZeroBalances)`	Rozszerzona o parametr `aOmitZeroBalances`. Gdy ustawiony na `True`, aktywa z zerowym saldem są wykluczone z odpowiedzi.
`GetOrderRateLimitUsage`	Zwraca bieżącą liczbę zleceń i zużycie limitu przepustowości — niezbędne do pozostania w granicach limitów API w scenariuszach wysokiej częstotliwości.
`GetPreventedMatches`	Zapytuje o zapobieżone własne transakcje. Obsługuje filtrowanie po symbolu, ID zlecenia lub ID zapobiegniętego dopasowania ze stronicowaniem.
`GetAllocations`	Pobiera alokacje zleceń SOR, pokazując jak zlecenie zostało rozdzielone między pule.
`GetAccountCommission`	Zwraca stawkę prowizji maker/taker dla określonego symbolu.

var
  vJSON: string;
begin
  // Get account info, omitting zero balances
  vJSON := sgcBinanceREST.GetAccountInformation(True);
  Memo1.Lines.Add(vJSON);
  // Check order rate limit usage
  vJSON := sgcBinanceREST.GetOrderRateLimitUsage;
  Memo1.Lines.Add(vJSON);
  // Get commission rates for BTCUSDT
  vJSON := sgcBinanceREST.GetAccountCommission('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Get prevented matches for a symbol
  vJSON := sgcBinanceREST.GetPreventedMatches('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Get SOR allocations for a symbol
  vJSON := sgcBinanceREST.GetAllocations('BTCUSDT');
  Memo1.Lines.Add(vJSON);
end;

Uwaga: Metody NewOrder i TestNewOrder zostały również rozszerzone o nowe parametry opcjonalne: aSelfTradePreventionMode, aStrategyId i aStrategyType. Metoda CancelOrder akceptuje teraz parametr aCancelRestrictions do warunkowego anulowania. Te dodatki są wstecznie kompatybilne — istniejący kod będzie nadal działać bez zmian.

2. Nowe metody Futures REST API

Klasa TsgcHTTP_API_Binance_Futures_Rest otrzymała największą partię nowych metod, obejmujących dane rynkowe, zarządzanie zleceniami, konfigurację konta i zarządzanie strumieniami. Wszystkie metody działają z kontraktami USDT-M i COIN-M, kontrolowanymi przez właściwość FuturesContracts.

Dane rynkowe Futures

Metoda	Opis
`GetContinuousKLines`	Dane kline/świeczki dla kontraktu ciągłego. Wymaga pary, typu kontraktu (np. `'PERPETUAL'`, `'CURRENT_QUARTER'`) i interwału.
`GetIndexPriceKLines`	Dane kline na podstawie ceny indeksowej pary tradingowej.
`GetMarkPriceKLines`	Dane kline na podstawie ceny mark symbolu.
`GetPremiumIndexKLines`	Dane kline premium index do obliczania basis i analizy stopy finansowania.
`GetFundingInfo`	Zwraca informacje o stopie finansowania dla wszystkich symboli, w tym interwał finansowania oraz stawki cap/floor.
`GetPriceTickerV2`	Ticker cenowy V2 z ulepszonym formatem odpowiedzi.
`GetIndexInfo`	Zwraca cenę indeksową i dane składowe dla symbolu indeksu złożonego.
`GetAssetIndex`	Ceny indeksów aktywów do obliczeń marży w trybie multi-asset.
`GetConstituents`	Zapytaj o składowe i ich wagi dla danego indeksu złożonego.
`GetDeliveryPrice`	Historyczne ceny dostawy dla kontraktów kwartalnych/dwukwartalnych.
`GetBasis`	Dane basis (spread między ceną futures a spot) dla danej pary i typu kontraktu.

var
  vJSON: string;
begin
  // Continuous klines for BTCUSDT perpetual, 1h interval
  vJSON := sgcBinanceFutREST.GetContinuousKLines(
    'BTCUSDT', 'PERPETUAL', bcih1h, 0, 0, 100);
  Memo1.Lines.Add(vJSON);
  // Mark price klines for ETHUSDT, 15m interval
  vJSON := sgcBinanceFutREST.GetMarkPriceKLines('ETHUSDT', bcih15m);
  Memo1.Lines.Add(vJSON);
  // Index price klines
  vJSON := sgcBinanceFutREST.GetIndexPriceKLines('BTCUSDT', bcih4h);
  Memo1.Lines.Add(vJSON);
  // Premium index klines for funding analysis
  vJSON := sgcBinanceFutREST.GetPremiumIndexKLines('BTCUSDT', bcih1h);
  Memo1.Lines.Add(vJSON);
  // Get funding info for all symbols
  vJSON := sgcBinanceFutREST.GetFundingInfo;
  Memo1.Lines.Add(vJSON);
  // V2 price ticker
  vJSON := sgcBinanceFutREST.GetPriceTickerV2('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Basis data
  vJSON := sgcBinanceFutREST.GetBasis('BTCUSDT', 'PERPETUAL', oip1h, 30);
  Memo1.Lines.Add(vJSON);
  // Delivery price history
  vJSON := sgcBinanceFutREST.GetDeliveryPrice('BTCUSD');
  Memo1.Lines.Add(vJSON);
end;

Zarządzanie zleceniami Futures

Nowe metody zleceń Futures umożliwiają testowanie zleceń, modyfikację, przetwarzanie wsadowe i zapytania o likwidacje.

Metoda	Opis
`TestNewOrder`	Waliduje nowe zlecenie futures bez składania go. Odzwierciedla sygnaturę `NewOrder`.
`ModifyOrder`	Modyfikuje cenę, ilość lub tryb dopasowania ceny istniejącego otwartego zlecenia.
`NewBatchOrders`	Składa do 5 zleceń w jednym żądaniu przez tablicę JSON obiektów zleceń.
`ModifyBatchOrders`	Modyfikuje do 5 istniejących zleceń w jednym żądaniu.
`CancelBatchOrders`	Anuluje wiele zleceń według listy ID zleceń lub listy ID zleceń klienta.
`GetOrderAmendment`	Pobiera historię zmian (modyfikacji) dla zlecenia.
`CountdownCancelAll`	Ustawia timer odliczający (w milisekundach), po którym wszystkie otwarte zlecenia dla symbolu są anulowane.
`GetForceOrders`	Zapytuje o zlecenia wymuszonej likwidacji z opcjonalnym filtrowaniem.
`GetADLQuantile`	Pobiera estymację kwantyla ADL (Auto-Deleveraging) dla pozycji.

Sygnatura NewOrder dla Futures została również rozszerzona o nowe parametry: aPriceMatch, aSelfTradePreventionMode, aGoodTillDate i aPriceProtect.

var
  vJSON: string;
begin
  // Test a futures order without execution
  vJSON := sgcBinanceFutREST.TestNewOrder(
    'BTCUSDT', 'BUY', '', 'LIMIT',
    'GTC', 0.001, 'false', 65000.0);
  Memo1.Lines.Add('TestNewOrder: ' + vJSON);
  // Modify an existing order's price
  vJSON := sgcBinanceFutREST.ModifyOrder('BTCUSDT', 123456, '',
    'BUY', 0.001, 64800.0);
  Memo1.Lines.Add('ModifyOrder: ' + vJSON);
  // Cancel multiple orders at once
  vJSON := sgcBinanceFutREST.CancelBatchOrders('BTCUSDT',
    '[123456,123457,123458]');
  Memo1.Lines.Add('CancelBatch: ' + vJSON);
  // Set countdown cancel: cancel all BTCUSDT orders in 30 seconds
  vJSON := sgcBinanceFutREST.CountdownCancelAll('BTCUSDT', 30000);
  Memo1.Lines.Add('Countdown: ' + vJSON);
  // Query forced liquidation orders
  vJSON := sgcBinanceFutREST.GetForceOrders('BTCUSDT');
  Memo1.Lines.Add('ForceOrders: ' + vJSON);
  // ADL quantile estimation
  vJSON := sgcBinanceFutREST.GetADLQuantile('BTCUSDT');
  Memo1.Lines.Add('ADL: ' + vJSON);
end;

Konto Futures i konfiguracja

Dodano kilka endpointów konta V3 wraz z metodami konfiguracji i zarządzania opłatami.

Metoda	Opis
`GetAccountBalanceV3`	Saldo konta V3 z ulepszoną obsługą marży multi-asset.
`GetAccountInformationV3`	Szczegóły konta V3 z trybem marży multi-asset i zaktualizowanymi poziomami opłat.
`GetPositionInformationV3`	Dane pozycji V3 z dodatkowymi polami precyzji.
`GetCommissionRate`	Zwraca bieżącą stawkę prowizji maker/taker dla określonego symbolu futures.
`GetAccountConfig`	Konfiguracja na poziomie konta: poziom opłat, tryb pozycji, tryb marży multi-asset.
`GetSymbolConfig`	Konfiguracja per symbol: dźwignia, typ marży i tryb pozycji.
`GetOrderRateLimit`	Bieżący status limitu przepustowości zleceń per symbol.
`GetApiTradingStatus`	Status handlowy API i wskaźniki mogące uruchomić ograniczenia handlowe.
`ChangeMultiAssetsMode`	Włącz lub wyłącz tryb marży multi-asset dla futures USDT-M.
`GetMultiAssetsMode`	Zapytaj o bieżące ustawienie trybu marży multi-asset.
`SetFeeBurn`	Włącz lub wyłącz spalanie opłat BNB (płatność opłat w BNB z rabatem).
`GetFeeBurn`	Zapytaj o bieżące ustawienie spalania opłat.

Zarządzanie kluczem nasłuchu

Trzy dedykowane metody obsługują teraz cykl życia klucza nasłuchu strumienia danych użytkownika Futures bezpośrednio przez REST, niezależnie od komponentu WebSocket:

Metoda	Opis
`CreateListenKey`	Generuje nowy klucz nasłuchu dla strumienia danych użytkownika (POST).
`KeepAliveListenKey`	Przedłuża ważność klucza nasłuchu (PUT). Musi być wywoływana co 60 minut.
`CloseListenKey`	Unieważnia i zamyka klucz nasłuchu (DELETE).

var
  vJSON: string;
begin
  // V3 balance and account info
  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);
  // Commission rate
  vJSON := sgcBinanceFutREST.GetCommissionRate('BTCUSDT');
  Memo1.Lines.Add('Commission: ' + vJSON);
  // Account and symbol configuration
  vJSON := sgcBinanceFutREST.GetAccountConfig;
  Memo1.Lines.Add('AccountConfig: ' + vJSON);
  vJSON := sgcBinanceFutREST.GetSymbolConfig('BTCUSDT');
  Memo1.Lines.Add('SymbolConfig: ' + vJSON);
  // Enable multi-asset margin mode
  vJSON := sgcBinanceFutREST.ChangeMultiAssetsMode(True);
  Memo1.Lines.Add('MultiAssets: ' + vJSON);
  // Enable BNB fee burn
  vJSON := sgcBinanceFutREST.SetFeeBurn(True);
  Memo1.Lines.Add('FeeBurn: ' + vJSON);
  // Check API trading status
  vJSON := sgcBinanceFutREST.GetApiTradingStatus('BTCUSDT');
  Memo1.Lines.Add('TradingStatus: ' + vJSON);
  // Listen key lifecycle (REST-only approach)
  vJSON := sgcBinanceFutREST.CreateListenKey;
  Memo1.Lines.Add('ListenKey: ' + vJSON);
end;

3. Nowe strumienie Spot WebSocket

Klasa TsgcWS_API_Binance została rozszerzona o trzy nowe typy strumieni, każdy z metodami subskrypcji i anulowania subskrypcji.

Metoda	Strumień	Opis
`SubscribeAvgPrice / UnSubscribeAvgPrice`	`<symbol>@avgPrice`	Strumień średniej ceny w czasie rzeczywistym dla symbolu.
`SubscribeRollingWindowTicker`	`<symbol>@ticker_<window>`	Statystyki ruchomego okna z konfigurowalnym rozmiarem (1h, 4h, 1d).
`SubscribeAllRollingWindowTickers`	`!ticker_<window>@arr`	Statystyki ruchomego okna dla wszystkich handlowanych symboli przy określonym rozmiarze okna.

Nowy typ wyliczeniowy TsgcWSBinanceRollingWindowSize zapewnia typowane określenie rozmiaru okna:

TsgcWSBinanceRollingWindowSize = (brw1h, brw4h, brw1d);

procedure TForm1.btnSubscribeClick(Sender: TObject);
begin
  if not sgcWebSocketClient1.Active then
    sgcWebSocketClient1.Active := True;
  // Subscribe to average price updates for BTCUSDT
  sgcBinance.SubscribeAvgPrice('btcusdt');
  // Subscribe to 1-hour rolling window ticker for ETHUSDT
  sgcBinance.SubscribeRollingWindowTicker('ethusdt', brw1h);
  // Subscribe to all tickers with a 4-hour rolling window
  sgcBinance.SubscribeAllRollingWindowTickers(brw4h);
end;
procedure TForm1.btnUnsubscribeClick(Sender: TObject);
begin
  sgcBinance.UnSubscribeAvgPrice('btcusdt');
  sgcBinance.UnSubscribeRollingWindowTicker('ethusdt', brw1h);
  sgcBinance.UnSubscribeAllRollingWindowTickers(brw4h);
end;

4. Nowe strumienie Futures WebSocket

Klasa TsgcWS_API_Binance_Futures otrzymuje największy zestaw nowych subskrypcji strumieni WebSocket. Obejmują one ciągłe kontrakty, indeksy złożone, indeksy aktywów, ceny indeksowe i klines ceny mark.

Metoda	Strumień	Opis
`SubscribeContinuousKLine`	`<pair>_<contract>@continuousKline_<interval>`	Strumień kline dla kontraktów ciągłych. Wymaga pary, typu kontraktu i interwału.
`SubscribeCompositeIndex`	`<symbol>@compositeIndex`	Strumień ceny indeksu złożonego z podziałem na składowe.
`SubscribeContractInfo`	`!contractInfo`	Strumień informacji o kontraktach. Przesyła aktualizacje dotyczące listowania, delistowania i zmian poziomów.
`SubscribeAssetIndex / SubscribeAllAssetIndex`	`<symbol>@assetIndex` / `!assetIndex@arr`	Ceny indeksów aktywów do obliczeń marży multi-asset. Per symbol lub cały rynek.
`SubscribeIndexPrice`	`<pair>@indexPrice`	Strumień ceny indeksowej dla pary tradingowej. Obsługuje opcjonalny parametr szybkości aktualizacji.
`SubscribeIndexPriceKLine`	`<pair>@indexPriceKline_<interval>`	Strumień kline/świeczek ceny indeksowej z konfigurowalnymi interwałami.
`SubscribeMarkPriceKLine`	`<symbol>@markPriceKline_<interval>`	Strumień kline ceny mark do śledzenia ceny mark używanej w obliczeniach likwidacji.

procedure TForm1.SubscribeFuturesStreams;
begin
  if not sgcWebSocketClient1.Active then
    sgcWebSocketClient1.Active := True;
  // Continuous kline for BTCUSDT perpetual contract, 1h interval
  sgcBinanceFutures.SubscribeContinuousKLine('btcusdt',
    'perpetual', bci1h);
  // Composite index stream
  sgcBinanceFutures.SubscribeCompositeIndex('defiusdt');
  // Contract info updates (no symbol needed)
  sgcBinanceFutures.SubscribeContractInfo;
  // Asset index for a single symbol
  sgcBinanceFutures.SubscribeAssetIndex('btcusd');
  // All asset index prices
  sgcBinanceFutures.SubscribeAllAssetIndex;
  // Index price with default update speed
  sgcBinanceFutures.SubscribeIndexPrice('btcusdt');
  // Index price kline, 15m interval
  sgcBinanceFutures.SubscribeIndexPriceKLine('btcusdt', bci15m);
  // Mark price kline, 5m interval
  sgcBinanceFutures.SubscribeMarkPriceKLine('btcusdt', bci5m);
end;

5. Pełne przykłady robocze

Przykład 1: Spot REST + WebSocket razem (aplikacja VCL)

Typowym wzorcem jest używanie REST API do składania zleceń i WebSocket API do danych rynkowych w czasie rzeczywistym. Poniższy przykład demonstruje konfigurację obu przez komponent 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
  // Configure API credentials
  sgcBinance.Binance.ApiKey := 'your-api-key';
  sgcBinance.Binance.ApiSecret := 'your-api-secret';
  sgcBinance.Binance.TestNet := True;  // use testnet during development
  sgcBinance.Binance.UserStream := False;
end;
procedure TForm1.btnConnectClick(Sender: TObject);
begin
  sgcWebSocketClient1.Active := True;
  // Subscribe to new streams
  sgcBinance.SubscribeAvgPrice('btcusdt');
  sgcBinance.SubscribeRollingWindowTicker('btcusdt', brw1h);
end;
procedure TForm1.btnGetTickerClick(Sender: TObject);
begin
  // Use new REST endpoints via the integrated REST_API property
  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
  // Test a Smart Order Routing order
  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.

Przykład 2: Futures REST + WebSocket (aplikacja konsolowa)

Aplikacje konsolowe są idealne dla botów i usług działających w tle. Poniższy przykład demonstruje użycie nowych metod Futures w kontekście konsolowym.

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 := 'your-api-key';
      FutREST.BinanceOptions.ApiSecret := 'your-api-secret';
      FutREST.BinanceOptions.TestNet := True;
      FutREST.FuturesContracts := bfchUSDT;
      // New market data methods
      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 account endpoints
      vJSON := FutREST.GetAccountBalanceV3;
      WriteLn('V3 Balance: ', Copy(vJSON, 1, 200), '...');
      // Account configuration
      vJSON := FutREST.GetAccountConfig;
      WriteLn('Config: ', vJSON);
      vJSON := FutREST.GetSymbolConfig('BTCUSDT');
      WriteLn('SymbolConfig: ', vJSON);
      // Commission and fee management
      vJSON := FutREST.GetCommissionRate('BTCUSDT');
      WriteLn('Commission: ', vJSON);
      vJSON := FutREST.GetFeeBurn;
      WriteLn('FeeBurn: ', vJSON);
      // Listen key management
      vJSON := FutREST.CreateListenKey;
      WriteLn('ListenKey: ', vJSON);
    finally
      FutREST.Free;
    end;
  except
    on E: Exception do
      WriteLn(E.ClassName, ': ', E.Message);
  end;
end.

Przykład 3: Strategia zleceń OTOCO

Typ zlecenia OTOCO reprezentuje najbardziej kompletny automatyczny cykl życia transakcji: jedno wywołanie składa zlecenie wejścia, które po zrealizowaniu automatycznie ustawia zarówno take-profit, jak i stop-loss.

procedure TForm1.PlaceOTOCOStrategy;
var
  vResult: string;
begin
  // Strategy: buy ETHUSDT at 3400, take profit at 3600, stop-loss at 3300
  vResult := sgcBinance.REST_API.NewOrderListOTOCO(
    'ETHUSDT',
    // Working order: limit buy entry
    'LIMIT',              // workingType
    'BUY',                // workingSide
    0.1,                  // workingQuantity
    3400.0,               // workingPrice
    // Pending OCO (triggered after entry fills)
    '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 placed successfully')
  else
    Memo1.Lines.Add('OTOCO error: ' + vResult);
end;

Podsumowanie

Poniższa tabela podsumowuje liczbę nowych metod dodanych do każdej klasy:

Komponent	Klasa	Nowe metody
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 (+ matching UnSubscribe methods)
Futures WebSocket	`TsgcWS_API_Binance_Futures`	SubscribeContinuousKLine, SubscribeCompositeIndex, SubscribeContractInfo, SubscribeAssetIndex, SubscribeAllAssetIndex, SubscribeIndexPrice, SubscribeIndexPriceKLine, SubscribeMarkPriceKLine (+ matching UnSubscribe methods)

Ważne: Wszystkie metody tradingowe składające, modyfikujące lub anulujące zlecenia wymagają prawidłowych poświadczeń ApiKey i ApiSecret. Zdecydowanie zaleca się tworzenie i testowanie na Binance TestNet przez ustawienie TestNet := True przed przejściem na produkcję. Upewnij się również, że uprawnienia klucza API (handel, marża, futures) odpowiadają operacjom, które zamierzasz wykonywać. Wsteczna kompatybilność: Wszystkie dodatki są wstecznie kompatybilne. Istniejące sygnatury metod zostały rozszerzone o domyślne wartości parametrów, więc wcześniej skompilowany kod nadal działa bez modyfikacji. Nowe parametry (aSelfTradePreventionMode, aStrategyId, aPriceMatch, itp.) domyślnie mają wartości puste lub zerowe, powodując używanie przez API standardowego zachowania.