Nieuwe Binance-API-methoden in sgcWebSockets

· Functies

De sgcWebSockets-bibliotheek blijft de Binance-integratie uitbreiden met een aanzienlijk pakket nieuwe methoden voor de Spot-REST-API, Futures-REST-API en WebSocket-streams. Dit artikel biedt een technische uitleg van elke nieuwe methode, de parameters ervan en praktische Delphi-codevoorbeelden om je snel op weg te helpen.

Inhoudsopgave

  1. Nieuwe Spot-REST-API-methoden
  2. Spot-marktdata: UI KLines, rolling window en trading-day-tickers
  3. Spot-orderbeheer: OCO-, OTO-, OTOCO- en SOR-orders
  4. Spot-account: commissie, allocaties, rate limits en prevented matches
  5. Nieuwe Futures-REST-API-methoden
  6. Futures-marktdata: continuous klines, premium index en meer
  7. Futures-orderbeheer: modify, batch en force orders
  8. Futures-account: V3-endpoints, config en fee burn
  9. Nieuwe Spot-WebSocket-streams
  10. Nieuwe Futures-WebSocket-streams
  11. Volledig werkende voorbeelden

1. Nieuwe Spot-REST-API-methoden

De class TsgcHTTP_API_Binance_Rest is uitgebreid met nieuwe marktdata-endpoints, geavanceerde ordertypes en account-query-methodes. Alle methodes zijn toegankelijk via het REST-component zelf of via de REST_API-property van TsgcWS_API_Binance.

Marktdata-endpoints

Methode Beschrijving Binance-endpoint
GetUIKLines Geoptimaliseerde kline-/candlestick-data voor UI-weergave. Geeft data terug in een formaat dat identiek is aan GetKLines, maar afgestemd op chart-rendering. /api/v3/uiKlines
GetRollingWindowTicker Prijswijzigingsstatistieken over een rollend venster. Ondersteunt configureerbare venstergroottes (bijvoorbeeld 1h, 4h, 1d), anders dan de vaste 24-uursticker. /api/v3/ticker
GetTradingDayTicker Prijswijzigingsstatistieken berekend over de handelsdag (UTC 00:00 tot nu). Ondersteunt één of meerdere symbolen. /api/v3/ticker/tradingDay
GetPriceTickers Haal prijs-tickers voor meerdere symbolen op in één request met een JSON-array van symboolnamen. /api/v3/ticker/price

GetUIKLines

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

Het verschil tussen GetKLines en GetUIKLines is subtiel: de UI-variant wordt door de Binance-backend geoptimaliseerd voor chart-rendering en kan aangepaste kline-grenzen teruggeven voor een betere visuele weergave. Het responseformaat is identiek, waardoor het een drop-in-vervanging is voor elk chart-scenario. 

var
  vJSON: string;
begin
  // 1-uurs UI-geoptimaliseerde klines voor BTCUSDT ophalen
  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;

Deze methode breidt de traditionele Get24hrTicker uit door aangepaste venstergroottes toe te staan. Geaccepteerde waarden voor aWindowSize zijn onder andere '1h', '4h' en '1d'. Als het wordt weggelaten, wordt het standaardvenster gebruikt. 

var
  vJSON: string;
begin
  // 4-uurs rolling-window-statistieken voor ETHUSDT ophalen
  vJSON := sgcBinanceREST.GetRollingWindowTicker('ETHUSDT', '', '4h');
  Memo1.Lines.Add(vJSON);
  // Rolling window voor meerdere symbolen ophalen
  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
  // Handelsdagstatistieken voor BTCUSDT ophalen (FULL response)
  vJSON := sgcBinanceREST.GetTradingDayTicker('BTCUSDT', '', 'FULL');
  Memo1.Lines.Add(vJSON);
end;

Geavanceerde ordertypes

Binance heeft verschillende nieuwe order-list-types geïntroduceerd die verder gaan dan de originele OCO. De sgcWebSockets-bibliotheek ondersteunt ze nu allemaal native.

NewOrderListOCO (New OCO Format)

Het nieuwe OCO-formaat vervangt de oude NewOCO en introduceert flexibelere above-/below-prijsconfiguraties. Elke leg van de OCO kan onafhankelijk worden geconfigureerd met een eigen ordertype, stop-prijs, trailing delta en 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
  // Een OCO in het nieuwe formaat plaatsen: take-profit erboven + stop-loss eronder
  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)

Een OTO-order-list bestaat uit een working-order en een pending-order. Wanneer de working-order wordt uitgevoerd, wordt de pending-order automatisch geplaatst. Dit is nuttig om entry-orders met automatische vervolgorders op te zetten. 

function NewOrderListOTO(const aSymbol: String;
  const aWorkingType, aWorkingSide: String;
  aWorkingQuantity: Double; aWorkingPrice: Double;
  const aPendingType, aPendingSide: String;
  aPendingQuantity: Double;
  { ... additional optional parameters ... }
  ): String;
var
  vJSON: string;
begin
  // BTCUSDT kopen tegen limiet en daarna automatisch een stop-loss-verkoop plaatsen
  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)

Combineert OTO- en OCO-logica: een working-order triggert een OCO-paar (take-profit + stop-loss) wanneer deze wordt gevuld. Hiermee zijn volledig geautomatiseerde entry-met-exit-plan-strategieën mogelijk in één API-aanroep. 

var
  vJSON: string;
begin
  // Entry: limit-koop op 65000
  // Bij vulling: plaatst OCO met take-profit op 72000 en stop-loss op 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)

Met SOR-orders kan Binance de uitvoering optimaliseren door te routeren over meerdere liquiditeitspools. Er zijn twee nieuwe methodes: NewSOROrder voor live uitvoering en TestSOROrder voor validatie zonder daadwerkelijke plaatsing. 

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
  // Een SOR-limit-order plaatsen
  vJSON := sgcBinanceREST.NewSOROrder(
    'BTCUSDT', 'BUY', 'LIMIT',
    0.001,             // quantity
    'GTC',             // timeInForce
    65000.0            // price
  );
  Memo1.Lines.Add(vJSON);
  // Een SOR-order testen zonder uitvoering
  vJSON := sgcBinanceREST.TestSOROrder('BTCUSDT', 'BUY', 'LIMIT',
    0.001, 'GTC', 65000.0);
  Memo1.Lines.Add(vJSON);
end;

CancelReplaceOrder

Annuleert een bestaande order atomair en plaatst een nieuwe. Dit is cruciaal voor strategieën die orders moeten wijzigen zonder het risico te lopen tussen twee aparte cancel+place-aanroepen zonder positie te zitten. 

var
  vJSON: string;
begin
  // Order 123456 annuleren en vervangen door een nieuwe limit-koop
  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- en query-endpoints

Methode Beschrijving
GetAccountInformation(aOmitZeroBalances) Uitgebreid met de aOmitZeroBalances-parameter. Wanneer ingesteld op True worden assets met een saldo van nul uitgesloten van het antwoord.
GetOrderRateLimitUsage Geeft het huidige aantal orders en het rate-limit-gebruik terug, essentieel om binnen de API-limieten te blijven in hoogfrequente scenario's.
GetPreventedMatches Bevraagt voorkomen self-trade-matches. Ondersteunt filteren op symbool, order-ID of prevented-match-ID met pagination.
GetAllocations Haalt SOR-orderallocaties op die laten zien hoe een order is verdeeld over pools.
GetAccountCommission Geeft het maker-/taker-commissietarief terug voor een specifiek symbool. 
var
  vJSON: string;
begin
  // Account-info ophalen, nul-saldi weglaten
  vJSON := sgcBinanceREST.GetAccountInformation(True);
  Memo1.Lines.Add(vJSON);
  // Order-rate-limit-gebruik controleren
  vJSON := sgcBinanceREST.GetOrderRateLimitUsage;
  Memo1.Lines.Add(vJSON);
  // Commissietarieven voor BTCUSDT ophalen
  vJSON := sgcBinanceREST.GetAccountCommission('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Prevented matches voor een symbool ophalen
  vJSON := sgcBinanceREST.GetPreventedMatches('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // SOR-allocaties voor een symbool ophalen
  vJSON := sgcBinanceREST.GetAllocations('BTCUSDT');
  Memo1.Lines.Add(vJSON);
end;
Let op: De methodes NewOrder en TestNewOrder zijn ook uitgebreid met nieuwe optionele parameters: aSelfTradePreventionMode, aStrategyId en aStrategyType. De methode CancelOrder accepteert nu een aCancelRestrictions-parameter voor conditionele annulering. Deze toevoegingen zijn backward-compatible — bestaande code blijft werken zonder wijzigingen.

2. Nieuwe Futures-REST-API-methoden

De class TsgcHTTP_API_Binance_Futures_Rest heeft de grootste batch nieuwe methodes gekregen, voor marktdata, orderbeheer, accountconfiguratie en streambeheer. Alle methodes werken met zowel USDT-M- als COIN-M-futures, geregeld via de FuturesContracts-property.

Futures-marktdata

Methode Beschrijving
GetContinuousKLinesKline-/candlestick-data voor een continuous contract. Vereist pair, contracttype (bijvoorbeeld 'PERPETUAL', 'CURRENT_QUARTER') en interval.
GetIndexPriceKLinesKline-data op basis van de indexprijs van een handelspaar.
GetMarkPriceKLinesKline-data op basis van de mark-price van een symbool.
GetPremiumIndexKLinesPremium-index-kline-data voor basis-berekening en funding-rate-analyse.
GetFundingInfoGeeft funding-rate-info terug voor alle symbolen, inclusief funding-interval en cap-/floor-tarieven.
GetPriceTickerV2V2-prijs-ticker met een verbeterd responseformaat.
GetIndexInfoGeeft de indexprijs en constituent-data terug voor een composite-index-symbool.
GetAssetIndexAsset-index-prijzen voor margin-berekeningen in multi-asset-modus.
GetConstituentsVraag de constituents en hun weights op voor een opgegeven composite-index.
GetDeliveryPriceHistorische delivery-prijzen voor quarterly-/bi-quarterly-contracten.
GetBasisBasis-data (spread tussen futures- en spot-prijzen) voor een opgegeven pair en contracttype.
 
var
  vJSON: string;
begin
  // Continuous klines voor BTCUSDT perpetual, 1-uursinterval
  vJSON := sgcBinanceFutREST.GetContinuousKLines(
    'BTCUSDT', 'PERPETUAL', bcih1h, 0, 0, 100);
  Memo1.Lines.Add(vJSON);
  // Mark-price-klines voor ETHUSDT, 15-minuteninterval
  vJSON := sgcBinanceFutREST.GetMarkPriceKLines('ETHUSDT', bcih15m);
  Memo1.Lines.Add(vJSON);
  // Indexprijs-klines
  vJSON := sgcBinanceFutREST.GetIndexPriceKLines('BTCUSDT', bcih4h);
  Memo1.Lines.Add(vJSON);
  // Premium-index-klines voor funding-analyse
  vJSON := sgcBinanceFutREST.GetPremiumIndexKLines('BTCUSDT', bcih1h);
  Memo1.Lines.Add(vJSON);
  // Funding-info ophalen voor alle symbolen
  vJSON := sgcBinanceFutREST.GetFundingInfo;
  Memo1.Lines.Add(vJSON);
  // V2-prijs-ticker
  vJSON := sgcBinanceFutREST.GetPriceTickerV2('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Basis-data
  vJSON := sgcBinanceFutREST.GetBasis('BTCUSDT', 'PERPETUAL', oip1h, 30);
  Memo1.Lines.Add(vJSON);
  // Delivery-prijsgeschiedenis
  vJSON := sgcBinanceFutREST.GetDeliveryPrice('BTCUSD');
  Memo1.Lines.Add(vJSON);
end;

Futures-orderbeheer

De nieuwe Futures-order-methodes bieden test-orders, order-modificatie, batch-verwerking en liquidatie-queries.

Methode Beschrijving
TestNewOrderValideert een nieuwe futures-order zonder deze te plaatsen. Volgt de signatuur van NewOrder.
ModifyOrderWijzigt de prijs, hoeveelheid of price-matching-modus van een bestaande open order.
NewBatchOrdersPlaatst tot 5 orders in één request via een JSON-array van order-objecten.
ModifyBatchOrdersWijzigt tot 5 bestaande orders in één request.
CancelBatchOrdersAnnuleert meerdere orders op basis van een order-ID-lijst of een client-order-ID-lijst.
GetOrderAmendmentHaalt de order-amendment-geschiedenis (wijzigingen) op voor een order.
CountdownCancelAllStelt een countdown-timer in (in milliseconden) waarna alle open orders voor een symbool worden geannuleerd.
GetForceOrdersVraagt gedwongen liquidatieorders op, met optionele filtering.
GetADLQuantileHaalt de ADL-quantile-schatting op (Auto-Deleveraging) voor posities.

De NewOrder-signatuur voor Futures is ook uitgebreid met nieuwe parameters: aPriceMatch, aSelfTradePreventionMode, aGoodTillDate en aPriceProtect. 

var
  vJSON: string;
begin
  // Een futures-order testen zonder uitvoering
  vJSON := sgcBinanceFutREST.TestNewOrder(
    'BTCUSDT', 'BUY', '', 'LIMIT',
    'GTC', 0.001, 'false', 65000.0);
  Memo1.Lines.Add('TestNewOrder: ' + vJSON);
  // De prijs van een bestaande order wijzigen
  vJSON := sgcBinanceFutREST.ModifyOrder('BTCUSDT', 123456, '',
    'BUY', 0.001, 64800.0);
  Memo1.Lines.Add('ModifyOrder: ' + vJSON);
  // Meerdere orders in één keer annuleren
  vJSON := sgcBinanceFutREST.CancelBatchOrders('BTCUSDT',
    '[123456,123457,123458]');
  Memo1.Lines.Add('CancelBatch: ' + vJSON);
  // Countdown-cancel instellen: alle BTCUSDT-orders na 30 seconden annuleren
  vJSON := sgcBinanceFutREST.CountdownCancelAll('BTCUSDT', 30000);
  Memo1.Lines.Add('Countdown: ' + vJSON);
  // Gedwongen liquidatieorders opvragen
  vJSON := sgcBinanceFutREST.GetForceOrders('BTCUSDT');
  Memo1.Lines.Add('ForceOrders: ' + vJSON);
  // ADL-quantile-schatting
  vJSON := sgcBinanceFutREST.GetADLQuantile('BTCUSDT');
  Memo1.Lines.Add('ADL: ' + vJSON);
end;

Futures-account en configuratie

Er zijn diverse V3-account-endpoints toegevoegd, naast configuratie- en fee-management-methodes.

Methode Beschrijving
GetAccountBalanceV3V3-accountsaldo met verbeterde multi-asset-margin-ondersteuning.
GetAccountInformationV3V3-accountdetails, inclusief multi-asset-margin-modus en bijgewerkte fee-tiers.
GetPositionInformationV3V3-positiedata met extra precisievelden.
GetCommissionRateGeeft het huidige maker-/taker-commissietarief terug voor een specifiek futures-symbool.
GetAccountConfigConfiguratie op accountniveau: fee-tier, positiemodus, multi-asset-margin-modus.
GetSymbolConfigConfiguratie per symbool: leverage, margin-type en positiemodus.
GetOrderRateLimitHuidige order-rate-limit-status per symbool.
GetApiTradingStatusAPI-trading-status en eventuele indicatoren die handelsbeperkingen kunnen activeren.
ChangeMultiAssetsModeSchakel multi-asset-margin-modus in of uit voor USDT-M-futures.
GetMultiAssetsModeVraag de huidige instelling van de multi-asset-margin-modus op.
SetFeeBurnSchakel BNB-fee-burn in of uit (kosten betalen met BNB tegen korting).
GetFeeBurnVraag de huidige fee-burn-instelling op.

Listen-key-beheer

Drie aparte methodes regelen nu de lifecycle van de listen-key voor de Futures-user-data-stream rechtstreeks via REST, onafhankelijk van het WebSocket-component:

Methode Beschrijving
CreateListenKeyGenereert een nieuwe listen-key voor de user-data-stream (POST).
KeepAliveListenKeyVerlengt de geldigheid van een listen-key (PUT). Moet elke 60 minuten worden aangeroepen.
CloseListenKeyMaakt een listen-key ongeldig en sluit deze (DELETE).
 
var
  vJSON: string;
begin
  // V3-saldo en 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);
  // Commissietarief
  vJSON := sgcBinanceFutREST.GetCommissionRate('BTCUSDT');
  Memo1.Lines.Add('Commission: ' + vJSON);
  // Account- en symboolconfiguratie
  vJSON := sgcBinanceFutREST.GetAccountConfig;
  Memo1.Lines.Add('AccountConfig: ' + vJSON);
  vJSON := sgcBinanceFutREST.GetSymbolConfig('BTCUSDT');
  Memo1.Lines.Add('SymbolConfig: ' + vJSON);
  // Multi-asset-margin-modus inschakelen
  vJSON := sgcBinanceFutREST.ChangeMultiAssetsMode(True);
  Memo1.Lines.Add('MultiAssets: ' + vJSON);
  // BNB-fee-burn inschakelen
  vJSON := sgcBinanceFutREST.SetFeeBurn(True);
  Memo1.Lines.Add('FeeBurn: ' + vJSON);
  // API-trading-status controleren
  vJSON := sgcBinanceFutREST.GetApiTradingStatus('BTCUSDT');
  Memo1.Lines.Add('TradingStatus: ' + vJSON);
  // Listen-key-lifecycle (alleen-REST-aanpak)
  vJSON := sgcBinanceFutREST.CreateListenKey;
  Memo1.Lines.Add('ListenKey: ' + vJSON);
end;

3. Nieuwe Spot-WebSocket-streams

De class TsgcWS_API_Binance is uitgebreid met drie nieuwe streamtypes, elk met subscribe- en unsubscribe-methodes.

Methode Stream Beschrijving
SubscribeAvgPrice / UnSubscribeAvgPrice <symbol>@avgPrice Realtime gemiddelde-prijsstream voor een symbool.
SubscribeRollingWindowTicker <symbol>@ticker_<window> Rolling-window-statistieken met configureerbare venstergrootte (1h, 4h, 1d).
SubscribeAllRollingWindowTickers !ticker_<window>@arr Rolling-window-statistieken voor alle verhandelde symbolen op een specifieke venstergrootte.

Een nieuw enumeration-type TsgcWSBinanceRollingWindowSize is beschikbaar voor type-veilige opgave van de venstergrootte:

TsgcWSBinanceRollingWindowSize = (brw1h, brw4h, brw1d);
procedure TForm1.btnSubscribeClick(Sender: TObject);
begin
  if not sgcWebSocketClient1.Active then
    sgcWebSocketClient1.Active := True;
  // Abonneren op gemiddelde-prijs-updates voor BTCUSDT
  sgcBinance.SubscribeAvgPrice('btcusdt');
  // Abonneren op 1-uurs rolling-window-ticker voor ETHUSDT
  sgcBinance.SubscribeRollingWindowTicker('ethusdt', brw1h);
  // Abonneren op alle tickers met een 4-uurs rolling window
  sgcBinance.SubscribeAllRollingWindowTickers(brw4h);
end;
procedure TForm1.btnUnsubscribeClick(Sender: TObject);
begin
  sgcBinance.UnSubscribeAvgPrice('btcusdt');
  sgcBinance.UnSubscribeRollingWindowTicker('ethusdt', brw1h);
  sgcBinance.UnSubscribeAllRollingWindowTickers(brw4h);
end;

4. Nieuwe Futures-WebSocket-streams

De class TsgcWS_API_Binance_Futures krijgt de grootste set nieuwe WebSocket-stream-subscriptions. Deze dekken continuous contracts, composite indices, asset indices, indexprijzen en mark-price-klines.

Methode Stream Beschrijving
SubscribeContinuousKLine<pair>_<contract>@continuousKline_<interval>Kline-stream voor continuous contracts. Vereist pair, contracttype en interval.
SubscribeCompositeIndex<symbol>@compositeIndexStream van composite-index-prijzen met component-uitsplitsing.
SubscribeContractInfo!contractInfoStream met contractinformatie. Pusht updates over listing, delisting en bracket-wijzigingen.
SubscribeAssetIndex / SubscribeAllAssetIndex<symbol>@assetIndex / !assetIndex@arrAsset-index-prijzen voor multi-asset-margin-berekeningen. Per symbool of de hele markt.
SubscribeIndexPrice<pair>@indexPriceIndexprijs-stream voor een handelspaar. Ondersteunt een optionele update-speed-parameter.
SubscribeIndexPriceKLine<pair>@indexPriceKline_<interval>Indexprijs-kline-/candlestick-stream met configureerbare intervallen.
SubscribeMarkPriceKLine<symbol>@markPriceKline_<interval>Mark-price-kline-stream voor het volgen van de mark-price die wordt gebruikt in liquidatieberekeningen.
 
procedure TForm1.SubscribeFuturesStreams;
begin
  if not sgcWebSocketClient1.Active then
    sgcWebSocketClient1.Active := True;
  // Continuous kline voor BTCUSDT-perpetual-contract, 1-uursinterval
  sgcBinanceFutures.SubscribeContinuousKLine('btcusdt',
    'perpetual', bci1h);
  // Composite-index-stream
  sgcBinanceFutures.SubscribeCompositeIndex('defiusdt');
  // Contract-info-updates (geen symbool nodig)
  sgcBinanceFutures.SubscribeContractInfo;
  // Asset-index voor één symbool
  sgcBinanceFutures.SubscribeAssetIndex('btcusd');
  // Alle asset-index-prijzen
  sgcBinanceFutures.SubscribeAllAssetIndex;
  // Indexprijs met standaard update-speed
  sgcBinanceFutures.SubscribeIndexPrice('btcusdt');
  // Indexprijs-kline, 15-minuteninterval
  sgcBinanceFutures.SubscribeIndexPriceKLine('btcusdt', bci15m);
  // Mark-price-kline, 5-minuteninterval
  sgcBinanceFutures.SubscribeMarkPriceKLine('btcusdt', bci5m);
end;

5. Volledig werkende voorbeelden

Voorbeeld 1: Spot REST + WebSocket gecombineerd (VCL-applicatie)

Een typisch patroon is om de REST-API te gebruiken voor het plaatsen van orders en de WebSocket-API voor realtime marktdata. Het volgende voorbeeld laat zien hoe je beide opzet via het TsgcWS_API_Binance-component. 

unit MainForm;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  StdCtrls, sgcWebSocket_Classes, sgcWebSocket_API_Binance,
  sgcWebSocket_APIs, sgcBase_Classes, sgcWebSocket_Client, sgcWebSocket;
type
  TForm1 = class(TForm)
    sgcWebSocketClient1: TsgcWebSocketClient;
    sgcBinance: TsgcWSAPI_Binance;
    btnConnect: TButton;
    btnGetTicker: TButton;
    btnPlaceSOROrder: TButton;
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure btnConnectClick(Sender: TObject);
    procedure btnGetTickerClick(Sender: TObject);
    procedure btnPlaceSOROrderClick(Sender: TObject);
    procedure sgcWebSocketClient1Message(Connection: TsgcWSConnection;
      const Text: string);
  end;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
begin
  // API-credentials configureren
  sgcBinance.Binance.ApiKey := 'your-api-key';
  sgcBinance.Binance.ApiSecret := 'your-api-secret';
  sgcBinance.Binance.TestNet := True;  // gebruik testnet tijdens ontwikkeling
  sgcBinance.Binance.UserStream := False;
end;
procedure TForm1.btnConnectClick(Sender: TObject);
begin
  sgcWebSocketClient1.Active := True;
  // Abonneren op nieuwe streams
  sgcBinance.SubscribeAvgPrice('btcusdt');
  sgcBinance.SubscribeRollingWindowTicker('btcusdt', brw1h);
end;
procedure TForm1.btnGetTickerClick(Sender: TObject);
begin
  // Nieuwe REST-endpoints gebruiken via de geïntegreerde 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
  // Een Smart-Order-Routing-order testen
  Memo1.Lines.Add(sgcBinance.REST_API.TestSOROrder(
    'BTCUSDT', 'BUY', 'LIMIT', 0.001, 'GTC', 65000.0));
end;
procedure TForm1.sgcWebSocketClient1Message(Connection: TsgcWSConnection;
  const Text: string);
begin
  Memo1.Lines.Add(Text);
end;
end.

Voorbeeld 2: Futures REST + WebSocket (console-applicatie)

Console-applicaties zijn ideaal voor headless bots en achtergrondservices. Het volgende voorbeeld laat zien hoe je de nieuwe Futures-methodes in een console-context gebruikt. 

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;
      // Nieuwe marktdata-methodes
      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), '...');
      // Accountconfiguratie
      vJSON := FutREST.GetAccountConfig;
      WriteLn('Config: ', vJSON);
      vJSON := FutREST.GetSymbolConfig('BTCUSDT');
      WriteLn('SymbolConfig: ', vJSON);
      // Commissie- en fee-beheer
      vJSON := FutREST.GetCommissionRate('BTCUSDT');
      WriteLn('Commission: ', vJSON);
      vJSON := FutREST.GetFeeBurn;
      WriteLn('FeeBurn: ', vJSON);
      // Listen-key-beheer
      vJSON := FutREST.CreateListenKey;
      WriteLn('ListenKey: ', vJSON);
    finally
      FutREST.Free;
    end;
  except
    on E: Exception do
      WriteLn(E.ClassName, ': ', E.Message);
  end;
end.

Voorbeeld 3: OTOCO-orderstrategie

Het OTOCO-ordertype vertegenwoordigt de meest complete geautomatiseerde trade-lifecycle: één aanroep plaatst een entry-order die, zodra deze gevuld is, automatisch zowel een take-profit als een stop-loss opzet. 

procedure TForm1.PlaceOTOCOStrategy;
var
  vResult: string;
begin
  // Strategie: ETHUSDT kopen op 3400, take profit op 3600, stop-loss op 3300
  vResult := sgcBinance.REST_API.NewOrderListOTOCO(
    'ETHUSDT',
    // Working-order: limit-koop entry
    'LIMIT',              // workingType
    'BUY',                // workingSide
    0.1,                  // workingQuantity
    3400.0,               // workingPrice
    // Pending OCO (getriggerd nadat de entry is gevuld)
    '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;

Samenvatting

De volgende tabel vat het aantal nieuwe methoden samen dat per klasse is toegevoegd:

Component Class Nieuwe methodes
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 (+ bijbehorende UnSubscribe-methodes)
Futures-WebSocket TsgcWS_API_Binance_Futures SubscribeContinuousKLine, SubscribeCompositeIndex, SubscribeContractInfo, SubscribeAssetIndex, SubscribeAllAssetIndex, SubscribeIndexPrice, SubscribeIndexPriceKLine, SubscribeMarkPriceKLine (+ bijbehorende UnSubscribe-methodes)
Belangrijk: Alle trading-methodes die orders plaatsen, wijzigen of annuleren, vereisen geldige ApiKey- en ApiSecret-credentials. Het wordt sterk aanbevolen om eerst te ontwikkelen en testen tegen het Binance TestNet door TestNet := True in te stellen voordat je naar productie gaat. Zorg er ook voor dat de permissies van de API-sleutel (trading, margin, futures) overeenkomen met de bewerkingen die je wilt uitvoeren. Backward Compatibility: Alle toevoegingen zijn backward-compatible. Bestaande method-signatures zijn uitgebreid met standaard parameterwaarden, zodat eerder gecompileerde code blijft werken zonder aanpassingen. De nieuwe parameters (aSelfTradePreventionMode, aStrategyId, aPriceMatch, enzovoort) hebben standaard lege waarden of nul, waardoor de API zijn standaardgedrag gebruikt.