bitvavo-api-upgraded 1.15.8__py3-none-any.whl → 1.17.0__py3-none-any.whl

bitvavo_api_upgraded/bitvavo.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
+import datetime as dt
 import hashlib
 import hmac
 import json
 import time
-import datetime as dt
 from threading import Thread
-from typing import Any, Callable, Dict, List, Union
+from typing import Any, Callable
 
 import websocket as ws_lib
 from requests import delete, get, post, put
@@ -13,22 +15,22 @@ from websocket import WebSocketApp  # missing stubs for WebSocketApp
 
 from bitvavo_api_upgraded.helper_funcs import configure_loggers, time_ms, time_to_wait
 from bitvavo_api_upgraded.settings import BITVAVO_API_UPGRADED
-from bitvavo_api_upgraded.type_aliases import anydict, errordict, intdict, ms, s_f, strdict
+from bitvavo_api_upgraded.type_aliases import anydict, errordict, intdict, ms, s_f, strdict, strintdict
 
 configure_loggers()
 
 logger = get_logger(__name__)
 
 
-def createSignature(timestamp: ms, method: str, url: str, body: anydict, APISECRET: str) -> str:
+def createSignature(timestamp: ms, method: str, url: str, body: anydict | None, api_secret: str) -> str:
     string = f"{timestamp}{method}/v2{url}"
-    if len(body.keys()) != 0:
+    if body is not None and len(body.keys()) > 0:
         string += json.dumps(body, separators=(",", ":"))
-    signature = hmac.new(APISECRET.encode("utf-8"), string.encode("utf-8"), hashlib.sha256).hexdigest()
+    signature = hmac.new(api_secret.encode("utf-8"), string.encode("utf-8"), hashlib.sha256).hexdigest()
     return signature
 
 
-def createPostfix(options: anydict) -> str:
+def createPostfix(options: anydict | None) -> str:
     """Generate a URL postfix, based on the `options` dict.
 
     ---
@@ -39,11 +41,29 @@ def createPostfix(options: anydict) -> str:
     Returns:
         str: [description]
     """
+    options = _default(options, {})
     params = [f"{key}={options[key]}" for key in options]
     postfix = "&".join(params)  # intersperse
     return f"?{postfix}" if len(options) > 0 else postfix
 
 
+def _default(value: anydict | None, fallback: anydict) -> anydict:
+    """
+    Note that is close, but not actually equal to:
+
+    `return value or fallback`
+
+    I checked this with a temporary hypothesis test.
+
+    This note is all you will get out of me.
+    """
+    return value if value is not None else fallback
+
+
+def _epoch_millis(dt: dt.datetime) -> int:
+    return int(dt.timestamp() * 1000)
+
+
 def asksCompare(a: float, b: float) -> bool:
     return a < b
 
@@ -53,10 +73,10 @@ def bidsCompare(a: float, b: float) -> bool:
 
 
 def sortAndInsert(
-    asks_or_bids: List[List[str]],
-    update: List[List[str]],
+    asks_or_bids: list[list[str]],
+    update: list[list[str]],
     compareFunc: Callable[[float, float], bool],
-) -> Union[List[List[str]], errordict]:
+) -> list[list[str]] | errordict:
     for updateEntry in update:
         entrySet: bool = False
         for j in range(len(asks_or_bids)):
@@ -70,16 +90,15 @@ def sortAndInsert(
                     asks_or_bids[j] = updateEntry
                     entrySet = True
                     break
-                else:
-                    asks_or_bids.pop(j)
-                    entrySet = True
-                    break
+                asks_or_bids.pop(j)
+                entrySet = True
+                break
         if not entrySet:
             asks_or_bids.append(updateEntry)
     return asks_or_bids
 
 
-def processLocalBook(ws: "Bitvavo.WebSocketAppFacade", message: anydict) -> None:
+def processLocalBook(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
     market: str = ""
     if "action" in message:
         if message["action"] == "getBook":
@@ -88,29 +107,31 @@ def processLocalBook(ws: "Bitvavo.WebSocketAppFacade", message: anydict) -> None
             ws.localBook[market]["asks"] = message["response"]["asks"]
             ws.localBook[market]["nonce"] = message["response"]["nonce"]
             ws.localBook[market]["market"] = market
-    elif "event" in message:
-        if message["event"] == "book":
-            market = message["market"]
+    elif "event" in message and message["event"] == "book":
+        market = message["market"]
 
-            if message["nonce"] != ws.localBook[market]["nonce"] + 1:
-                # I think I've fixed this, by looking at the other Bitvavo repos (search for 'nonce' or '!=' 😆)
-                ws.subscriptionBook(market, ws.callbacks[market])
-                return
-            ws.localBook[market]["bids"] = sortAndInsert(ws.localBook[market]["bids"], message["bids"], bidsCompare)
-            ws.localBook[market]["asks"] = sortAndInsert(ws.localBook[market]["asks"], message["asks"], asksCompare)
-            ws.localBook[market]["nonce"] = message["nonce"]
+        if message["nonce"] != ws.localBook[market]["nonce"] + 1:
+            # I think I've fixed this, by looking at the other Bitvavo repos (search for 'nonce' or '!=' 😆)
+            ws.subscriptionBook(market, ws.callbacks[market])
+            return
+        ws.localBook[market]["bids"] = sortAndInsert(ws.localBook[market]["bids"], message["bids"], bidsCompare)
+        ws.localBook[market]["asks"] = sortAndInsert(ws.localBook[market]["asks"], message["asks"], asksCompare)
+        ws.localBook[market]["nonce"] = message["nonce"]
 
     if market != "":
         ws.callbacks["subscriptionBookUser"][market](ws.localBook[market])
 
 
 class ReceiveThread(Thread):
-    def __init__(self, ws: WebSocketApp, ws_facade: "Bitvavo.WebSocketAppFacade"):
+    """This used to be `class rateLimitThread`."""
+
+    def __init__(self, ws: WebSocketApp, ws_facade: Bitvavo.WebSocketAppFacade) -> None:
         self.ws = ws
         self.ws_facade = ws_facade
         Thread.__init__(self)
 
     def run(self) -> None:
+        """This used to be `self.waitForReset`."""
         try:
             while self.ws_facade.keepAlive:
                 self.ws.run_forever()
@@ -118,9 +139,8 @@ class ReceiveThread(Thread):
                 self.ws_facade.authenticated = False
                 time.sleep(self.ws_facade.reconnectTimer)
                 if self.ws_facade.bitvavo.debugging:
-                    logger.debug(
-                        f"we have just set reconnect to true and have waited for {self.ws_facade.reconnectTimer}",
-                    )
+                    msg = f"we have just set reconnect to true and have waited for {self.ws_facade.reconnectTimer}"
+                    logger.debug(msg)
                 self.ws_facade.reconnectTimer = self.ws_facade.reconnectTimer * 2
         except KeyboardInterrupt:
             if self.ws_facade.bitvavo.debugging:
@@ -136,17 +156,18 @@ def callback_example(response: Any) -> None:
 
     I  made this so you can see what kind of function you'll need to stick into the websocket functions.
     """
-    if isinstance(response, Dict):
+    if isinstance(response, dict):
         # instead of printing, you could save the object to a file:
         import json
         from pathlib import Path
 
         HERE = Path.cwd()  # root of your project folder
         filepath = HERE / "your_output.json"
-        # a = append; figure out yourself to create multiple callback functions, probably one for each type of call that you want to make
+        # a = append; figure out yourself to create multiple callback functions, probably one for each type of call that
+        # you want to make
         with filepath.open("a") as file:
             file.write(json.dumps(response))
-    elif isinstance(response, List):
+    elif isinstance(response, list):
         # Whether `item` is a list or a dict doesn't matter to print
         for item in response:
             print(item)
@@ -187,9 +208,9 @@ def error_callback_example(msg: errordict) -> None:
         content=f"{msg}",
     ).execute()
     ```
-    """
+    """  # noqa: E501
     # easiest thing is to use the logger, but there's a good chance this message gets silently eaten.
-    logger.error(msg)
+    logger.error("error", msg=msg)
 
 
 class Bitvavo:
@@ -211,7 +232,9 @@ class Bitvavo:
     ```
     """
 
-    def __init__(self, options: Dict[str, Union[str, int]] = {}):
+    def __init__(self, options: dict[str, str | int] | None = None) -> None:
+        if options is None:
+            options = {}
         _options = {k.upper(): v for k, v in options.items()}
         self.base: str = str(_options.get("RESTURL", "https://api.bitvavo.com/v2"))
         self.wsUrl: str = str(_options.get("WSURL", "wss://ws.bitvavo.com/v2/"))
@@ -220,7 +243,7 @@ class Bitvavo:
         self.APISECRET = str(_options.get("APISECRET", ""))
         self.rateLimitRemaining: int = 1000
         self.rateLimitResetAt: ms = 0
-        # TODO(NostraDavid) for v2: remove this functionality - logger.debug is a level that can be set
+        # TODO(NostraDavid): for v2: remove this functionality - logger.debug is a level that can be set
         self.debugging = bool(_options.get("DEBUGGING", False))
 
     def calcLag(self) -> ms:
@@ -256,7 +279,7 @@ class Bitvavo:
         """
         return self.rateLimitRemaining
 
-    def updateRateLimit(self, response: Union[anydict, errordict]) -> None:
+    def updateRateLimit(self, response: anydict | errordict) -> None:
         """
         Update the rate limited
 
@@ -264,34 +287,33 @@ class Bitvavo:
 
         If you're not banned, then use the received headers to update the variables.
         """
-        if "errorCode" in response:
-            if response["errorCode"] == 105:
-                self.rateLimitRemaining = 0
-                # rateLimitResetAt is a value that's stripped from a string.
-                # Kind of a terrible way to pass that information, but eh, whatever, I guess...
-                # Anyway, here is the string that's being pulled apart:
-                # "Your IP or API key has been banned for not respecting the rate limit. The ban expires at ${expiryInMs}""
-                self.rateLimitResetAt = ms(response["error"].split(" at ")[1].split(".")[0])
-                timeToWait = time_to_wait(self.rateLimitResetAt)
-                logger.warning(
-                    "banned",
-                    info={
-                        "wait_time_seconds": timeToWait + 1,
-                        "until": (dt.datetime.now() + dt.timedelta(seconds=timeToWait + 1)).isoformat(),
-                    },
-                )
-                logger.info("napping-until-ban-lifted")
-                time.sleep(timeToWait + 1)  # plus one second to ENSURE we're able to run again.
-        if "Bitvavo-Ratelimit-Remaining" in response:
-            self.rateLimitRemaining = int(response["Bitvavo-Ratelimit-Remaining"])
-        if "Bitvavo-Ratelimit-ResetAt" in response:
-            self.rateLimitResetAt = int(response["Bitvavo-Ratelimit-ResetAt"])
+        if "errorCode" in response and response["errorCode"] == 105:  # noqa: PLR2004
+            self.rateLimitRemaining = 0
+            # rateLimitResetAt is a value that's stripped from a string.
+            # Kind of a terrible way to pass that information, but eh, whatever, I guess...
+            # Anyway, here is the string that's being pulled apart:
+            # "Your IP or API key has been banned for not respecting the rate limit. The ban expires at ${expiryInMs}""
+            self.rateLimitResetAt = ms(response["error"].split(" at ")[1].split(".")[0])
+            timeToWait = time_to_wait(self.rateLimitResetAt)
+            logger.warning(
+                "banned",
+                info={
+                    "wait_time_seconds": timeToWait + 1,
+                    "until": (dt.datetime.now(tz=dt.timezone.utc) + dt.timedelta(seconds=timeToWait + 1)).isoformat(),
+                },
+            )
+            logger.info("napping-until-ban-lifted")
+            time.sleep(timeToWait + 1)  # plus one second to ENSURE we're able to run again.
+        if "bitvavo-ratelimit-remaining" in response:
+            self.rateLimitRemaining = int(response["bitvavo-ratelimit-remaining"])
+        if "bitvavo-ratelimit-resetat" in response:
+            self.rateLimitResetAt = int(response["bitvavo-ratelimit-resetat"])
 
     def publicRequest(
         self,
         url: str,
         rateLimitingWeight: int = 1,
-    ) -> Union[List[anydict], List[List[str]], intdict, strdict, anydict, errordict]:
+    ) -> list[anydict] | list[list[str]] | intdict | strdict | anydict | errordict:
         """Execute a request to the public part of the API; no API key and/or SECRET necessary.
         Will return the reponse as one of three types.
 
@@ -305,9 +327,9 @@ class Bitvavo:
         Returns:
         ```python
         # either of one:
-        Dict[str, Any]
-        List[Dict[str, Any]]
-        List[List[str]]
+        dict[str, Any]
+        list[dict[str, Any]]
+        list[list[str]]
         ```
         """
         if (self.rateLimitRemaining - rateLimitingWeight) <= BITVAVO_API_UPGRADED.RATE_LIMITING_BUFFER:
@@ -323,12 +345,12 @@ class Bitvavo:
             )
         if self.APIKEY != "":
             now = time_ms() + BITVAVO_API_UPGRADED.LAG
-            sig = createSignature(now, "GET", url.replace(self.base, ""), {}, self.APISECRET)
+            sig = createSignature(now, "GET", url.replace(self.base, ""), None, self.APISECRET)
             headers = {
-                "Bitvavo-Access-Key": self.APIKEY,
-                "Bitvavo-Access-Signature": sig,
-                "Bitvavo-Access-Timestamp": str(now),
-                "Bitvavo-Access-Window": str(self.ACCESSWINDOW),
+                "bitvavo-access-key": self.APIKEY,
+                "bitvavo-access-signature": sig,
+                "bitvavo-access-timestamp": str(now),
+                "bitvavo-access-window": str(self.ACCESSWINDOW),
             }
             r = get(url, headers=headers, timeout=(self.ACCESSWINDOW / 1000))
         else:
@@ -337,16 +359,16 @@ class Bitvavo:
             self.updateRateLimit(r.json())
         else:
             self.updateRateLimit(dict(r.headers))
-        return r.json()  # type:ignore
+        return r.json()  # type:ignore[no-any-return]
 
     def privateRequest(
         self,
         endpoint: str,
         postfix: str,
-        body: anydict,
+        body: anydict | None = None,
         method: str = "GET",
         rateLimitingWeight: int = 1,
-    ) -> Union[List[anydict], List[List[str]], intdict, strdict, anydict, Any, errordict]:
+    ) -> list[anydict] | list[list[str]] | intdict | strdict | anydict | Any | errordict:
         """Execute a request to the private  part of the API. API key and SECRET are required.
         Will return the reponse as one of three types.
 
@@ -364,22 +386,22 @@ class Bitvavo:
         Returns:
         ```python
         # either of one:
-        Dict[str, Any]
-        List[Dict[str, Any]]
-        List[List[str]]
+        dict[str, Any]
+        list[dict[str, Any]]
+        list[list[str]]
         ```
         """
         if (self.rateLimitRemaining - rateLimitingWeight) <= BITVAVO_API_UPGRADED.RATE_LIMITING_BUFFER:
             self.sleep_until_can_continue()
-        # if this method breaks: add `= {}` after `body:Dict``
+        # if this method breaks: add `= {}` after `body: dict`
         now = time_ms() + BITVAVO_API_UPGRADED.LAG
         sig = createSignature(now, method, (endpoint + postfix), body, self.APISECRET)
         url = self.base + endpoint + postfix
         headers = {
-            "Bitvavo-Access-Key": self.APIKEY,
-            "Bitvavo-Access-Signature": sig,
-            "Bitvavo-Access-Timestamp": str(now),
-            "Bitvavo-Access-Window": str(self.ACCESSWINDOW),
+            "bitvavo-access-key": self.APIKEY,
+            "bitvavo-access-signature": sig,
+            "bitvavo-access-timestamp": str(now),
+            "bitvavo-access-window": str(self.ACCESSWINDOW),
         }
         if self.debugging:
             logger.debug(
@@ -405,12 +427,15 @@ class Bitvavo:
             self.updateRateLimit(dict(r.headers))
         return r.json()
 
-    def sleep_until_can_continue(self):
+    def sleep_until_can_continue(self) -> None:
         napTime = time_to_wait(self.rateLimitResetAt)
         logger.warning("rate-limit-reached", rateLimitRemaining=self.rateLimitRemaining)
-        logger.info("napping-until-reset", napTime=napTime,
-                    currentTime=dt.datetime.now().isoformat(),
-                    targetDatetime=dt.datetime.fromtimestamp(self.rateLimitResetAt / 1000.0).isoformat())
+        logger.info(
+            "napping-until-reset",
+            napTime=napTime,
+            currentTime=dt.datetime.now(tz=dt.timezone.utc).isoformat(),
+            targetDatetime=dt.datetime.fromtimestamp(self.rateLimitResetAt / 1000.0, tz=dt.timezone.utc).isoformat(),
+        )
         time.sleep(napTime + 1)  # +1 to add a tiny bit of buffer time
 
     def time(self) -> intdict:
@@ -432,9 +457,9 @@ class Bitvavo:
         {"time": 1539180275424 }
         ```
         """
-        return self.publicRequest(f"{self.base}/time")
+        return self.publicRequest(f"{self.base}/time")  # type: ignore[return-value]
 
-    def markets(self, options: strdict) -> Union[List[anydict], anydict, errordict]:
+    def markets(self, options: strdict | None = None) -> list[anydict] | anydict | errordict:
         """Get all available markets with some meta-information, unless options is given a `market` key.
         Then you will get a single market, instead of a list of markets.
 
@@ -484,9 +509,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/markets{postfix}")
+        return self.publicRequest(f"{self.base}/markets{postfix}")  # type: ignore[return-value]
 
-    def assets(self, options: strdict) -> Union[List[anydict], anydict]:
+    def assets(self, options: strdict | None = None) -> list[anydict] | anydict:
         """Get all available assets, unless `options` is given a `symbol` key.
         Then you will get a single asset, instead of a list of assets.
 
@@ -533,9 +558,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/assets{postfix}")
+        return self.publicRequest(f"{self.base}/assets{postfix}")  # type: ignore[return-value]
 
-    def book(self, market: str, options: intdict) -> Union[Dict[str, Union[str, int, List[str]]], errordict]:
+    def book(self, market: str, options: intdict | None = None) -> dict[str, str | int | list[str]] | errordict:
         """Get a book (with two lists: asks and bids, as they're called)
 
         ---
@@ -577,9 +602,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/{market}/book{postfix}")
+        return self.publicRequest(f"{self.base}/{market}/book{postfix}")  # type: ignore[return-value]
 
-    def publicTrades(self, market: str, options: Dict[str, Union[str, int]]) -> Union[List[anydict], errordict]:
+    def publicTrades(self, market: str, options: strintdict | None = None) -> list[anydict] | errordict:
         """Publically available trades
 
         ---
@@ -599,7 +624,8 @@ class Bitvavo:
         options={
             "limit": [ 1 .. 1000 ], default 500
             "start": int timestamp in ms >= 0
-            "end": int timestamp in ms <= 8_640_000_000_000_000 # (that's somewhere in the year 2243, or near the number 2^52)
+            # (that's somewhere in the year 2243, or near the number 2^52)
+            "end": int timestamp in ms <= 8_640_000_000_000_000
             "tradeIdFrom": ""  # if you get a list and want everything AFTER a certain id, put that id here
             "tradeIdTo": ""  # if you get a list and want everything BEFORE a certain id, put that id here
         }
@@ -626,14 +652,17 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/{market}/trades{postfix}", 5)
+        return self.publicRequest(f"{self.base}/{market}/trades{postfix}", 5)  # type: ignore[return-value]
 
-    def candles(
+    def candles(  # noqa: PLR0913
         self,
         market: str,
         interval: str,
-        options: Dict[str, Union[str, int]],
-    ) -> Union[List[List[str]], errordict]:
+        options: strintdict | None = None,
+        limit: int | None = None,
+        start: dt.datetime | None = None,
+        end: dt.datetime | None = None,
+    ) -> list[list[str]] | errordict:
         """Get up to 1440 candles for a market, with a specific interval (candle size)
 
         Extra reading material: https://en.wikipedia.org/wiki/Candlestick_chart
@@ -679,11 +708,18 @@ class Bitvavo:
         ]
         ```
         """
+        options = _default(options, {})
         options["interval"] = interval
+        if limit is not None:
+            options["limit"] = limit
+        if start is not None:
+            options["start"] = _epoch_millis(start)
+        if end is not None:
+            options["end"] = _epoch_millis(end)
         postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/{market}/candles{postfix}")
+        return self.publicRequest(f"{self.base}/{market}/candles{postfix}")  # type: ignore[return-value]
 
-    def tickerPrice(self, options: strdict) -> Union[List[strdict], strdict]:
+    def tickerPrice(self, options: strdict | None = None) -> list[strdict] | strdict:
         """Get the current price for each market
 
         ---
@@ -729,9 +765,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/ticker/price{postfix}")
+        return self.publicRequest(f"{self.base}/ticker/price{postfix}")  # type: ignore[return-value]
 
-    def tickerBook(self, options: strdict) -> Union[List[strdict], strdict]:
+    def tickerBook(self, options: strdict | None = None) -> list[strdict] | strdict:
         """Get current bid/ask, bidsize/asksize per market
 
         ---
@@ -770,9 +806,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/ticker/book{postfix}")
+        return self.publicRequest(f"{self.base}/ticker/book{postfix}")  # type: ignore[return-value]
 
-    def ticker24h(self, options: strdict) -> Union[List[anydict], anydict, errordict]:
+    def ticker24h(self, options: strdict | None = None) -> list[anydict] | anydict | errordict:
         """Get current bid/ask, bidsize/asksize per market
 
         ---
@@ -834,11 +870,12 @@ class Bitvavo:
         ]
         ```
         """
+        options = _default(options, {})
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
         postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/ticker/24h{postfix}", rateLimitingWeight)
+        return self.publicRequest(f"{self.base}/ticker/24h{postfix}", rateLimitingWeight)  # type: ignore[return-value]
 
     def placeOrder(self, market: str, side: str, orderType: str, body: anydict) -> anydict:
         """Place a new order on the exchange
@@ -959,15 +996,14 @@ class Bitvavo:
           "disableMarketProtection": true
         }
         ```
-        """
+        """  # noqa: E501
         body["market"] = market
         body["side"] = side
         body["orderType"] = orderType
-        return self.privateRequest("/order", "", body, "POST")
+        return self.privateRequest("/order", "", body, "POST")  # type: ignore[return-value]
 
     def updateOrder(self, market: str, orderId: str, body: anydict) -> anydict:
-        """Update an existing order for a specific market. Make sure that at least one of the optional parameters is set,
-        otherwise nothing will be updated.
+        """Update an existing order for a specific market. Make sure that at least one of the optional parameters is set, otherwise nothing will be updated.
 
         ---
         Args:
@@ -1044,10 +1080,10 @@ class Bitvavo:
           "disableMarketProtection": true
         }
         ```
-        """
+        """  # noqa: E501
         body["market"] = market
         body["orderId"] = orderId
-        return self.privateRequest("/order", "", body, "PUT")
+        return self.privateRequest("/order", "", body, "PUT")  # type: ignore[return-value]
 
     def cancelOrder(self, market: str, orderId: str) -> strdict:
         """Cancel an existing order for a specific market
@@ -1072,9 +1108,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix({"market": market, "orderId": orderId})
-        return self.privateRequest("/order", postfix, {}, "DELETE")
+        return self.privateRequest("/order", postfix, {}, "DELETE")  # type: ignore[return-value]
 
-    def getOrder(self, market: str, orderId: str) -> Union[List[anydict], errordict]:
+    def getOrder(self, market: str, orderId: str) -> list[anydict] | errordict:
         """Get an existing order for a specific market
 
         ---
@@ -1137,9 +1173,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix({"market": market, "orderId": orderId})
-        return self.privateRequest("/order", postfix, {}, "GET")
+        return self.privateRequest("/order", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def getOrders(self, market: str, options: anydict) -> Union[List[anydict], errordict]:
+    def getOrders(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
         """Get multiple existing orders for a specific market
 
         ---
@@ -1209,12 +1245,13 @@ class Bitvavo:
           }
         ]
         ```
-        """
+        """  # noqa: E501
+        options = _default(options, {})
         options["market"] = market
         postfix = createPostfix(options)
-        return self.privateRequest("/orders", postfix, {}, "GET", 5)
+        return self.privateRequest("/orders", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
-    def cancelOrders(self, options: anydict) -> Union[List[strdict], errordict]:
+    def cancelOrders(self, options: anydict | None = None) -> list[strdict] | errordict:
         """Cancel all existing orders for a specific market (or account)
 
         ---
@@ -1240,9 +1277,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix(options)
-        return self.privateRequest("/orders", postfix, {}, "DELETE")
+        return self.privateRequest("/orders", postfix, {}, "DELETE")  # type: ignore[return-value]
 
-    def ordersOpen(self, options: anydict) -> Union[List[anydict], errordict]:
+    def ordersOpen(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get all open orders, either for all markets, or a single market
 
         ---
@@ -1307,13 +1344,14 @@ class Bitvavo:
         ]
         ```
         """
+        options = _default(options, {})
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
         postfix = createPostfix(options)
-        return self.privateRequest("/ordersOpen", postfix, {}, "GET", rateLimitingWeight)
+        return self.privateRequest("/ordersOpen", postfix, {}, "GET", rateLimitingWeight)  # type: ignore[return-value]
 
-    def trades(self, market: str, options: anydict) -> Union[List[anydict], errordict]:
+    def trades(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
         """Get all historic trades from this account
 
         ---
@@ -1354,12 +1392,13 @@ class Bitvavo:
           }
         ]
         ```
-        """
+        """  # noqa: E501
+        options = _default(options, {})
         options["market"] = market
         postfix = createPostfix(options)
-        return self.privateRequest("/trades", postfix, {}, "GET", 5)
+        return self.privateRequest("/trades", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
-    def account(self) -> Dict[str, strdict]:
+    def account(self) -> dict[str, strdict]:
         """Get all fees for this account
 
         ---
@@ -1380,9 +1419,18 @@ class Bitvavo:
         }
         ```
         """
-        return self.privateRequest("/account", "", {}, "GET")
+        return self.privateRequest("/account", "", {}, "GET")  # type: ignore[return-value]
+
+    def fees(self, market: str | None = None, quote: str | None = None) -> list[strdict] | errordict:
+        options = {}
+        if market is not None:
+            options["market"] = market
+        if quote is not None:
+            options["quote"] = quote
+        postfix = createPostfix(options)
+        return self.privateRequest("/account/fees", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def balance(self, options: strdict) -> Union[List[strdict], errordict]:
+    def balance(self, options: strdict | None = None) -> list[strdict] | errordict:
         """Get the balance for this account
 
         ---
@@ -1411,7 +1459,7 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix(options)
-        return self.privateRequest("/balance", postfix, {}, "GET", 5)
+        return self.privateRequest("/balance", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
     def depositAssets(self, symbol: str) -> strdict:
         """Get the deposit address (with paymentId for some assets) or bank account information to increase your balance
@@ -1446,9 +1494,9 @@ class Bitvavo:
         ```
         """
         postfix = createPostfix({"symbol": symbol})
-        return self.privateRequest("/deposit", postfix, {}, "GET")
+        return self.privateRequest("/deposit", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def depositHistory(self, options: anydict) -> Union[List[anydict], errordict]:
+    def depositHistory(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get the deposit history of the account
 
         Even when you want something from a single `symbol`, you'll still receive a list with multiple deposits.
@@ -1495,9 +1543,9 @@ class Bitvavo:
           }
         ]
         ```
-        """
+        """  # noqa: E501
         postfix = createPostfix(options)
-        return self.privateRequest("/depositHistory", postfix, {}, "GET", 5)
+        return self.privateRequest("/depositHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
     def withdrawAssets(self, symbol: str, amount: str, address: str, body: anydict) -> anydict:
         """Withdraw a coin/token to an external crypto address or bank account.
@@ -1530,13 +1578,13 @@ class Bitvavo:
           "amount": "1.5"
         }
         ```
-        """
+        """  # noqa: E501
         body["symbol"] = symbol
         body["amount"] = amount
         body["address"] = address
-        return self.privateRequest("/withdrawal", "", body, "POST")
+        return self.privateRequest("/withdrawal", "", body, "POST")  # type: ignore[return-value]
 
-    def withdrawalHistory(self, options: anydict) -> Union[List[anydict], anydict]:
+    def withdrawalHistory(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get the withdrawal history
 
         ---
@@ -1572,11 +1620,11 @@ class Bitvavo:
           }
         }
         ```
-        """
+        """  # noqa: E501
         postfix = createPostfix(options)
-        return self.privateRequest("/withdrawalHistory", postfix, {}, "GET", 5)
+        return self.privateRequest("/withdrawalHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
-    def newWebsocket(self) -> "Bitvavo.WebSocketAppFacade":
+    def newWebsocket(self) -> Bitvavo.WebSocketAppFacade:
         return Bitvavo.WebSocketAppFacade(self.APIKEY, self.APISECRET, self.ACCESSWINDOW, self.wsUrl, self)
 
     class WebSocketAppFacade:
@@ -1586,7 +1634,14 @@ class Bitvavo:
         It's a facade for the WebSocketApp class, with its own implementation for the on_* methods
         """
 
-        def __init__(self, APIKEY: str, APISECRET: str, ACCESSWINDOW: int, WSURL: str, bitvavo: "Bitvavo"):
+        def __init__(
+            self,
+            APIKEY: str,
+            APISECRET: str,
+            ACCESSWINDOW: int,
+            WSURL: str,
+            bitvavo: Bitvavo,
+        ) -> None:
             self.APIKEY = APIKEY
             self.APISECRET = APISECRET
             self.ACCESSWINDOW = ACCESSWINDOW
@@ -1623,35 +1678,38 @@ class Bitvavo:
             self.keepAlive = False
             self.receiveThread.join()
 
-        def waitForSocket(self, ws: WebSocketApp, message: str, private: bool) -> None:
+        def waitForSocket(self, ws: WebSocketApp, message: str, private: bool) -> None:  # noqa: ARG002, FBT001
             while True:
                 if (not private and self.open) or (private and self.authenticated and self.open):
                     return
                 time.sleep(0.1)
 
-        def doSend(self, ws: WebSocketApp, message: str, private: bool = False) -> None:
-            # TODO(NostraDavid) add nap-time to the websocket, or do it here; I don't know yet.
+        def doSend(self, ws: WebSocketApp, message: str, private: bool = False) -> None:  # noqa: FBT001, FBT002
+            # TODO(NostraDavid): add nap-time to the websocket, or do it here; I don't know yet.
             if private and self.APIKEY == "":
-                logger.error("no-apikey", tip="set the API key to be able to make private API calls")
+                logger.error(
+                    "no-apikey",
+                    tip="set the API key to be able to make private API calls",
+                )
                 return
             self.waitForSocket(ws, message, private)
             ws.send(message)
             if self.bitvavo.debugging:
                 logger.debug("message-sent", message=message)
 
-        def on_message(self, ws, msg: str) -> None:  # noqa: C901 (too-complex)
+        def on_message(self, ws: Any, msg: str) -> None:  # noqa: C901, PLR0912, PLR0915, ARG002 (too-complex)
             if self.bitvavo.debugging:
                 logger.debug("message-received", message=msg)
             msg_dict: anydict = json.loads(msg)
             callbacks = self.callbacks
 
             if "error" in msg_dict:
-                if msg_dict["errorCode"] == 105:
+                if msg_dict["errorCode"] == 105:  # noqa: PLR2004
                     self.bitvavo.updateRateLimit(msg_dict)
                 if "error" in callbacks:
                     callbacks["error"](msg_dict)
                 else:
-                    logger.error(msg_dict)
+                    logger.error("error", msg_dict=msg_dict)
 
             if "action" in msg_dict:
                 if msg_dict["action"] == "getTime":
@@ -1686,6 +1744,8 @@ class Bitvavo:
                     callbacks["trades"](msg_dict["response"])
                 elif msg_dict["action"] == "privateGetAccount":
                     callbacks["account"](msg_dict["response"])
+                elif msg_dict["action"] == "privateGetFees":
+                    callbacks["fees"](msg_dict["response"])
                 elif msg_dict["action"] == "privateGetBalance":
                     callbacks["balance"](msg_dict["response"])
                 elif msg_dict["action"] == "privateDepositAssets":
@@ -1702,17 +1762,13 @@ class Bitvavo:
                     market = msg_dict["response"]["market"]
                     if "book" in callbacks:
                         callbacks["book"](msg_dict["response"])
-                    if self.keepBookCopy:
-                        if market in callbacks["subscriptionBook"]:
-                            callbacks["subscriptionBook"][market](self, msg_dict)
+                    if self.keepBookCopy and market in callbacks["subscriptionBook"]:
+                        callbacks["subscriptionBook"][market](self, msg_dict)
 
             elif "event" in msg_dict:
                 if msg_dict["event"] == "authenticate":
                     self.authenticated = True
-                elif msg_dict["event"] == "fill":
-                    market = msg_dict["market"]
-                    callbacks["subscriptionAccount"][market](msg_dict)
-                elif msg_dict["event"] == "order":
+                elif msg_dict["event"] == "fill" or msg_dict["event"] == "order":
                     market = msg_dict["market"]
                     callbacks["subscriptionAccount"][market](msg_dict)
                 elif msg_dict["event"] == "ticker":
@@ -1727,29 +1783,27 @@ class Bitvavo:
                     callbacks["subscriptionCandles"][market][interval](msg_dict)
                 elif msg_dict["event"] == "book":
                     market = msg_dict["market"]
-                    if "subscriptionBookUpdate" in callbacks:
-                        if market in callbacks["subscriptionBookUpdate"]:
-                            callbacks["subscriptionBookUpdate"][market](msg_dict)
-                    if self.keepBookCopy:
-                        if market in callbacks["subscriptionBook"]:
-                            callbacks["subscriptionBook"][market](self, msg_dict)
+                    if "subscriptionBookUpdate" in callbacks and market in callbacks["subscriptionBookUpdate"]:
+                        callbacks["subscriptionBookUpdate"][market](msg_dict)
+                    if self.keepBookCopy and market in callbacks["subscriptionBook"]:
+                        callbacks["subscriptionBook"][market](self, msg_dict)
                 elif msg_dict["event"] == "trade":
                     market = msg_dict["market"]
                     if "subscriptionTrades" in callbacks:
                         callbacks["subscriptionTrades"][market](msg_dict)
 
-        def on_error(self, ws, error: Any) -> None:
+        def on_error(self, ws: Any, error: Any) -> None:  # noqa: ARG002
             if "error" in self.callbacks:
                 self.callbacks["error"](error)
             else:
                 logger.error(error)
 
-        def on_close(self, ws) -> None:
+        def on_close(self, ws: Any) -> None:  # noqa: ARG002
             self.receiveThread.stop()
             if self.bitvavo.debugging:
                 logger.debug("websocket-closed")
 
-        def checkReconnect(self) -> None:  # noqa: C901 (too-complex)
+        def checkReconnect(self) -> None:  # noqa: C901, PLR0912 (too-complex)
             if "subscriptionTicker" in self.callbacks:
                 for market in self.callbacks["subscriptionTicker"]:
                     self.subscriptionTicker(market, self.callbacks["subscriptionTicker"][market])
@@ -1777,7 +1831,7 @@ class Bitvavo:
                 for market in self.callbacks["subscriptionBookUser"]:
                     self.subscriptionBook(market, self.callbacks["subscriptionBookUser"][market])
 
-        def on_open(self, ws) -> None:
+        def on_open(self, ws: Any) -> None:  # noqa: ARG002
             now = time_ms() + BITVAVO_API_UPGRADED.LAG
             self.open = True
             self.reconnectTimer = 0.5
@@ -2028,13 +2082,19 @@ class Bitvavo:
               }
             ]
             ```
-            """
+            """  # noqa: E501
             self.callbacks["publicTrades"] = callback
             options["market"] = market
             options["action"] = "getTrades"
             self.doSend(self.ws, json.dumps(options))
 
-        def candles(self, market: str, interval: str, options: anydict, callback: Callable[[Any], None]) -> None:
+        def candles(
+            self,
+            market: str,
+            interval: str,
+            options: anydict,
+            callback: Callable[[Any], None],
+        ) -> None:
             """Get up to 1440 candles for a market, with a specific interval (candle size)
 
             Extra reading material: https://en.wikipedia.org/wiki/Candlestick_chart
@@ -2175,7 +2235,7 @@ class Bitvavo:
                 # and another 215 markets below this point
             ]
             ```
-            """
+            """  # noqa: E501
             self.callbacks["tickerBook"] = callback
             options["action"] = "getTickerBook"
             self.doSend(self.ws, json.dumps(options))
@@ -2374,7 +2434,7 @@ class Bitvavo:
               "disableMarketProtection": true
             }
             ```
-            """
+            """  # noqa: E501
             self.callbacks["placeOrder"] = callback
             body["market"] = market
             body["side"] = side
@@ -2382,9 +2442,16 @@ class Bitvavo:
             body["action"] = "privateCreateOrder"
             self.doSend(self.ws, json.dumps(body), True)
 
-        def updateOrder(self, market: str, orderId: str, body: anydict, callback: Callable[[Any], None]) -> None:
-            """Update an existing order for a specific market. Make sure that at least one of the optional parameters is set,
-            otherwise nothing will be updated.
+        def updateOrder(
+            self,
+            market: str,
+            orderId: str,
+            body: anydict,
+            callback: Callable[[Any], None],
+        ) -> None:
+            """
+            Update an existing order for a specific market. Make sure that at least one of the optional parameters
+            is set, otherwise nothing will be updated.
 
             ---
             Args:
@@ -2462,7 +2529,7 @@ class Bitvavo:
               "disableMarketProtection": true
             }
             ```
-            """
+            """  # noqa: E501
             self.callbacks["updateOrder"] = callback
             body["market"] = market
             body["orderId"] = orderId
@@ -2581,9 +2648,12 @@ class Bitvavo:
             options={
                 "limit": [ 1 .. 1000 ], default 500
                 "start": int timestamp in ms >= 0
-                "end": int timestamp in ms <= 8_640_000_000_000_000 # (that's somewhere in the year 2243, or near the number 2^52)
-                "tradeIdFrom": ""  # if you get a list and want everything AFTER a certain id, put that id here
-                "tradeIdTo": ""  # if you get a list and want everything BEFORE a certain id, put that id here
+                # (that's somewhere in the year 2243, or near the number 2^52)
+                "end": int timestamp in ms <= 8_640_000_000_000_000
+                # if you get a list and want everything AFTER a certain id, put that id here
+                "tradeIdFrom": ""
+                # if you get a list and want everything BEFORE a certain id, put that id here
+                "tradeIdTo": ""
             }
             callback=callback_example
             ```
@@ -2758,7 +2828,8 @@ class Bitvavo:
             options={
                 "limit": [ 1 .. 1000 ], default 500
                 "start": int timestamp in ms >= 0
-                "end": int timestamp in ms <= 8_640_000_000_000_000 # (that's somewhere in the year 2243, or near the number 2^52)
+                # (that's somewhere in the year 2243, or near the number 2^52)
+                "end": int timestamp in ms <= 8_640_000_000_000_000
                 "tradeIdFrom": ""  # if you get a list and want everything AFTER a certain id, put that id here
                 "tradeIdTo": ""  # if you get a list and want everything BEFORE a certain id, put that id here
             }
@@ -2860,7 +2931,9 @@ class Bitvavo:
             self.doSend(self.ws, json.dumps(options), True)
 
         def depositAssets(self, symbol: str, callback: Callable[[Any], None]) -> None:
-            """Get the deposit address (with paymentId for some assets) or bank account information to increase your balance
+            """
+            Get the deposit address (with paymentId for some assets) or bank account information to increase your
+            balance.
 
             ---
             Args:
@@ -2911,7 +2984,8 @@ class Bitvavo:
                 "symbol":"EUR"
                 "limit": [ 1 .. 1000 ], default 500
                 "start": int timestamp in ms >= 0
-                "end": int timestamp in ms <= 8_640_000_000_000_000 # (that's somewhere in the year 2243, or near the number 2^52)
+                # (that's somewhere in the year 2243, or near the number 2^52)
+                "end": int timestamp in ms <= 8_640_000_000_000_000
             }
             callback=callback_example
             ```
@@ -2969,9 +3043,15 @@ class Bitvavo:
             amount=10
             address="BitcoinAddress",  # Wallet address or IBAN
             options={
-              "paymentId": "10002653",  # For digital assets only. Should be set when withdrawing straight to another exchange or merchants that require payment id's.
-              "internal": false,  # For digital assets only. Should be set to true if the withdrawal must be sent to another Bitvavo user internally
-              "addWithdrawalFee": false  # If set to true, the fee will be added on top of the requested amount, otherwise the fee is part of the requested amount and subtracted from the withdrawal.
+              # For digital assets only. Should be set when withdrawing straight to another exchange or merchants that
+              # require payment id's.
+              "paymentId": "10002653",
+              # For digital assets only. Should be set to true if the withdrawal must be sent to another Bitvavo user
+              # internally
+              "internal": false,
+              # If set to true, the fee will be added on top of the requested amount, otherwise the fee is part of the
+              # requested amount and subtracted from the withdrawal.
+              "addWithdrawalFee": false
             }
             callback=callback_example
             ```
@@ -3009,7 +3089,8 @@ class Bitvavo:
                 "symbol":"SHIB"
                 "limit": [ 1 .. 1000 ], default 500
                 "start": int timestamp in ms >= 0
-                "end": int timestamp in ms <= 8_640_000_000_000_000 # (that's somewhere in the year 2243, or near the number 2^52)
+                # (that's somewhere in the year 2243, or near the number 2^52)
+                "end": int timestamp in ms <= 8_640_000_000_000_000
             }
             callback=callback_example
             ```
@@ -3042,8 +3123,11 @@ class Bitvavo:
             self.doSend(self.ws, json.dumps(options), True)
 
         def subscriptionTicker(self, market: str, callback: Callable[[Any], None]) -> None:
-            # TODO(NostraDavid) one possible improvement here is to turn `market` into a list of markets, so we can sub to all of them at once. Same goes for other `subscription*()`
-            """Subscribe to the ticker channel, which means `callback` gets passed the new best bid or ask whenever they change (server-side).
+            # TODO(NostraDavid): one possible improvement here is to turn `market` into a list of markets, so we can sub
+            # to all of them at once. Same goes for other `subscription*()`
+            """
+            Subscribe to the ticker channel, which means `callback` gets passed the new best bid or ask whenever they
+            change (server-side).
 
 
             ---
@@ -3091,7 +3175,9 @@ class Bitvavo:
             )
 
         def subscriptionTicker24h(self, market: str, callback: Callable[[Any], None]) -> None:
-            """Subscribe to the ticker-24-hour channel, which means `callback` gets passed the new object every second, if values have changed.
+            """
+            Subscribe to the ticker-24-hour channel, which means `callback` gets passed the new object every second, if
+            values have changed.
 
             ---
             Args:
@@ -3146,8 +3232,9 @@ class Bitvavo:
             )
 
         def subscriptionAccount(self, market: str, callback: Callable[[Any], None]) -> None:
-            """Subscribes to the account channel, which sends an update whenever an event happens which is related to the account.
-            These are 'order' events (create, update, cancel) or 'fill' events (a trade occurred).
+            """
+            Subscribes to the account channel, which sends an update whenever an event happens which is related to
+            the account. These are 'order' events (create, update, cancel) or 'fill' events (a trade occurred).
 
             ---
             Args: