From bd29d92944d4a13eaa25ef05802ff9a2e76887ad Mon Sep 17 00:00:00 2001
From: antlen <antlen@users.noreply.github.com>
Date: Wed, 5 Jan 2022 14:41:22 +0900
Subject: [PATCH 1/7] issue #409 API should allow integration with
 ExecutorService to allow better control of client threading.

---
 .../BinanceApiAsyncExecutorRestClient.java    | 309 ++++++++++++++++++
 .../api/client/BinanceApiClientFactory.java   |  16 +
 ...BinanceApiAsyncExecutorRestClientImpl.java | 234 +++++++++++++
 .../BinanceApiAsyncRestClientAdapter.java     | 198 +++++++++++
 4 files changed, 757 insertions(+)
 create mode 100755 src/main/java/com/binance/api/client/BinanceApiAsyncExecutorRestClient.java
 create mode 100644 src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
 create mode 100644 src/main/java/com/binance/api/client/impl/BinanceApiAsyncRestClientAdapter.java

diff --git a/src/main/java/com/binance/api/client/BinanceApiAsyncExecutorRestClient.java b/src/main/java/com/binance/api/client/BinanceApiAsyncExecutorRestClient.java
new file mode 100755
index 000000000..dbd23cd1b
--- /dev/null
+++ b/src/main/java/com/binance/api/client/BinanceApiAsyncExecutorRestClient.java
@@ -0,0 +1,309 @@
+package com.binance.api.client;
+
+import com.binance.api.client.domain.account.*;
+import com.binance.api.client.domain.account.request.*;
+import com.binance.api.client.domain.event.ListenKey;
+import com.binance.api.client.domain.general.Asset;
+import com.binance.api.client.domain.general.ExchangeInfo;
+import com.binance.api.client.domain.general.ServerTime;
+import com.binance.api.client.domain.market.*;
+
+import java.util.List;
+import java.util.concurrent.Future;
+
+/**
+ * Binance API facade, supporting asynchronous/non-blocking access Binance's REST API using ExecutorServices to
+ * handling the request and response threading.
+ */
+public interface BinanceApiAsyncExecutorRestClient {
+
+  // General endpoints
+
+  /**
+   * Test connectivity to the Rest API.
+   * @return
+   */
+  Future<Void> ping(BinanceApiCallback<Void> callback);
+
+  /**
+   * Check server time.
+   * @return
+   */
+  Future<ServerTime> getServerTime(BinanceApiCallback<ServerTime> callback);
+
+  /**
+   * Current exchange trading rules and symbol information
+   *
+   * @return
+   */
+  Future<ExchangeInfo> getExchangeInfo(BinanceApiCallback<ExchangeInfo> callback);
+
+  /**
+   * ALL supported assets and whether or not they can be withdrawn.
+   *
+   * @return
+   */
+  Future<List<Asset>> getAllAssets(BinanceApiCallback<List<Asset>> callback);
+
+  // Market Data endpoints
+
+  /**
+   * Get order book of a symbol (asynchronous)
+   *
+   * @param symbol ticker symbol (e.g. ETHBTC)
+   * @param limit depth of the order book (max 100)
+   * @param callback the callback that handles the response
+   *
+   * @return
+   */
+  Future<OrderBook> getOrderBook(String symbol, Integer limit, BinanceApiCallback<OrderBook> callback);
+
+  /**
+   * Get recent trades (up to last 500). Weight: 1
+   *
+   * @param symbol ticker symbol (e.g. ETHBTC)
+   * @param limit of last trades (Default 500; max 1000.)
+   * @param callback the callback that handles the response
+   *
+   * @return
+   */
+  Future<List<TradeHistoryItem>> getTrades(String symbol, Integer limit, BinanceApiCallback<List<TradeHistoryItem>> callback);
+
+  /**
+   * Get older trades. Weight: 5
+   *
+   * @param symbol ticker symbol (e.g. ETHBTC)
+   * @param limit of last trades (Default 500; max 1000.)
+   * @param fromId TradeId to fetch from. Default gets most recent trades.
+   * @param callback the callback that handles the response
+   *
+   * @return
+   */
+  Future<List<TradeHistoryItem>> getHistoricalTrades(String symbol, Integer limit, Long fromId, BinanceApiCallback<List<TradeHistoryItem>> callback);
+
+  /**
+   * Get compressed, aggregate trades. Trades that fill at the time, from the same order, with
+   * the same price will have the quantity aggregated.
+   *
+   * If both <code>startTime</code> and <code>endTime</code> are sent, <code>limit</code>should not
+   * be sent AND the distance between <code>startTime</code> and <code>endTime</code> must be less than 24 hours.
+   *
+   * @param symbol symbol to aggregate (mandatory)
+   * @param fromId ID to get aggregate trades from INCLUSIVE (optional)
+   * @param limit Default 500; max 1000 (optional)
+   * @param startTime Timestamp in ms to get aggregate trades from INCLUSIVE (optional).
+   * @param endTime Timestamp in ms to get aggregate trades until INCLUSIVE (optional).
+   * @param callback the callback that handles the response
+   * @return a list of aggregate trades for the given symbol
+   */
+  Future<List<AggTrade>> getAggTrades(String symbol, String fromId, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<AggTrade>> callback);
+
+  /**
+   * Return the most recent aggregate trades for <code>symbol</code>
+   *
+   * @see #getAggTrades(String, String, Integer, Long, Long, BinanceApiCallback)
+   */
+  Future<List<AggTrade>> getAggTrades(String symbol, BinanceApiCallback<List<AggTrade>> callback);
+
+  /**
+   * Kline/candlestick bars for a symbol. Klines are uniquely identified by their open time.
+   *
+   * @param symbol symbol to aggregate (mandatory)
+   * @param interval candlestick interval (mandatory)
+   * @param limit Default 500; max 1000 (optional)
+   * @param startTime Timestamp in ms to get candlestick bars from INCLUSIVE (optional).
+   * @param endTime Timestamp in ms to get candlestick bars until INCLUSIVE (optional).
+   * @param callback the callback that handles the response containing a candlestick bar for the given symbol and interval
+   */
+  Future<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<Candlestick>> callback);
+
+  /**
+   * Kline/candlestick bars for a symbol. Klines are uniquely identified by their open time.
+   *
+   * @see #getCandlestickBars(String, CandlestickInterval, BinanceApiCallback)
+   */
+  Future<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, BinanceApiCallback<List<Candlestick>> callback);
+
+  /**
+   * Get 24 hour price change statistics (asynchronous).
+   *
+   * @param symbol ticker symbol (e.g. ETHBTC)
+   * @param callback the callback that handles the response
+   */
+  Future<TickerStatistics> get24HrPriceStatistics(String symbol, BinanceApiCallback<TickerStatistics> callback);
+  
+  /**
+   * Get 24 hour price change statistics for all symbols (asynchronous).
+   * 
+   * @param callback the callback that handles the response
+   */
+  Future<List<TickerStatistics>> getAll24HrPriceStatistics(BinanceApiCallback<List<TickerStatistics>> callback);
+
+  /**
+   * Get Latest price for all symbols (asynchronous).
+   *
+   * @param callback the callback that handles the response
+   */
+  Future<List<TickerPrice>> getAllPrices(BinanceApiCallback<List<TickerPrice>> callback);
+  
+  /**
+   * Get latest price for <code>symbol</code> (asynchronous).
+   * 
+   * @param symbol ticker symbol (e.g. ETHBTC)
+   * @param callback the callback that handles the response
+   */
+  Future<TickerPrice> getPrice(String symbol , BinanceApiCallback<TickerPrice> callback);
+
+  /**
+   * Get best price/qty on the order book for all symbols (asynchronous).
+   *
+   * @param callback the callback that handles the response
+   */
+  Future<List<BookTicker>> getBookTickers(BinanceApiCallback<List<BookTicker>> callback);
+
+  // Account endpoints
+
+  /**
+   * Send in a new order (asynchronous)
+   *
+   * @param order the new order to submit.
+   * @param callback the callback that handles the response
+   */
+  Future<NewOrderResponse> newOrder(NewOrder order, BinanceApiCallback<NewOrderResponse> callback);
+
+  /**
+   * Test new order creation and signature/recvWindow long. Creates and validates a new order but does not send it into the matching engine.
+   *
+   * @param order the new TEST order to submit.
+   * @param callback the callback that handles the response
+   */
+  Future<Void> newOrderTest(NewOrder order, BinanceApiCallback<Void> callback);
+
+  /**
+   * Check an order's status (asynchronous).
+   *
+   * @param orderStatusRequest order status request parameters
+   * @param callback the callback that handles the response
+   */
+  Future<Order> getOrderStatus(OrderStatusRequest orderStatusRequest, BinanceApiCallback<Order> callback);
+
+  /**
+   * Cancel an active order (asynchronous).
+   *
+   * @param cancelOrderRequest order status request parameters
+   * @param callback the callback that handles the response
+   */
+  Future<CancelOrderResponse> cancelOrder(CancelOrderRequest cancelOrderRequest, BinanceApiCallback<CancelOrderResponse> callback);
+
+  /**
+   * Get all open orders on a symbol (asynchronous).
+   *
+   * @param orderRequest order request parameters
+   * @param callback the callback that handles the response
+   */
+  Future<List<Order>> getOpenOrders(OrderRequest orderRequest, BinanceApiCallback<List<Order>> callback);
+
+  /**
+   * Get all account orders; active, canceled, or filled.
+   *
+   * @param orderRequest order request parameters
+   * @param callback the callback that handles the response
+   */
+  Future<List<Order>> getAllOrders(AllOrdersRequest orderRequest, BinanceApiCallback<List<Order>> callback);
+
+  /**
+   * Get current account information (async).
+   */
+  Future<Account> getAccount(Long recvWindow, Long timestamp, BinanceApiCallback<Account> callback);
+
+  /**
+   * Get current account information using default parameters (async).
+   */
+  Future<Account> getAccount(BinanceApiCallback<Account> callback);
+
+  /**
+   * Get trades for a specific account and symbol.
+   *
+   * @param symbol symbol to get trades from
+   * @param limit default 500; max 1000
+   * @param fromId TradeId to fetch from. Default gets most recent trades.
+   * @param callback the callback that handles the response with a list of trades
+   */
+  Future<List<Trade>> getMyTrades(String symbol, Integer limit, Long fromId, Long recvWindow, Long timestamp, BinanceApiCallback<List<Trade>> callback);
+
+  /**
+   * Get trades for a specific account and symbol.
+   *
+   * @param symbol symbol to get trades from
+   * @param limit default 500; max 1000
+   * @param callback the callback that handles the response with a list of trades
+   */
+  Future<List<Trade>> getMyTrades(String symbol, Integer limit, BinanceApiCallback<List<Trade>> callback);
+
+  /**
+   * Get trades for a specific account and symbol.
+   *
+   * @param symbol symbol to get trades from
+   * @param callback the callback that handles the response with a list of trades
+   */
+  Future<List<Trade>> getMyTrades(String symbol, BinanceApiCallback<List<Trade>> callback);
+
+  /**
+   * Submit a withdraw request.
+   *
+   * Enable Withdrawals option has to be active in the API settings.
+   *
+   * @param asset asset symbol to withdraw
+   * @param address address to withdraw to
+   * @param amount amount to withdraw
+   * @param name description/alias of the address
+   * @param addressTag Secondary address identifier for coins like XRP,XMR etc.
+   */
+  Future<WithdrawResult> withdraw(String asset, String address, String amount, String name, String addressTag, BinanceApiCallback<WithdrawResult> callback);
+
+  /**
+   * Fetch account deposit history.
+   *
+   * @param callback the callback that handles the response and returns the deposit history
+   */
+  Future<DepositHistory> getDepositHistory(String asset, BinanceApiCallback<DepositHistory> callback);
+
+  /**
+   * Fetch account withdraw history.
+   *
+   * @param callback the callback that handles the response and returns the withdraw history
+   */
+  Future<WithdrawHistory> getWithdrawHistory(String asset, BinanceApiCallback<WithdrawHistory> callback);
+
+  /**
+   * Fetch deposit address.
+   *
+   * @param callback the callback that handles the response and returns the deposit address
+   */
+  Future<DepositAddress> getDepositAddress(String asset, BinanceApiCallback<DepositAddress> callback);
+
+  // User stream endpoints
+
+  /**
+   * Start a new user data stream.
+   *
+   * @param callback the callback that handles the response which contains a listenKey
+   */
+  Future<ListenKey> startUserDataStream(BinanceApiCallback<ListenKey> callback);
+
+  /**
+   * PING a user data stream to prevent a time out.
+   *
+   * @param listenKey listen key that identifies a data stream
+   * @param callback the callback that handles the response which contains a listenKey
+   */
+  Future<Void> keepAliveUserDataStream(String listenKey, BinanceApiCallback<Void> callback);
+
+  /**
+   * Close out a new user data stream.
+   *
+   * @param listenKey listen key that identifies a data stream
+   * @param callback the callback that handles the response which contains a listenKey
+   */
+  Future<Void> closeUserDataStream(String listenKey, BinanceApiCallback<Void> callback);
+}
\ No newline at end of file
diff --git a/src/main/java/com/binance/api/client/BinanceApiClientFactory.java b/src/main/java/com/binance/api/client/BinanceApiClientFactory.java
index 7ba5551bb..26f197370 100755
--- a/src/main/java/com/binance/api/client/BinanceApiClientFactory.java
+++ b/src/main/java/com/binance/api/client/BinanceApiClientFactory.java
@@ -2,6 +2,9 @@
 
 import com.binance.api.client.impl.*;
 import com.binance.api.client.config.BinanceApiConfig;
+
+import java.util.concurrent.ExecutorService;
+
 import static com.binance.api.client.impl.BinanceApiServiceGenerator.getSharedClient;
 
 /**
@@ -101,6 +104,19 @@ public BinanceApiRestClient newRestClient() {
     return new BinanceApiRestClientImpl(apiKey, secret);
   }
 
+  /**
+   * Creates a new asynchronous/non-blocking REST client that uses Executor Services for handling
+   * the request and response threading.
+   *
+   * @param requestService
+   * @param responseService
+   * @return
+   */
+  public BinanceApiAsyncExecutorRestClient newAsyncExecutorRestClient(ExecutorService requestService,
+                                                                      ExecutorService responseService) {
+    return new BinanceApiAsyncExecutorRestClientImpl(newRestClient(), requestService, responseService);
+  }
+
   /**
    * Creates a new asynchronous/non-blocking REST client.
    */
diff --git a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
new file mode 100644
index 000000000..da7905e34
--- /dev/null
+++ b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
@@ -0,0 +1,234 @@
+package com.binance.api.client.impl;
+
+import com.binance.api.client.BinanceApiAsyncExecutorRestClient;
+import com.binance.api.client.BinanceApiCallback;
+import com.binance.api.client.BinanceApiRestClient;
+import com.binance.api.client.domain.account.*;
+import com.binance.api.client.domain.account.request.*;
+import com.binance.api.client.domain.event.ListenKey;
+import com.binance.api.client.domain.general.Asset;
+import com.binance.api.client.domain.general.ExchangeInfo;
+import com.binance.api.client.domain.general.ServerTime;
+import com.binance.api.client.domain.market.*;
+
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.function.Supplier;
+
+/**
+ * Implementation of BinanceApiAsyncExecutorRestClient using ExecutorServices for handling request and responses.
+ */
+public class BinanceApiAsyncExecutorRestClientImpl implements BinanceApiAsyncExecutorRestClient {
+    private final BinanceApiRestClient client;
+    private final ExecutorService requestService;
+    private final ExecutorService responseService;
+
+    public BinanceApiAsyncExecutorRestClientImpl(BinanceApiRestClient client, ExecutorService requestService, ExecutorService responseService) {
+        this.client = client;
+        this.requestService = requestService;
+        this.responseService = responseService;
+    }
+
+    private <T> Future<T> invoke(BinanceApiCallback<T> callback, Supplier<T> t){
+        return requestService.submit(() -> {
+            try {
+                T v = t.get();
+                responseService.submit(() -> callback.onResponse(v));
+                return v;
+            }catch (Exception e){
+                responseService.submit(() -> callback.onFailure(e));
+                throw e;
+            }
+        });
+    }
+
+    @Override
+    public Future<Void> ping(BinanceApiCallback<Void> callback) {
+        return invoke(callback,() -> {
+            client.ping();
+            return null;
+        });
+    }
+
+    @Override
+    public Future<ServerTime> getServerTime(BinanceApiCallback<ServerTime> callback) {
+        return invoke(callback, () -> {
+            ServerTime t = new ServerTime();
+            t.setServerTime(client.getServerTime());
+            return t;
+        });
+    }
+
+    @Override
+    public Future<ExchangeInfo> getExchangeInfo(BinanceApiCallback<ExchangeInfo> callback) {
+        return invoke(callback, () -> client.getExchangeInfo());
+    }
+
+    @Override
+    public Future<List<Asset>> getAllAssets(BinanceApiCallback<List<Asset>> callback) {
+        return invoke(callback, () -> client.getAllAssets());
+    }
+
+    @Override
+    public Future<OrderBook> getOrderBook(String symbol, Integer limit, BinanceApiCallback<OrderBook> callback) {
+        return invoke(callback, () -> client.getOrderBook(symbol,limit));
+    }
+
+    @Override
+    public Future<List<TradeHistoryItem>> getTrades(String symbol, Integer limit, BinanceApiCallback<List<TradeHistoryItem>> callback) {
+        return invoke(callback, () -> client.getTrades(symbol, limit));
+    }
+
+    @Override
+    public Future<List<TradeHistoryItem>> getHistoricalTrades(String symbol, Integer limit, Long fromId, BinanceApiCallback<List<TradeHistoryItem>> callback) {
+        return invoke(callback, () -> client.getHistoricalTrades(symbol, limit, fromId));
+    }
+
+    @Override
+    public Future<List<AggTrade>> getAggTrades(String symbol, String fromId, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<AggTrade>> callback) {
+        return invoke(callback, () -> client.getAggTrades(symbol,fromId,limit,startTime,endTime));
+    }
+
+    @Override
+    public Future<List<AggTrade>> getAggTrades(String symbol, BinanceApiCallback<List<AggTrade>> callback) {
+        return invoke(callback, () -> client.getAggTrades(symbol));
+    }
+
+    @Override
+    public Future<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<Candlestick>> callback) {
+        return invoke(callback, () -> client.getCandlestickBars(symbol,interval,limit,startTime, endTime));
+    }
+
+    @Override
+    public Future<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, BinanceApiCallback<List<Candlestick>> callback) {
+        return invoke(callback, () -> client.getCandlestickBars(symbol, interval));
+    }
+
+    @Override
+    public Future<TickerStatistics> get24HrPriceStatistics(String symbol, BinanceApiCallback<TickerStatistics> callback) {
+        return invoke(callback, () -> client.get24HrPriceStatistics(symbol));
+    }
+
+    @Override
+    public Future<List<TickerStatistics>> getAll24HrPriceStatistics(BinanceApiCallback<List<TickerStatistics>> callback) {
+        return invoke(callback, () -> client.getAll24HrPriceStatistics());
+    }
+
+    @Override
+    public Future<List<TickerPrice>> getAllPrices(BinanceApiCallback<List<TickerPrice>> callback) {
+        return invoke(callback, () -> client.getAllPrices());
+    }
+
+    @Override
+    public Future<TickerPrice> getPrice(String symbol, BinanceApiCallback<TickerPrice> callback) {
+        return invoke(callback, () -> client.getPrice(symbol));
+    }
+
+    @Override
+    public Future<List<BookTicker>> getBookTickers(BinanceApiCallback<List<BookTicker>> callback) {
+        return invoke(callback, () -> client.getBookTickers());
+    }
+
+    @Override
+    public Future<NewOrderResponse> newOrder(NewOrder order, BinanceApiCallback<NewOrderResponse> callback) {
+        return invoke(callback, () -> client.newOrder(order));
+    }
+
+    @Override
+    public Future<Void> newOrderTest(NewOrder order, BinanceApiCallback<Void> callback) {
+        return invoke(callback, () -> {
+            client.newOrderTest(order);
+            return null;
+        });
+    }
+
+    @Override
+    public Future<Order> getOrderStatus(OrderStatusRequest orderStatusRequest, BinanceApiCallback<Order> callback) {
+        return invoke(callback, () -> client.getOrderStatus(orderStatusRequest));
+    }
+
+    @Override
+    public Future<CancelOrderResponse> cancelOrder(CancelOrderRequest cancelOrderRequest, BinanceApiCallback<CancelOrderResponse> callback) {
+        return invoke(callback, () -> client.cancelOrder(cancelOrderRequest));
+    }
+
+    @Override
+    public Future<List<Order>> getOpenOrders(OrderRequest orderRequest, BinanceApiCallback<List<Order>> callback) {
+        return invoke(callback, () -> client.getOpenOrders(orderRequest));
+    }
+
+    @Override
+    public Future<List<Order>> getAllOrders(AllOrdersRequest orderRequest, BinanceApiCallback<List<Order>> callback) {
+        return invoke(callback, () -> client.getAllOrders(orderRequest));
+    }
+
+    @Override
+    public Future<Account> getAccount(Long recvWindow, Long timestamp, BinanceApiCallback<Account> callback) {
+        return invoke(callback, () -> client.getAccount(recvWindow, timestamp));
+    }
+
+    @Override
+    public Future<Account> getAccount(BinanceApiCallback<Account> callback) {
+        return invoke(callback, () -> client.getAccount());
+    }
+
+    @Override
+    public Future<List<Trade>> getMyTrades(String symbol, Integer limit, Long fromId, Long recvWindow, Long timestamp, BinanceApiCallback<List<Trade>> callback) {
+        return invoke(callback, () -> client.getMyTrades(symbol, limit, fromId, recvWindow, timestamp));
+    }
+
+    @Override
+    public Future<List<Trade>> getMyTrades(String symbol, Integer limit, BinanceApiCallback<List<Trade>> callback) {
+        return invoke(callback, () -> client.getMyTrades(symbol, limit));
+    }
+
+    @Override
+    public Future<List<Trade>> getMyTrades(String symbol, BinanceApiCallback<List<Trade>> callback) {
+        return invoke(callback, () -> client.getMyTrades(symbol));
+    }
+
+    @Override
+    public Future<WithdrawResult> withdraw(String asset, String address, String amount, String name, String addressTag, BinanceApiCallback<WithdrawResult> callback) {
+        return invoke(callback, () -> client.withdraw(asset, address, amount, name, addressTag));
+    }
+
+    @Override
+    public Future<DepositHistory> getDepositHistory(String asset, BinanceApiCallback<DepositHistory> callback) {
+        return invoke(callback, () -> client.getDepositHistory(asset));
+    }
+
+    @Override
+    public Future<WithdrawHistory> getWithdrawHistory(String asset, BinanceApiCallback<WithdrawHistory> callback) {
+        return invoke(callback, () -> client.getWithdrawHistory(asset));
+    }
+
+    @Override
+    public Future<DepositAddress> getDepositAddress(String asset, BinanceApiCallback<DepositAddress> callback) {
+        return invoke(callback, () -> client.getDepositAddress(asset));
+    }
+
+    @Override
+    public Future<ListenKey> startUserDataStream(BinanceApiCallback<ListenKey> callback) {
+        return invoke(callback, () -> {
+            client.startUserDataStream();
+            return null;
+        });
+    }
+
+    @Override
+    public Future<Void> keepAliveUserDataStream(String listenKey, BinanceApiCallback<Void> callback) {
+        return invoke(callback, () -> {
+            client.keepAliveUserDataStream(listenKey);
+            return null;
+        });
+    }
+
+    @Override
+    public Future<Void> closeUserDataStream(String listenKey, BinanceApiCallback<Void> callback) {
+        return invoke(callback, () -> {
+            client.closeUserDataStream(listenKey);
+            return null;
+        });
+    }
+}
diff --git a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncRestClientAdapter.java b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncRestClientAdapter.java
new file mode 100644
index 000000000..e37dcec9a
--- /dev/null
+++ b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncRestClientAdapter.java
@@ -0,0 +1,198 @@
+package com.binance.api.client.impl;
+
+import com.binance.api.client.BinanceApiAsyncExecutorRestClient;
+import com.binance.api.client.BinanceApiAsyncRestClient;
+import com.binance.api.client.BinanceApiCallback;
+import com.binance.api.client.domain.account.*;
+import com.binance.api.client.domain.account.request.*;
+import com.binance.api.client.domain.event.ListenKey;
+import com.binance.api.client.domain.general.Asset;
+import com.binance.api.client.domain.general.ExchangeInfo;
+import com.binance.api.client.domain.general.ServerTime;
+import com.binance.api.client.domain.market.*;
+
+import java.util.List;
+
+/**
+ * Adapter to make calls to a BinanceApiAsyncExecutorRestClient using the BinanceApiAsyncRestClient
+ * interface.  This allows existing code to migrate to use BinanceApiAsyncExecutorRestClient with dedicated
+ * ExecutorServices without a major lift.
+ * If you are writing new code, consider to use BinanceApiAsyncExecutorRestClient directly.
+ */
+public class BinanceApiAsyncRestClientAdapter implements BinanceApiAsyncRestClient {
+    private BinanceApiAsyncExecutorRestClient delegate;
+
+    public BinanceApiAsyncRestClientAdapter(BinanceApiAsyncExecutorRestClient delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public void ping(BinanceApiCallback<Void> callback) {
+        delegate.ping(callback);
+    }
+
+    @Override
+    public void getServerTime(BinanceApiCallback<ServerTime> callback) {
+        delegate.getServerTime(callback);
+    }
+
+    @Override
+    public void getExchangeInfo(BinanceApiCallback<ExchangeInfo> callback) {
+        delegate.getExchangeInfo(callback);
+    }
+
+    @Override
+    public void getAllAssets(BinanceApiCallback<List<Asset>> callback) {
+        delegate.getAllAssets(callback);
+    }
+
+    @Override
+    public void getOrderBook(String symbol, Integer limit, BinanceApiCallback<OrderBook> callback) {
+        delegate.getOrderBook(symbol, limit,callback);
+    }
+
+    @Override
+    public void getTrades(String symbol, Integer limit, BinanceApiCallback<List<TradeHistoryItem>> callback) {
+        delegate.getTrades(symbol, limit,callback);
+    }
+
+    @Override
+    public void getHistoricalTrades(String symbol, Integer limit, Long fromId, BinanceApiCallback<List<TradeHistoryItem>> callback) {
+        delegate.getHistoricalTrades(symbol, limit, fromId,callback);
+    }
+
+    @Override
+    public void getAggTrades(String symbol, String fromId, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<AggTrade>> callback) {
+        delegate.getAggTrades(symbol, fromId,limit, startTime, endTime, callback);
+    }
+
+    @Override
+    public void getAggTrades(String symbol, BinanceApiCallback<List<AggTrade>> callback) {
+        delegate.getAggTrades(symbol, callback);
+    }
+
+    @Override
+    public void getCandlestickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<Candlestick>> callback) {
+        delegate.getCandlestickBars(symbol, interval, limit, startTime, endTime,callback);
+    }
+
+    @Override
+    public void getCandlestickBars(String symbol, CandlestickInterval interval, BinanceApiCallback<List<Candlestick>> callback) {
+        delegate.getCandlestickBars(symbol, interval,callback);
+    }
+
+    @Override
+    public void get24HrPriceStatistics(String symbol, BinanceApiCallback<TickerStatistics> callback) {
+        delegate.get24HrPriceStatistics(symbol,callback);
+    }
+
+    @Override
+    public void getAll24HrPriceStatistics(BinanceApiCallback<List<TickerStatistics>> callback) {
+        delegate.getAll24HrPriceStatistics(callback);
+    }
+
+    @Override
+    public void getAllPrices(BinanceApiCallback<List<TickerPrice>> callback) {
+        delegate.getAllPrices(callback);
+    }
+
+    @Override
+    public void getPrice(String symbol, BinanceApiCallback<TickerPrice> callback) {
+        delegate.getPrice(symbol,callback);
+    }
+
+    @Override
+    public void getBookTickers(BinanceApiCallback<List<BookTicker>> callback) {
+        delegate.getBookTickers(callback);
+    }
+
+    @Override
+    public void newOrder(NewOrder order, BinanceApiCallback<NewOrderResponse> callback) {
+        delegate.newOrder(order,callback);
+    }
+
+    @Override
+    public void newOrderTest(NewOrder order, BinanceApiCallback<Void> callback) {
+        delegate.newOrderTest(order,callback);
+    }
+
+    @Override
+    public void getOrderStatus(OrderStatusRequest orderStatusRequest, BinanceApiCallback<Order> callback) {
+        delegate.getOrderStatus(orderStatusRequest,callback);
+    }
+
+    @Override
+    public void cancelOrder(CancelOrderRequest cancelOrderRequest, BinanceApiCallback<CancelOrderResponse> callback) {
+        delegate.cancelOrder(cancelOrderRequest,callback);
+    }
+
+    @Override
+    public void getOpenOrders(OrderRequest orderRequest, BinanceApiCallback<List<Order>> callback) {
+        delegate.getOpenOrders(orderRequest,callback);
+    }
+
+    @Override
+    public void getAllOrders(AllOrdersRequest orderRequest, BinanceApiCallback<List<Order>> callback) {
+        delegate.getAllOrders(orderRequest,callback);
+    }
+
+    @Override
+    public void getAccount(Long recvWindow, Long timestamp, BinanceApiCallback<Account> callback) {
+        delegate.getAccount(recvWindow,timestamp,callback);
+    }
+
+    @Override
+    public void getAccount(BinanceApiCallback<Account> callback) {
+        delegate.getAccount(callback);
+    }
+
+    @Override
+    public void getMyTrades(String symbol, Integer limit, Long fromId, Long recvWindow, Long timestamp, BinanceApiCallback<List<Trade>> callback) {
+        delegate.getMyTrades(symbol, limit,fromId, recvWindow, timestamp,callback);
+    }
+
+    @Override
+    public void getMyTrades(String symbol, Integer limit, BinanceApiCallback<List<Trade>> callback) {
+        delegate.getMyTrades(symbol, limit,callback);
+    }
+
+    @Override
+    public void getMyTrades(String symbol, BinanceApiCallback<List<Trade>> callback) {
+        delegate.getMyTrades(symbol, callback);
+    }
+
+    @Override
+    public void withdraw(String asset, String address, String amount, String name, String addressTag, BinanceApiCallback<WithdrawResult> callback) {
+        delegate.withdraw(asset, address,amount, name, addressTag,callback);
+    }
+
+    @Override
+    public void getDepositHistory(String asset, BinanceApiCallback<DepositHistory> callback) {
+        delegate.getDepositHistory(asset, callback);
+    }
+
+    @Override
+    public void getWithdrawHistory(String asset, BinanceApiCallback<WithdrawHistory> callback) {
+        delegate.getWithdrawHistory(asset, callback);
+    }
+
+    @Override
+    public void getDepositAddress(String asset, BinanceApiCallback<DepositAddress> callback) {
+        delegate.getDepositAddress(asset, callback);
+    }
+
+    @Override
+    public void startUserDataStream(BinanceApiCallback<ListenKey> callback) {
+        delegate.startUserDataStream(callback);
+    }
+
+    @Override
+    public void keepAliveUserDataStream(String listenKey, BinanceApiCallback<Void> callback) {
+        delegate.keepAliveUserDataStream(listenKey, callback);
+    }
+
+    @Override
+    public void closeUserDataStream(String listenKey, BinanceApiCallback<Void> callback) {
+        delegate.closeUserDataStream(listenKey, callback);
+    }
+}

From d2677160d036a6b34a726e13bb0d453e71281093 Mon Sep 17 00:00:00 2001
From: antlen <antlen@users.noreply.github.com>
Date: Mon, 10 Jan 2022 19:19:22 +0900
Subject: [PATCH 2/7] use CompletableFuture rather than Future

---
 .../BinanceApiAsyncExecutorRestClient.java    | 71 +++++++-------
 ...BinanceApiAsyncExecutorRestClientImpl.java | 94 ++++++++++---------
 2 files changed, 83 insertions(+), 82 deletions(-)

diff --git a/src/main/java/com/binance/api/client/BinanceApiAsyncExecutorRestClient.java b/src/main/java/com/binance/api/client/BinanceApiAsyncExecutorRestClient.java
index dbd23cd1b..ca35f2c51 100755
--- a/src/main/java/com/binance/api/client/BinanceApiAsyncExecutorRestClient.java
+++ b/src/main/java/com/binance/api/client/BinanceApiAsyncExecutorRestClient.java
@@ -7,9 +7,8 @@
 import com.binance.api.client.domain.general.ExchangeInfo;
 import com.binance.api.client.domain.general.ServerTime;
 import com.binance.api.client.domain.market.*;
-
 import java.util.List;
-import java.util.concurrent.Future;
+import java.util.concurrent.CompletableFuture;
 
 /**
  * Binance API facade, supporting asynchronous/non-blocking access Binance's REST API using ExecutorServices to
@@ -23,27 +22,27 @@ public interface BinanceApiAsyncExecutorRestClient {
    * Test connectivity to the Rest API.
    * @return
    */
-  Future<Void> ping(BinanceApiCallback<Void> callback);
+  CompletableFuture<Void> ping(BinanceApiCallback<Void> callback);
 
   /**
    * Check server time.
    * @return
    */
-  Future<ServerTime> getServerTime(BinanceApiCallback<ServerTime> callback);
+  CompletableFuture<ServerTime> getServerTime(BinanceApiCallback<ServerTime> callback);
 
   /**
    * Current exchange trading rules and symbol information
    *
    * @return
    */
-  Future<ExchangeInfo> getExchangeInfo(BinanceApiCallback<ExchangeInfo> callback);
+  CompletableFuture<ExchangeInfo> getExchangeInfo(BinanceApiCallback<ExchangeInfo> callback);
 
   /**
    * ALL supported assets and whether or not they can be withdrawn.
    *
    * @return
    */
-  Future<List<Asset>> getAllAssets(BinanceApiCallback<List<Asset>> callback);
+  CompletableFuture<List<Asset>> getAllAssets(BinanceApiCallback<List<Asset>> callback);
 
   // Market Data endpoints
 
@@ -56,7 +55,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    *
    * @return
    */
-  Future<OrderBook> getOrderBook(String symbol, Integer limit, BinanceApiCallback<OrderBook> callback);
+  CompletableFuture<OrderBook> getOrderBook(String symbol, Integer limit, BinanceApiCallback<OrderBook> callback);
 
   /**
    * Get recent trades (up to last 500). Weight: 1
@@ -67,7 +66,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    *
    * @return
    */
-  Future<List<TradeHistoryItem>> getTrades(String symbol, Integer limit, BinanceApiCallback<List<TradeHistoryItem>> callback);
+  CompletableFuture<List<TradeHistoryItem>> getTrades(String symbol, Integer limit, BinanceApiCallback<List<TradeHistoryItem>> callback);
 
   /**
    * Get older trades. Weight: 5
@@ -79,7 +78,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    *
    * @return
    */
-  Future<List<TradeHistoryItem>> getHistoricalTrades(String symbol, Integer limit, Long fromId, BinanceApiCallback<List<TradeHistoryItem>> callback);
+  CompletableFuture<List<TradeHistoryItem>> getHistoricalTrades(String symbol, Integer limit, Long fromId, BinanceApiCallback<List<TradeHistoryItem>> callback);
 
   /**
    * Get compressed, aggregate trades. Trades that fill at the time, from the same order, with
@@ -96,14 +95,14 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param callback the callback that handles the response
    * @return a list of aggregate trades for the given symbol
    */
-  Future<List<AggTrade>> getAggTrades(String symbol, String fromId, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<AggTrade>> callback);
+  CompletableFuture<List<AggTrade>> getAggTrades(String symbol, String fromId, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<AggTrade>> callback);
 
   /**
    * Return the most recent aggregate trades for <code>symbol</code>
    *
    * @see #getAggTrades(String, String, Integer, Long, Long, BinanceApiCallback)
    */
-  Future<List<AggTrade>> getAggTrades(String symbol, BinanceApiCallback<List<AggTrade>> callback);
+  CompletableFuture<List<AggTrade>> getAggTrades(String symbol, BinanceApiCallback<List<AggTrade>> callback);
 
   /**
    * Kline/candlestick bars for a symbol. Klines are uniquely identified by their open time.
@@ -115,14 +114,14 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param endTime Timestamp in ms to get candlestick bars until INCLUSIVE (optional).
    * @param callback the callback that handles the response containing a candlestick bar for the given symbol and interval
    */
-  Future<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<Candlestick>> callback);
+  CompletableFuture<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<Candlestick>> callback);
 
   /**
    * Kline/candlestick bars for a symbol. Klines are uniquely identified by their open time.
    *
    * @see #getCandlestickBars(String, CandlestickInterval, BinanceApiCallback)
    */
-  Future<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, BinanceApiCallback<List<Candlestick>> callback);
+  CompletableFuture<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, BinanceApiCallback<List<Candlestick>> callback);
 
   /**
    * Get 24 hour price change statistics (asynchronous).
@@ -130,21 +129,21 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param symbol ticker symbol (e.g. ETHBTC)
    * @param callback the callback that handles the response
    */
-  Future<TickerStatistics> get24HrPriceStatistics(String symbol, BinanceApiCallback<TickerStatistics> callback);
+  CompletableFuture<TickerStatistics> get24HrPriceStatistics(String symbol, BinanceApiCallback<TickerStatistics> callback);
   
   /**
    * Get 24 hour price change statistics for all symbols (asynchronous).
    * 
    * @param callback the callback that handles the response
    */
-  Future<List<TickerStatistics>> getAll24HrPriceStatistics(BinanceApiCallback<List<TickerStatistics>> callback);
+  CompletableFuture<List<TickerStatistics>> getAll24HrPriceStatistics(BinanceApiCallback<List<TickerStatistics>> callback);
 
   /**
    * Get Latest price for all symbols (asynchronous).
    *
    * @param callback the callback that handles the response
    */
-  Future<List<TickerPrice>> getAllPrices(BinanceApiCallback<List<TickerPrice>> callback);
+  CompletableFuture<List<TickerPrice>> getAllPrices(BinanceApiCallback<List<TickerPrice>> callback);
   
   /**
    * Get latest price for <code>symbol</code> (asynchronous).
@@ -152,14 +151,14 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param symbol ticker symbol (e.g. ETHBTC)
    * @param callback the callback that handles the response
    */
-  Future<TickerPrice> getPrice(String symbol , BinanceApiCallback<TickerPrice> callback);
+  CompletableFuture<TickerPrice> getPrice(String symbol , BinanceApiCallback<TickerPrice> callback);
 
   /**
    * Get best price/qty on the order book for all symbols (asynchronous).
    *
    * @param callback the callback that handles the response
    */
-  Future<List<BookTicker>> getBookTickers(BinanceApiCallback<List<BookTicker>> callback);
+  CompletableFuture<List<BookTicker>> getBookTickers(BinanceApiCallback<List<BookTicker>> callback);
 
   // Account endpoints
 
@@ -169,7 +168,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param order the new order to submit.
    * @param callback the callback that handles the response
    */
-  Future<NewOrderResponse> newOrder(NewOrder order, BinanceApiCallback<NewOrderResponse> callback);
+  CompletableFuture<NewOrderResponse> newOrder(NewOrder order, BinanceApiCallback<NewOrderResponse> callback);
 
   /**
    * Test new order creation and signature/recvWindow long. Creates and validates a new order but does not send it into the matching engine.
@@ -177,7 +176,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param order the new TEST order to submit.
    * @param callback the callback that handles the response
    */
-  Future<Void> newOrderTest(NewOrder order, BinanceApiCallback<Void> callback);
+  CompletableFuture<Void> newOrderTest(NewOrder order, BinanceApiCallback<Void> callback);
 
   /**
    * Check an order's status (asynchronous).
@@ -185,7 +184,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param orderStatusRequest order status request parameters
    * @param callback the callback that handles the response
    */
-  Future<Order> getOrderStatus(OrderStatusRequest orderStatusRequest, BinanceApiCallback<Order> callback);
+  CompletableFuture<Order> getOrderStatus(OrderStatusRequest orderStatusRequest, BinanceApiCallback<Order> callback);
 
   /**
    * Cancel an active order (asynchronous).
@@ -193,7 +192,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param cancelOrderRequest order status request parameters
    * @param callback the callback that handles the response
    */
-  Future<CancelOrderResponse> cancelOrder(CancelOrderRequest cancelOrderRequest, BinanceApiCallback<CancelOrderResponse> callback);
+  CompletableFuture<CancelOrderResponse> cancelOrder(CancelOrderRequest cancelOrderRequest, BinanceApiCallback<CancelOrderResponse> callback);
 
   /**
    * Get all open orders on a symbol (asynchronous).
@@ -201,7 +200,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param orderRequest order request parameters
    * @param callback the callback that handles the response
    */
-  Future<List<Order>> getOpenOrders(OrderRequest orderRequest, BinanceApiCallback<List<Order>> callback);
+  CompletableFuture<List<Order>> getOpenOrders(OrderRequest orderRequest, BinanceApiCallback<List<Order>> callback);
 
   /**
    * Get all account orders; active, canceled, or filled.
@@ -209,17 +208,17 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param orderRequest order request parameters
    * @param callback the callback that handles the response
    */
-  Future<List<Order>> getAllOrders(AllOrdersRequest orderRequest, BinanceApiCallback<List<Order>> callback);
+  CompletableFuture<List<Order>> getAllOrders(AllOrdersRequest orderRequest, BinanceApiCallback<List<Order>> callback);
 
   /**
    * Get current account information (async).
    */
-  Future<Account> getAccount(Long recvWindow, Long timestamp, BinanceApiCallback<Account> callback);
+  CompletableFuture<Account> getAccount(Long recvWindow, Long timestamp, BinanceApiCallback<Account> callback);
 
   /**
    * Get current account information using default parameters (async).
    */
-  Future<Account> getAccount(BinanceApiCallback<Account> callback);
+  CompletableFuture<Account> getAccount(BinanceApiCallback<Account> callback);
 
   /**
    * Get trades for a specific account and symbol.
@@ -229,7 +228,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param fromId TradeId to fetch from. Default gets most recent trades.
    * @param callback the callback that handles the response with a list of trades
    */
-  Future<List<Trade>> getMyTrades(String symbol, Integer limit, Long fromId, Long recvWindow, Long timestamp, BinanceApiCallback<List<Trade>> callback);
+  CompletableFuture<List<Trade>> getMyTrades(String symbol, Integer limit, Long fromId, Long recvWindow, Long timestamp, BinanceApiCallback<List<Trade>> callback);
 
   /**
    * Get trades for a specific account and symbol.
@@ -238,7 +237,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param limit default 500; max 1000
    * @param callback the callback that handles the response with a list of trades
    */
-  Future<List<Trade>> getMyTrades(String symbol, Integer limit, BinanceApiCallback<List<Trade>> callback);
+  CompletableFuture<List<Trade>> getMyTrades(String symbol, Integer limit, BinanceApiCallback<List<Trade>> callback);
 
   /**
    * Get trades for a specific account and symbol.
@@ -246,7 +245,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param symbol symbol to get trades from
    * @param callback the callback that handles the response with a list of trades
    */
-  Future<List<Trade>> getMyTrades(String symbol, BinanceApiCallback<List<Trade>> callback);
+  CompletableFuture<List<Trade>> getMyTrades(String symbol, BinanceApiCallback<List<Trade>> callback);
 
   /**
    * Submit a withdraw request.
@@ -259,28 +258,28 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param name description/alias of the address
    * @param addressTag Secondary address identifier for coins like XRP,XMR etc.
    */
-  Future<WithdrawResult> withdraw(String asset, String address, String amount, String name, String addressTag, BinanceApiCallback<WithdrawResult> callback);
+  CompletableFuture<WithdrawResult> withdraw(String asset, String address, String amount, String name, String addressTag, BinanceApiCallback<WithdrawResult> callback);
 
   /**
    * Fetch account deposit history.
    *
    * @param callback the callback that handles the response and returns the deposit history
    */
-  Future<DepositHistory> getDepositHistory(String asset, BinanceApiCallback<DepositHistory> callback);
+  CompletableFuture<DepositHistory> getDepositHistory(String asset, BinanceApiCallback<DepositHistory> callback);
 
   /**
    * Fetch account withdraw history.
    *
    * @param callback the callback that handles the response and returns the withdraw history
    */
-  Future<WithdrawHistory> getWithdrawHistory(String asset, BinanceApiCallback<WithdrawHistory> callback);
+  CompletableFuture<WithdrawHistory> getWithdrawHistory(String asset, BinanceApiCallback<WithdrawHistory> callback);
 
   /**
    * Fetch deposit address.
    *
    * @param callback the callback that handles the response and returns the deposit address
    */
-  Future<DepositAddress> getDepositAddress(String asset, BinanceApiCallback<DepositAddress> callback);
+  CompletableFuture<DepositAddress> getDepositAddress(String asset, BinanceApiCallback<DepositAddress> callback);
 
   // User stream endpoints
 
@@ -289,7 +288,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    *
    * @param callback the callback that handles the response which contains a listenKey
    */
-  Future<ListenKey> startUserDataStream(BinanceApiCallback<ListenKey> callback);
+  CompletableFuture<ListenKey> startUserDataStream(BinanceApiCallback<ListenKey> callback);
 
   /**
    * PING a user data stream to prevent a time out.
@@ -297,7 +296,7 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param listenKey listen key that identifies a data stream
    * @param callback the callback that handles the response which contains a listenKey
    */
-  Future<Void> keepAliveUserDataStream(String listenKey, BinanceApiCallback<Void> callback);
+  CompletableFuture<Void> keepAliveUserDataStream(String listenKey, BinanceApiCallback<Void> callback);
 
   /**
    * Close out a new user data stream.
@@ -305,5 +304,5 @@ public interface BinanceApiAsyncExecutorRestClient {
    * @param listenKey listen key that identifies a data stream
    * @param callback the callback that handles the response which contains a listenKey
    */
-  Future<Void> closeUserDataStream(String listenKey, BinanceApiCallback<Void> callback);
+  CompletableFuture<Void> closeUserDataStream(String listenKey, BinanceApiCallback<Void> callback);
 }
\ No newline at end of file
diff --git a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
index da7905e34..d079a41b0 100644
--- a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
+++ b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
@@ -10,10 +10,9 @@
 import com.binance.api.client.domain.general.ExchangeInfo;
 import com.binance.api.client.domain.general.ServerTime;
 import com.binance.api.client.domain.market.*;
-
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Future;
 import java.util.function.Supplier;
 
 /**
@@ -30,21 +29,24 @@ public BinanceApiAsyncExecutorRestClientImpl(BinanceApiRestClient client, Execut
         this.responseService = responseService;
     }
 
-    private <T> Future<T> invoke(BinanceApiCallback<T> callback, Supplier<T> t){
-        return requestService.submit(() -> {
-            try {
-                T v = t.get();
-                responseService.submit(() -> callback.onResponse(v));
+    private <T> CompletableFuture<T> invoke(BinanceApiCallback<T> callback, Supplier<T> t){
+        CompletableFuture<T> f = CompletableFuture.supplyAsync(t, requestService);
+        if(callback != null){
+            f = f.thenApplyAsync(v -> {
+                callback.onResponse(v);
                 return v;
-            }catch (Exception e){
-                responseService.submit(() -> callback.onFailure(e));
-                throw e;
-            }
-        });
+            }, responseService);
+
+            f.exceptionallyAsync(throwable -> {
+                callback.onFailure(throwable);
+                return null;
+            }, responseService);
+        }
+        return f;
     }
 
     @Override
-    public Future<Void> ping(BinanceApiCallback<Void> callback) {
+    public CompletableFuture<Void> ping(BinanceApiCallback<Void> callback) {
         return invoke(callback,() -> {
             client.ping();
             return null;
@@ -52,7 +54,7 @@ public Future<Void> ping(BinanceApiCallback<Void> callback) {
     }
 
     @Override
-    public Future<ServerTime> getServerTime(BinanceApiCallback<ServerTime> callback) {
+    public CompletableFuture<ServerTime> getServerTime(BinanceApiCallback<ServerTime> callback) {
         return invoke(callback, () -> {
             ServerTime t = new ServerTime();
             t.setServerTime(client.getServerTime());
@@ -61,82 +63,82 @@ public Future<ServerTime> getServerTime(BinanceApiCallback<ServerTime> callback)
     }
 
     @Override
-    public Future<ExchangeInfo> getExchangeInfo(BinanceApiCallback<ExchangeInfo> callback) {
+    public CompletableFuture<ExchangeInfo> getExchangeInfo(BinanceApiCallback<ExchangeInfo> callback) {
         return invoke(callback, () -> client.getExchangeInfo());
     }
 
     @Override
-    public Future<List<Asset>> getAllAssets(BinanceApiCallback<List<Asset>> callback) {
+    public CompletableFuture<List<Asset>> getAllAssets(BinanceApiCallback<List<Asset>> callback) {
         return invoke(callback, () -> client.getAllAssets());
     }
 
     @Override
-    public Future<OrderBook> getOrderBook(String symbol, Integer limit, BinanceApiCallback<OrderBook> callback) {
+    public CompletableFuture<OrderBook> getOrderBook(String symbol, Integer limit, BinanceApiCallback<OrderBook> callback) {
         return invoke(callback, () -> client.getOrderBook(symbol,limit));
     }
 
     @Override
-    public Future<List<TradeHistoryItem>> getTrades(String symbol, Integer limit, BinanceApiCallback<List<TradeHistoryItem>> callback) {
+    public CompletableFuture<List<TradeHistoryItem>> getTrades(String symbol, Integer limit, BinanceApiCallback<List<TradeHistoryItem>> callback) {
         return invoke(callback, () -> client.getTrades(symbol, limit));
     }
 
     @Override
-    public Future<List<TradeHistoryItem>> getHistoricalTrades(String symbol, Integer limit, Long fromId, BinanceApiCallback<List<TradeHistoryItem>> callback) {
+    public CompletableFuture<List<TradeHistoryItem>> getHistoricalTrades(String symbol, Integer limit, Long fromId, BinanceApiCallback<List<TradeHistoryItem>> callback) {
         return invoke(callback, () -> client.getHistoricalTrades(symbol, limit, fromId));
     }
 
     @Override
-    public Future<List<AggTrade>> getAggTrades(String symbol, String fromId, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<AggTrade>> callback) {
+    public CompletableFuture<List<AggTrade>> getAggTrades(String symbol, String fromId, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<AggTrade>> callback) {
         return invoke(callback, () -> client.getAggTrades(symbol,fromId,limit,startTime,endTime));
     }
 
     @Override
-    public Future<List<AggTrade>> getAggTrades(String symbol, BinanceApiCallback<List<AggTrade>> callback) {
+    public CompletableFuture<List<AggTrade>> getAggTrades(String symbol, BinanceApiCallback<List<AggTrade>> callback) {
         return invoke(callback, () -> client.getAggTrades(symbol));
     }
 
     @Override
-    public Future<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<Candlestick>> callback) {
+    public CompletableFuture<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, Integer limit, Long startTime, Long endTime, BinanceApiCallback<List<Candlestick>> callback) {
         return invoke(callback, () -> client.getCandlestickBars(symbol,interval,limit,startTime, endTime));
     }
 
     @Override
-    public Future<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, BinanceApiCallback<List<Candlestick>> callback) {
+    public CompletableFuture<List<Candlestick>> getCandlestickBars(String symbol, CandlestickInterval interval, BinanceApiCallback<List<Candlestick>> callback) {
         return invoke(callback, () -> client.getCandlestickBars(symbol, interval));
     }
 
     @Override
-    public Future<TickerStatistics> get24HrPriceStatistics(String symbol, BinanceApiCallback<TickerStatistics> callback) {
+    public CompletableFuture<TickerStatistics> get24HrPriceStatistics(String symbol, BinanceApiCallback<TickerStatistics> callback) {
         return invoke(callback, () -> client.get24HrPriceStatistics(symbol));
     }
 
     @Override
-    public Future<List<TickerStatistics>> getAll24HrPriceStatistics(BinanceApiCallback<List<TickerStatistics>> callback) {
+    public CompletableFuture<List<TickerStatistics>> getAll24HrPriceStatistics(BinanceApiCallback<List<TickerStatistics>> callback) {
         return invoke(callback, () -> client.getAll24HrPriceStatistics());
     }
 
     @Override
-    public Future<List<TickerPrice>> getAllPrices(BinanceApiCallback<List<TickerPrice>> callback) {
+    public CompletableFuture<List<TickerPrice>> getAllPrices(BinanceApiCallback<List<TickerPrice>> callback) {
         return invoke(callback, () -> client.getAllPrices());
     }
 
     @Override
-    public Future<TickerPrice> getPrice(String symbol, BinanceApiCallback<TickerPrice> callback) {
+    public CompletableFuture<TickerPrice> getPrice(String symbol, BinanceApiCallback<TickerPrice> callback) {
         return invoke(callback, () -> client.getPrice(symbol));
     }
 
     @Override
-    public Future<List<BookTicker>> getBookTickers(BinanceApiCallback<List<BookTicker>> callback) {
+    public CompletableFuture<List<BookTicker>> getBookTickers(BinanceApiCallback<List<BookTicker>> callback) {
         return invoke(callback, () -> client.getBookTickers());
     }
 
     @Override
-    public Future<NewOrderResponse> newOrder(NewOrder order, BinanceApiCallback<NewOrderResponse> callback) {
+    public CompletableFuture<NewOrderResponse> newOrder(NewOrder order, BinanceApiCallback<NewOrderResponse> callback) {
         return invoke(callback, () -> client.newOrder(order));
     }
 
     @Override
-    public Future<Void> newOrderTest(NewOrder order, BinanceApiCallback<Void> callback) {
+    public CompletableFuture<Void> newOrderTest(NewOrder order, BinanceApiCallback<Void> callback) {
         return invoke(callback, () -> {
             client.newOrderTest(order);
             return null;
@@ -144,72 +146,72 @@ public Future<Void> newOrderTest(NewOrder order, BinanceApiCallback<Void> callba
     }
 
     @Override
-    public Future<Order> getOrderStatus(OrderStatusRequest orderStatusRequest, BinanceApiCallback<Order> callback) {
+    public CompletableFuture<Order> getOrderStatus(OrderStatusRequest orderStatusRequest, BinanceApiCallback<Order> callback) {
         return invoke(callback, () -> client.getOrderStatus(orderStatusRequest));
     }
 
     @Override
-    public Future<CancelOrderResponse> cancelOrder(CancelOrderRequest cancelOrderRequest, BinanceApiCallback<CancelOrderResponse> callback) {
+    public CompletableFuture<CancelOrderResponse> cancelOrder(CancelOrderRequest cancelOrderRequest, BinanceApiCallback<CancelOrderResponse> callback) {
         return invoke(callback, () -> client.cancelOrder(cancelOrderRequest));
     }
 
     @Override
-    public Future<List<Order>> getOpenOrders(OrderRequest orderRequest, BinanceApiCallback<List<Order>> callback) {
+    public CompletableFuture<List<Order>> getOpenOrders(OrderRequest orderRequest, BinanceApiCallback<List<Order>> callback) {
         return invoke(callback, () -> client.getOpenOrders(orderRequest));
     }
 
     @Override
-    public Future<List<Order>> getAllOrders(AllOrdersRequest orderRequest, BinanceApiCallback<List<Order>> callback) {
+    public CompletableFuture<List<Order>> getAllOrders(AllOrdersRequest orderRequest, BinanceApiCallback<List<Order>> callback) {
         return invoke(callback, () -> client.getAllOrders(orderRequest));
     }
 
     @Override
-    public Future<Account> getAccount(Long recvWindow, Long timestamp, BinanceApiCallback<Account> callback) {
+    public CompletableFuture<Account> getAccount(Long recvWindow, Long timestamp, BinanceApiCallback<Account> callback) {
         return invoke(callback, () -> client.getAccount(recvWindow, timestamp));
     }
 
     @Override
-    public Future<Account> getAccount(BinanceApiCallback<Account> callback) {
+    public CompletableFuture<Account> getAccount(BinanceApiCallback<Account> callback) {
         return invoke(callback, () -> client.getAccount());
     }
 
     @Override
-    public Future<List<Trade>> getMyTrades(String symbol, Integer limit, Long fromId, Long recvWindow, Long timestamp, BinanceApiCallback<List<Trade>> callback) {
+    public CompletableFuture<List<Trade>> getMyTrades(String symbol, Integer limit, Long fromId, Long recvWindow, Long timestamp, BinanceApiCallback<List<Trade>> callback) {
         return invoke(callback, () -> client.getMyTrades(symbol, limit, fromId, recvWindow, timestamp));
     }
 
     @Override
-    public Future<List<Trade>> getMyTrades(String symbol, Integer limit, BinanceApiCallback<List<Trade>> callback) {
+    public CompletableFuture<List<Trade>> getMyTrades(String symbol, Integer limit, BinanceApiCallback<List<Trade>> callback) {
         return invoke(callback, () -> client.getMyTrades(symbol, limit));
     }
 
     @Override
-    public Future<List<Trade>> getMyTrades(String symbol, BinanceApiCallback<List<Trade>> callback) {
+    public CompletableFuture<List<Trade>> getMyTrades(String symbol, BinanceApiCallback<List<Trade>> callback) {
         return invoke(callback, () -> client.getMyTrades(symbol));
     }
 
     @Override
-    public Future<WithdrawResult> withdraw(String asset, String address, String amount, String name, String addressTag, BinanceApiCallback<WithdrawResult> callback) {
+    public CompletableFuture<WithdrawResult> withdraw(String asset, String address, String amount, String name, String addressTag, BinanceApiCallback<WithdrawResult> callback) {
         return invoke(callback, () -> client.withdraw(asset, address, amount, name, addressTag));
     }
 
     @Override
-    public Future<DepositHistory> getDepositHistory(String asset, BinanceApiCallback<DepositHistory> callback) {
+    public CompletableFuture<DepositHistory> getDepositHistory(String asset, BinanceApiCallback<DepositHistory> callback) {
         return invoke(callback, () -> client.getDepositHistory(asset));
     }
 
     @Override
-    public Future<WithdrawHistory> getWithdrawHistory(String asset, BinanceApiCallback<WithdrawHistory> callback) {
+    public CompletableFuture<WithdrawHistory> getWithdrawHistory(String asset, BinanceApiCallback<WithdrawHistory> callback) {
         return invoke(callback, () -> client.getWithdrawHistory(asset));
     }
 
     @Override
-    public Future<DepositAddress> getDepositAddress(String asset, BinanceApiCallback<DepositAddress> callback) {
+    public CompletableFuture<DepositAddress> getDepositAddress(String asset, BinanceApiCallback<DepositAddress> callback) {
         return invoke(callback, () -> client.getDepositAddress(asset));
     }
 
     @Override
-    public Future<ListenKey> startUserDataStream(BinanceApiCallback<ListenKey> callback) {
+    public CompletableFuture<ListenKey> startUserDataStream(BinanceApiCallback<ListenKey> callback) {
         return invoke(callback, () -> {
             client.startUserDataStream();
             return null;
@@ -217,7 +219,7 @@ public Future<ListenKey> startUserDataStream(BinanceApiCallback<ListenKey> callb
     }
 
     @Override
-    public Future<Void> keepAliveUserDataStream(String listenKey, BinanceApiCallback<Void> callback) {
+    public CompletableFuture<Void> keepAliveUserDataStream(String listenKey, BinanceApiCallback<Void> callback) {
         return invoke(callback, () -> {
             client.keepAliveUserDataStream(listenKey);
             return null;
@@ -225,7 +227,7 @@ public Future<Void> keepAliveUserDataStream(String listenKey, BinanceApiCallback
     }
 
     @Override
-    public Future<Void> closeUserDataStream(String listenKey, BinanceApiCallback<Void> callback) {
+    public CompletableFuture<Void> closeUserDataStream(String listenKey, BinanceApiCallback<Void> callback) {
         return invoke(callback, () -> {
             client.closeUserDataStream(listenKey);
             return null;

From 013430befad66e8c780c60b91693b6141326c754 Mon Sep 17 00:00:00 2001
From: antlen <antlen@users.noreply.github.com>
Date: Mon, 10 Jan 2022 20:37:01 +0900
Subject: [PATCH 3/7] manually put on the reponse service

---
 .../client/impl/BinanceApiAsyncExecutorRestClientImpl.java  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
index d079a41b0..9abbeda8b 100644
--- a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
+++ b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
@@ -37,10 +37,10 @@ private <T> CompletableFuture<T> invoke(BinanceApiCallback<T> callback, Supplier
                 return v;
             }, responseService);
 
-            f.exceptionallyAsync(throwable -> {
-                callback.onFailure(throwable);
+            f.exceptionally(throwable -> {
+                responseService.submit(()->callback.onFailure(throwable));
                 return null;
-            }, responseService);
+            });
         }
         return f;
     }

From 92aafa3064dc6bb4b6287a1a0f7f82d3e06240f0 Mon Sep 17 00:00:00 2001
From: antlen <antlen@users.noreply.github.com>
Date: Sun, 15 May 2022 10:20:42 +0900
Subject: [PATCH 4/7] my binance changes

---
 pom.xml                                                     | 6 +++---
 .../com/binance/api/client/domain/general/FilterType.java   | 1 +
 .../client/impl/BinanceApiAsyncExecutorRestClientImpl.java  | 2 ++
 .../api/client/impl/BinanceApiWebSocketClientImpl.java      | 6 ++++--
 4 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index 67e7af532..e6b62a87e 100755
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
   <groupId>com.binance.api</groupId>
   <artifactId>binance-api-client</artifactId>
-  <version>1.0.1</version>
+  <version>1.0.1-el</version>
   <licenses>
     <license>
       <name>The MIT License</name>
@@ -53,8 +53,8 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <configuration>
-          <source>1.8</source>
-          <target>1.8</target>
+          <source>14</source>
+          <target>14</target>
         </configuration>
       </plugin>
     </plugins>
diff --git a/src/main/java/com/binance/api/client/domain/general/FilterType.java b/src/main/java/com/binance/api/client/domain/general/FilterType.java
index 57c2931db..beda8d142 100755
--- a/src/main/java/com/binance/api/client/domain/general/FilterType.java
+++ b/src/main/java/com/binance/api/client/domain/general/FilterType.java
@@ -19,6 +19,7 @@ public enum FilterType {
   MARKET_LOT_SIZE,
   MAX_NUM_ICEBERG_ORDERS,
   MAX_POSITION,
+  TRAILING_DELTA,
 
   // Exchange
   EXCHANGE_MAX_NUM_ORDERS,
diff --git a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
index 9abbeda8b..180d8fbf5 100644
--- a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
+++ b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
@@ -19,6 +19,7 @@
  * Implementation of BinanceApiAsyncExecutorRestClient using ExecutorServices for handling request and responses.
  */
 public class BinanceApiAsyncExecutorRestClientImpl implements BinanceApiAsyncExecutorRestClient {
+
     private final BinanceApiRestClient client;
     private final ExecutorService requestService;
     private final ExecutorService responseService;
@@ -38,6 +39,7 @@ private <T> CompletableFuture<T> invoke(BinanceApiCallback<T> callback, Supplier
             }, responseService);
 
             f.exceptionally(throwable -> {
+                throwable.printStackTrace();
                 responseService.submit(()->callback.onFailure(throwable));
                 return null;
             });
diff --git a/src/main/java/com/binance/api/client/impl/BinanceApiWebSocketClientImpl.java b/src/main/java/com/binance/api/client/impl/BinanceApiWebSocketClientImpl.java
index 4d68fb436..c7509d5da 100755
--- a/src/main/java/com/binance/api/client/impl/BinanceApiWebSocketClientImpl.java
+++ b/src/main/java/com/binance/api/client/impl/BinanceApiWebSocketClientImpl.java
@@ -30,7 +30,8 @@ public BinanceApiWebSocketClientImpl(OkHttpClient client) {
     public Closeable onDepthEvent(String symbols, BinanceApiCallback<DepthEvent> callback) {
         final String channel = Arrays.stream(symbols.split(","))
                 .map(String::trim)
-                .map(s -> String.format("%s@depth", s))
+                   .map(s -> String.format("%s@depth@100ms", s))
+                //.map(s -> String.format("%s@depth", s))
                 .collect(Collectors.joining("/"));
         return createNewWebSocket(channel, new BinanceApiWebSocketListener<>(callback, DepthEvent.class));
     }
@@ -75,7 +76,8 @@ public Closeable onAllMarketTickersEvent(BinanceApiCallback<List<TickerEvent>> c
     public Closeable onBookTickerEvent(String symbols, BinanceApiCallback<BookTickerEvent> callback) {
         final String channel = Arrays.stream(symbols.split(","))
                 .map(String::trim)
-                .map(s -> String.format("%s@bookTicker", s))
+                .map(s -> String.format("%s@bookTicker@100ms", s))
+              //  .map(s -> String.format("%s@bookTicker", s))
                 .collect(Collectors.joining("/"));
         return createNewWebSocket(channel, new BinanceApiWebSocketListener<>(callback, BookTickerEvent.class));
     }

From 88029e15b229ca7b63e3ebaad09c3aea6a5887cd Mon Sep 17 00:00:00 2001
From: antlen <antlen@users.noreply.github.com>
Date: Fri, 29 Jul 2022 17:41:48 +0900
Subject: [PATCH 5/7] small changes

---
 .../com/binance/api/client/domain/event/UserDataUpdateEvent.java | 1 +
 .../api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java   | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/com/binance/api/client/domain/event/UserDataUpdateEvent.java b/src/main/java/com/binance/api/client/domain/event/UserDataUpdateEvent.java
index 062565790..fd41dbad4 100755
--- a/src/main/java/com/binance/api/client/domain/event/UserDataUpdateEvent.java
+++ b/src/main/java/com/binance/api/client/domain/event/UserDataUpdateEvent.java
@@ -123,4 +123,5 @@ public static UserDataUpdateEventType fromEventTypeId(String eventTypeId) {
       throw new UnsupportedEventException("Unrecognized user data update event type id: " + eventTypeId);
     }
   }
+
 }
diff --git a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
index 180d8fbf5..0fbe95d56 100644
--- a/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
+++ b/src/main/java/com/binance/api/client/impl/BinanceApiAsyncExecutorRestClientImpl.java
@@ -39,7 +39,6 @@ private <T> CompletableFuture<T> invoke(BinanceApiCallback<T> callback, Supplier
             }, responseService);
 
             f.exceptionally(throwable -> {
-                throwable.printStackTrace();
                 responseService.submit(()->callback.onFailure(throwable));
                 return null;
             });

From 2a159e359ff920544646850fe552a3864cbc0ae7 Mon Sep 17 00:00:00 2001
From: antlen <antlen@users.noreply.github.com>
Date: Wed, 10 Aug 2022 18:21:53 +0900
Subject: [PATCH 6/7] new enum value

---
 .../java/com/binance/api/client/domain/general/FilterType.java   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/java/com/binance/api/client/domain/general/FilterType.java b/src/main/java/com/binance/api/client/domain/general/FilterType.java
index beda8d142..a15416982 100755
--- a/src/main/java/com/binance/api/client/domain/general/FilterType.java
+++ b/src/main/java/com/binance/api/client/domain/general/FilterType.java
@@ -20,6 +20,7 @@ public enum FilterType {
   MAX_NUM_ICEBERG_ORDERS,
   MAX_POSITION,
   TRAILING_DELTA,
+  PERCENT_PRICE_BY_SIDE,
 
   // Exchange
   EXCHANGE_MAX_NUM_ORDERS,

From 50538d3fee2490fd0eb02f36f7a7b767a3c34d33 Mon Sep 17 00:00:00 2001
From: antlen <antlen@users.noreply.github.com>
Date: Tue, 22 Aug 2023 17:59:11 +0900
Subject: [PATCH 7/7] new event type

---
 .../com/binance/api/client/domain/general/FilterType.java     | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/binance/api/client/domain/general/FilterType.java b/src/main/java/com/binance/api/client/domain/general/FilterType.java
index a15416982..8e960f5c5 100755
--- a/src/main/java/com/binance/api/client/domain/general/FilterType.java
+++ b/src/main/java/com/binance/api/client/domain/general/FilterType.java
@@ -24,5 +24,7 @@ public enum FilterType {
 
   // Exchange
   EXCHANGE_MAX_NUM_ORDERS,
-  EXCHANGE_MAX_ALGO_ORDERS
+  EXCHANGE_MAX_ALGO_ORDERS,
+
+  NOTIONAL
 }
\ No newline at end of file