Nuovi metodi API Binance in sgcWebSockets

24 febbraio 2026 · Funzionalità

La libreria sgcWebSockets continua a estendere la sua integrazione con Binance con un'importante batch di nuovi metodi che coprono l'API REST Spot, l'API REST Futures e gli stream WebSocket. Questo articolo fornisce un'analisi tecnica di ogni nuovo metodo, dei suoi parametri ed esempi pratici di codice Delphi per metterti rapidamente all'opera.

Indice

Nuovi metodi API REST Spot
Dati di mercato Spot: UI KLines, Rolling Window e Trading Day Ticker
Gestione ordini Spot: ordini OCO, OTO, OTOCO e SOR
Account Spot: commission, allocations, rate limit e prevented match
Nuovi metodi API REST Futures
Dati di mercato Futures: Continuous KLines, Premium Index e altro
Gestione ordini Futures: Modify, Batch e Force Ordini
Account Futures: endpoint V3, configurazione e Fee Burn
Nuovi stream WebSocket Spot
Nuovi stream WebSocket Futures
Esempi funzionanti completi

1. Nuovi metodi API REST Spot

La classe TsgcHTTP_API_Binance_Rest e' stata estesa con nuovi endpoint dei dati di mercato, tipi di ordine avanzati e metodi di query sull'account. Tutti i metodi sono accessibili sia direttamente tramite il componente REST sia tramite la proprieta' REST_API di TsgcWS_API_Binance.

Endpoint dei dati di mercato

Metodo	Descrizione	Endpoint Binance
`GetUIKLines`	Dati di kline/candle ottimizzati per la presentazione UI. Restituisce dati in formato identico a `GetKLines` ma ottimizzati per il rendering grafico.	`/api/v3/uiKlines`
`GetRollingWindowTicker`	Statistiche di variazione prezzo su finestra mobile. Supporta dimensioni di finestra configurabili (ad esempio 1h, 4h, 1d) a differenza del ticker fisso a 24 ore.	`/api/v3/ticker`
`GetTradingDayTicker`	Statistiche di variazione prezzo calcolate sul trading day (dalle UTC 00:00 al momento corrente). Supporta uno o piu' simboli.	`/api/v3/ticker/tradingDay`
`GetPriceTickers`	Recupera i price ticker per piu' simboli in una singola richiesta utilizzando un array JSON di nomi di simboli.	`/api/v3/ticker/price`

GetUIKLines

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

La differenza tra GetKLines e GetUIKLines e' sottile: la variante UI e' ottimizzata dal backend di Binance per il rendering grafico e puo' restituire confini di kline modificati per una migliore presentazione visiva. Il formato della risposta e' identico, rendendola un sostituto drop-in per qualsiasi scenario di charting.

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;

Questo metodo estende il tradizionale Get24hrTicker permettendo dimensioni di finestra personalizzate. I valori accettati per aWindowSize includono '1h', '4h' e '1d'. Se omesso, viene utilizzata la finestra di default.

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;

Tipi di ordine avanzati

Binance ha introdotto diversi nuovi tipi di order list che vanno oltre l'OCO originale. La libreria sgcWebSockets li supporta ora tutti nativamente.

NewOrderListOCO (nuovo formato OCO)

Il nuovo formato OCO sostituisce il legacy NewOCO e introduce configurazioni di prezzo above/below piu' flessibili. Ogni leg dell'OCO puo' essere configurata in modo indipendente con il proprio tipo di ordine, stop price, trailing delta e 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)

Una order list OTO e' composta da un working order e un pending order. Quando il working order viene eseguito, il pending order viene piazzato automaticamente. E' utile per configurare ordini di ingresso con follow-up automatico.

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)

Combina la logica OTO e OCO: un working order, una volta eseguito, attiva una coppia OCO (take-profit + stop-loss). Questo abilita strategie di ingresso con piano di uscita completamente automatizzate in una singola chiamata 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)

Gli ordini SOR permettono a Binance di ottimizzare l'esecuzione instradando attraverso piu' liquidity pool. Sono forniti due nuovi metodi: NewSOROrder per l'esecuzione live e TestSOROrder per la convalida senza piazzamento effettivo.

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

Annulla atomicamente un ordine esistente e ne piazza uno nuovo. E' fondamentale per strategie che devono modificare ordini senza il rischio di rimanere senza posizione tra una chiamata di cancel e una di place separate.

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;

Endpoint Account e Query

Metodo	Descrizione
`GetAccountInformation(aOmitZeroBalances)`	Esteso con il parametro `aOmitZeroBalances`. Quando impostato a `True`, gli asset con saldo zero vengono esclusi dalla risposta.
`GetOrderRateLimitUsage`	Restituisce il conteggio corrente degli ordini e l'uso dei rate limit, indispensabile per restare entro i limiti API in scenari ad alta frequenza.
`GetPreventedMatches`	Interroga i match di self-trade prevenuti. Supporta filtraggio per simbolo, order ID o prevented match ID con paginazione.
`GetAllocations`	Recupera le allocazioni degli ordini SOR, mostrando come un ordine e' stato distribuito tra i pool.
`GetAccountCommission`	Restituisce il rate di commissione maker/taker per uno specifico simbolo.

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;

Nota: Anche i metodi NewOrder e TestNewOrder sono stati estesi con nuovi parametri opzionali: aSelfTradePreventionMode, aStrategyId e aStrategyType. Il metodo CancelOrder ora accetta un parametro aCancelRestrictions per l'annullamento condizionale. Queste aggiunte sono backward-compatible — il codice esistente continuera' a funzionare senza modifiche.

2. Nuovi metodi API REST Futures

La classe TsgcHTTP_API_Binance_Futures_Rest ha ricevuto il batch piu' grande di nuovi metodi, coprendo dati di mercato, gestione degli ordini, configurazione dell'account e gestione degli stream. Tutti i metodi funzionano sia con futures USDT-M sia COIN-M, controllati dalla proprieta' FuturesContracts.

Dati di mercato Futures

Metodo	Descrizione
`GetContinuousKLines`	Dati kline/candle per un contratto continuous. Richiede pair, contract type (ad esempio `'PERPETUAL'`, `'CURRENT_QUARTER'`) e intervallo.
`GetIndexPriceKLines`	Dati kline basati sul prezzo dell'indice di una coppia di trading.
`GetMarkPriceKLines`	Dati kline basati sul mark price di un simbolo.
`GetPremiumIndexKLines`	Dati kline del premium index per il calcolo del basis e l'analisi del funding rate.
`GetFundingInfo`	Restituisce informazioni sul funding rate per tutti i simboli, inclusi funding interval e rate cap/floor.
`GetPriceTickerV2`	Price ticker V2 con formato di risposta migliorato.
`GetIndexInfo`	Restituisce il prezzo dell'indice e i dati dei costituenti per un simbolo di composite index.
`GetAssetIndex`	Prezzi degli asset index per i calcoli di margine in multi-asset mode.
`GetConstituents`	Interroga i costituenti e i relativi pesi per un dato composite index.
`GetDeliveryPrice`	Prezzi storici di delivery per contratti trimestrali/bi-trimestrali.
`GetBasis`	Dati del basis (spread tra prezzi futures e spot) per una data coppia e contract type.

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;

Gestione ordini Futures

I nuovi metodi sugli ordini Futures forniscono test order, modifica degli ordini, elaborazione batch e query sulle liquidazioni.

Metodo	Descrizione
`TestNewOrder`	Convalida un nuovo ordine futures senza piazzarlo. Riflette la signature di `NewOrder`.
`ModifyOrder`	Modifica prezzo, quantita' o price matching mode di un ordine aperto esistente.
`NewBatchOrdini`	Piazza fino a 5 ordini in una singola richiesta tramite un array JSON di oggetti ordine.
`ModifyBatchOrdini`	Modifica fino a 5 ordini esistenti in una singola richiesta.
`CancelBatchOrdini`	Annulla piu' ordini tramite una lista di order ID o di client order ID.
`GetOrderAmendment`	Recupera lo storico degli amendment (modifiche) di un ordine.
`CountdownCancelAll`	Imposta un countdown timer (in millisecondi) dopo il quale tutti gli ordini aperti per un simbolo vengono annullati.
`GetForceOrdini`	Interroga gli ordini di liquidazione forzata con filtraggio opzionale.
`GetADLQuantile`	Recupera la stima del quantile ADL (Auto-Deleveraging) per le posizioni.

Anche la signature di NewOrder per Futures e' stata estesa con nuovi parametri: aPriceMatch, aSelfTradePreventionMode, aGoodTillDate e 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.CancelBatchOrdini('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.GetForceOrdini('BTCUSDT');
  Memo1.Lines.Add('ForceOrdini: ' + vJSON);
  // ADL quantile estimation
  vJSON := sgcBinanceFutREST.GetADLQuantile('BTCUSDT');
  Memo1.Lines.Add('ADL: ' + vJSON);
end;

Account Futures e configurazione

Sono stati aggiunti diversi endpoint V3 dell'account insieme a metodi di configurazione e di gestione delle commissioni.

Metodo	Descrizione
`GetAccountBalanceV3`	Saldo dell'account V3 con supporto migliorato al multi-asset margin.
`GetAccountInformationV3`	Dettagli dell'account V3 inclusi multi-asset margin mode e fee tier aggiornati.
`GetPositionInformationV3`	Dati di posizione V3 con campi di precisione aggiuntivi.
`GetCommissionRate`	Restituisce il rate corrente di commissione maker/taker per uno specifico simbolo futures.
`GetAccountConfig`	Configurazione a livello di account: fee tier, position mode, multi-asset margin mode.
`GetSymbolConfig`	Configurazione per simbolo: leva, margin type e position mode.
`GetOrderRateLimit`	Stato corrente del rate limit degli ordini per simbolo.
`GetApiTradingStatus`	Stato del trading via API ed eventuali indicatori che possono attivare restrizioni di trading.
`ChangeMultiAssetsMode`	Abilita o disabilita il multi-asset margin mode per i futures USDT-M.
`GetMultiAssetsMode`	Interroga l'impostazione corrente del multi-asset margin mode.
`SetFeeBurn`	Abilita o disabilita il BNB fee burn (pagamento delle commissioni in BNB con sconto).
`GetFeeBurn`	Interroga l'impostazione corrente del fee burn.

Gestione delle listen key

Tre metodi dedicati ora gestiscono il ciclo di vita della listen key dello user data stream Futures direttamente via REST, indipendentemente dal componente WebSocket:

Metodo	Descrizione
`CreateListenKey`	Genera una nuova listen key per lo user data stream (POST).
`KeepAliveListenKey`	Estende la validita' di una listen key (PUT). Deve essere chiamato ogni 60 minuti.
`CloseListenKey`	Invalida e chiude una 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. Nuovi stream WebSocket Spot

La classe TsgcWS_API_Binance e' stata estesa con tre nuovi tipi di stream, ciascuno con metodi di subscribe e unsubscribe.

Metodo	Stream	Descrizione
`SubscribeAvgPrice / UnSubscribeAvgPrice`	`<symbol>@avgPrice`	Stream del prezzo medio in tempo reale per un simbolo.
`SubscribeRollingWindowTicker`	`<symbol>@ticker_<window>`	Statistiche su finestra mobile con dimensione di finestra configurabile (1h, 4h, 1d).
`SubscribeAllRollingWindowTickers`	`!ticker_<window>@arr`	Statistiche su finestra mobile per tutti i simboli trattati a una specifica dimensione di finestra.

E' fornito un nuovo tipo enumerato TsgcWSBinanceRollingWindowSize per specificare la dimensione della finestra in modo type-safe:

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. Nuovi stream WebSocket Futures

La classe TsgcWS_API_Binance_Futures riceve il set piu' ampio di nuove sottoscrizioni a stream WebSocket. Coprono contratti continuous, composite index, asset index, index price e kline del mark price.

Metodo	Stream	Descrizione
`SubscribeContinuousKLine`	`<pair>_<contract>@continuousKline_<interval>`	Stream di kline per contratti continuous. Richiede pair, contract type e intervallo.
`SubscribeCompositeIndex`	`<symbol>@compositeIndex`	Stream del prezzo del composite index con breakdown dei componenti.
`SubscribeContractInfo`	`!contractInfo`	Stream delle informazioni sui contratti. Notifica aggiornamenti su listing, delisting e modifiche dei bracket.
`SubscribeAssetIndex / SubscribeAllAssetIndex`	`<symbol>@assetIndex` / `!assetIndex@arr`	Prezzi degli asset index per i calcoli di margine multi-asset. Per simbolo o per l'intero mercato.
`SubscribeIndexPrice`	`<pair>@indexPrice`	Stream del prezzo dell'indice per una coppia di trading. Supporta un parametro opzionale di update speed.
`SubscribeIndexPriceKLine`	`<pair>@indexPriceKline_<interval>`	Stream di kline/candle del prezzo dell'indice con intervalli configurabili.
`SubscribeMarkPriceKLine`	`<symbol>@markPriceKline_<interval>`	Stream di kline del mark price per tracciare il mark price utilizzato nei calcoli di liquidazione.

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. Esempi funzionanti completi

Esempio 1: REST Spot + WebSocket combinati (applicazione VCL)

Un pattern tipico e' usare l'API REST per piazzare ordini e l'API WebSocket per dati di mercato in tempo reale. L'esempio seguente mostra come configurare entrambi tramite il componente TsgcWS_API_Binance.

unit MainForm;
interface
uses
  Windows, Messages, SysUtils, Classees, Graphics, Controls, Forms,
  StdCtrls, sgcWebSocket_Classees, sgcWebSocket_API_Binance,
  sgcWebSocket_APIs, sgcBase_Classees, 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.

Esempio 2: REST Futures + WebSocket (applicazione console)

Le applicazioni console sono ideali per bot headless e servizi in background. L'esempio seguente mostra come usare i nuovi metodi Futures in un contesto console.

program BinanceFuturesConsole;
{$APPTYPE CONSOLE}
{$R *.res}
uses
  Classees, SysUtils,
  sgcWebSocket, sgcWebSocket_APIs, sgcWebSocket_Types,
  sgcWebSocket_Classees, 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.ClasseName, ': ', E.Message);
  end;
end.

Esempio 3: strategia di ordine OTOCO

Il tipo di ordine OTOCO rappresenta il ciclo di vita di trade automatizzato piu' completo: una singola chiamata piazza un ordine di ingresso che, una volta eseguito, imposta automaticamente sia un take-profit sia uno 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;

Riepilogo

La tabella seguente riassume il conteggio dei nuovi metodi aggiunti a ciascuna classe:

Componente	Classe	Nuovi metodi
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, NewBatchOrdini, ModifyBatchOrdini, CancelBatchOrdini, GetOrderAmendment, CountdownCancelAll, GetForceOrdini, 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)

Importante: Tutti i metodi di trading che piazzano, modificano o annullano ordini richiedono credenziali ApiKey e ApiSecret valide. Si raccomanda fortemente di sviluppare e testare sulla Binance TestNet impostando TestNet := True prima di passare in produzione. Assicurati inoltre che i permessi dell'API key (trading, margin, futures) corrispondano alle operazioni che intendi eseguire. Compatibilita' all'indietro: Tutte le aggiunte sono backward-compatible. Le signature dei metodi esistenti sono state estese con valori di default per i parametri, quindi il codice gia' compilato continua a funzionare senza modifiche. I nuovi parametri (aSelfTradePreventionMode, aStrategyId, aPriceMatch, ecc.) hanno come default valori vuoti o zero che fanno usare all'API il suo comportamento standard.