ccxt 4.0.72__py2.py3-none-any.whl → 4.0.73__py2.py3-none-any.whl

ccxt/async_support/okx.py

@@ -101,6 +101,7 @@ class okx(Exchange, ImplicitAPI):
                 'fetchMarketLeverageTiers': True,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': True,
+                'fetchMySettlementHistory': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.0.72'
+__version__ = '4.0.73'
 
 # -----------------------------------------------------------------------------
 
@@ -1923,7 +1923,7 @@ class Exchange(object):
         raise NotSupported(self.id + ' parseWsOrderTrade() is not supported yet')
 
     def parse_ws_ohlcv(self, ohlcv, market=None):
-        raise NotSupported(self.id + ' parseWsOHLCV() is not supported yet')
+        return self.parse_ohlcv(ohlcv, market)
 
     def fetch_funding_rates(self, symbols: Optional[List[str]] = None, params={}):
         raise NotSupported(self.id + ' fetchFundingRates() is not supported yet')
@@ -4147,6 +4147,12 @@ class Exchange(object):
         market = self.market(firstMarket)
         return market
 
+    def parse_ws_ohlcvs(self, ohlcvs: List[object], market: Optional[Any] = None, timeframe: str = '1m', since: Optional[int] = None, limit: Optional[int] = None):
+        results = []
+        for i in range(0, len(ohlcvs)):
+            results.append(self.parse_ws_ohlcv(ohlcvs[i], market))
+        return results
+
     def fetch_transactions(self, code: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
         """
          * @deprecated

ccxt/binance.py

@@ -102,6 +102,7 @@ class binance(Exchange, ImplicitAPI):
                 'fetchMarketLeverageTiers': 'emulated',
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': True,
+                'fetchMySettlementHistory': True,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,
@@ -7175,7 +7176,57 @@ class binance(Exchange, ImplicitAPI):
         sorted = self.sort_by(settlements, 'timestamp')
         return self.filter_by_symbol_since_limit(sorted, symbol, since, limit)
 
+    def fetch_my_settlement_history(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
+        """
+        fetches historical settlement records of the user
+        see https://binance-docs.github.io/apidocs/voptions/en/#user-exercise-record-user_data
+        :param str symbol: unified market symbol of the settlement history
+        :param int [since]: timestamp in ms
+        :param int [limit]: number of records
+        :param dict [params]: exchange specific params
+        :returns dict[]: a list of [settlement history objects]
+        """
+        self.load_markets()
+        market = None if (symbol is None) else self.market(symbol)
+        type = None
+        type, params = self.handle_market_type_and_params('fetchMySettlementHistory', market, params)
+        if type != 'option':
+            raise NotSupported(self.id + ' fetchMySettlementHistory() supports option markets only')
+        request = {}
+        if symbol is not None:
+            request['symbol'] = market['id']
+        if since is not None:
+            request['startTime'] = since
+        if limit is not None:
+            request['limit'] = limit
+        response = self.eapiPrivateGetExerciseRecord(self.extend(request, params))
+        #
+        #     [
+        #         {
+        #             "id": "1125899906842897036",
+        #             "currency": "USDT",
+        #             "symbol": "BTC-230728-30000-C",
+        #             "exercisePrice": "30000.00000000",
+        #             "markPrice": "29160.71284993",
+        #             "quantity": "1.00000000",
+        #             "amount": "0.00000000",
+        #             "fee": "0.00000000",
+        #             "createDate": 1690531200000,
+        #             "priceScale": 0,
+        #             "quantityScale": 2,
+        #             "optionSide": "CALL",
+        #             "positionSide": "LONG",
+        #             "quoteAsset": "USDT"
+        #         }
+        #     ]
+        #
+        settlements = self.parse_settlements(response, market)
+        sorted = self.sort_by(settlements, 'timestamp')
+        return self.filter_by_symbol_since_limit(sorted, market['symbol'], since, limit)
+
     def parse_settlement(self, settlement, market):
+        #
+        # fetchSettlementHistory
         #
         #     {
         #         "symbol": "ETH-230223-1900-P",
@@ -7185,17 +7236,38 @@ class binance(Exchange, ImplicitAPI):
         #         "strikeResult": "REALISTIC_VALUE_STRICKEN"
         #     }
         #
-        timestamp = self.safe_integer(settlement, 'expiryDate')
+        # fetchMySettlementHistory
+        #
+        #     {
+        #         "id": "1125899906842897036",
+        #         "currency": "USDT",
+        #         "symbol": "BTC-230728-30000-C",
+        #         "exercisePrice": "30000.00000000",
+        #         "markPrice": "29160.71284993",
+        #         "quantity": "1.00000000",
+        #         "amount": "0.00000000",
+        #         "fee": "0.00000000",
+        #         "createDate": 1690531200000,
+        #         "priceScale": 0,
+        #         "quantityScale": 2,
+        #         "optionSide": "CALL",
+        #         "positionSide": "LONG",
+        #         "quoteAsset": "USDT"
+        #     }
+        #
+        timestamp = self.safe_integer_2(settlement, 'expiryDate', 'createDate')
         marketId = self.safe_string(settlement, 'symbol')
         return {
             'info': settlement,
             'symbol': self.safe_symbol(marketId, market),
-            'price': self.safe_number(settlement, 'realStrikePrice'),
+            'price': self.safe_number_2(settlement, 'realStrikePrice', 'exercisePrice'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
         }
 
     def parse_settlements(self, settlements, market):
+        #
+        # fetchSettlementHistory
         #
         #     [
         #         {
@@ -7207,6 +7279,27 @@ class binance(Exchange, ImplicitAPI):
         #         }
         #     ]
         #
+        # fetchMySettlementHistory
+        #
+        #     [
+        #         {
+        #             "id": "1125899906842897036",
+        #             "currency": "USDT",
+        #             "symbol": "BTC-230728-30000-C",
+        #             "exercisePrice": "30000.00000000",
+        #             "markPrice": "29160.71284993",
+        #             "quantity": "1.00000000",
+        #             "amount": "0.00000000",
+        #             "fee": "0.00000000",
+        #             "createDate": 1690531200000,
+        #             "priceScale": 0,
+        #             "quantityScale": 2,
+        #             "optionSide": "CALL",
+        #             "positionSide": "LONG",
+        #             "quoteAsset": "USDT"
+        #         }
+        #     ]
+        #
         result = []
         for i in range(0, len(settlements)):
             result.append(self.parse_settlement(settlements[i], market))

ccxt/bybit.py

@@ -80,6 +80,7 @@ class bybit(Exchange, ImplicitAPI):
                 'fetchMarketLeverageTiers': True,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': True,
+                'fetchMySettlementHistory': True,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,
@@ -8308,7 +8309,68 @@ class bybit(Exchange, ImplicitAPI):
         sorted = self.sort_by(settlements, 'timestamp')
         return self.filter_by_symbol_since_limit(sorted, market['symbol'], since, limit)
 
+    def fetch_my_settlement_history(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
+        """
+        fetches historical settlement records of the user
+        see https://bybit-exchange.github.io/docs/v5/asset/delivery
+        :param str symbol: unified market symbol of the settlement history
+        :param int [since]: timestamp in ms
+        :param int [limit]: number of records
+        :param dict [params]: exchange specific params
+        :returns dict[]: a list of [settlement history objects]
+        """
+        self.load_markets()
+        request = {}
+        market = None
+        if symbol is not None:
+            market = self.market(symbol)
+            request['symbol'] = market['id']
+        type = None
+        type, params = self.handle_market_type_and_params('fetchMySettlementHistory', market, params)
+        if type == 'option':
+            request['category'] = 'option'
+        else:
+            subType = None
+            subType, params = self.handle_sub_type_and_params('fetchMySettlementHistory', market, params, 'linear')
+            if subType == 'inverse':
+                raise NotSupported(self.id + ' fetchMySettlementHistory() doesn\'t support inverse markets')
+            request['category'] = 'linear'
+        if limit is not None:
+            request['limit'] = limit
+        response = self.privateGetV5AssetDeliveryRecord(self.extend(request, params))
+        #
+        #     {
+        #         "retCode": 0,
+        #         "retMsg": "success",
+        #         "result": {
+        #             "category": "option",
+        #             "nextPageCursor": "0%2C3",
+        #             "list": [
+        #                 {
+        #                     "symbol": "SOL-27JUN23-20-C",
+        #                     "deliveryPrice": "16.62258889",
+        #                     "deliveryTime": "1687852800000",
+        #                     "side": "Buy",
+        #                     "strike": "20",
+        #                     "fee": "0.00000000",
+        #                     "position": "0.01",
+        #                     "deliveryRpl": "3.5"
+        #                 },
+        #             ]
+        #         },
+        #         "retExtInfo": {},
+        #         "time": 1689043527231
+        #     }
+        #
+        result = self.safe_value(response, 'result', {})
+        data = self.safe_value(result, 'list', [])
+        settlements = self.parse_settlements(data, market)
+        sorted = self.sort_by(settlements, 'timestamp')
+        return self.filter_by_symbol_since_limit(sorted, market['symbol'], since, limit)
+
     def parse_settlement(self, settlement, market):
+        #
+        # fetchSettlementHistory
         #
         #     {
         #         "symbol": "SOL-27JUN23-20-C",
@@ -8316,6 +8378,19 @@ class bybit(Exchange, ImplicitAPI):
         #         "deliveryTime": "1687852800000"
         #     }
         #
+        # fetchMySettlementHistory
+        #
+        #     {
+        #         "symbol": "SOL-27JUN23-20-C",
+        #         "deliveryPrice": "16.62258889",
+        #         "deliveryTime": "1687852800000",
+        #         "side": "Buy",
+        #         "strike": "20",
+        #         "fee": "0.00000000",
+        #         "position": "0.01",
+        #         "deliveryRpl": "3.5"
+        #     }
+        #
         timestamp = self.safe_integer(settlement, 'deliveryTime')
         marketId = self.safe_string(settlement, 'symbol')
         return {
@@ -8327,6 +8402,8 @@ class bybit(Exchange, ImplicitAPI):
         }
 
     def parse_settlements(self, settlements, market):
+        #
+        # fetchSettlementHistory
         #
         #     [
         #         {
@@ -8336,6 +8413,21 @@ class bybit(Exchange, ImplicitAPI):
         #         }
         #     ]
         #
+        # fetchMySettlementHistory
+        #
+        #     [
+        #         {
+        #             "symbol": "SOL-27JUN23-20-C",
+        #             "deliveryPrice": "16.62258889",
+        #             "deliveryTime": "1687852800000",
+        #             "side": "Buy",
+        #             "strike": "20",
+        #             "fee": "0.00000000",
+        #             "position": "0.01",
+        #             "deliveryRpl": "3.5"
+        #         }
+        #     ]
+        #
         result = []
         for i in range(0, len(settlements)):
             result.append(self.parse_settlement(settlements[i], market))

ccxt/cryptocom.py

@@ -78,6 +78,7 @@ class cryptocom(Exchange, ImplicitAPI):
                 'fetchMarketLeverageTiers': False,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': False,
+                'fetchMySettlementHistory': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenOrders': True,

ccxt/delta.py

@@ -63,6 +63,7 @@ class delta(Exchange, ImplicitAPI):
                 'fetchMarketLeverageTiers': False,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': True,
+                'fetchMySettlementHistory': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenInterest': True,

ccxt/deribit.py

@@ -76,6 +76,7 @@ class deribit(Exchange, ImplicitAPI):
                 'fetchMarginMode': False,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': False,
+                'fetchMySettlementHistory': False,
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenOrders': True,

ccxt/gate.py

@@ -129,6 +129,7 @@ class gate(Exchange, ImplicitAPI):
                 'fetchMarketLeverageTiers': 'emulated',
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': True,
+                'fetchMySettlementHistory': True,
                 'fetchMyTrades': True,
                 'fetchNetworkDepositAddress': True,
                 'fetchOHLCV': True,
@@ -833,6 +834,97 @@ class gate(Exchange, ImplicitAPI):
         super(gate, self).set_sandbox_mode(enable)
         self.options['sandboxMode'] = enable
 
+    def convert_expire_date(self, date):
+        # parse YYMMDD to timestamp
+        year = date[0:2]
+        month = date[2:4]
+        day = date[4:6]
+        reconstructedDate = '20' + year + '-' + month + '-' + day + 'T00:00:00Z'
+        return reconstructedDate
+
+    def create_expired_option_market(self, symbol):
+        # support expired option contracts
+        quote = 'USDT'
+        settle = quote
+        optionParts = symbol.split('-')
+        symbolBase = symbol.split('/')
+        marketIdBase = symbol.split('_')
+        base = None
+        expiry = self.safe_string(optionParts, 1)
+        if symbol.find('/') > -1:
+            base = self.safe_string(symbolBase, 0)
+        else:
+            base = self.safe_string(marketIdBase, 0)
+            expiry = expiry[2:8]  # convert 20230728 to 230728
+        strike = self.safe_string(optionParts, 2)
+        optionType = self.safe_string(optionParts, 3)
+        datetime = self.convert_expire_date(expiry)
+        timestamp = self.parse8601(datetime)
+        return {
+            'id': base + '_' + quote + '-' + '20' + expiry + '-' + strike + '-' + optionType,
+            'symbol': base + '/' + quote + ':' + settle + '-' + expiry + '-' + strike + '-' + optionType,
+            'base': base,
+            'quote': quote,
+            'settle': settle,
+            'baseId': base,
+            'quoteId': quote,
+            'settleId': settle,
+            'active': False,
+            'type': 'option',
+            'linear': None,
+            'inverse': None,
+            'spot': False,
+            'swap': False,
+            'future': False,
+            'option': True,
+            'margin': False,
+            'contract': True,
+            'contractSize': self.parse_number('1'),
+            'expiry': timestamp,
+            'expiryDatetime': datetime,
+            'optionType': 'call' if (optionType == 'C') else 'put',
+            'strike': self.parse_number(strike),
+            'precision': {
+                'amount': self.parse_number('1'),
+                'price': None,
+            },
+            'limits': {
+                'amount': {
+                    'min': None,
+                    'max': None,
+                },
+                'price': {
+                    'min': None,
+                    'max': None,
+                },
+                'cost': {
+                    'min': None,
+                    'max': None,
+                },
+            },
+            'info': None,
+        }
+
+    def market(self, symbol):
+        if self.markets is None:
+            raise ExchangeError(self.id + ' markets not loaded')
+        if isinstance(symbol, str):
+            if symbol in self.markets:
+                return self.markets[symbol]
+            elif symbol in self.markets_by_id:
+                markets = self.markets_by_id[symbol]
+                return markets[0]
+            elif (symbol.find('-C') > -1) or (symbol.find('-P') > -1):
+                return self.create_expired_option_market(symbol)
+        raise BadSymbol(self.id + ' does not have market symbol ' + symbol)
+
+    def safe_market(self, marketId=None, market=None, delimiter=None, marketType=None):
+        isOption = (marketId is not None) and ((marketId.find('-C') > -1) or (marketId.find('-P') > -1))
+        if isOption and not (marketId in self.markets_by_id):
+            # handle expired option contracts
+            return self.create_expired_option_market(marketId)
+        return super(gate, self).safe_market(marketId, market, delimiter, marketType)
+
     def fetch_markets(self, params={}):
         """
         retrieves data on all markets for gate
@@ -5400,7 +5492,58 @@ class gate(Exchange, ImplicitAPI):
         sorted = self.sort_by(settlements, 'timestamp')
         return self.filter_by_symbol_since_limit(sorted, symbol, since, limit)
 
+    def fetch_my_settlement_history(self, symbol: Optional[str] = None, since: Optional[int] = None, limit: Optional[int] = None, params={}):
+        """
+        fetches historical settlement records of the user
+        see https://www.gate.io/docs/developers/apiv4/en/#list-my-options-settlements
+        :param str symbol: unified market symbol of the settlement history
+        :param int [since]: timestamp in ms
+        :param int [limit]: number of records
+        :param dict [params]: exchange specific params
+        :returns dict[]: a list of [settlement history objects]
+        """
+        self.check_required_symbol('fetchMySettlementHistory', symbol)
+        self.load_markets()
+        market = self.market(symbol)
+        type = None
+        type, params = self.handle_market_type_and_params('fetchMySettlementHistory', market, params)
+        if type != 'option':
+            raise NotSupported(self.id + ' fetchMySettlementHistory() supports option markets only')
+        marketId = market['id']
+        optionParts = marketId.split('-')
+        request = {
+            'underlying': self.safe_string(optionParts, 0),
+            'contract': marketId,
+        }
+        if since is not None:
+            request['from'] = since
+        if limit is not None:
+            request['limit'] = limit
+        response = self.privateOptionsGetMySettlements(self.extend(request, params))
+        #
+        #     [
+        #         {
+        #             "size": -1,
+        #             "settle_profit": "0",
+        #             "contract": "BTC_USDT-20220624-26000-C",
+        #             "strike_price": "26000",
+        #             "time": 1656057600,
+        #             "settle_price": "20917.461281337048",
+        #             "underlying": "BTC_USDT",
+        #             "realised_pnl": "-0.00116042",
+        #             "fee": "0"
+        #         }
+        #     ]
+        #
+        result = self.safe_value(response, 'result', {})
+        data = self.safe_value(result, 'list', [])
+        settlements = self.parse_settlements(data, market)
+        sorted = self.sort_by(settlements, 'timestamp')
+        return self.filter_by_symbol_since_limit(sorted, market['symbol'], since, limit)
+
     def parse_settlement(self, settlement, market):
+        #
+        # fetchSettlementHistory
         #
         #     {
         #         "time": 1685952000,
@@ -5411,6 +5554,20 @@ class gate(Exchange, ImplicitAPI):
         #         "strike_price": "25000"
         #     }
         #
+        # fetchMySettlementHistory
+        #
+        #     {
+        #         "size": -1,
+        #         "settle_profit": "0",
+        #         "contract": "BTC_USDT-20220624-26000-C",
+        #         "strike_price": "26000",
+        #         "time": 1656057600,
+        #         "settle_price": "20917.461281337048",
+        #         "underlying": "BTC_USDT",
+        #         "realised_pnl": "-0.00116042",
+        #         "fee": "0"
+        #     }
+        #
         timestamp = self.safe_timestamp(settlement, 'time')
         marketId = self.safe_string(settlement, 'contract')
         return {
@@ -5422,6 +5579,8 @@ class gate(Exchange, ImplicitAPI):
         }
 
     def parse_settlements(self, settlements, market):
+        #
+        # fetchSettlementHistory
         #
         #     [
         #         {
@@ -5434,6 +5593,22 @@ class gate(Exchange, ImplicitAPI):
         #         }
         #     ]
         #
+        # fetchMySettlementHistory
+        #
+        #     [
+        #         {
+        #             "size": -1,
+        #             "settle_profit": "0",
+        #             "contract": "BTC_USDT-20220624-26000-C",
+        #             "strike_price": "26000",
+        #             "time": 1656057600,
+        #             "settle_price": "20917.461281337048",
+        #             "underlying": "BTC_USDT",
+        #             "realised_pnl": "-0.00116042",
+        #             "fee": "0"
+        #         }
+        #     ]
+        #
         result = []
         for i in range(0, len(settlements)):
             result.append(self.parse_settlement(settlements[i], market))