New Binance API Methods in sgcWebSockets

24 de fevereiro de 2026 · Recursos

A biblioteca sgcWebSockets continua expandindo sua integração com a Binance com um conjunto significativo de novos métodos cobrindo a Spot REST API, a Futures REST API e os streams WebSocket. Este artigo fornece uma análise técnica de cada novo método, seus parâmetros e exemplos práticos em Delphi para você começar rapidamente.

Índice

Novos Métodos da Spot REST API
Dados de Mercado Spot: UI KLines, Rolling Window e Trading Day Tickers
Gerenciamento de Ordens Spot: Ordens OCO, OTO, OTOCO e SOR
Conta Spot: Comissão, Alocações, Limites de Taxa e Matches Impedidos
Novos Métodos da Futures REST API
Dados de Mercado Futures: KLines Contínuos, Premium Index e Mais
Gerenciamento de Ordens Futures: Modificar, Lote e Ordens Forçadas
Conta Futures: Endpoints V3, Configuração e Fee Burn
Novos Streams WebSocket Spot
Novos Streams WebSocket Futures
Exemplos Completos Funcionais

1. Novos Métodos da Spot REST API

A classe TsgcHTTP_API_Binance_Rest foi estendida com novos endpoints de dados de mercado, tipos de ordem avançados e métodos de consulta de conta. Todos os métodos são acessíveis diretamente pelo componente REST ou através da propriedade REST_API de TsgcWS_API_Binance.

Endpoints de Dados de Mercado

Método	Descrição	Endpoint Binance
`GetUIKLines`	Dados de kline/candlestick otimizados para apresentação em UI. Retorna dados em formato idêntico ao `GetKLines`, mas ajustado para renderização de gráficos.	`/api/v3/uiKlines`
`GetRollingWindowTicker`	Estatísticas de variação de preço em janela deslizante. Suporta tamanhos de janela configuráveis (ex: 1h, 4h, 1d), ao contrário do ticker fixo de 24h.	`/api/v3/ticker`
`GetTradingDayTicker`	Estatísticas de variação de preço calculadas ao longo do dia de negociação (UTC 00:00 até o momento atual). Suporta um ou múltiplos símbolos.	`/api/v3/ticker/tradingDay`
`GetPriceTickers`	Recupera tickers de preço para múltiplos símbolos em uma única requisição usando um array JSON de nomes de símbolos.	`/api/v3/ticker/price`

GetUIKLines

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

A diferença entre GetKLines e GetUIKLines é sutil: a variante UI é otimizada pelo backend da Binance para renderização de gráficos e pode retornar limites de kline modificados para melhor apresentação visual. O formato da resposta é idêntico, tornando-o um substituto direto para qualquer caso de uso com gráficos.

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;

Este método estende o Get24hrTicker tradicional ao permitir tamanhos de janela personalizados. Os valores aceitos para aWindowSize incluem '1h', '4h' e '1d'. Se omitido, a janela padrão é usada.

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;

Tipos de Ordem Avançados

A Binance introduziu vários novos tipos de lista de ordens que vão além do OCO original. A biblioteca sgcWebSockets agora os suporta todos nativamente.

NewOrderListOCO (New OCO Format)

O novo formato OCO substitui o NewOCO legado e introduz configurações de preço acima/abaixo mais flexíveis. Cada parte do OCO pode ser configurada de forma independente com seu próprio tipo de ordem, 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)

Uma lista de ordens OTO consiste em uma ordem ativa e uma ordem pendente. Quando a ordem ativa é executada, a ordem pendente é colocada automaticamente. Isso é útil para configurar ordens de entrada com ordens de acompanhamento automáticas.

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 a lógica OTO e OCO: uma ordem ativa aciona um par OCO (take-profit + stop-loss) quando executada. Isso permite estratégias totalmente automatizadas de entrada com plano de saída em uma única chamada de 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)

As ordens SOR permitem que a Binance otimize a execução roteando por múltiplos pools de liquidez. Dois novos métodos são fornecidos: NewSOROrder para execução real e TestSOROrder para validação sem efetuar o pedido.

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

Cancela atomicamente uma ordem existente e coloca uma nova. Isso é fundamental para estratégias que precisam modificar ordens sem o risco de ficar sem posição entre duas chamadas separadas de cancelar+colocar.

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;

Endpoints de Conta e Consulta

Method	Description
`GetAccountInformation(aOmitZeroBalances)`	Estendido com o parâmetro `aOmitZeroBalances`. Quando definido como `True`, ativos com saldo zero são excluídos da resposta.
`GetOrderRateLimitUsage`	Retorna a contagem atual de ordens e o uso do limite de taxa, essencial para manter-se dentro dos limites da API em cenários de alta frequência.
`GetPreventedMatches`	Consulta matches de auto-negociação impedidos. Suporta filtragem por símbolo, ID de ordem ou ID de match impedido com paginação.
`GetAllocations`	Recupera alocações de ordens SOR, mostrando como uma ordem foi distribuída pelos pools.
`GetAccountCommission`	Retorna a taxa de comissão maker/taker para um símbolo específico.

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: Os métodos NewOrder e TestNewOrder também foram estendidos com novos parâmetros opcionais: aSelfTradePreventionMode, aStrategyId e aStrategyType. O método CancelOrder agora aceita um parâmetro aCancelRestrictions para cancelamento condicional. Essas adições são retrocompatíveis — o código existente continuará funcionando sem alterações.

2. Novos Métodos da Futures REST API

A classe TsgcHTTP_API_Binance_Futures_Rest recebeu o maior conjunto de novos métodos, cobrindo dados de mercado, gerenciamento de ordens, configuração de conta e gerenciamento de streams. Todos os métodos funcionam com futuros USDT-M e COIN-M, controlados pela propriedade FuturesContracts.

Dados de Mercado Futures

Method	Description
`GetContinuousKLines`	Dados de kline/candlestick para um contrato contínuo. Requer par, tipo de contrato (ex: `'PERPETUAL'`, `'CURRENT_QUARTER'`) e intervalo.
`GetIndexPriceKLines`	Dados de kline baseados no preço do índice de um par de negociação.
`GetMarkPriceKLines`	Dados de kline baseados no mark price de um símbolo.
`GetPremiumIndexKLines`	Dados de kline do índice premium para cálculo de basis e análise de taxa de financiamento.
`GetFundingInfo`	Retorna informações de taxa de financiamento para todos os símbolos, incluindo intervalo de financiamento e taxas máximas/mínimas.
`GetPriceTickerV2`	Ticker de preço V2 com formato de resposta melhorado.
`GetIndexInfo`	Retorna o preço do índice e dados dos componentes para um símbolo de índice composto.
`GetAssetIndex`	Preços do índice de ativos para cálculos de margem no modo multi-ativo.
`GetConstituents`	Consulta os componentes e seus pesos para um índice composto específico.
`GetDeliveryPrice`	Preços históricos de entrega para contratos trimestrais/bimestrais.
`GetBasis`	Dados de basis (spread entre preços de futuros e spot) para um par e tipo de contrato específicos.

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;

Gerenciamento de Ordens Futures

Os novos métodos de ordens Futures fornecem ordens de teste, modificação de ordens, processamento em lote e consultas de liquidação.

Method	Description
`TestNewOrder`	Valida uma nova ordem de futuros sem efetivá-la. Espelha a assinatura de `NewOrder`.
`ModifyOrder`	Modifica o preço, a quantidade ou o modo de correspondência de preço de uma ordem aberta existente.
`NewBatchOrders`	Coloca até 5 ordens em uma única requisição via um array JSON de objetos de ordem.
`ModifyBatchOrders`	Modifica até 5 ordens existentes em uma única requisição.
`CancelBatchOrders`	Cancela múltiplas ordens por lista de IDs de ordem ou lista de IDs de ordem do cliente.
`GetOrderAmendment`	Recupera o histórico de emendas (modificações) de uma ordem.
`CountdownCancelAll`	Define um temporizador de contagem regressiva (em milissegundos) após o qual todas as ordens abertas de um símbolo são canceladas.
`GetForceOrders`	Consulta ordens de liquidação forçada com filtragem opcional.
`GetADLQuantile`	Recupera a estimativa de quantil ADL (Desalavancagem Automática) para posições.

A assinatura de NewOrder para Futures também foi estendida com novos parâmetros: 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.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;

Conta e Configuração Futures

Vários endpoints de conta V3 foram adicionados juntamente com métodos de configuração e gerenciamento de taxas.

Method	Description
`GetAccountBalanceV3`	Saldo de conta V3 com suporte aprimorado a margem multi-ativo.
`GetAccountInformationV3`	Detalhes de conta V3, incluindo modo de margem multi-ativo e níveis de taxa atualizados.
`GetPositionInformationV3`	Dados de posição V3 com campos de precisão adicionais.
`GetCommissionRate`	Retorna a taxa de comissão maker/taker atual para um símbolo de futuros específico.
`GetAccountConfig`	Configuração no nível da conta: nível de taxa, modo de posição, modo de margem multi-ativo.
`GetSymbolConfig`	Configuração por símbolo: alavancagem, tipo de margem e modo de posição.
`GetOrderRateLimit`	Status atual do limite de taxa de ordens por símbolo.
`GetApiTradingStatus`	Status de negociação da API e indicadores que podem acionar restrições de negociação.
`ChangeMultiAssetsMode`	Habilita ou desabilita o modo de margem multi-ativo para futuros USDT-M.
`GetMultiAssetsMode`	Consulta a configuração atual do modo de margem multi-ativo.
`SetFeeBurn`	Habilita ou desabilita o BNB fee burn (pagar taxas com BNB com desconto).
`GetFeeBurn`	Consulta a configuração atual do fee burn.

Gerenciamento de Listen Key

Três métodos dedicados agora gerenciam o ciclo de vida da listen key do stream de dados do usuário Futures diretamente via REST, independentemente do componente WebSocket:

Method	Description
`CreateListenKey`	Gera uma nova listen key para o stream de dados do usuário (POST).
`KeepAliveListenKey`	Estende a validade de uma listen key (PUT). Deve ser chamado a cada 60 minutos.
`CloseListenKey`	Invalida e fecha uma 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. Novos Streams WebSocket Spot

A classe TsgcWS_API_Binance foi estendida com três novos tipos de stream, cada um com métodos de inscrição e cancelamento de inscrição.

Método	Stream	Descrição
`SubscribeAvgPrice / UnSubscribeAvgPrice`	`<symbol>@avgPrice`	Stream de preço médio em tempo real para um símbolo.
`SubscribeRollingWindowTicker`	`<symbol>@ticker_<window>`	Estatísticas de janela deslizante com tamanho de janela configurável (1h, 4h, 1d).
`SubscribeAllRollingWindowTickers`	`!ticker_<window>@arr`	Estatísticas de janela deslizante para todos os símbolos negociados em um tamanho de janela específico.

Um novo tipo de enumeração TsgcWSBinanceRollingWindowSize é fornecido para especificação segura de tamanho de janela:

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. Novos Streams WebSocket Futures

A classe TsgcWS_API_Binance_Futures recebe o maior conjunto de novas assinaturas de stream WebSocket. Elas cobrem contratos contínuos, índices compostos, índices de ativos, preços de índice e klines de mark price.

Método	Stream	Descrição
`SubscribeContinuousKLine`	`<pair>_<contract>@continuousKline_<interval>`	Stream de kline para contratos contínuos. Requer par, tipo de contrato e intervalo.
`SubscribeCompositeIndex`	`<symbol>@compositeIndex`	Stream de preço de índice composto com detalhamento dos componentes.
`SubscribeContractInfo`	`!contractInfo`	Stream de informações de contrato. Envia atualizações sobre listagem, cancelamento de listagem e alterações de faixas.
`SubscribeAssetIndex / SubscribeAllAssetIndex`	`<symbol>@assetIndex` / `!assetIndex@arr`	Preços do índice de ativos para cálculos de margem multi-ativo. Por símbolo ou mercado completo.
`SubscribeIndexPrice`	`<pair>@indexPrice`	Stream de preço de índice para um par de negociação. Suporta parâmetro opcional de velocidade de atualização.
`SubscribeIndexPriceKLine`	`<pair>@indexPriceKline_<interval>`	Stream de kline/candlestick de preço de índice com intervalos configuráveis.
`SubscribeMarkPriceKLine`	`<symbol>@markPriceKline_<interval>`	Stream de kline de mark price para rastrear o mark price usado nos cálculos de liquidação.

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. Exemplos Completos Funcionais

Exemplo 1: Spot REST + WebSocket Combinados (Aplicação VCL)

Um padrão típico é usar a REST API para colocar ordens e a WebSocket API para dados de mercado em tempo real. O exemplo a seguir demonstra como configurar ambos através do componente 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.

Exemplo 2: Futures REST + WebSocket (Aplicação Console)

Aplicações console são ideais para bots sem interface e serviços em segundo plano. O exemplo a seguir demonstra o uso dos novos métodos Futures em um contexto de console.

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.

Exemplo 3: Estratégia de Ordem OTOCO

O tipo de ordem OTOCO representa o ciclo de vida de negociação automatizado mais completo: uma única chamada coloca uma ordem de entrada que, uma vez executada, configura automaticamente tanto um take-profit quanto um 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;

Resumo

A tabela a seguir resume a quantidade de novos métodos adicionados a cada classe:

Componente	Classe	Novos Métodos
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
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)

Importante: Todos os métodos de negociação que colocam, modificam ou cancelam ordens exigem credenciais válidas ApiKey e ApiSecret. É altamente recomendado desenvolver e testar na Binance TestNet definindo TestNet := True antes de ir para produção. Certifique-se também de que as permissões da chave de API (trading, margem, futuros) correspondam às operações que você pretende realizar. Compatibilidade com versões anteriores: Todas as adições são retrocompatíveis. As assinaturas de métodos existentes foram estendidas com valores de parâmetros padrão, então o código compilado anteriormente continua funcionando sem modificações. Os novos parâmetros (aSelfTradePreventionMode, aStrategyId, aPriceMatch, etc.) têm como padrão valores vazios ou zero que fazem a API usar seu comportamento padrão.