crypticorn 2.5.0rc5__py3-none-any.whl → 2.5.2__py3-none-any.whl

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/client.py

@@ -1,13 +1,14 @@
-from typing import Union
-
-from crypticorn.hive import HiveClient, Configuration as HiveConfig
-from crypticorn.klines import KlinesClient, Configuration as KlinesConfig
-from crypticorn.pay import PayClient, Configuration as PayConfig
-from crypticorn.trade import TradeClient, Configuration as TradeConfig
-from crypticorn.metrics import MetricsClient, Configuration as MetricsConfig
-from crypticorn.auth import AuthClient, Configuration as AuthConfig
+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
-import warnings
+
+ConfigT = TypeVar("ConfigT")
+SubClient = TypeVar("SubClient")
 
 
 class ApiClient:
@@ -30,35 +31,49 @@ class ApiClient:
         self.jwt = jwt
         """The JWT to use for authentication."""
 
-        self.hive = HiveClient(self._get_default_config(Service.HIVE))
-        self.trade = TradeClient(self._get_default_config(Service.TRADE))
-        self.klines = KlinesClient(self._get_default_config(Service.KLINES))
-        self.pay = PayClient(self._get_default_config(Service.PAY))
-        self.metrics = MetricsClient(self._get_default_config(Service.METRICS))
-        self.auth = AuthClient(self._get_default_config(Service.AUTH))
-
-    def __new__(cls, *args, **kwargs):
-        if kwargs.get("api_key") and not kwargs.get("jwt"):
-            # auth-service does not allow api_key
-            warnings.warn(
-                "The auth module does only accept JWT to be used to authenticate. If you use this module, you need to provide a JWT."
-            )
-        return super().__new__(cls)
+        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."""
-        clients = [
-            self.hive.base_client,
-            self.trade.base_client,
-            self.klines.base_client,
-            self.pay.base_client,
-            self.metrics.base_client,
-            self.auth.base_client,
-        ]
-
-        for client in clients:
-            if hasattr(client, "close"):
-                await client.close()
+        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
@@ -66,63 +81,39 @@ class ApiClient:
         """
         Get the default configuration for a given service.
         """
-        config_class = {
-            Service.HIVE: HiveConfig,
-            Service.TRADE: TradeConfig,
-            Service.KLINES: KlinesConfig,
-            Service.PAY: PayConfig,
-            Service.METRICS: MetricsConfig,
-            Service.AUTH: AuthConfig,
-        }[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,
-            # not necessary
-            # api_key_prefix=(
-            #     {aph.scheme_name: aph.model.name} if self.api_key else None
-            # ),
         )
 
     def configure(
         self,
-        config: Union[
-            HiveConfig, TradeConfig, KlinesConfig, PayConfig, MetricsConfig, AuthConfig
-        ],
-        sub_client: any,
+        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 sub_client: The sub-client to configure.
+        :param service: The service to configure.
 
         Example:
-        This will override the host for the Hive client to connect to http://localhost:8000 instead of the default proxy:
         >>> async with ApiClient(base_url=BaseUrl.DEV, jwt=jwt) 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)
         """
-        new_config = sub_client.config
+        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)
 
-        if sub_client == self.hive:
-            self.hive = HiveClient(new_config)
-        elif sub_client == self.trade:
-            self.trade = TradeClient(new_config)
-        elif sub_client == self.klines:
-            self.klines = KlinesClient(new_config)
-        elif sub_client == self.pay:
-            self.pay = PayClient(new_config)
-        elif sub_client == self.metrics:
-            self.metrics = MetricsClient(new_config)
-        elif sub_client == self.auth:
-            self.auth = AuthClient(new_config)
-        else:
-            raise ValueError(f"Unknown sub-client: {sub_client}")
+        self.services[service] = type(client)(new_config)
 
     async def __aenter__(self):
         return self

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/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/common/enums.py

@@ -1,42 +1,15 @@
 from enum import StrEnum
+from crypticorn.common.mixins import ValidateEnumMixin, ExcludeEnumMixin
 
 
-class ValidateEnumMixin:
-    """
-    Mixin for validating enum values manually.
-
-    ⚠️ Note:
-    This does NOT enforce validation automatically on enum creation.
-    It's up to the developer to call `Class.validate(value)` where needed.
-
-    Usage:
-        >>> class Color(ValidateEnumMixin, StrEnum):
-        >>>     RED = "red"
-        >>>     GREEN = "green"
-
-        >>> Color.validate("red")     # True
-        >>> Color.validate("yellow")  # False
-
-    Order of inheritance matters — the mixin must come first.
-    """
-
-    @classmethod
-    def validate(cls, value) -> bool:
-        try:
-            cls(value)
-            return True
-        except ValueError:
-            return False
-
-
-class Exchange(ValidateEnumMixin, StrEnum):
+class Exchange(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
     """Supported exchanges for trading"""
 
     KUCOIN = "kucoin"
     BINGX = "bingx"
 
 
-class InternalExchange(ValidateEnumMixin, StrEnum):
+class InternalExchange(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
     """All exchanges we are using, including public (Exchange)"""
 
     KUCOIN = "kucoin"
@@ -47,7 +20,7 @@ class InternalExchange(ValidateEnumMixin, StrEnum):
     BITGET = "bitget"
 
 
-class MarketType(ValidateEnumMixin, StrEnum):
+class MarketType(ValidateEnumMixin, ExcludeEnumMixin, StrEnum):
     """
     Market types
     """

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