async_client

Async Client

This module contains the main client class that is used to interact with the API.

Classes

• AsyncClient: The main client class.

AsyncClient

Bases: AbstractClient, CoreClient

Main client class that is used to interact with the API.

Attributes:

Name	Type	Description
BASE_URL	str	The base URL of the API.
API_VERSION	str	The API version.
REQUEST_TIMEOUT	int	The request timeout.
WITHDRAW_NETWORKS_URI	str	The URI for getting the withdrawal networks.
SUBMIT_WITHDRAW_URI	str	The URI for submitting a withdrawal.
DEPOSIT_NETWORKS_URI	str	The URI for getting the deposit networks.
ASSETS_INFORMATION_URI	str	The URI for getting the assets' information.
ASSETS_HISTORY_URI	str	The URI for getting the assets' history.
CREATE_ORDER_URI	str	The URI for creating an order.
CANCEL_ORDER_URI	str	The URI for cancelling an order.
ORDERS_HISTORY_URI	str	The URI for getting the orders' history.
MARKETS_INFORMATION_URI	str	The URI for getting the markets' information.
ORDER_BOOK_URI	str	The URI for getting the order book.

Methods:

Name	Description
_get_headers	Get the headers.
_get_request_kwargs	Get the request keyword arguments.
_hmac_signature	Generate the HMAC signature.
_order_params	Order the parameters.
_generate_signature	Generate the signature.
_create_api_uri	Create the API URI.
_get_kwargs_from_locals	Get the keyword arguments from the locals.
_init_session	Initialize the session.
_request	Make a request.
_request_api	Make a request to the API.
_get	Make a GET request to the API.
_post	Make a POST request to the API.
_handle_response	Handle the response.
get_withdraw_networks	Get the withdrawal networks.
submit_withdraw	Submit a withdrawal.
get_deposit_networks	Get the deposit networks.
get_assets_information	Get the assets' information.
get_assets_history	Get the assets' history.
create_order	Create an order.
cancel_order	Cancel an order.
get_orders_history	Get the orders' history.
get_markets_information	Get the markets' information.
get_order_book	Get the order book.

Parameters:

Name	Type	Description	Default
api_key	str	The API key.	required
api_secret	str | None	The API secret.	None
session_params	Optional[Dict[str, Any]]	The session parameters.	None
requests_params	Optional[Dict[str, Any]]	The requests parameters.	None

Source code in src/bit24/clients/async_client.py

class AsyncClient(AbstractClient, CoreClient):
    """
    Main client class that is used to interact with the API.

    Attributes:
        BASE_URL (str): The base URL of the API.
        API_VERSION (str): The API version.
        REQUEST_TIMEOUT (int): The request timeout.
        WITHDRAW_NETWORKS_URI (str): The URI for getting the withdrawal networks.
        SUBMIT_WITHDRAW_URI (str): The URI for submitting a withdrawal.
        DEPOSIT_NETWORKS_URI (str): The URI for getting the deposit networks.
        ASSETS_INFORMATION_URI (str): The URI for getting the assets' information.
        ASSETS_HISTORY_URI (str): The URI for getting the assets' history.
        CREATE_ORDER_URI (str): The URI for creating an order.
        CANCEL_ORDER_URI (str): The URI for cancelling an order.
        ORDERS_HISTORY_URI (str): The URI for getting the orders' history.
        MARKETS_INFORMATION_URI (str): The URI for getting the markets' information.
        ORDER_BOOK_URI (str): The URI for getting the order book.

    Methods:
        _get_headers: Get the headers.
        _get_request_kwargs: Get the request keyword arguments.
        _hmac_signature: Generate the HMAC signature.
        _order_params: Order the parameters.
        _generate_signature: Generate the signature.
        _create_api_uri: Create the API URI.
        _get_kwargs_from_locals: Get the keyword arguments from the locals.
        _init_session: Initialize the session.
        _request: Make a request.
        _request_api: Make a request to the API.
        _get: Make a GET request to the API.
        _post: Make a POST request to the API.
        _handle_response: Handle the response.
        get_withdraw_networks: Get the withdrawal networks.
        submit_withdraw: Submit a withdrawal.
        get_deposit_networks: Get the deposit networks.
        get_assets_information: Get the assets' information.
        get_assets_history: Get the assets' history.
        create_order: Create an order.
        cancel_order: Cancel an order.
        get_orders_history: Get the orders' history.
        get_markets_information: Get the markets' information.
        get_order_book: Get the order book.

    Args:
        api_key (str): The API key.
        api_secret (str | None): The API secret.
        session_params (Optional[Dict[str, Any]]): The session parameters.
        requests_params (Optional[Dict[str, Any]]): The requests parameters.
    """

    def __init__(  # noqa: PLR0913
        self,
        api_key: str,
        api_secret: str | None = None,
        session_params: dict[str, Any] | None = None,
        requests_params: dict[str, Any] | None = None,
        loop: asyncio.AbstractEventLoop | None = None,
    ) -> None:
        """
        Initialize the core client.

        Args:
            api_key (str): The API key.
            api_secret (str | None): The API secret.
            session_params (dict[str, Any] | None): The session parameters.
            requests_params (dict[str, Any] | None): The requests parameters.
            loop (Optional[AbstractEventLoop]): The event loop.
        """
        super().__init__(api_key, api_secret, session_params, requests_params)
        self.loop = loop or get_loop()
        self.session = self._init_session()

    def _init_session(self) -> aiohttp.ClientSession:
        """
        (Private)

        Initialize the session.

        Returns:
            ClientSession: The session.
        """
        return aiohttp.ClientSession(
            loop=self.loop,
            headers=self._get_headers(),
            **self._session_params,
        )

    async def _request(  # type: ignore[override]
        self,
        method: enums.HTTPMethod | str,
        uri: str,
        signed: bool = False,
        **kwargs: Any,
    ) -> rt.BaseResponse:
        """
        (Private)

        Make a request to the API.

        Args:
            method (HTTPMethod | str): The HTTP method.
            uri (str): The URI.
            signed (bool): If the request is signed.
            **kwargs (Any): The keyword arguments.

        Returns:
            BaseResponse: The response.
        """
        kwargs = self._get_request_kwargs(method, signed, **kwargs)

        async with getattr(self.session, method.lower())(uri, **kwargs) as response:
            return await self._handle_response(response)

    async def _request_api(  # type: ignore[override]
        self,
        method: enums.HTTPMethod | str,
        path: str,
        signed: bool = False,
        version: str = CoreClient.API_VERSION,
        **kwargs: Any,
    ) -> rt.BaseResponse:
        """
        (Private)

        Make a request to the API.

        Args:
            method (HTTPMethod | str): The HTTP method.
            path (str): The path.
            signed (bool): If the request is signed.
            version (str): The API version.
            **kwargs (Any): The keyword arguments.

        Returns:
            BaseResponse: The response.
        """
        uri = self._create_api_uri(path, version)
        return await self._request(method, uri, signed, **kwargs)

    async def _get(  # type: ignore[override]
        self,
        path: str,
        signed: bool = False,
        version: str = CoreClient.API_VERSION,
        **kwargs: Any,
    ) -> rt.BaseResponse:
        """
        (Private)

        Make a GET request to the API.

        Args:
            path (str): The path.
            signed (bool): If the request is signed.
            version (str): The API version.
            **kwargs (Any): The keyword arguments.

        Returns:
            BaseResponse: The response.
        """
        return await self._request_api(
            enums.HTTPMethod.GET, path, signed, version, **kwargs
        )

    async def _post(  # type: ignore[override]
        self,
        path: str,
        signed: bool = False,
        version: str = CoreClient.API_VERSION,
        **kwargs: Any,
    ) -> rt.BaseResponse:
        """
        (Private)

        Make a POST request to the API.

        Args:
            path (str): The path.
            signed (bool): If the request is signed.
            version (str): The API version.
            **kwargs (Any): The keyword arguments.

        Returns:
            BaseResponse: The response.
        """
        return await self._request_api(
            enums.HTTPMethod.POST, path, signed, version, **kwargs
        )

    @staticmethod
    async def _handle_response(response: aiohttp.ClientResponse) -> rt.BaseResponse:  # type: ignore[override]
        """
        (Private)

        Handle the response.

        Args:
            response (HttpResponse): The response.

        Returns:
            BaseResponse: The response.
        """
        if not str(response.status).startswith("2"):
            raise APIError(response, response.status, await response.text())
        try:
            _: rt.BaseResponse = await response.json()
        except ValueError as exc:
            msg = f"Invalid Response: {await response.text()}"
            raise RequestError(msg) from exc
        else:
            return _

    async def get_withdraw_networks(  # type: ignore[override]
        self, symbol: str, **kwargs: Any
    ) -> rt.BaseResponse[rt.WithdrawalNetworksResponse]:
        """
        Get the withdrawal networks.

        Args:
            symbol (str): The symbol.
            kwargs (Any): The keyword arguments.

        Returns:
            BaseResponse[WithdrawalNetworksResponse]: The response.

        Raises:
            APIError: An error occurred.
            RequestError: An error occurred.
        """
        kwargs["params"] = self._get_kwargs_from_locals(locals())
        return await self._get(self.WITHDRAW_NETWORKS_URI, **kwargs)

    async def submit_withdraw(  # type: ignore[override] # noqa: PLR0913
        self,
        symbol: str,
        network_id: int,
        address: str,
        value: str,
        memo: str | None = None,
        **kwargs: Any,
    ) -> rt.BaseResponse[rt.SubmitWithdrawResponse]:
        """
        Submit a withdrawal.

        Args:
            symbol (str): The symbol
            network_id (int): The network ID.
            address (str): The address.
            value (str): The value.
            memo (str | None): The memo.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.
        """
        kwargs["data"] = self._get_kwargs_from_locals(locals())
        return await self._post(self.SUBMIT_WITHDRAW_URI, signed=True, **kwargs)

    async def get_deposit_networks(  # type: ignore[override]
        self, symbol: str, **kwargs: Any
    ) -> rt.BaseResponse[rt.DepositNetworksResponse]:
        """
        Get the deposit networks.

        Args:
            symbol (str): The symbol.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.
        """
        kwargs["params"] = self._get_kwargs_from_locals(locals())
        return await self._get(self.DEPOSIT_NETWORKS_URI, **kwargs)

    async def get_assets_information(  # type: ignore[override]
        self,
        name: str | None = None,
        alphabet: str | None = None,
        without_irt: str | None = None,
        without_zero: str | None = None,
        **kwargs: Any,
    ) -> rt.BaseResponse[rt.AssetInformationResponse]:
        """
        Get the assets' information.

        Args:
            name (str | None): The name.
            alphabet (str | None): The starting alphabet.
            without_irt (str | enums.WithoutIrt | None): If the IRT should be excluded.
            without_zero (str | enums.WithoutZero | None): If the zero balances should be excluded.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.

        Notes:
            Use `without_irt` and `without_zero` respective enums for better readability.
        """
        kwargs["params"] = self._get_kwargs_from_locals(locals())
        return await self._get(self.ASSETS_INFORMATION_URI, **kwargs)

    async def get_assets_history(  # type: ignore[override]
        self,
        type: str | enums.TransactionType | None = None,  # noqa: A002
        symbol: str | None = None,
        coin_type: str | enums.CoinType | None = None,
        reason_type: str | enums.ReasonType | None = None,
        **kwargs: Any,
    ) -> rt.BaseResponse[rt.AssetsHistoryResponse]:
        """
        Get the assets' history.

        Args:
            type (str | enums.TransactionType | None): The transaction type.
            symbol (str | None): The symbol.
            coin_type (str | enums.CoinType | None): The coin type.
            reason_type (str | enums.ReasonType | None): The reason type.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.

        Notes:
            Use `type`, `coin_type`, and `reason_type` respective enums for better readability.
        """
        kwargs["params"] = self._get_kwargs_from_locals(locals())
        return await self._get(self.ASSETS_HISTORY_URI, **kwargs)

    async def create_order(  # type: ignore[override] # noqa: PLR0913, PLR0917
        self,
        base_coin_symbol: str,
        quote_coin_symbol: str,
        category_type: str | enums.OrderCategoryType,
        type: str | enums.OrderType,  # noqa: A002
        amount: float | None = None,
        price: float | None = None,
        quote_coin_amount: float | None = None,
        stop_price: float | None = None,
        trigger_price: float | None = None,
        **kwargs: Any,
    ) -> rt.BaseResponse[rt.CreateOrderResponse]:
        """
        Create an order.

        Args:
            base_coin_symbol (str): The base coin symbol.
            quote_coin_symbol (str): The quote coin symbol.
            category_type (str | enums.OrderCategoryType): The order category type.
            type (str | enums.OrderType): The order type.
            amount (float | None): The amount.
            price (float | None): The price.
            quote_coin_amount (float | None): The quote coin amount.
            stop_price (float | None): The stop price.
            trigger_price (float | None): The trigger price.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.

        Notes:
            Use `category_type` and `type` respective enums for better readability.
        """
        kwargs["data"] = self._get_kwargs_from_locals(locals())
        return await self._post(self.CREATE_ORDER_URI, signed=True, **kwargs)

    async def cancel_order(  # type: ignore[override]
        self, order_id: int, **kwargs: Any
    ) -> rt.BaseResponse[rt.CancelOrderResponse]:
        """
        Cancel an order.

        Args:
            order_id (int): The order ID.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.
        """
        kwargs["data"] = self._get_kwargs_from_locals(locals())
        return await self._post(self.CANCEL_ORDER_URI, signed=True, **kwargs)

    async def get_orders_history(  # type: ignore[override] # noqa: PLR0913, PLR0917
        self,
        is_trade: str | enums.IsTrade,
        market_id: int | None = None,
        type: str | enums.OrderType | None = None,  # noqa: A002
        category_type: str | enums.OrderCategoryType | None = None,
        from_date: str | None = None,
        to_date: str | None = None,
        **kwargs: Any,
    ) -> rt.BaseResponse[rt.OrdersHistoryResponse]:
        """
        Get the orders' history.

        Args:
            is_trade (str | enums.IsTrade): If the order is a trade.
            market_id (int | None): The market ID.
            type (str | enums.OrderType | None): The order type.
            category_type (str | enums.OrderCategoryType | None): The order category type.
            from_date (str | None): The start date.
            to_date (str | None): The end date.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.

        Notes:
            Use `is_trade`, `type`, and `category_type` respective enums for better readability.
        """
        kwargs["params"] = self._get_kwargs_from_locals(locals())
        return await self._get(self.ORDERS_HISTORY_URI, **kwargs)

    async def get_markets_information(  # type: ignore[override]
        self, page: int | None = None, **kwargs: Any
    ) -> rt.BaseResponse[rt.MarketListResponse]:
        """
        Get the markets' information.

        Args:
            page (int | None): The page.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.
        """
        kwargs["params"] = self._get_kwargs_from_locals(locals())
        return await self._get(self.MARKETS_INFORMATION_URI, **kwargs)

    async def get_order_book(  # type: ignore[override]
        self, base_coin: str, quote_coin: str, **kwargs: Any
    ) -> rt.BaseResponse[dict[str, rt.OrderBookResponse]]:
        """
        Get the order book.

        Args:
            base_coin (str): The base coin.
            quote_coin (str): The quote coin.
            kwargs (Any): The keyword arguments.

        Returns:
            rt.BaseResponse: The response.
        """
        kwargs["params"] = self._get_kwargs_from_locals(locals())
        return await self._get(self.ORDER_BOOK_URI, **kwargs)

    async def close_connection(self) -> None:  # type: ignore[override]
        """
        Close the connection.

        Returns:
            None
        """
        await self.session.close()
        await asyncio.sleep(0.250)
        self.loop.stop()
        self.loop.close()

__init__(api_key, api_secret=None, session_params=None, requests_params=None, loop=None)

Initialize the core client.

Parameters:

Name	Type	Description	Default
api_key	str	The API key.	required
api_secret	str | None	The API secret.	None
session_params	dict[str, Any] | None	The session parameters.	None
requests_params	dict[str, Any] | None	The requests parameters.	None
loop	Optional[AbstractEventLoop]	The event loop.	None

Source code in src/bit24/clients/async_client.py

def __init__(  # noqa: PLR0913
    self,
    api_key: str,
    api_secret: str | None = None,
    session_params: dict[str, Any] | None = None,
    requests_params: dict[str, Any] | None = None,
    loop: asyncio.AbstractEventLoop | None = None,
) -> None:
    """
    Initialize the core client.

    Args:
        api_key (str): The API key.
        api_secret (str | None): The API secret.
        session_params (dict[str, Any] | None): The session parameters.
        requests_params (dict[str, Any] | None): The requests parameters.
        loop (Optional[AbstractEventLoop]): The event loop.
    """
    super().__init__(api_key, api_secret, session_params, requests_params)
    self.loop = loop or get_loop()
    self.session = self._init_session()

cancel_order(order_id, **kwargs) async

Cancel an order.

Parameters:

Name	Type	Description	Default
order_id	int	The order ID.	required
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[CancelOrderResponse]	rt.BaseResponse: The response.

Source code in src/bit24/clients/async_client.py

async def cancel_order(  # type: ignore[override]
    self, order_id: int, **kwargs: Any
) -> rt.BaseResponse[rt.CancelOrderResponse]:
    """
    Cancel an order.

    Args:
        order_id (int): The order ID.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.
    """
    kwargs["data"] = self._get_kwargs_from_locals(locals())
    return await self._post(self.CANCEL_ORDER_URI, signed=True, **kwargs)

close_connection() async

Close the connection.

Returns:

Type	Description
None	None

Source code in src/bit24/clients/async_client.py

async def close_connection(self) -> None:  # type: ignore[override]
    """
    Close the connection.

    Returns:
        None
    """
    await self.session.close()
    await asyncio.sleep(0.250)
    self.loop.stop()
    self.loop.close()

create_order(base_coin_symbol, quote_coin_symbol, category_type, type, amount=None, price=None, quote_coin_amount=None, stop_price=None, trigger_price=None, **kwargs) async

Create an order.

Parameters:

Name	Type	Description	Default
base_coin_symbol	str	The base coin symbol.	required
quote_coin_symbol	str	The quote coin symbol.	required
category_type	str | OrderCategoryType	The order category type.	required
type	str | OrderType	The order type.	required
amount	float | None	The amount.	None
price	float | None	The price.	None
quote_coin_amount	float | None	The quote coin amount.	None
stop_price	float | None	The stop price.	None
trigger_price	float | None	The trigger price.	None
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[CreateOrderResponse]	rt.BaseResponse: The response.

Notes

Use category_type and type respective enums for better readability.

Source code in src/bit24/clients/async_client.py

async def create_order(  # type: ignore[override] # noqa: PLR0913, PLR0917
    self,
    base_coin_symbol: str,
    quote_coin_symbol: str,
    category_type: str | enums.OrderCategoryType,
    type: str | enums.OrderType,  # noqa: A002
    amount: float | None = None,
    price: float | None = None,
    quote_coin_amount: float | None = None,
    stop_price: float | None = None,
    trigger_price: float | None = None,
    **kwargs: Any,
) -> rt.BaseResponse[rt.CreateOrderResponse]:
    """
    Create an order.

    Args:
        base_coin_symbol (str): The base coin symbol.
        quote_coin_symbol (str): The quote coin symbol.
        category_type (str | enums.OrderCategoryType): The order category type.
        type (str | enums.OrderType): The order type.
        amount (float | None): The amount.
        price (float | None): The price.
        quote_coin_amount (float | None): The quote coin amount.
        stop_price (float | None): The stop price.
        trigger_price (float | None): The trigger price.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.

    Notes:
        Use `category_type` and `type` respective enums for better readability.
    """
    kwargs["data"] = self._get_kwargs_from_locals(locals())
    return await self._post(self.CREATE_ORDER_URI, signed=True, **kwargs)

get_assets_history(type=None, symbol=None, coin_type=None, reason_type=None, **kwargs) async

Get the assets' history.

Parameters:

Name	Type	Description	Default
type	str | TransactionType | None	The transaction type.	None
symbol	str | None	The symbol.	None
coin_type	str | CoinType | None	The coin type.	None
reason_type	str | ReasonType | None	The reason type.	None
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[AssetsHistoryResponse]	rt.BaseResponse: The response.

Notes

Use type, coin_type, and reason_type respective enums for better readability.

Source code in src/bit24/clients/async_client.py

async def get_assets_history(  # type: ignore[override]
    self,
    type: str | enums.TransactionType | None = None,  # noqa: A002
    symbol: str | None = None,
    coin_type: str | enums.CoinType | None = None,
    reason_type: str | enums.ReasonType | None = None,
    **kwargs: Any,
) -> rt.BaseResponse[rt.AssetsHistoryResponse]:
    """
    Get the assets' history.

    Args:
        type (str | enums.TransactionType | None): The transaction type.
        symbol (str | None): The symbol.
        coin_type (str | enums.CoinType | None): The coin type.
        reason_type (str | enums.ReasonType | None): The reason type.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.

    Notes:
        Use `type`, `coin_type`, and `reason_type` respective enums for better readability.
    """
    kwargs["params"] = self._get_kwargs_from_locals(locals())
    return await self._get(self.ASSETS_HISTORY_URI, **kwargs)

get_assets_information(name=None, alphabet=None, without_irt=None, without_zero=None, **kwargs) async

Get the assets' information.

Parameters:

Name	Type	Description	Default
name	str | None	The name.	None
alphabet	str | None	The starting alphabet.	None
without_irt	str | WithoutIrt | None	If the IRT should be excluded.	None
without_zero	str | WithoutZero | None	If the zero balances should be excluded.	None
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[AssetInformationResponse]	rt.BaseResponse: The response.

Notes

Use without_irt and without_zero respective enums for better readability.

Source code in src/bit24/clients/async_client.py

async def get_assets_information(  # type: ignore[override]
    self,
    name: str | None = None,
    alphabet: str | None = None,
    without_irt: str | None = None,
    without_zero: str | None = None,
    **kwargs: Any,
) -> rt.BaseResponse[rt.AssetInformationResponse]:
    """
    Get the assets' information.

    Args:
        name (str | None): The name.
        alphabet (str | None): The starting alphabet.
        without_irt (str | enums.WithoutIrt | None): If the IRT should be excluded.
        without_zero (str | enums.WithoutZero | None): If the zero balances should be excluded.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.

    Notes:
        Use `without_irt` and `without_zero` respective enums for better readability.
    """
    kwargs["params"] = self._get_kwargs_from_locals(locals())
    return await self._get(self.ASSETS_INFORMATION_URI, **kwargs)

get_deposit_networks(symbol, **kwargs) async

Get the deposit networks.

Parameters:

Name	Type	Description	Default
symbol	str	The symbol.	required
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[DepositNetworksResponse]	rt.BaseResponse: The response.

Source code in src/bit24/clients/async_client.py

async def get_deposit_networks(  # type: ignore[override]
    self, symbol: str, **kwargs: Any
) -> rt.BaseResponse[rt.DepositNetworksResponse]:
    """
    Get the deposit networks.

    Args:
        symbol (str): The symbol.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.
    """
    kwargs["params"] = self._get_kwargs_from_locals(locals())
    return await self._get(self.DEPOSIT_NETWORKS_URI, **kwargs)

get_markets_information(page=None, **kwargs) async

Get the markets' information.

Parameters:

Name	Type	Description	Default
page	int | None	The page.	None
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[MarketListResponse]	rt.BaseResponse: The response.

Source code in src/bit24/clients/async_client.py

async def get_markets_information(  # type: ignore[override]
    self, page: int | None = None, **kwargs: Any
) -> rt.BaseResponse[rt.MarketListResponse]:
    """
    Get the markets' information.

    Args:
        page (int | None): The page.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.
    """
    kwargs["params"] = self._get_kwargs_from_locals(locals())
    return await self._get(self.MARKETS_INFORMATION_URI, **kwargs)

get_order_book(base_coin, quote_coin, **kwargs) async

Get the order book.

Parameters:

Name	Type	Description	Default
base_coin	str	The base coin.	required
quote_coin	str	The quote coin.	required
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[dict[str, OrderBookResponse]]	rt.BaseResponse: The response.

Source code in src/bit24/clients/async_client.py

async def get_order_book(  # type: ignore[override]
    self, base_coin: str, quote_coin: str, **kwargs: Any
) -> rt.BaseResponse[dict[str, rt.OrderBookResponse]]:
    """
    Get the order book.

    Args:
        base_coin (str): The base coin.
        quote_coin (str): The quote coin.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.
    """
    kwargs["params"] = self._get_kwargs_from_locals(locals())
    return await self._get(self.ORDER_BOOK_URI, **kwargs)

get_orders_history(is_trade, market_id=None, type=None, category_type=None, from_date=None, to_date=None, **kwargs) async

Get the orders' history.

Parameters:

Name	Type	Description	Default
is_trade	str | IsTrade	If the order is a trade.	required
market_id	int | None	The market ID.	None
type	str | OrderType | None	The order type.	None
category_type	str | OrderCategoryType | None	The order category type.	None
from_date	str | None	The start date.	None
to_date	str | None	The end date.	None
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[OrdersHistoryResponse]	rt.BaseResponse: The response.

Notes

Use is_trade, type, and category_type respective enums for better readability.

Source code in src/bit24/clients/async_client.py

async def get_orders_history(  # type: ignore[override] # noqa: PLR0913, PLR0917
    self,
    is_trade: str | enums.IsTrade,
    market_id: int | None = None,
    type: str | enums.OrderType | None = None,  # noqa: A002
    category_type: str | enums.OrderCategoryType | None = None,
    from_date: str | None = None,
    to_date: str | None = None,
    **kwargs: Any,
) -> rt.BaseResponse[rt.OrdersHistoryResponse]:
    """
    Get the orders' history.

    Args:
        is_trade (str | enums.IsTrade): If the order is a trade.
        market_id (int | None): The market ID.
        type (str | enums.OrderType | None): The order type.
        category_type (str | enums.OrderCategoryType | None): The order category type.
        from_date (str | None): The start date.
        to_date (str | None): The end date.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.

    Notes:
        Use `is_trade`, `type`, and `category_type` respective enums for better readability.
    """
    kwargs["params"] = self._get_kwargs_from_locals(locals())
    return await self._get(self.ORDERS_HISTORY_URI, **kwargs)

get_withdraw_networks(symbol, **kwargs) async

Get the withdrawal networks.

Parameters:

Name	Type	Description	Default
symbol	str	The symbol.	required
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[WithdrawalNetworksResponse]	BaseResponse[WithdrawalNetworksResponse]: The response.

Raises:

Type	Description
APIError	An error occurred.
RequestError	An error occurred.

Source code in src/bit24/clients/async_client.py

async def get_withdraw_networks(  # type: ignore[override]
    self, symbol: str, **kwargs: Any
) -> rt.BaseResponse[rt.WithdrawalNetworksResponse]:
    """
    Get the withdrawal networks.

    Args:
        symbol (str): The symbol.
        kwargs (Any): The keyword arguments.

    Returns:
        BaseResponse[WithdrawalNetworksResponse]: The response.

    Raises:
        APIError: An error occurred.
        RequestError: An error occurred.
    """
    kwargs["params"] = self._get_kwargs_from_locals(locals())
    return await self._get(self.WITHDRAW_NETWORKS_URI, **kwargs)

submit_withdraw(symbol, network_id, address, value, memo=None, **kwargs) async

Submit a withdrawal.

Parameters:

Name	Type	Description	Default
symbol	str	The symbol	required
network_id	int	The network ID.	required
address	str	The address.	required
value	str	The value.	required
memo	str | None	The memo.	None
kwargs	Any	The keyword arguments.	{}

Returns:

Type	Description
BaseResponse[SubmitWithdrawResponse]	rt.BaseResponse: The response.

Source code in src/bit24/clients/async_client.py

async def submit_withdraw(  # type: ignore[override] # noqa: PLR0913
    self,
    symbol: str,
    network_id: int,
    address: str,
    value: str,
    memo: str | None = None,
    **kwargs: Any,
) -> rt.BaseResponse[rt.SubmitWithdrawResponse]:
    """
    Submit a withdrawal.

    Args:
        symbol (str): The symbol
        network_id (int): The network ID.
        address (str): The address.
        value (str): The value.
        memo (str | None): The memo.
        kwargs (Any): The keyword arguments.

    Returns:
        rt.BaseResponse: The response.
    """
    kwargs["data"] = self._get_kwargs_from_locals(locals())
    return await self._post(self.SUBMIT_WITHDRAW_URI, signed=True, **kwargs)