ccxt 4.3.69__py2.py3-none-any.whl → 4.3.71__py2.py3-none-any.whl

ccxt/async_support/poloniex.py

@@ -359,6 +359,7 @@ class poloniex(Exchange, ImplicitAPI):
                     '21350': InvalidOrder,  # Amount must be greater than 1 USDT
                     '21355': ExchangeError,  # Interval between startTime and endTime in trade/order history has exceeded 7 day limit
                     '21356': BadRequest,  # Order size would cause too much price movement. Reduce order size.
+                    '21721': InsufficientFunds,
                     '24101': BadSymbol,  # Invalid symbol
                     '24102': InvalidOrder,  # Invalid K-line type
                     '24103': InvalidOrder,  # Invalid endTime

ccxt/async_support/woo.py

@@ -2464,11 +2464,13 @@ class woo(Exchange, ImplicitAPI):
         #
         marketId = self.safe_string(income, 'symbol')
         symbol = self.safe_symbol(marketId, market)
-        amount = self.safe_number(income, 'funding_fee')
+        amount = self.safe_string(income, 'funding_fee')
         code = self.safe_currency_code('USD')
         id = self.safe_string(income, 'id')
         timestamp = self.safe_timestamp(income, 'updated_time')
         rate = self.safe_number(income, 'funding_rate')
+        paymentType = self.safe_string(income, 'payment_type')
+        amount = Precise.string_neg(amount) if (paymentType == 'Pay') else amount
         return {
             'info': income,
             'symbol': symbol,
@@ -2476,7 +2478,7 @@ class woo(Exchange, ImplicitAPI):
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'id': id,
-            'amount': amount,
+            'amount': self.parse_number(amount),
             'rate': rate,
         }
 

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.69'
+__version__ = '4.3.71'
 
 # -----------------------------------------------------------------------------
 
@@ -59,6 +59,12 @@ from ccxt.static_dependencies.ethereum import abi
 from ccxt.static_dependencies.ethereum import account
 from ccxt.static_dependencies.msgpack import packb
 
+# starknet
+from ccxt.static_dependencies.starknet.ccxt_utils import get_private_key_from_eth_signature
+from ccxt.static_dependencies.starknet.hash.address import compute_address
+from ccxt.static_dependencies.starknet.hash.selector import get_selector_from_name
+from ccxt.static_dependencies.starknet.hash.utils import message_signature, private_to_stark_key
+from ccxt.static_dependencies.starknet.utils.typed_data import TypedData as TypedDataDataclass
 
 # -----------------------------------------------------------------------------
 
@@ -1286,6 +1292,57 @@ class Exchange(object):
         encodedData = account.messages.encode_typed_data(domain, messageTypes, message)
         return Exchange.binary_concat(b"\x19\x01", encodedData.header, encodedData.body)
 
+    @staticmethod
+    def retrieve_stark_account (signature, accountClassHash, accountProxyClassHash):
+        privateKey = get_private_key_from_eth_signature(signature)
+        publicKey = private_to_stark_key(privateKey)
+        calldata = [
+            int(accountClassHash, 16),
+            get_selector_from_name("initialize"),
+            2,
+            publicKey,
+            0,
+        ]
+
+        address = compute_address(
+            class_hash=int(accountProxyClassHash, 16),
+            constructor_calldata=calldata,
+            salt=publicKey,
+        )
+        return {
+            'privateKey': privateKey,
+            'publicKey': publicKey,
+            'address': hex(address)
+        }
+
+    @staticmethod
+    def starknet_encode_structured_data (domain, messageTypes, messageData, address):
+        types = list(messageTypes.keys())
+        if len(types) > 1:
+            raise NotSupported(this.id + 'starknetEncodeStructuredData only support single type')
+
+        request = {
+            'domain': domain,
+            'primaryType': types[0],
+            'types': Exchange.extend({
+                'StarkNetDomain': [
+                    {'name': "name", 'type': "felt"},
+                    {'name': "chainId", 'type': "felt"},
+                    {'name': "version", 'type': "felt"},
+                ],
+            }, messageTypes),
+            'message': messageData,
+        }
+        typedDataClass = TypedDataDataclass.from_dict(request)
+        msgHash = typedDataClass.message_hash(int(address, 16))
+        return msgHash
+
+    @staticmethod
+    def starknet_sign (hash, pri):
+        # // TODO: unify to ecdsa
+        r, s = message_signature(hash, pri)
+        return Exchange.json([hex(r), hex(s)])
+
     @staticmethod
     def packb(o):
         return packb(o)
@@ -2117,6 +2174,11 @@ class Exchange(object):
     def handle_delta(self, bookside, delta):
         raise NotSupported(self.id + ' handleDelta not supported yet')
 
+    def handle_deltas_with_keys(self, bookSide: Any, deltas, priceKey: IndexType = 0, amountKey: IndexType = 1, countOrIdKey: IndexType = 2):
+        for i in range(0, len(deltas)):
+            bidAsk = self.parse_bid_ask(deltas[i], priceKey, amountKey, countOrIdKey)
+            bookSide.storeArray(bidAsk)
+
     def get_cache_index(self, orderbook, deltas):
         # return the first index of the cache that can be applied to the orderbook or -1 if not possible
         return -1

ccxt/blofin.py

@@ -29,6 +29,7 @@ class blofin(Exchange, ImplicitAPI):
             'countries': ['US'],
             'version': 'v1',
             'rateLimit': 100,
+            'pro': True,
             'has': {
                 'CORS': None,
                 'spot': False,
@@ -103,7 +104,7 @@ class blofin(Exchange, ImplicitAPI):
                 'fetchOpenInterestHistory': False,
                 'fetchOpenOrder': None,
                 'fetchOpenOrders': True,
-                'fetchOrder': True,
+                'fetchOrder': None,
                 'fetchOrderBook': True,
                 'fetchOrderBooks': False,
                 'fetchOrders': False,
@@ -153,11 +154,12 @@ class blofin(Exchange, ImplicitAPI):
                 '2h': '2H',
                 '4h': '4H',
                 '6h': '6H',
+                '8h': '8H',
                 '12h': '12H',
                 '1d': '1D',
+                '3d': '3D',
                 '1w': '1W',
                 '1M': '1M',
-                '3M': '3M',
             },
             'hostname': 'www.blofin.com',
             'urls': {
@@ -492,6 +494,25 @@ class blofin(Exchange, ImplicitAPI):
         return self.parse_order_book(first, symbol, timestamp)
 
     def parse_ticker(self, ticker: dict, market: Market = None) -> Ticker:
+        #
+        # response similar for REST & WS
+        #
+        #     {
+        #         instId: "ADA-USDT",
+        #         ts: "1707736811486",
+        #         last: "0.5315",
+        #         lastSize: "4",
+        #         askPrice: "0.5318",
+        #         askSize: "248",
+        #         bidPrice: "0.5315",
+        #         bidSize: "63",
+        #         open24h: "0.5555",
+        #         high24h: "0.5563",
+        #         low24h: "0.5315",
+        #         volCurrency24h: "198560100",
+        #         vol24h: "1985601",
+        #     }
+        #
         timestamp = self.safe_integer(ticker, 'ts')
         marketId = self.safe_string(ticker, 'instId')
         market = self.safe_market(marketId, market, '-')
@@ -560,7 +581,8 @@ class blofin(Exchange, ImplicitAPI):
 
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
-        # fetch trades
+        # fetch trades(response similar for REST & WS)
+        #
         #   {
         #       "tradeId": "3263934920",
         #       "instId": "LTC-USDT",
@@ -569,6 +591,7 @@ class blofin(Exchange, ImplicitAPI):
         #       "side": "buy",
         #       "ts": "1707232020854"
         #   }
+        #
         # my trades
         #   {
         #       "instId": "LTC-USDT",
@@ -825,9 +848,11 @@ class blofin(Exchange, ImplicitAPI):
         if type:
             return self.parse_funding_balance(response)
         else:
-            return self.parse_trading_balance(response)
+            return self.parse_balance(response)
 
-    def parse_trading_balance(self, response):
+    def parse_balance(self, response):
+        #
+        # "data" similar for REST & WS
         #
         # {
         #     "code": "0",
@@ -849,7 +874,8 @@ class blofin(Exchange, ImplicitAPI):
         #                 "orderFrozen": "14920.994472632597427761",
         #                 "equityUsd": "10011254.077985990315787910",
         #                 "isolatedUnrealizedPnl": "-22.151999999999999999952",
-        #                 "bonus": "0"
+        #                 "bonus": "0"  # present only in REST
+        #                 "unrealizedPnl": "0"  # present only in WS
         #             }
         #         ]
         #     }
@@ -998,6 +1024,8 @@ class blofin(Exchange, ImplicitAPI):
         return self.safe_string(statuses, status, status)
 
     def parse_order(self, order: dict, market: Market = None) -> Order:
+        #
+        # response similar for REST & WS
         #
         # {
         #     "orderId": "2075628533",
@@ -1026,6 +1054,9 @@ class blofin(Exchange, ImplicitAPI):
         #     "cancelSource": "not_canceled",
         #     "cancelSourceReason": null,
         #     "brokerId": "ec6dd3a7dd982d0b"
+        #     "filled_amount": "1.000000000000000000",  # filledAmount in "ws" watchOrders
+        #     "cancelSource": "",  # only in WS
+        #     "instType": "SWAP",  # only in WS
         # }
         #
         id = self.safe_string_2(order, 'tpslId', 'orderId')
@@ -1695,6 +1726,32 @@ class blofin(Exchange, ImplicitAPI):
         return self.filter_by_array_positions(result, 'symbol', symbols, False)
 
     def parse_position(self, position: dict, market: Market = None):
+        #
+        # response similar for REST & WS
+        #
+        #     {
+        #         instType: 'SWAP',
+        #         instId: 'LTC-USDT',
+        #         marginMode: 'cross',
+        #         positionId: '644159',
+        #         positionSide: 'net',
+        #         positions: '1',
+        #         availablePositions: '1',
+        #         averagePrice: '68.16',
+        #         unrealizedPnl: '0.80631223',
+        #         unrealizedPnlRatio: '0.03548909463028169',
+        #         leverage: '3',
+        #         liquidationPrice: '10.116655172370356435',
+        #         markPrice: '68.96',
+        #         initialMargin: '22.988770743333333333',
+        #         margin: '',  # self field might not exist in rest response
+        #         marginRatio: '152.523509620342499273',
+        #         maintenanceMargin: '0.34483156115',
+        #         adl: '4',
+        #         createTime: '1707235776528',
+        #         updateTime: '1707235776528'
+        #     }
+        #
         marketId = self.safe_string(position, 'instId')
         market = self.safe_market(marketId, market)
         symbol = market['symbol']

ccxt/bybit.py

@@ -7624,7 +7624,7 @@ class bybit(Exchange, ImplicitAPI):
         quoteValueString = Precise.string_mul(baseValueString, priceString)
         return self.safe_liquidation({
             'info': liquidation,
-            'symbol': self.safe_symbol(marketId, market),
+            'symbol': self.safe_symbol(marketId, market, None, 'contract'),
             'contracts': self.parse_number(contractsString),
             'contractSize': self.parse_number(contractSizeString),
             'price': self.parse_number(priceString),

ccxt/coinbaseinternational.py

@@ -92,7 +92,7 @@ class coinbaseinternational(Exchange, ImplicitAPI):
                 'fetchMyBuys': True,
                 'fetchMySells': True,
                 'fetchMyTrades': True,
-                'fetchOHLCV': False,
+                'fetchOHLCV': True,
                 'fetchOpenInterestHistory': False,
                 'fetchOpenOrders': True,
                 'fetchOrder': True,
@@ -111,6 +111,7 @@ class coinbaseinternational(Exchange, ImplicitAPI):
                 'fetchTrades': False,
                 'fetchTradingFee': False,
                 'fetchTradingFees': False,
+                'fetchTransfers': True,
                 'fetchWithdrawals': True,
                 'reduceMargin': False,
                 'sandbox': True,
@@ -153,7 +154,7 @@ class coinbaseinternational(Exchange, ImplicitAPI):
                             'instruments/{instrument}',
                             'instruments/{instrument}/quote',
                             'instruments/{instrument}/funding',
-                            '',
+                            'instruments/{instrument}/candles',
                         ],
                     },
                     'private': {
@@ -351,6 +352,75 @@ class coinbaseinternational(Exchange, ImplicitAPI):
             'info': account,
         }
 
+    def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = 100, params={}) -> List[list]:
+        """
+        fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://docs.cdp.coinbase.com/intx/reference/getinstrumentcandles
+        :param str symbol: unified symbol of the market to fetch OHLCV data for
+        :param str timeframe: the length of time each candle represents
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch, default 100 max 10000
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        :param int [params.until]: timestamp in ms of the latest candle to fetch
+        :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+        """
+        self.load_markets()
+        paginate = False
+        paginate, params = self.handle_option_and_params(params, 'fetchOHLCV', 'paginate')
+        if paginate:
+            return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 10000)
+        market = self.market(symbol)
+        request: dict = {
+            'instrument': market['id'],
+            'granularity': self.safe_string(self.timeframes, timeframe, timeframe),
+        }
+        if since is not None:
+            request['start'] = self.iso8601(since)
+        else:
+            raise ArgumentsRequired(self.id + ' fetchOHLCV() requires a since argument')
+        unitl = self.safe_integer(params, 'until')
+        if unitl is not None:
+            params = self.omit(params, 'until')
+            request['end'] = self.iso8601(unitl)
+        response = self.v1PublicGetInstrumentsInstrumentCandles(self.extend(request, params))
+        #
+        #   {
+        #       "aggregations": [
+        #         {
+        #           "start": "2024-04-23T00:00:00Z",
+        #           "open": "62884.4",
+        #           "high": "64710.6",
+        #           "low": "62884.4",
+        #           "close": "63508.4",
+        #           "volume": "3253.9983"
+        #         }
+        #       ]
+        #   }
+        #
+        candles = self.safe_list(response, 'aggregations', [])
+        return self.parse_ohlcvs(candles, market, timeframe, since, limit)
+
+    def parse_ohlcv(self, ohlcv, market: Market = None) -> list:
+        #
+        #   {
+        #     "start": "2024-04-23T00:00:00Z",
+        #     "open": "62884.4",
+        #     "high": "64710.6",
+        #     "low": "62884.4",
+        #     "close": "63508.4",
+        #     "volume": "3253.9983"
+        #   }
+        #
+        return [
+            self.parse8601(self.safe_string_2(ohlcv, 'start', 'time')),
+            self.safe_number(ohlcv, 'open'),
+            self.safe_number(ohlcv, 'high'),
+            self.safe_number(ohlcv, 'low'),
+            self.safe_number(ohlcv, 'close'),
+            self.safe_number(ohlcv, 'volume'),
+        ]
+
     def fetch_funding_rate_history(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetches historical funding rate prices
@@ -504,6 +574,89 @@ class coinbaseinternational(Exchange, ImplicitAPI):
             'rate': None,
         }
 
+    def fetch_transfers(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[TransferEntry]:
+        """
+        fetch a history of internal transfers made on an account
+        :see: https://docs.cdp.coinbase.com/intx/reference/gettransfers
+        :param str code: unified currency code of the currency transferred
+        :param int [since]: the earliest time in ms to fetch transfers for
+        :param int [limit]: the maximum number of  transfers structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `transfer structures <https://docs.ccxt.com/#/?id=transfer-structure>`
+        """
+        self.load_markets()
+        request: dict = {
+            'type': 'INTERNAL',
+        }
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
+        portfolios = None
+        portfolios, params = self.handle_option_and_params(params, 'fetchTransfers', 'portfolios')
+        if portfolios is not None:
+            request['portfolios'] = portfolios
+        if since is not None:
+            request['time_from'] = self.iso8601(since)
+        if limit is not None:
+            request['result_limit'] = limit
+        else:
+            request['result_limit'] = 100
+        response = self.v1PrivateGetTransfers(self.extend(request, params))
+        transfers = self.safe_list(response, 'results', [])
+        return self.parse_transfers(transfers, currency, since, limit)
+
+    def parse_transfer(self, transfer: dict, currency: Currency = None) -> TransferEntry:
+        #
+        # {
+        #     "amount":"0.0008",
+        #     "asset":"USDC",
+        #     "created_at":"2024-02-22T16:00:00Z",
+        #     "from_portfolio":{
+        #        "id":"13yuk1fs-1-0",
+        #        "name":"Eng Test Portfolio - 2",
+        #        "uuid":"018712f2-5ff9-7de3-9010-xxxxxxxxx"
+        #     },
+        #     "instrument_id":"149264164756389888",
+        #     "instrument_symbol":"ETH-PERP",
+        #     "position_id":"1xy4v51m-1-2",
+        #     "status":"PROCESSED",
+        #     "to_portfolio":{
+        #        "name":"CB_FUND"
+        #     },
+        #     "transfer_type":"FUNDING",
+        #     "transfer_uuid":"a6b708df-2c44-32c5-bb98-xxxxxxxxxx",
+        #     "updated_at":"2024-02-22T16:00:00Z"
+        # }
+        #
+        datetime = self.safe_integer(transfer, 'created_at')
+        timestamp = self.parse8601(datetime)
+        currencyId = self.safe_string(transfer, 'asset')
+        code = self.safe_currency_code(currencyId)
+        fromPorfolio = self.safe_dict(transfer, 'from_portfolio', {})
+        fromId = self.safe_string(fromPorfolio, 'id')
+        toPorfolio = self.safe_dict(transfer, 'to_portfolio', {})
+        toId = self.safe_string(toPorfolio, 'id')
+        return {
+            'info': transfer,
+            'id': self.safe_string(transfer, 'transfer_uuid'),
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'currency': code,
+            'amount': self.safe_number(transfer, 'amount'),
+            'fromAccount': fromId,
+            'toAccount': toId,
+            'status': self.parse_transfer_status(self.safe_string(transfer, 'status')),
+        }
+
+    def parse_transfer_status(self, status: Str) -> Str:
+        statuses: dict = {
+            'FAILED': 'failed',
+            'PROCESSED': 'ok',
+            'NEW': 'pending',
+            'STARTED': 'pending',
+        }
+        return self.safe_string(statuses, status, status)
+
     def create_deposit_address(self, code: str, params={}):
         """
         create a currency deposit address

ccxt/cryptocom.py

@@ -17,10 +17,13 @@ from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
 from ccxt.base.errors import InsufficientFunds
 from ccxt.base.errors import InvalidOrder
+from ccxt.base.errors import OrderNotFound
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import DDoSProtection
+from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import OnMaintenance
 from ccxt.base.errors import InvalidNonce
+from ccxt.base.errors import RequestTimeout
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
@@ -401,7 +404,15 @@ class cryptocom(Exchange, ImplicitAPI):
                     '40006': BadRequest,
                     '40007': BadRequest,
                     '40101': AuthenticationError,
-                    '50001': BadRequest,
+                    '40102': InvalidNonce,  # Nonce value differs by more than 60 seconds from server
+                    '40103': AuthenticationError,  # IP address not whitelisted
+                    '40104': AuthenticationError,  # Disallowed based on user tier
+                    '40107': BadRequest,  # Session subscription limit has been exceeded
+                    '40401': OrderNotFound,
+                    '40801': RequestTimeout,
+                    '42901': RateLimitExceeded,
+                    '43005': InvalidOrder,  # Rejected POST_ONLY create-order request(normally happened when exec_inst contains POST_ONLY but time_in_force is NOT GOOD_TILL_CANCEL)
+                    '50001': ExchangeError,
                     '9010001': OnMaintenance,  # {"code":9010001,"message":"SYSTEM_MAINTENANCE","details":"Crypto.com Exchange is currently under maintenance. Please refer to https://status.crypto.com for more details."}
                 },
                 'broad': {},