crypticorn 2.5.0rc5__tar.gz → 2.5.2__tar.gz

{crypticorn-2.5.0rc5 → crypticorn-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crypticorn
-Version: 2.5.0rc5
+Version: 2.5.2
 Summary: Maximise Your Crypto Trading Profits with AI Predictions
 Author-email: Crypticorn <timon@crypticorn.com>
 Project-URL: Homepage, https://crypticorn.com
@@ -36,6 +36,7 @@ Requires-Dist: pytest==8.3.5; extra == "test"
 Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
 Requires-Dist: pytest-cov==6.1.1; extra == "test"
 Requires-Dist: python-dotenv==1.0.1; extra == "test"
+Requires-Dist: PyJWT==2.10.0; extra == "test"
 Provides-Extra: extra
 Requires-Dist: pandas<3.0.0,>=2.2.0; extra == "extra"
 
@@ -86,7 +87,7 @@ The `common` submodule contains shared classes not bound to a specific API.
 from crypticorn.common import Scope, Exchange
 ```
 
-## Usage
+## Basic Usage
 
 ### With Async Context Protocol
 ```python
@@ -107,6 +108,7 @@ async def main():
 
 asyncio.run(main())
 asyncio.run(client.close())
+
 ## Response Types
 
 There are three different available output formats you can choose from:
@@ -155,12 +157,12 @@ The output would look like this:
 
 ## Advanced Usage
 
-You can override some configuration for specific sub clients. If you just want to use the API as is, you don't need to configure anything.
+You can override some configuration for specific services. If you just want to use the API as is, you don't need to configure anything.
 This might be of use if you are testing a specific API locally.
 
-To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default caddy proxy, you would do:
+To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default proxy, you would do:
 ```python
 from crypticorn.hive import Configuration as Hiveconfig
 async with ApiClient(base_url=BaseUrl.DEV) as client:
-        client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+        client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
 ```

{crypticorn-2.5.0rc5 → crypticorn-2.5.2}/README.md

@@ -45,7 +45,7 @@ The `common` submodule contains shared classes not bound to a specific API.
 from crypticorn.common import Scope, Exchange
 ```
 
-## Usage
+## Basic Usage
 
 ### With Async Context Protocol
 ```python
@@ -66,6 +66,7 @@ async def main():
 
 asyncio.run(main())
 asyncio.run(client.close())
+
 ## Response Types
 
 There are three different available output formats you can choose from:
@@ -114,12 +115,12 @@ The output would look like this:
 
 ## Advanced Usage
 
-You can override some configuration for specific sub clients. If you just want to use the API as is, you don't need to configure anything.
+You can override some configuration for specific services. If you just want to use the API as is, you don't need to configure anything.
 This might be of use if you are testing a specific API locally.
 
-To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default caddy proxy, you would do:
+To override e.g. the host for the Hive client to connect to http://localhost:8000 instead of the default proxy, you would do:
 ```python
 from crypticorn.hive import Configuration as Hiveconfig
 async with ApiClient(base_url=BaseUrl.DEV) as client:
-        client.configure(config=HiveConfig(host="http://localhost:8000"), sub_client=client.hive)
+        client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
 ```

{crypticorn-2.5.0rc5 → crypticorn-2.5.2}/crypticorn/auth/main.py

@@ -14,6 +14,8 @@ class AuthClient:
     A client for interacting with the Crypticorn Auth API.
     """
 
+    config_class = Configuration
+
     def __init__(
         self,
         config: Configuration,

crypticorn-2.5.2/crypticorn/client.py

@@ -0,0 +1,122 @@
+from typing import TypeVar
+from crypticorn.hive import HiveClient
+from crypticorn.klines import KlinesClient
+from crypticorn.pay import PayClient
+from crypticorn.trade import TradeClient
+from crypticorn.metrics import MetricsClient
+from crypticorn.auth import AuthClient
+from crypticorn.common import BaseUrl, ApiVersion, Service, apikey_header as aph
+
+ConfigT = TypeVar("ConfigT")
+SubClient = TypeVar("SubClient")
+
+
+class ApiClient:
+    """
+    The official client for interacting with the Crypticorn API.
+
+    It is consisting of multiple microservices covering the whole stack of the Crypticorn project.
+    """
+
+    def __init__(
+        self,
+        api_key: str = None,
+        jwt: str = None,
+        base_url: BaseUrl = BaseUrl.PROD,
+    ):
+        self.base_url = base_url
+        """The base URL the client will use to connect to the API."""
+        self.api_key = api_key
+        """The API key to use for authentication."""
+        self.jwt = jwt
+        """The JWT to use for authentication."""
+
+        self.service_classes: dict[Service, type[SubClient]] = {
+            Service.HIVE: HiveClient,
+            Service.TRADE: TradeClient,
+            Service.KLINES: KlinesClient,
+            Service.PAY: PayClient,
+            Service.METRICS: MetricsClient,
+            Service.AUTH: AuthClient,
+        }
+
+        self.services: dict[Service, SubClient] = {
+            service: client_class(self._get_default_config(service))
+            for service, client_class in self.service_classes.items()
+        }
+
+    @property
+    def hive(self) -> HiveClient:
+        return self.services[Service.HIVE]
+
+    @property
+    def trade(self) -> TradeClient:
+        return self.services[Service.TRADE]
+
+    @property
+    def klines(self) -> KlinesClient:
+        return self.services[Service.KLINES]
+
+    @property
+    def metrics(self) -> MetricsClient:
+        return self.services[Service.METRICS]
+
+    @property
+    def pay(self) -> PayClient:
+        return self.services[Service.PAY]
+
+    @property
+    def auth(self) -> AuthClient:
+        return self.services[Service.AUTH]
+
+    async def close(self):
+        """Close all client sessions."""
+        for service in self.services.values():
+            if hasattr(service.base_client, "close"):
+                await service.base_client.close()
+
+    def _get_default_config(
+        self, service: Service, version: ApiVersion = ApiVersion.V1
+    ):
+        """
+        Get the default configuration for a given service.
+        """
+        config_class = self.service_classes[service].config_class
+        return config_class(
+            host=f"{self.base_url}/{version}/{service}",
+            access_token=self.jwt,
+            api_key={aph.scheme_name: self.api_key} if self.api_key else None,
+        )
+
+    def configure(
+        self,
+        config: ConfigT,
+        service: Service,
+    ):
+        """
+        Update a sub-client's configuration by overriding with the values set in the new config.
+        Useful for testing a specific service against a local server instead of the default proxy.
+
+        :param config: The new configuration to use for the sub-client.
+        :param service: The service to configure.
+
+        Example:
+        >>> async with ApiClient(base_url=BaseUrl.DEV, jwt=jwt) as client:
+        >>>     client.configure(config=HiveConfig(host="http://localhost:8000"), client=client.hive)
+        """
+        assert Service.validate(service), f"Invalid service: {service}"
+        client = self.services[service]
+        new_config = client.config
+
+        for attr in vars(config):
+            new_value = getattr(config, attr)
+            if new_value:
+                setattr(new_config, attr, new_value)
+
+        self.services[service] = type(client)(new_config)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()

{crypticorn-2.5.0rc5 → crypticorn-2.5.2}/crypticorn/common/__init__.py

@@ -1,8 +1,10 @@
 from crypticorn.common.errors import *
 from crypticorn.common.scopes import *
 from crypticorn.common.urls import *
-from crypticorn.common.pydantic import *
+from crypticorn.common.decorators import *
+from crypticorn.common.mixins import *
 from crypticorn.common.auth import *
 from crypticorn.common.enums import *
 from crypticorn.common.utils import *
 from crypticorn.common.exceptions import *
+from crypticorn.common.status_router import router as status_router

{crypticorn-2.5.0rc5 → crypticorn-2.5.2}/crypticorn/common/auth.py

@@ -2,14 +2,10 @@ import json
 
 from crypticorn.auth import Verify200Response, AuthClient, Configuration
 from crypticorn.auth.client.exceptions import ApiException
-from crypticorn.common import (
-    ApiError,
-    ApiVersion,
-    BaseUrl,
-    Scope,
-    Service,
-)
-from fastapi import Depends, HTTPException, Query, status, WebSocketException
+from crypticorn.common.scopes import Scope
+from crypticorn.common.exceptions import ApiError, HTTPException, ExceptionContent
+from crypticorn.common.urls import BaseUrl, Service, ApiVersion
+from fastapi import Depends, Query, status, WebSocketException
 from fastapi.security import (
     HTTPAuthorizationCredentials,
     SecurityScopes,
@@ -48,11 +44,6 @@ class AuthHandler:
         self.url = f"{base_url}/{ApiVersion.V1}/{Service.AUTH}"
         self.client = AuthClient(Configuration(host=self.url))
 
-        self.no_credentials_exception = HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=ApiError.NO_CREDENTIALS.identifier,
-        )
-
     async def _verify_api_key(self, api_key: str) -> Verify200Response:
         """
         Verifies the API key.
@@ -76,8 +67,10 @@ class AuthHandler:
         """
         if not set(api_scopes).issubset(user_scopes):
             raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail=ApiError.INSUFFICIENT_SCOPES.identifier,
+                content=ExceptionContent(
+                    error=ApiError.INSUFFICIENT_SCOPES,
+                    message="Insufficient scopes to access this resource",
+                ),
             )
 
     async def _extract_message(self, e: ApiException) -> str:
@@ -100,16 +93,33 @@ class AuthHandler:
         Handles exceptions and returns a HTTPException with the appropriate status code and detail.
         """
         if isinstance(e, ApiException):
+            # handle the TRPC Zod errors from auth-service
+            # Unfortunately, we cannot share the error messages defined in python/crypticorn/common/errors.py with the typescript client
+            message = await self._extract_message(e)
+            if message == "Invalid API key":
+                error = ApiError.INVALID_API_KEY
+            elif message == "API key expired":
+                error = ApiError.EXPIRED_API_KEY
+            elif message == "jwt expired":
+                error = ApiError.EXPIRED_BEARER
+            else:
+                error = (
+                    ApiError.INVALID_BEARER
+                )  # jwt malformed, jwt not active (https://www.npmjs.com/package/jsonwebtoken#errors--codes)
             return HTTPException(
-                status_code=e.status,
-                detail=await self._extract_message(e),
+                content=ExceptionContent(
+                    error=error,
+                    message=message,
+                ),
             )
         elif isinstance(e, HTTPException):
             return e
         else:
             return HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=str(e),
+                content=ExceptionContent(
+                    error=ApiError.UNKNOWN_ERROR,
+                    message=str(e),
+                ),
             )
 
     async def api_key_auth(
@@ -172,7 +182,15 @@ class AuthHandler:
                 last_error = await self._handle_exception(e)
                 continue
 
-        raise last_error or self.no_credentials_exception
+        if last_error:
+            raise last_error
+        else:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.NO_CREDENTIALS,
+                    message="No credentials provided",
+                ),
+            )
 
     async def ws_api_key_auth(
         self,

crypticorn-2.5.2/crypticorn/common/enums.py

@@ -0,0 +1,29 @@
+from enum import StrEnum
+from crypticorn.common.mixins import ValidateEnumMixin, ExcludeEnumMixin
+
+
+class Exchange(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
+    """Supported exchanges for trading"""
+
+    KUCOIN = "kucoin"
+    BINGX = "bingx"
+
+
+class InternalExchange(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
+    """All exchanges we are using, including public (Exchange)"""
+
+    KUCOIN = "kucoin"
+    BINGX = "bingx"
+    BINANCE = "binance"
+    BYBIT = "bybit"
+    HYPERLIQUID = "hyperliquid"
+    BITGET = "bitget"
+
+
+class MarketType(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
+    """
+    Market types
+    """
+
+    SPOT = "spot"
+    FUTURES = "futures"

{crypticorn-2.5.0rc5 → crypticorn-2.5.2}/crypticorn/common/errors.py

@@ -1,6 +1,7 @@
 from enum import Enum, EnumMeta, StrEnum
 import logging
 from fastapi import status
+from crypticorn.common.mixins import ExcludeEnumMixin
 
 logger = logging.getLogger(__name__)
 
@@ -18,7 +19,7 @@ class Fallback(EnumMeta):
         return cls.UNKNOWN_ERROR
 
 
-class ApiErrorType(StrEnum):
+class ApiErrorType(ExcludeEnumMixin, StrEnum):
     """Type of API error"""
 
     USER_ERROR = "user error"
@@ -31,15 +32,17 @@ class ApiErrorType(StrEnum):
     """error that does not need to be handled or does not affect the program or is a placeholder."""
 
 
-class ApiErrorIdentifier(StrEnum):
+class ApiErrorIdentifier(ExcludeEnumMixin, StrEnum):
     """API error identifiers"""
 
     ALLOCATION_BELOW_EXPOSURE = "allocation_below_current_exposure"
     ALLOCATION_BELOW_MINIMUM = "allocation_below_min_amount"
+    ALPHANUMERIC_CHARACTERS_ONLY = "alphanumeric_characters_only"
     BLACK_SWAN = "black_swan"
     BOT_ALREADY_DELETED = "bot_already_deleted"
     BOT_DISABLED = "bot_disabled"
     BOT_STOPPING_COMPLETED = "bot_stopping_completed"
+    BOT_STOPPING_STARTED = "bot_stopping_started"
     CLIENT_ORDER_ID_REPEATED = "client_order_id_already_exists"
     CONTENT_TYPE_ERROR = "invalid_content_type"
     DELETE_BOT_ERROR = "delete_bot_error"
@@ -56,6 +59,9 @@ class ApiErrorIdentifier(StrEnum):
     EXCHANGE_SYSTEM_CONFIG_ERROR = "exchange_system_configuration_error"
     EXCHANGE_SYSTEM_ERROR = "exchange_internal_system_error"
     EXCHANGE_USER_FROZEN = "exchange_user_account_is_frozen"
+    EXPIRED_API_KEY = "api_key_expired"
+    EXPIRED_BEARER = "bearer_token_expired"
+    FORBIDDEN = "forbidden"
     HEDGE_MODE_NOT_ACTIVE = "hedge_mode_not_active"
     HTTP_ERROR = "http_request_error"
     INSUFFICIENT_BALANCE = "insufficient_balance"
@@ -68,13 +74,15 @@ class ApiErrorIdentifier(StrEnum):
     INVALID_EXCHANGE_KEY = "invalid_exchange_key"
     INVALID_MARGIN_MODE = "invalid_margin_mode"
     INVALID_PARAMETER = "invalid_parameter_provided"
-    JWT_EXPIRED = "jwt_expired"
     LEVERAGE_EXCEEDED = "leverage_limit_exceeded"
     LIQUIDATION_PRICE_VIOLATION = "order_violates_liquidation_price_constraints"
     NO_CREDENTIALS = "no_credentials"
     NOW_API_DOWN = "now_api_down"
-    OBJECT_NOT_FOUND = "object_not_found"
     OBJECT_ALREADY_EXISTS = "object_already_exists"
+    OBJECT_CREATED = "object_created"
+    OBJECT_DELETED = "object_deleted"
+    OBJECT_NOT_FOUND = "object_not_found"
+    OBJECT_UPDATED = "object_updated"
     ORDER_ALREADY_FILLED = "order_is_already_filled"
     ORDER_IN_PROCESS = "order_is_being_processed"
     ORDER_LIMIT_EXCEEDED = "order_quantity_limit_exceeded"
@@ -90,6 +98,7 @@ class ApiErrorIdentifier(StrEnum):
     RISK_LIMIT_EXCEEDED = "risk_limit_exceeded"
     RPC_TIMEOUT = "rpc_timeout"
     SETTLEMENT_IN_PROGRESS = "system_settlement_in_process"
+    STRATEGY_ALREADY_EXISTS = "strategy_already_exists"
     STRATEGY_DISABLED = "strategy_disabled"
     STRATEGY_LEVERAGE_MISMATCH = "strategy_leverage_mismatch"
     STRATEGY_NOT_SUPPORTING_EXCHANGE = "strategy_not_supporting_exchange"
@@ -108,7 +117,7 @@ class ApiErrorIdentifier(StrEnum):
         return ApiError[self.value]
 
 
-class ApiErrorLevel(StrEnum):
+class ApiErrorLevel(ExcludeEnumMixin, StrEnum):
     """API error levels"""
 
     ERROR = "error"
@@ -117,7 +126,7 @@ class ApiErrorLevel(StrEnum):
     WARNING = "warning"
 
 
-class ApiError(Enum, metaclass=Fallback):
+class ApiError(ExcludeEnumMixin, Enum, metaclass=Fallback):
     """API error codes. Fallback to UNKNOWN_ERROR for error codes not yet published to PyPI."""
 
     ALLOCATION_BELOW_EXPOSURE = (
@@ -130,6 +139,11 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.USER_ERROR,
         ApiErrorLevel.ERROR,
     )
+    ALPHANUMERIC_CHARACTERS_ONLY = (
+        ApiErrorIdentifier.ALPHANUMERIC_CHARACTERS_ONLY,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
     BLACK_SWAN = (
         ApiErrorIdentifier.BLACK_SWAN,
         ApiErrorType.USER_ERROR,
@@ -150,6 +164,11 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.NO_ERROR,
         ApiErrorLevel.INFO,
     )
+    BOT_STOPPING_STARTED = (
+        ApiErrorIdentifier.BOT_STOPPING_STARTED,
+        ApiErrorType.NO_ERROR,
+        ApiErrorLevel.INFO,
+    )
     CLIENT_ORDER_ID_REPEATED = (
         ApiErrorIdentifier.CLIENT_ORDER_ID_REPEATED,
         ApiErrorType.SERVER_ERROR,
@@ -230,6 +249,21 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.USER_ERROR,
         ApiErrorLevel.ERROR,
     )
+    EXPIRED_API_KEY = (
+        ApiErrorIdentifier.EXPIRED_API_KEY,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
+    EXPIRED_BEARER = (
+        ApiErrorIdentifier.EXPIRED_BEARER,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
+    FORBIDDEN = (
+        ApiErrorIdentifier.FORBIDDEN,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
     HEDGE_MODE_NOT_ACTIVE = (
         ApiErrorIdentifier.HEDGE_MODE_NOT_ACTIVE,
         ApiErrorType.USER_ERROR,
@@ -290,11 +324,6 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.SERVER_ERROR,
         ApiErrorLevel.ERROR,
     )
-    JWT_EXPIRED = (
-        ApiErrorIdentifier.JWT_EXPIRED,
-        ApiErrorType.SERVER_ERROR,
-        ApiErrorLevel.ERROR,
-    )
     LEVERAGE_EXCEEDED = (
         ApiErrorIdentifier.LEVERAGE_EXCEEDED,
         ApiErrorType.SERVER_ERROR,
@@ -315,15 +344,30 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.SERVER_ERROR,
         ApiErrorLevel.ERROR,
     )
+    OBJECT_ALREADY_EXISTS = (
+        ApiErrorIdentifier.OBJECT_ALREADY_EXISTS,
+        ApiErrorType.SERVER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
+    OBJECT_CREATED = (
+        ApiErrorIdentifier.OBJECT_CREATED,
+        ApiErrorType.SERVER_ERROR,
+        ApiErrorLevel.INFO,
+    )
+    OBJECT_DELETED = (
+        ApiErrorIdentifier.OBJECT_DELETED,
+        ApiErrorType.SERVER_ERROR,
+        ApiErrorLevel.INFO,
+    )
     OBJECT_NOT_FOUND = (
         ApiErrorIdentifier.OBJECT_NOT_FOUND,
         ApiErrorType.SERVER_ERROR,
         ApiErrorLevel.ERROR,
     )
-    OBJECT_ALREADY_EXISTS = (
-        ApiErrorIdentifier.OBJECT_ALREADY_EXISTS,
+    OBJECT_UPDATED = (
+        ApiErrorIdentifier.OBJECT_UPDATED,
         ApiErrorType.SERVER_ERROR,
-        ApiErrorLevel.ERROR,
+        ApiErrorLevel.INFO,
     )
     ORDER_ALREADY_FILLED = (
         ApiErrorIdentifier.ORDER_ALREADY_FILLED,
@@ -400,6 +444,11 @@ class ApiError(Enum, metaclass=Fallback):
         ApiErrorType.EXCHANGE_ERROR,
         ApiErrorLevel.ERROR,
     )
+    STRATEGY_ALREADY_EXISTS = (
+        ApiErrorIdentifier.STRATEGY_ALREADY_EXISTS,
+        ApiErrorType.USER_ERROR,
+        ApiErrorLevel.ERROR,
+    )
     STRATEGY_DISABLED = (
         ApiErrorIdentifier.STRATEGY_DISABLED,
         ApiErrorType.USER_ERROR,
@@ -476,18 +525,18 @@ class ApiError(Enum, metaclass=Fallback):
 class HttpStatusMapper:
     """Map API errors to HTTP status codes."""
 
-    # TODO: decide if we need all of these mappings, since most errors are not exposed to the client via HTTP
-    # in case we remove some, update the pytest length check
     _mapping = {
         # Authentication/Authorization
-        ApiError.JWT_EXPIRED: status.HTTP_401_UNAUTHORIZED,
+        ApiError.EXPIRED_BEARER: status.HTTP_401_UNAUTHORIZED,
         ApiError.INVALID_BEARER: status.HTTP_401_UNAUTHORIZED,
+        ApiError.EXPIRED_API_KEY: status.HTTP_401_UNAUTHORIZED,
         ApiError.INVALID_API_KEY: status.HTTP_401_UNAUTHORIZED,
         ApiError.NO_CREDENTIALS: status.HTTP_401_UNAUTHORIZED,
         ApiError.INSUFFICIENT_SCOPES: status.HTTP_403_FORBIDDEN,
         ApiError.EXCHANGE_PERMISSION_DENIED: status.HTTP_403_FORBIDDEN,
         ApiError.EXCHANGE_USER_FROZEN: status.HTTP_403_FORBIDDEN,
         ApiError.TRADING_LOCKED: status.HTTP_403_FORBIDDEN,
+        ApiError.FORBIDDEN: status.HTTP_403_FORBIDDEN,
         # Not Found
         ApiError.URL_NOT_FOUND: status.HTTP_404_NOT_FOUND,
         ApiError.OBJECT_NOT_FOUND: status.HTTP_404_NOT_FOUND,
@@ -499,6 +548,7 @@ class HttpStatusMapper:
         ApiError.OBJECT_ALREADY_EXISTS: status.HTTP_409_CONFLICT,
         ApiError.EXCHANGE_KEY_ALREADY_EXISTS: status.HTTP_409_CONFLICT,
         ApiError.BOT_ALREADY_DELETED: status.HTTP_409_CONFLICT,
+        ApiError.STRATEGY_ALREADY_EXISTS: status.HTTP_409_CONFLICT,
         # Invalid Content
         ApiError.CONTENT_TYPE_ERROR: status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
         ApiError.INVALID_DATA_REQUEST: status.HTTP_422_UNPROCESSABLE_ENTITY,
@@ -519,6 +569,7 @@ class HttpStatusMapper:
         ApiError.POSITION_SUSPENDED: status.HTTP_503_SERVICE_UNAVAILABLE,
         ApiError.TRADING_SUSPENDED: status.HTTP_503_SERVICE_UNAVAILABLE,
         # Bad Requests (400) - Invalid parameters or states
+        ApiError.ALPHANUMERIC_CHARACTERS_ONLY: status.HTTP_400_BAD_REQUEST,
         ApiError.ALLOCATION_BELOW_EXPOSURE: status.HTTP_400_BAD_REQUEST,
         ApiError.ALLOCATION_BELOW_MINIMUM: status.HTTP_400_BAD_REQUEST,
         ApiError.BLACK_SWAN: status.HTTP_400_BAD_REQUEST,
@@ -555,6 +606,10 @@ class HttpStatusMapper:
         # Success cases
         ApiError.SUCCESS: status.HTTP_200_OK,
         ApiError.BOT_STOPPING_COMPLETED: status.HTTP_200_OK,
+        ApiError.BOT_STOPPING_STARTED: status.HTTP_200_OK,
+        ApiError.OBJECT_CREATED: status.HTTP_201_CREATED,
+        ApiError.OBJECT_UPDATED: status.HTTP_200_OK,
+        ApiError.OBJECT_DELETED: status.HTTP_204_NO_CONTENT,
     }
 
     @classmethod