New Binance API Methods in sgcWebSockets

· Fonctionnalités

La bibliothèque sgcWebSockets continue d'étendre son intégration Binance avec un lot important de nouvelles méthodes couvrant l'API REST Spot, l'API REST Futures et les flux WebSocket. Cet article propose un découpage technique de chaque nouvelle méthode, de ses paramètres et des exemples de code Delphi pratiques pour démarrer rapidement.

Table des matières

  1. Nouvelles méthodes API REST Spot
  2. Données de marché Spot : UI KLines, fenêtre glissante et tickers de jour de trading
  3. Gestion des ordres Spot : OCO, OTO, OTOCO et ordres SOR
  4. Compte Spot : commission, allocations, limites de débit et matches empêchés
  5. Nouvelles méthodes API REST Futures
  6. Données de marché Futures : KLines continues, indice de prime et plus
  7. Gestion des ordres Futures : modification, lot et ordres forcés
  8. Compte Futures : endpoints V3, configuration et fee burn
  9. Nouveaux flux WebSocket Spot
  10. Nouveaux flux WebSocket Futures
  11. Exemples complets fonctionnels

1. Nouvelles méthodes API REST Spot

La classe TsgcHTTP_API_Binance_Rest a été étendue avec de nouveaux endpoints de données de marché , des types d'ordres avancés et des méthodes de requête de compte. Toutes les méthodes sont accessibles soit directement via le composant REST, soit via la propriété REST_API de TsgcWS_API_Binance.

Endpoints de données de marché

Méthode Description Endpoint Binance
GetUIKLines Données kline/chandeliers optimisées pour la présentation UI. Renvoie les données dans un format identique à GetKLines mais ajusté pour le rendu de graphique. /api/v3/uiKlines
GetRollingWindowTicker Statistiques de changement de prix sur fenêtre glissante. Prend en charge des tailles de fenêtre configurables (par exemple, 1h, 4h, 1j) contrairement au ticker fixe 24h. /api/v3/ticker
GetTradingDayTicker Statistiques de changement de prix calculées sur la journée de trading (UTC 00:00 à maintenant). Prend en charge un ou plusieurs symboles. /api/v3/ticker/tradingDay
GetPriceTickers Récupère les tickers de prix pour plusieurs symboles en une seule requête via un tableau JSON de noms de symboles. /api/v3/ticker/price

GetUIKLines

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

La différence entre GetKLines et GetUIKLines est subtile : la variante UI est optimisée par le backend Binance pour le rendu de graphique et peut renvoyer des bornes de kline modifiées pour une meilleure présentation visuelle. Le format de réponse est identique, ce qui en fait un remplacement direct pour n'importe quel cas d'usage de graphique. 

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;

Cette méthode étend le Get24hrTicker traditionnel en autorisant des tailles de fenêtre personnalisées. Les valeurs acceptées pour aWindowSize incluent '1h', '4h', et '1d'. Si omise, la fenêtre par défaut est utilisée. 

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;

Types d'ordres avancés

Binance a introduit plusieurs nouveaux types de listes d'ordres qui vont au-delà du OCO d'origine. La bibliothèque sgcWebSockets les prend désormais tous en charge nativement.

NewOrderListOCO (nouveau format OCO)

Le nouveau format OCO remplace l'ancien NewOCO et introduit des configurations de prix above/below plus flexibles. Chaque branche du OCO peut être configurée indépendamment avec son propre type d'ordre, prix stop, delta trailing et 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)

Une liste d'ordres OTO se compose d'un working order et d'un pending order. Quand le working order s'exécute, le pending order est placé automatiquement. C'est utile pour configurer des ordres d'entrée avec des ordres de suivi automatiques. 

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)

Combines OTO and OCO logic: a working order triggers an OCO pair (take-profit + stop-loss) when filled. This enables fully automated entry-with-exit-plan strategies in a single API call. 

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)

SOR orders allow Binance to optimize execution by routing across multiple liquidity pools. Two new methods are provided: NewSOROrder for live execution and TestSOROrder for validation without actual placement. 

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

Atomically cancels an existing order and places a new one. This is critical for strategies that need to modify orders without the risk of being left without a position in between two separate cancel+place calls. 

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;

Account & Query Endpoints

Méthode Description
GetAccountInformation(aOmitZeroBalances) Extended with aOmitZeroBalances parameter. When set to True, assets with zero balance are excluded from the response.
GetOrderRateLimitUsage Renvoie le nombre actuel d'ordres et l'utilisation des limites de débit, essentiel pour rester dans les limites API en scénarios haute fréquence.
GetPreventedMatches Interroge les matches self-trade empêchés. Prend en charge le filtrage par symbole, ID d'ordre ou ID de match empêché avec pagination.
GetAllocations Récupère les allocations d'ordres SOR, montrant comment un ordre a été distribué entre les pools.
GetAccountCommission Renvoie le taux de commission maker/taker pour un symbole spécifique. 
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;
Remarque : The NewOrder and TestNewOrder methods have also been extended with new optional parameters: aSelfTradePreventionMode, aStrategyId, and aStrategyType. La méthode CancelOrder accepte désormais un paramètre aCancelRestrictions pour l'annulation conditionnelle. These additions are backward-compatible — existing code will continue to work without changes.

2. Nouvelles méthodes API REST Futures

La classe TsgcHTTP_API_Binance_Futures_Rest a reçu le plus grand lot de nouvelles methods, covering market data, order management, account configuration, and stream management. All methods work with both USDT-M and COIN-M futures, controlled by the FuturesContracts property.

Futures Market Data

Méthode Description
GetContinuousKLinesKline/candlestick data for a continuous contract. Requires pair, contract type (e.g., 'PERPETUAL', 'CURRENT_QUARTER'), and interval.
GetIndexPriceKLinesDonnées kline basées sur le prix d'index d'une paire de trading.
GetMarkPriceKLinesDonnées kline basées sur le prix mark d'un symbole.
GetPremiumIndexKLinesDonnées kline de l'indice de prime pour le calcul de basis et l'analyse du taux de financement.
GetFundingInfoRenvoie les infos de taux de financement pour tous les symboles, y compris l'intervalle de financement et les taux cap/floor.
GetPriceTickerV2Ticker de prix V2 avec format de réponse amélioré.
GetIndexInfoRenvoie le prix d'index et les données de constituant pour un symbole d'index composite.
GetAssetIndexPrix d'index d'actifs pour les calculs de marge en mode multi-actifs.
GetConstituentsInterroge les constituants et leurs poids pour un index composite donné.
GetDeliveryPricePrix de livraison historiques pour les contrats trimestriels/bi-trimestriels.
GetBasisDonnées de basis (spread entre prix futures et spot) pour une paire et un type de contrat donnés.
 
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;

Futures Order Management

The new Futures order methods provide test orders, order modification, batch processing, and liquidation queries.

Méthode Description
TestNewOrderValidates a new futures order without placing it. Mirrors the NewOrder signature.
ModifyOrderModifie le prix, la quantité ou le mode de price matching d'un ordre ouvert existant.
NewBatchOrdersPlace jusqu'à 5 ordres en une seule requête via un tableau JSON d'objets ordre.
ModifyBatchOrdersModifie jusqu'à 5 ordres existants en une seule requête.
CancelBatchOrdersAnnule plusieurs ordres par liste d'ID d'ordre ou liste d'ID d'ordre client.
GetOrderAmendmentRécupère l'historique des modifications (amendments) pour un ordre.
CountdownCancelAllDéfinit un minuteur (en millisecondes) après lequel tous les ordres ouverts d'un symbole sont annulés.
GetForceOrdersInterroge les ordres de liquidation forcée avec filtrage optionnel.
GetADLQuantileRécupère l'estimation des quantiles ADL (Auto-Deleveraging) pour les positions.

La signature NewOrder pour Futures a également été étendue avec de nouveaux paramètres : aPriceMatch, aSelfTradePreventionMode, aGoodTillDate, and 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;

Futures Account & Configuration

Several V3 account endpoints have been added alongside configuration and fee management methods.

Méthode Description
GetAccountBalanceV3Solde de compte V3 avec support amélioré de la marge multi-actifs.
GetAccountInformationV3Détails de compte V3 incluant le mode de marge multi-actifs et les paliers de frais mis à jour.
GetPositionInformationV3Données de position V3 avec champs de précision supplémentaires.
GetCommissionRateRenvoie le taux de commission maker/taker actuel pour un symbole futures spécifique.
GetAccountConfigConfiguration au niveau du compte : palier de frais, mode de position, mode de marge multi-actifs.
GetSymbolConfigConfiguration par symbole : levier, type de marge et mode de position.
GetOrderRateLimitStatut actuel de la limite de débit des ordres par symbole.
GetApiTradingStatusStatut de trading API et tout indicateur pouvant déclencher des restrictions de trading.
ChangeMultiAssetsModeActive ou désactive le mode de marge multi-actifs pour les futures USDT-M.
GetMultiAssetsModeInterroge le paramètre actuel du mode de marge multi-actifs.
SetFeeBurnActive ou désactive le burn de frais BNB (payer les frais en BNB avec une remise).
GetFeeBurnInterroge le paramètre actuel de burn de frais.

Listen Key Management

Three dedicated methods now handle the Futures user data stream listen key lifecycle directly via REST, independent of the WebSocket component:

Méthode Description
CreateListenKeyGénère une nouvelle listen key pour le flux de données utilisateur (POST).
KeepAliveListenKeyÉtend la validité d'une listen key (PUT). Doit être appelé toutes les 60 minutes.
CloseListenKeyInvalide et ferme une listen key (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. Nouveaux flux WebSocket Spot

La classe TsgcWS_API_Binance a été étendue avec trois nouveaux types de flux, chacun with subscribe and unsubscribe methods.

Méthode Stream Description
SubscribeAvgPrice / UnSubscribeAvgPrice <symbol>@avgPrice Flux du prix moyen en temps réel pour un symbole.
SubscribeRollingWindowTicker <symbol>@ticker_<window> Statistiques de fenêtre glissante avec taille de fenêtre configurable (1h, 4h, 1j).
SubscribeAllRollingWindowTickers !ticker_<window>@arr Statistiques de fenêtre glissante pour tous les symboles tradés à une taille de fenêtre spécifique.

A new enumeration type TsgcWSBinanceRollingWindowSize is provided for type-safe window size specification:

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. Nouveaux flux WebSocket Futures

La classe TsgcWS_API_Binance_Futures reçoit le plus grand ensemble de nouveaux flux WebSocket stream subscriptions. These cover continuous contracts, composite indices, asset indices, index prices, and mark price klines.

Méthode Stream Description
SubscribeContinuousKLine<pair>_<contract>@continuousKline_<interval>Flux kline pour les contrats continus. Nécessite la paire, le type de contrat et l'intervalle.
SubscribeCompositeIndex<symbol>@compositeIndexFlux de prix d'index composite avec ventilation par composant.
SubscribeContractInfo!contractInfoFlux d'informations de contrat. Pousse les mises à jour sur les listings, delistings et changements de bracket.
SubscribeAssetIndex / SubscribeAllAssetIndex<symbol>@assetIndex / !assetIndex@arrPrix d'index d'actifs pour les calculs de marge multi-actifs. Par symbole ou marché complet.
SubscribeIndexPrice<pair>@indexPriceFlux du prix d'index pour une paire de trading. Prend en charge un paramètre optionnel de vitesse de mise à jour.
SubscribeIndexPriceKLine<pair>@indexPriceKline_<interval>Flux kline/chandeliers basé sur le prix d'index avec intervalles configurables.
SubscribeMarkPriceKLine<symbol>@markPriceKline_<interval>Flux kline du prix mark pour suivre le prix mark utilisé dans les calculs de liquidation.
 
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. Exemples complets fonctionnels

Example 1: Spot REST + WebSocket Combined (VCL Application)

A typical pattern is to use the REST API for placing orders and the WebSocket API for real-time market data. L'exemple suivant montre comment configurer les deux via le composant 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.

Example 2: Futures REST + WebSocket (Console Application)

Console applications are ideal for headless bots and background services. The following example demonstrates using the new Futures methods in a console context. 

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.

Example 3: OTOCO Order Strategy

Le type d'ordre OTOCO représente le cycle de vie automatisé le plus complet : un seul appel place un ordre d'entrée that, once filled, automatically sets up both a take-profit and a 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;

Summary

The following table summarizes the count of new methods added to each class:

Composant Class Nouvelles méthodes
API REST Spot TsgcHTTP_API_Binance_Rest GetUIKLines, GetRollingWindowTicker, GetTradingDayTicker, NewOrderListOCO, NewOrderListOTO, NewOrderListOTOCO, NewSOROrder, TestSOROrder, CancelReplaceOrder, GetOrderRateLimitUsage, GetPreventedMatches, GetAllocations, GetAccountCommission
API REST Futures 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
WebSocket Spot TsgcWS_API_Binance SubscribeAvgPrice, SubscribeRollingWindowTicker, SubscribeAllRollingWindowTickers (+ matching UnSubscribe methods)
WebSocket Futures TsgcWS_API_Binance_Futures SubscribeContinuousKLine, SubscribeCompositeIndex, SubscribeContractInfo, SubscribeAssetIndex, SubscribeAllAssetIndex, SubscribeIndexPrice, SubscribeIndexPriceKLine, SubscribeMarkPriceKLine (+ matching UnSubscribe methods)
Important : All trading methods that place, modify, or cancel orders require valid ApiKey and ApiSecret credentials. It is strongly recommended to develop and test against the Binance TestNet by setting TestNet := True before moving to production. Also, ensure that the API key permissions (trading, margin, futures) match the operations you intend to perform. Backward Compatibility: All additions are backward-compatible. Existing method signatures have been extended with default parameter values, so previously compiled code continues to work without modification. The new parameters (aSelfTradePreventionMode, aStrategyId, aPriceMatch, etc.) default to empty or zero values that cause the API to use its standard behavior.

Enter your text here ...