ccxt 4.4.67__py2.py3-none-any.whl → 4.4.69__py2.py3-none-any.whl

ccxt/async_support/luno.py

@@ -5,7 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.luno import ImplicitAPI
-from ccxt.base.types import Account, Any, Balances, Currency, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface
+from ccxt.base.types import Account, Any, Balances, Currency, DepositAddress, Int, LedgerEntry, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
@@ -35,6 +35,7 @@ class luno(Exchange, ImplicitAPI):
                 'cancelOrder': True,
                 'closeAllPositions': False,
                 'closePosition': False,
+                'createDepositAddress': True,
                 'createOrder': True,
                 'createReduceOnlyOrder': False,
                 'fetchAccounts': True,
@@ -43,6 +44,7 @@ class luno(Exchange, ImplicitAPI):
                 'fetchClosedOrders': True,
                 'fetchCrossBorrowRate': False,
                 'fetchCrossBorrowRates': False,
+                'fetchDepositAddress': True,
                 'fetchFundingHistory': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
@@ -1158,6 +1160,116 @@ class luno(Exchange, ImplicitAPI):
             'fee': None,
         }, currency)
 
+    async def create_deposit_address(self, code: str, params={}) -> DepositAddress:
+        """
+        create a currency deposit address
+
+        https://www.luno.com/en/developers/api#tag/Receive/operation/createFundingAddress
+
+        :param str code: unified currency code of the currency for the deposit address
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.name]: an optional name for the new address
+        :param int [params.account_id]: an optional account id for the new address
+        :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
+        """
+        await self.load_markets()
+        currency = self.currency(code)
+        request: dict = {
+            'asset': currency['id'],
+        }
+        response = await self.privatePostFundingAddress(self.extend(request, params))
+        #
+        #     {
+        #         "account_id": "string",
+        #         "address": "string",
+        #         "address_meta": [
+        #             {
+        #                 "label": "string",
+        #                 "value": "string"
+        #             }
+        #         ],
+        #         "asset": "string",
+        #         "assigned_at": 0,
+        #         "name": "string",
+        #         "network": 0,
+        #         "qr_code_uri": "string",
+        #         "receive_fee": "string",
+        #         "total_received": "string",
+        #         "total_unconfirmed": "string"
+        #     }
+        #
+        return self.parse_deposit_address(response, currency)
+
+    async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
+        """
+        fetch the deposit address for a currency associated with self account
+
+        https://www.luno.com/en/developers/api#tag/Receive/operation/getFundingAddress
+
+        :param str code: unified currency code
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.address]: a specific cryptocurrency address to retrieve
+        :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
+        """
+        await self.load_markets()
+        currency = self.currency(code)
+        request: dict = {
+            'asset': currency['id'],
+        }
+        response = await self.privateGetFundingAddress(self.extend(request, params))
+        #
+        #     {
+        #         "account_id": "string",
+        #         "address": "string",
+        #         "address_meta": [
+        #             {
+        #                 "label": "string",
+        #                 "value": "string"
+        #             }
+        #         ],
+        #         "asset": "string",
+        #         "assigned_at": 0,
+        #         "name": "string",
+        #         "network": 0,
+        #         "qr_code_uri": "string",
+        #         "receive_fee": "string",
+        #         "total_received": "string",
+        #         "total_unconfirmed": "string"
+        #     }
+        #
+        return self.parse_deposit_address(response, currency)
+
+    def parse_deposit_address(self, depositAddress, currency: Currency = None) -> DepositAddress:
+        #
+        #     {
+        #         "account_id": "string",
+        #         "address": "string",
+        #         "address_meta": [
+        #             {
+        #                 "label": "string",
+        #                 "value": "string"
+        #             }
+        #         ],
+        #         "asset": "string",
+        #         "assigned_at": 0,
+        #         "name": "string",
+        #         "network": 0,
+        #         "qr_code_uri": "string",
+        #         "receive_fee": "string",
+        #         "total_received": "string",
+        #         "total_unconfirmed": "string"
+        #     }
+        #
+        currencyId = self.safe_string_upper(depositAddress, 'currency')
+        code = self.safe_currency_code(currencyId, currency)
+        return {
+            'info': depositAddress,
+            'currency': code,
+            'network': None,
+            'address': self.safe_string(depositAddress, 'address'),
+            'tag': self.safe_string(depositAddress, 'name'),
+        }
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         url = self.urls['api'][api] + '/' + self.version + '/' + self.implode_params(path, params)
         query = self.omit(params, self.extract_params(path))

ccxt/async_support/paradex.py

@@ -5,7 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.paradex import ImplicitAPI
-from ccxt.base.types import Any, Balances, Currency, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Any, Balances, Currency, Int, Leverage, MarginMode, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -79,10 +79,10 @@ class paradex(Exchange, ImplicitAPI):
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
                 'fetchLedger': False,
-                'fetchLeverage': False,
+                'fetchLeverage': True,
                 'fetchLeverageTiers': False,
                 'fetchLiquidations': True,
-                'fetchMarginMode': None,
+                'fetchMarginMode': True,
                 'fetchMarketLeverageTiers': False,
                 'fetchMarkets': True,
                 'fetchMarkOHLCV': False,
@@ -116,8 +116,8 @@ class paradex(Exchange, ImplicitAPI):
                 'repayCrossMargin': False,
                 'repayIsolatedMargin': False,
                 'sandbox': True,
-                'setLeverage': False,
-                'setMarginMode': False,
+                'setLeverage': True,
+                'setMarginMode': True,
                 'setPositionMode': False,
                 'transfer': False,
                 'withdraw': False,
@@ -159,12 +159,23 @@ class paradex(Exchange, ImplicitAPI):
                         'system/state': 1,
                         'system/time': 1,
                         'trades': 1,
+                        'vaults': 1,
+                        'vaults/balance': 1,
+                        'vaults/config': 1,
+                        'vaults/history': 1,
+                        'vaults/positions': 1,
+                        'vaults/summary': 1,
+                        'vaults/transfers': 1,
                     },
                 },
                 'private': {
                     'get': {
                         'account': 1,
+                        'account/info': 1,
+                        'account/history': 1,
+                        'account/margin': 1,
                         'account/profile': 1,
+                        'account/subaccounts': 1,
                         'balance': 1,
                         'fills': 1,
                         'funding/payments': 1,
@@ -177,20 +188,34 @@ class paradex(Exchange, ImplicitAPI):
                         'orders/by_client_id/{client_id}': 1,
                         'orders/{order_id}': 1,
                         'points_data/{market}/{program}': 1,
+                        'referrals/qr-code': 1,
                         'referrals/summary': 1,
                         'transfers': 1,
+                        'algo/orders': 1,
+                        'algo/orders-history': 1,
+                        'algo/orders/{algo_id}': 1,
+                        'vaults/account-summary': 1,
                     },
                     'post': {
+                        'account/margin/{market}': 1,
+                        'account/profile/max_slippage': 1,
                         'account/profile/referral_code': 1,
                         'account/profile/username': 1,
                         'auth': 1,
                         'onboarding': 1,
                         'orders': 1,
+                        'orders/batch': 1,
+                        'algo/orders': 1,
+                        'vaults': 1,
+                    },
+                    'put': {
+                        'orders/{order_id}': 1,
                     },
                     'delete': {
                         'orders': 1,
                         'orders/by_client_id/{client_id}': 1,
                         'orders/{order_id}': 1,
+                        'algo/orders/{algo_id}': 1,
                     },
                 },
             },
@@ -2063,6 +2088,149 @@ class paradex(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
+    async def fetch_margin_mode(self, symbol: str, params={}) -> MarginMode:
+        """
+        fetches the margin mode of a specific symbol
+
+        https://docs.api.testnet.paradex.trade/#get-account-margin-configuration
+
+        :param str symbol: unified symbol of the market the order was made in
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `margin mode structure <https://docs.ccxt.com/#/?id=margin-mode-structure>`
+        """
+        await self.authenticate_rest()
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+        }
+        response = await self.privateGetAccountMargin(self.extend(request, params))
+        #
+        # {
+        #     "account": "0x6343248026a845b39a8a73fbe9c7ef0a841db31ed5c61ec1446aa9d25e54dbc",
+        #     "configs": [
+        #         {
+        #             "market": "SOL-USD-PERP",
+        #             "leverage": 50,
+        #             "margin_type": "CROSS"
+        #         }
+        #     ]
+        # }
+        #
+        configs = self.safe_list(response, 'configs')
+        return self.parse_margin_mode(self.safe_dict(configs, 0), market)
+
+    def parse_margin_mode(self, rawMarginMode: dict, market=None) -> MarginMode:
+        marketId = self.safe_string(rawMarginMode, 'market')
+        market = self.safe_market(marketId, market)
+        marginMode = self.safe_string_lower(rawMarginMode, 'margin_type')
+        return {
+            'info': rawMarginMode,
+            'symbol': market['symbol'],
+            'marginMode': marginMode,
+        }
+
+    async def set_margin_mode(self, marginMode: str, symbol: Str = None, params={}):
+        """
+        set margin mode to 'cross' or 'isolated'
+
+        https://docs.api.testnet.paradex.trade/#set-margin-configuration
+
+        :param str marginMode: 'cross' or 'isolated'
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param float [params.leverage]: the rate of leverage
+        :returns dict: response from the exchange
+        """
+        self.check_required_argument('setMarginMode', symbol, 'symbol')
+        await self.authenticate_rest()
+        await self.load_markets()
+        market: Market = self.market(symbol)
+        leverage: Str = None
+        leverage, params = self.handle_option_and_params(params, 'setMarginMode', 'leverage', 1)
+        request: dict = {
+            'market': market['id'],
+            'leverage': leverage,
+            'margin_type': self.encode_margin_mode(marginMode),
+        }
+        return await self.privatePostAccountMarginMarket(self.extend(request, params))
+
+    async def fetch_leverage(self, symbol: str, params={}) -> Leverage:
+        """
+        fetch the set leverage for a market
+
+        https://docs.api.testnet.paradex.trade/#get-account-margin-configuration
+
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `leverage structure <https://docs.ccxt.com/#/?id=leverage-structure>`
+        """
+        await self.authenticate_rest()
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+        }
+        response = await self.privateGetAccountMargin(self.extend(request, params))
+        #
+        # {
+        #     "account": "0x6343248026a845b39a8a73fbe9c7ef0a841db31ed5c61ec1446aa9d25e54dbc",
+        #     "configs": [
+        #         {
+        #             "market": "SOL-USD-PERP",
+        #             "leverage": 50,
+        #             "margin_type": "CROSS"
+        #         }
+        #     ]
+        # }
+        #
+        configs = self.safe_list(response, 'configs')
+        return self.parse_leverage(self.safe_dict(configs, 0), market)
+
+    def parse_leverage(self, leverage: dict, market: Market = None) -> Leverage:
+        marketId = self.safe_string(leverage, 'market')
+        market = self.safe_market(marketId, market)
+        marginMode = self.safe_string_lower(leverage, 'margin_type')
+        return {
+            'info': leverage,
+            'symbol': self.safe_symbol(marketId, market),
+            'marginMode': marginMode,
+            'longLeverage': self.safe_integer(leverage, 'leverage'),
+            'shortLeverage': self.safe_integer(leverage, 'leverage'),
+        }
+
+    def encode_margin_mode(self, mode):
+        modes = {
+            'cross': 'CROSS',
+            'isolated': 'ISOLATED',
+        }
+        return self.safe_string(modes, mode, mode)
+
+    async def set_leverage(self, leverage: Int, symbol: Str = None, params={}):
+        """
+        set the level of leverage for a market
+
+        https://docs.api.testnet.paradex.trade/#set-margin-configuration
+
+        :param float leverage: the rate of leverage
+        :param str [symbol]: unified market symbol(is mandatory for swap markets)
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.marginMode]: 'cross' or 'isolated'
+        :returns dict: response from the exchange
+        """
+        self.check_required_argument('setLeverage', symbol, 'symbol')
+        await self.authenticate_rest()
+        await self.load_markets()
+        market: Market = self.market(symbol)
+        marginMode: Str = None
+        marginMode, params = self.handle_margin_mode_and_params('setLeverage', params, 'cross')
+        request: dict = {
+            'market': market['id'],
+            'leverage': leverage,
+            'margin_type': self.encode_margin_mode(marginMode),
+        }
+        return await self.privatePostAccountMarginMarket(self.extend(request, params))
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         url = self.implode_hostname(self.urls['api'][self.version]) + '/' + self.implode_params(path, params)
         query = self.omit(params, self.extract_params(path))

ccxt/async_support/phemex.py

@@ -3581,14 +3581,14 @@ class phemex(Exchange, ImplicitAPI):
 
         :param str[] [symbols]: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param str [params.code]: the currency code to fetch positions for, USD, BTC or USDT, USD is the default
+        :param str [params.code]: the currency code to fetch positions for, USD, BTC or USDT, USDT is the default
         :param str [params.method]: *USDT contracts only* 'privateGetGAccountsAccountPositions' or 'privateGetAccountsPositions' default is 'privateGetGAccountsAccountPositions'
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/#/?id=position-structure>`
         """
         await self.load_markets()
         symbols = self.market_symbols(symbols)
         subType = None
-        code = self.safe_string_2(params, 'currency', 'code', 'USD')
+        code = self.safe_string_2(params, 'currency', 'code', 'USDT')
         params = self.omit(params, ['currency', 'code'])
         settle = None
         market = None

ccxt/async_support/tradeogre.py

@@ -135,6 +135,7 @@ class tradeogre(Exchange, ImplicitAPI):
                         'ticker/{market}': 1,
                         'history/{market}': 1,
                         'chart/{interval}/{market}/{timestamp}': 1,
+                        'chart/{interval}/{market}': 1,
                     },
                 },
                 'private': {
@@ -422,15 +423,15 @@ class tradeogre(Exchange, ImplicitAPI):
             'ask': self.safe_string(ticker, 'ask'),
             'askVolume': None,
             'vwap': None,
-            'open': self.safe_string(ticker, 'open'),
-            'close': None,
+            'open': self.safe_string(ticker, 'initialprice'),
+            'close': self.safe_string(ticker, 'price'),
             'last': None,
             'previousClose': None,
             'change': None,
             'percentage': None,
             'average': None,
-            'baseVolume': self.safe_string(ticker, 'volume'),
-            'quoteVolume': None,
+            'baseVolume': None,
+            'quoteVolume': self.safe_string(ticker, 'volume'),
             'info': ticker,
         }, market)
 
@@ -442,6 +443,7 @@ class tradeogre(Exchange, ImplicitAPI):
         :param int [since]: timestamp in ms of the earliest candle to fetch
         :param int [limit]: the maximum amount of candles to fetch
         :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: timestamp of the latest candle in ms
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         await self.load_markets()
@@ -450,11 +452,14 @@ class tradeogre(Exchange, ImplicitAPI):
             'market': market['id'],
             'interval': self.safe_string(self.timeframes, timeframe, timeframe),
         }
-        if since is None:
-            raise BadRequest(self.id + ' fetchOHLCV requires a since argument')
+        response = None
+        until = self.safe_integer(params, 'until')
+        if until is not None:
+            params = self.omit(params, 'until')
+            request['timestamp'] = self.parse_to_int(until / 1000)
+            response = await self.publicGetChartIntervalMarketTimestamp(self.extend(request, params))
         else:
-            request['timestamp'] = since
-        response = await self.publicGetChartIntervalMarketTimestamp(self.extend(request, params))
+            response = await self.publicGetChartIntervalMarket(self.extend(request, params))
         #
         #     [
         #         [
@@ -483,9 +488,9 @@ class tradeogre(Exchange, ImplicitAPI):
         return [
             self.safe_timestamp(ohlcv, 0),
             self.safe_number(ohlcv, 1),
+            self.safe_number(ohlcv, 2),
             self.safe_number(ohlcv, 3),
             self.safe_number(ohlcv, 4),
-            self.safe_number(ohlcv, 2),
             self.safe_number(ohlcv, 5),
         ]