ccxt 4.4.25__py2.py3-none-any.whl → 4.4.27__py2.py3-none-any.whl

ccxt/async_support/alpaca.py

@@ -5,10 +5,11 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.alpaca import ImplicitAPI
-from ccxt.base.types import Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Trade
+from ccxt.base.types import Currency, DepositAddress, Int, 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 PermissionDenied
+from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import BadSymbol
 from ccxt.base.errors import InsufficientFunds
@@ -32,7 +33,7 @@ class alpaca(Exchange, ImplicitAPI):
             'hostname': 'alpaca.markets',
             'pro': True,
             'urls': {
-                'logo': 'https://user-images.githubusercontent.com/1294454/187234005-b864db3d-f1e3-447a-aaf9-a9fc7b955d07.jpg',
+                'logo': 'https://github.com/user-attachments/assets/e9476df8-a450-4c3e-ab9a-1a7794219e1b',
                 'www': 'https://alpaca.markets',
                 'api': {
                     'broker': 'https://broker-api.{hostname}',
@@ -63,10 +64,10 @@ class alpaca(Exchange, ImplicitAPI):
                 'fetchBidsAsks': False,
                 'fetchClosedOrders': True,
                 'fetchCurrencies': False,
-                'fetchDepositAddress': False,
+                'fetchDepositAddress': True,
                 'fetchDepositAddressesByNetwork': False,
-                'fetchDeposits': False,
-                'fetchDepositsWithdrawals': False,
+                'fetchDeposits': True,
+                'fetchDepositsWithdrawals': True,
                 'fetchFundingHistory': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
@@ -74,7 +75,7 @@ class alpaca(Exchange, ImplicitAPI):
                 'fetchL1OrderBook': True,
                 'fetchL2OrderBook': False,
                 'fetchMarkets': True,
-                'fetchMyTrades': False,
+                'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenOrder': False,
                 'fetchOpenOrders': True,
@@ -89,8 +90,8 @@ class alpaca(Exchange, ImplicitAPI):
                 'fetchPositionsHistory': False,
                 'fetchPositionsRisk': False,
                 'fetchStatus': False,
-                'fetchTicker': False,
-                'fetchTickers': False,
+                'fetchTicker': True,
+                'fetchTickers': True,
                 'fetchTime': True,
                 'fetchTrades': True,
                 'fetchTradingFee': False,
@@ -98,12 +99,12 @@ class alpaca(Exchange, ImplicitAPI):
                 'fetchTransactionFees': False,
                 'fetchTransactions': False,
                 'fetchTransfers': False,
-                'fetchWithdrawals': False,
+                'fetchWithdrawals': True,
                 'sandbox': True,
                 'setLeverage': False,
                 'setMarginMode': False,
                 'transfer': False,
-                'withdraw': False,
+                'withdraw': True,
             },
             'api': {
                 'broker': {
@@ -129,12 +130,15 @@ class alpaca(Exchange, ImplicitAPI):
                             'v2/assets/{symbol_or_asset_id}',
                             'v2/corporate_actions/announcements/{id}',
                             'v2/corporate_actions/announcements',
+                            'v2/wallets',
+                            'v2/wallets/transfers',
                         ],
                         'post': [
                             'v2/orders',
                             'v2/watchlists',
                             'v2/watchlists/{watchlist_id}',
                             'v2/watchlists:by_name',
+                            'v2/wallets/transfers',
                         ],
                         'put': [
                             'v2/watchlists/{watchlist_id}',
@@ -671,6 +675,130 @@ class alpaca(Exchange, ImplicitAPI):
             self.safe_number(ohlcv, 'v'),  # volume
         ]
 
+    async def fetch_ticker(self, symbol: str, params={}) -> Ticker:
+        """
+        fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://docs.alpaca.markets/reference/cryptosnapshots-1
+        :param str symbol: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.loc]: crypto location, default: us
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbol = self.symbol(symbol)
+        tickers = await self.fetch_tickers([symbol], params)
+        return self.safe_dict(tickers, symbol)
+
+    async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+        :see: https://docs.alpaca.markets/reference/cryptosnapshots-1
+        :param str[] symbols: unified symbols of the markets to fetch tickers for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.loc]: crypto location, default: us
+        :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        if symbols is None:
+            raise ArgumentsRequired(self.id + ' fetchTickers() requires a symbols argument')
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        loc = self.safe_string(params, 'loc', 'us')
+        ids = self.market_ids(symbols)
+        request = {
+            'symbols': ','.join(ids),
+            'loc': loc,
+        }
+        params = self.omit(params, 'loc')
+        response = await self.marketPublicGetV1beta3CryptoLocSnapshots(self.extend(request, params))
+        #
+        #     {
+        #         "snapshots": {
+        #             "BTC/USD": {
+        #                 "dailyBar": {
+        #                     "c": 69403.554,
+        #                     "h": 69609.6515,
+        #                     "l": 69013.26,
+        #                     "n": 9,
+        #                     "o": 69536.7,
+        #                     "t": "2024-11-01T05:00:00Z",
+        #                     "v": 0.210809181,
+        #                     "vw": 69327.655393908
+        #                 },
+        #                 "latestQuote": {
+        #                     "ap": 69424.19,
+        #                     "as": 0.68149,
+        #                     "bp": 69366.086,
+        #                     "bs": 0.68312,
+        #                     "t": "2024-11-01T08:31:41.880246926Z"
+        #                 },
+        #                 "latestTrade": {
+        #                     "i": 5272941104897543146,
+        #                     "p": 69416.9,
+        #                     "s": 0.014017324,
+        #                     "t": "2024-11-01T08:14:28.245088803Z",
+        #                     "tks": "B"
+        #                 },
+        #                 "minuteBar": {
+        #                     "c": 69403.554,
+        #                     "h": 69403.554,
+        #                     "l": 69399.125,
+        #                     "n": 0,
+        #                     "o": 69399.125,
+        #                     "t": "2024-11-01T08:30:00Z",
+        #                     "v": 0,
+        #                     "vw": 0
+        #                 },
+        #                 "prevDailyBar": {
+        #                     "c": 69515.1415,
+        #                     "h": 72668.837,
+        #                     "l": 68796.85,
+        #                     "n": 129,
+        #                     "o": 72258.9,
+        #                     "t": "2024-10-31T05:00:00Z",
+        #                     "v": 2.217683307,
+        #                     "vw": 70782.6811608144
+        #                 }
+        #             },
+        #         }
+        #     }
+        #
+        results = []
+        snapshots = self.safe_dict(response, 'snapshots', {})
+        marketIds = list(snapshots.keys())
+        for i in range(0, len(marketIds)):
+            marketId = marketIds[i]
+            market = self.safe_market(marketId)
+            entry = self.safe_dict(snapshots, marketId)
+            dailyBar = self.safe_dict(entry, 'dailyBar', {})
+            prevDailyBar = self.safe_dict(entry, 'prevDailyBar', {})
+            latestQuote = self.safe_dict(entry, 'latestQuote', {})
+            latestTrade = self.safe_dict(entry, 'latestTrade', {})
+            datetime = self.safe_string(latestQuote, 't')
+            ticker = self.safe_ticker({
+                'info': entry,
+                'symbol': market['symbol'],
+                'timestamp': self.parse8601(datetime),
+                'datetime': datetime,
+                'high': self.safe_string(dailyBar, 'h'),
+                'low': self.safe_string(dailyBar, 'l'),
+                'bid': self.safe_string(latestQuote, 'bp'),
+                'bidVolume': self.safe_string(latestQuote, 'bs'),
+                'ask': self.safe_string(latestQuote, 'ap'),
+                'askVolume': self.safe_string(latestQuote, 'as'),
+                'vwap': self.safe_string(dailyBar, 'vw'),
+                'open': self.safe_string(dailyBar, 'o'),
+                'close': self.safe_string(dailyBar, 'c'),
+                'last': self.safe_string(latestTrade, 'p'),
+                'previousClose': self.safe_string(prevDailyBar, 'c'),
+                'change': None,
+                'percentage': None,
+                'average': None,
+                'baseVolume': self.safe_string(dailyBar, 'v'),
+                'quoteVolume': self.safe_string(dailyBar, 'n'),
+            }, market)
+            results.append(ticker)
+        return self.filter_by_array(results, 'symbol', symbols)
+
     async def create_order(self, symbol: str, type: OrderType, side: OrderSide, amount: float, price: Num = None, params={}):
         """
         create a trade order
@@ -1014,7 +1142,54 @@ class alpaca(Exchange, ImplicitAPI):
         }
         return self.safe_string(timeInForces, timeInForce, timeInForce)
 
+    async def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
+        """
+        fetch all trades made by the user
+        :see: https://docs.alpaca.markets/reference/getaccountactivitiesbyactivitytype-1
+        :param str [symbol]: unified market symbol
+        :param int [since]: the earliest time in ms to fetch trades for
+        :param int [limit]: the maximum number of trade structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param int [params.until]: the latest time in ms to fetch trades for
+        :returns Trade[]: a list of `trade structures <https://docs.ccxt.com/#/?id=trade-structure>`
+        """
+        await self.load_markets()
+        market = None
+        request: dict = {
+            'activity_type': 'FILL',
+        }
+        if symbol is not None:
+            market = self.market(symbol)
+        if since is not None:
+            request['after'] = since
+        if limit is not None:
+            request['page_size'] = limit
+        request, params = self.handle_until_option('until', request, params)
+        response = await self.traderPrivateGetV2AccountActivitiesActivityType(self.extend(request, params))
+        #
+        #     [
+        #         {
+        #             "id": "20221228071929579::ca2aafd0-1270-4b56-b0a9-85423b4a07c8",
+        #             "activity_type": "FILL",
+        #             "transaction_time": "2022-12-28T12:19:29.579352Z",
+        #             "type": "fill",
+        #             "price": "67.31",
+        #             "qty": "0.07",
+        #             "side": "sell",
+        #             "symbol": "LTC/USD",
+        #             "leaves_qty": "0",
+        #             "order_id": "82eebcf7-6e66-4b7e-93f8-be0df0e4f12e",
+        #             "cum_qty": "0.07",
+        #             "order_status": "filled",
+        #             "swap_rate": "1"
+        #         },
+        #     ]
+        #
+        return self.parse_trades(response, market, since, limit)
+
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
+        #
+        # fetchTrades
         #
         #   {
         #       "t":"2022-06-14T05:00:00.027869Z",
@@ -1025,25 +1200,43 @@ class alpaca(Exchange, ImplicitAPI):
         #       "i":"355681339"
         #   }
         #
-        marketId = self.safe_string(trade, 'S')
+        # fetchMyTrades
+        #
+        #     {
+        #         "id": "20221228071929579::ca2aafd0-1270-4b56-b0a9-85423b4a07c8",
+        #         "activity_type": "FILL",
+        #         "transaction_time": "2022-12-28T12:19:29.579352Z",
+        #         "type": "fill",
+        #         "price": "67.31",
+        #         "qty": "0.07",
+        #         "side": "sell",
+        #         "symbol": "LTC/USD",
+        #         "leaves_qty": "0",
+        #         "order_id": "82eebcf7-6e66-4b7e-93f8-be0df0e4f12e",
+        #         "cum_qty": "0.07",
+        #         "order_status": "filled",
+        #         "swap_rate": "1"
+        #     },
+        #
+        marketId = self.safe_string_2(trade, 'S', 'symbol')
         symbol = self.safe_symbol(marketId, market)
-        datetime = self.safe_string(trade, 't')
+        datetime = self.safe_string_2(trade, 't', 'transaction_time')
         timestamp = self.parse8601(datetime)
         alpacaSide = self.safe_string(trade, 'tks')
-        side: str
+        side = self.safe_string(trade, 'side')
         if alpacaSide == 'B':
             side = 'buy'
         elif alpacaSide == 'S':
             side = 'sell'
-        priceString = self.safe_string(trade, 'p')
-        amountString = self.safe_string(trade, 's')
+        priceString = self.safe_string_2(trade, 'p', 'price')
+        amountString = self.safe_string_2(trade, 's', 'qty')
         return self.safe_trade({
             'info': trade,
-            'id': self.safe_string(trade, 'i'),
+            'id': self.safe_string_2(trade, 'i', 'id'),
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'symbol': symbol,
-            'order': None,
+            'order': self.safe_string(trade, 'order_id'),
             'type': None,
             'side': side,
             'takerOrMaker': 'taker',
@@ -1053,6 +1246,222 @@ class alpaca(Exchange, ImplicitAPI):
             'fee': None,
         }, market)
 
+    async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
+        """
+        fetch the deposit address for a currency associated with self account
+        :see: https://docs.alpaca.markets/reference/listcryptofundingwallets
+        :param str code: unified currency code
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :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.traderPrivateGetV2Wallets(self.extend(request, params))
+        #
+        #     {
+        #         "asset_id": "4fa30c85-77b7-4cbc-92dd-7b7513640aad",
+        #         "address": "bc1q2fpskfnwem3uq9z8660e4z6pfv7aqfamysk75r",
+        #         "created_at": "2024-11-03T07:30:05.609976344Z"
+        #     }
+        #
+        return self.parse_deposit_address(response, currency)
+
+    def parse_deposit_address(self, depositAddress, currency: Currency = None) -> DepositAddress:
+        #
+        #     {
+        #         "asset_id": "4fa30c85-77b7-4cbc-92dd-7b7513640aad",
+        #         "address": "bc1q2fpskfnwem3uq9z8660e4z6pfv7aqfamysk75r",
+        #         "created_at": "2024-11-03T07:30:05.609976344Z"
+        #     }
+        #
+        parsedCurrency = None
+        if currency is not None:
+            parsedCurrency = currency['id']
+        return {
+            'info': depositAddress,
+            'currency': parsedCurrency,
+            'network': None,
+            'address': self.safe_string(depositAddress, 'address'),
+            'tag': None,
+        }
+
+    async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}):
+        """
+        make a withdrawal
+        :see: https://docs.alpaca.markets/reference/createcryptotransferforaccount
+        :param str code: unified currency code
+        :param float amount: the amount to withdraw
+        :param str address: the address to withdraw to
+        :param str tag: a memo for the transaction
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
+        """
+        tag, params = self.handle_withdraw_tag_and_params(tag, params)
+        self.check_address(address)
+        await self.load_markets()
+        currency = self.currency(code)
+        if tag:
+            address = address + ':' + tag
+        request: dict = {
+            'asset': currency['id'],
+            'address': address,
+            'amount': self.number_to_string(amount),
+        }
+        response = await self.traderPrivatePostV2WalletsTransfers(self.extend(request, params))
+        #
+        #     {
+        #         "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+        #         "tx_hash": "string",
+        #         "direction": "INCOMING",
+        #         "status": "PROCESSING",
+        #         "amount": "string",
+        #         "usd_value": "string",
+        #         "network_fee": "string",
+        #         "fees": "string",
+        #         "chain": "string",
+        #         "asset": "string",
+        #         "from_address": "string",
+        #         "to_address": "string",
+        #         "created_at": "2024-11-02T07:42:48.402Z"
+        #     }
+        #
+        return self.parse_transaction(response, currency)
+
+    async def fetch_transactions_helper(self, type, code, since, limit, params):
+        await self.load_markets()
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
+        response = await self.traderPrivateGetV2WalletsTransfers(params)
+        #
+        #     {
+        #         "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+        #         "tx_hash": "string",
+        #         "direction": "INCOMING",
+        #         "status": "PROCESSING",
+        #         "amount": "string",
+        #         "usd_value": "string",
+        #         "network_fee": "string",
+        #         "fees": "string",
+        #         "chain": "string",
+        #         "asset": "string",
+        #         "from_address": "string",
+        #         "to_address": "string",
+        #         "created_at": "2024-11-02T07:42:48.402Z"
+        #     }
+        #
+        results = []
+        for i in range(0, len(response)):
+            entry = response[i]
+            direction = self.safe_string(entry, 'direction')
+            if direction == type:
+                results.append(entry)
+            elif direction == 'BOTH':
+                results.append(entry)
+        return self.parse_transactions(results, currency, since, limit, params)
+
+    async def fetch_deposits_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
+        """
+        fetch history of deposits and withdrawals
+        :see: https://docs.alpaca.markets/reference/listcryptofundingtransfers
+        :param str [code]: unified currency code for the currency of the deposit/withdrawals, default is None
+        :param int [since]: timestamp in ms of the earliest deposit/withdrawal, default is None
+        :param int [limit]: max number of deposit/withdrawals to return, default is None
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a list of `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
+        """
+        return await self.fetch_transactions_helper('BOTH', code, since, limit, params)
+
+    async def fetch_deposits(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
+        """
+        fetch all deposits made to an account
+        :see: https://docs.alpaca.markets/reference/listcryptofundingtransfers
+        :param str [code]: unified currency code
+        :param int [since]: the earliest time in ms to fetch deposits for
+        :param int [limit]: the maximum number of deposit structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
+        """
+        return await self.fetch_transactions_helper('INCOMING', code, since, limit, params)
+
+    async def fetch_withdrawals(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Transaction]:
+        """
+        fetch all withdrawals made from an account
+        :see: https://docs.alpaca.markets/reference/listcryptofundingtransfers
+        :param str [code]: unified currency code
+        :param int [since]: the earliest time in ms to fetch withdrawals for
+        :param int [limit]: the maximum number of withdrawal structures to retrieve
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
+        """
+        return await self.fetch_transactions_helper('OUTGOING', code, since, limit, params)
+
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
+        #
+        #     {
+        #         "id": "3fa85f64-5717-4562-b3fc-2c963f66afa6",
+        #         "tx_hash": "string",
+        #         "direction": "INCOMING",
+        #         "status": "PROCESSING",
+        #         "amount": "string",
+        #         "usd_value": "string",
+        #         "network_fee": "string",
+        #         "fees": "string",
+        #         "chain": "string",
+        #         "asset": "string",
+        #         "from_address": "string",
+        #         "to_address": "string",
+        #         "created_at": "2024-11-02T07:42:48.402Z"
+        #     }
+        #
+        datetime = self.safe_string(transaction, 'created_at')
+        currencyId = self.safe_string(transaction, 'asset')
+        code = self.safe_currency_code(currencyId, currency)
+        fee = {
+            'cost': self.safe_number(transaction, 'fees'),
+            'currency': code,
+        }
+        return {
+            'info': transaction,
+            'id': self.safe_string(transaction, 'id'),
+            'txid': self.safe_string(transaction, 'tx_hash'),
+            'timestamp': self.parse8601(datetime),
+            'datetime': datetime,
+            'network': self.safe_string(transaction, 'chain'),
+            'address': self.safe_string(transaction, 'to_address'),
+            'addressTo': self.safe_string(transaction, 'to_address'),
+            'addressFrom': self.safe_string(transaction, 'from_address'),
+            'tag': None,
+            'tagTo': None,
+            'tagFrom': None,
+            'type': self.parse_transaction_type(self.safe_string(transaction, 'direction')),
+            'amount': self.safe_number(transaction, 'amount'),
+            'currency': code,
+            'status': self.parse_transaction_status(self.safe_string(transaction, 'status')),
+            'updated': None,
+            'fee': fee,
+            'comment': None,
+            'internal': None,
+        }
+
+    def parse_transaction_status(self, status: Str):
+        statuses: dict = {
+            'PROCESSING': 'pending',
+            # 'FAILED': 'failed',
+            # 'SUCCESS': 'ok',
+        }
+        return self.safe_string(statuses, status, status)
+
+    def parse_transaction_type(self, type):
+        types: dict = {
+            'INCOMING': 'deposit',
+            'OUTGOING': 'withdrawal',
+        }
+        return self.safe_string(types, type, type)
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         endpoint = '/' + self.implode_params(path, params)
         url = self.implode_hostname(self.urls['api'][api[0]])

ccxt/async_support/ascendex.py

@@ -125,7 +125,7 @@ class ascendex(Exchange, ImplicitAPI):
             },
             'version': 'v2',
             'urls': {
-                'logo': 'https://user-images.githubusercontent.com/1294454/112027508-47984600-8b48-11eb-9e17-d26459cc36c6.jpg',
+                'logo': 'https://github.com/user-attachments/assets/55bab6b9-d4ca-42a8-a0e6-fac81ae557f1',
                 'api': {
                     'rest': 'https://ascendex.com',
                 },

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.25'
+__version__ = '4.4.27'
 
 # -----------------------------------------------------------------------------
 
@@ -598,9 +598,15 @@ class Exchange(BaseExchange):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchTrades() is not supported yet')
 
+    async def un_watch_trades(self, symbol: str, params={}):
+        raise NotSupported(self.id + ' unWatchTrades() is not supported yet')
+
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchTradesForSymbols() is not supported yet')
 
+    async def un_watch_trades_for_symbols(self, symbols: List[str], params={}):
+        raise NotSupported(self.id + ' unWatchTradesForSymbols() is not supported yet')
+
     async def watch_my_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchMyTradesForSymbols() is not supported yet')
 
@@ -610,9 +616,15 @@ class Exchange(BaseExchange):
     async def watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], since: Int = None, limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchOHLCVForSymbols() is not supported yet')
 
+    async def un_watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], params={}):
+        raise NotSupported(self.id + ' unWatchOHLCVForSymbols() is not supported yet')
+
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchOrderBookForSymbols() is not supported yet')
 
+    async def un_watch_order_book_for_symbols(self, symbols: List[str], params={}):
+        raise NotSupported(self.id + ' unWatchOrderBookForSymbols() is not supported yet')
+
     async def fetch_deposit_addresses(self, codes: Strings = None, params={}):
         raise NotSupported(self.id + ' fetchDepositAddresses() is not supported yet')
 
@@ -643,6 +655,9 @@ class Exchange(BaseExchange):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}):
         raise NotSupported(self.id + ' watchOrderBook() is not supported yet')
 
+    async def un_watch_order_book(self, symbol: str, params={}):
+        raise NotSupported(self.id + ' unWatchOrderBook() is not supported yet')
+
     async def fetch_time(self, params={}):
         raise NotSupported(self.id + ' fetchTime() is not supported yet')
 
@@ -743,13 +758,13 @@ class Exchange(BaseExchange):
     async def fetch_payment_methods(self, params={}):
         raise NotSupported(self.id + ' fetchPaymentMethods() is not supported yet')
 
-    async def fetch_borrow_rate(self, code: str, amount, params={}):
+    async def fetch_borrow_rate(self, code: str, amount: float, params={}):
         raise NotSupported(self.id + ' fetchBorrowRate is deprecated, please use fetchCrossBorrowRate or fetchIsolatedBorrowRate instead')
 
-    async def repay_cross_margin(self, code: str, amount, params={}):
+    async def repay_cross_margin(self, code: str, amount: float, params={}):
         raise NotSupported(self.id + ' repayCrossMargin is not support yet')
 
-    async def repay_isolated_margin(self, symbol: str, code: str, amount, params={}):
+    async def repay_isolated_margin(self, symbol: str, code: str, amount: float, params={}):
         raise NotSupported(self.id + ' repayIsolatedMargin is not support yet')
 
     async def borrow_cross_margin(self, code: str, amount: float, params={}):
@@ -758,10 +773,10 @@ class Exchange(BaseExchange):
     async def borrow_isolated_margin(self, symbol: str, code: str, amount: float, params={}):
         raise NotSupported(self.id + ' borrowIsolatedMargin is not support yet')
 
-    async def borrow_margin(self, code: str, amount, symbol: Str = None, params={}):
+    async def borrow_margin(self, code: str, amount: float, symbol: Str = None, params={}):
         raise NotSupported(self.id + ' borrowMargin is deprecated, please use borrowCrossMargin or borrowIsolatedMargin instead')
 
-    async def repay_margin(self, code: str, amount, symbol: Str = None, params={}):
+    async def repay_margin(self, code: str, amount: float, symbol: Str = None, params={}):
         raise NotSupported(self.id + ' repayMargin is deprecated, please use repayCrossMargin or repayIsolatedMargin instead')
 
     async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}):
@@ -1074,6 +1089,9 @@ class Exchange(BaseExchange):
     async def watch_tickers(self, symbols: Strings = None, params={}):
         raise NotSupported(self.id + ' watchTickers() is not supported yet')
 
+    async def un_watch_tickers(self, symbols: Strings = None, params={}):
+        raise NotSupported(self.id + ' unWatchTickers() is not supported yet')
+
     async def fetch_order(self, id: str, symbol: Str = None, params={}):
         raise NotSupported(self.id + ' fetchOrder() is not supported yet')
 

ccxt/async_support/bequant.py

@@ -16,7 +16,7 @@ class bequant(hitbtc, ImplicitAPI):
             'countries': ['MT'],  # Malta
             'pro': True,
             'urls': {
-                'logo': 'https://user-images.githubusercontent.com/1294454/55248342-a75dfe00-525a-11e9-8aa2-05e9dca943c6.jpg',
+                'logo': 'https://github.com/user-attachments/assets/0583ef1f-29fe-4b7c-8189-63565a0e2867',
                 'api': {
                     'public': 'https://api.bequant.io/api/3',
                     'private': 'https://api.bequant.io/api/3',

ccxt/async_support/bigone.py

@@ -93,7 +93,7 @@ class bigone(Exchange, ImplicitAPI):
             },
             'hostname': 'big.one',  # or 'bigone.com'
             'urls': {
-                'logo': 'https://user-images.githubusercontent.com/1294454/69354403-1d532180-0c91-11ea-88ed-44c06cefdf87.jpg',
+                'logo': 'https://github.com/user-attachments/assets/4e5cfd53-98cc-4b90-92cd-0d7b512653d1',
                 'api': {
                     'public': 'https://{hostname}/api/v3',
                     'private': 'https://{hostname}/api/v3/viewer',