decibel-python-sdk 0.1.0__py3-none-any.whl

decibel/read/__init__.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from aptos_sdk.async_client import RestClient
+
+from ._account_overview import (
+    AccountOverview,
+    AccountOverviewReader,
+    AccountOverviewWsMessage,
+    VolumeWindow,
+)
+from ._base import ReaderDeps
+from ._candlesticks import (
+    Candlestick,
+    CandlestickInterval,
+    CandlesticksReader,
+    CandlestickWsMessage,
+)
+from ._delegations import Delegation, DelegationsReader
+from ._leaderboard import (
+    LeaderboardItem,
+    LeaderboardReader,
+    LeaderboardResponse,
+    LeaderboardSortKey,
+)
+from ._market_contexts import MarketContext, MarketContextsReader
+from ._market_depth import (
+    MarketDepth,
+    MarketDepthAggregationSize,
+    MarketDepthReader,
+    MarketDepthWsMessage,
+    MarketOrder,
+)
+from ._market_prices import (
+    AllMarketPricesWsMessage,
+    MarketPrice,
+    MarketPricesReader,
+    MarketPriceWsMessage,
+)
+from ._market_trades import (
+    MarketTrade,
+    MarketTradesReader,
+    MarketTradesResponse,
+    MarketTradeWsMessage,
+)
+from ._markets import (
+    MarketMode,
+    MarketModeConfig,
+    MarketsReader,
+    PerpMarket,
+    PerpMarketConfig,
+    SzPrecision,
+)
+from ._portfolio_chart import (
+    PortfolioChartItem,
+    PortfolioChartReader,
+    PortfolioChartTimeRange,
+    PortfolioChartType,
+)
+from ._trading_points import (
+    OwnerTradingPoints,
+    SubaccountPoints,
+    TradingPointsReader,
+)
+from ._types import (
+    ActivateVaultArgs,
+    AssetType,
+    BalanceTable,
+    CollateralBalanceSheet,
+    CreateVaultArgs,
+    CrossedPosition,
+    DepositToVaultArgs,
+    GlobalAccountsState,
+    GlobalAccountsStateV1,
+    LiquidationConfigV1,
+    PerpPosition,
+    Precision,
+    Store,
+    StoreExtendRef,
+    WithdrawFromVaultArgs,
+)
+from ._user_active_twaps import (
+    TwapStatus,
+    UserActiveTwap,
+    UserActiveTwapsReader,
+    UserActiveTwapsWsMessage,
+)
+from ._user_bulk_orders import (
+    UserBulkOrder,
+    UserBulkOrdersReader,
+    UserBulkOrderWsMessage,
+)
+from ._user_fund_history import (
+    FundMovementType,
+    UserFund,
+    UserFundHistoryReader,
+    UserFundHistoryResponse,
+)
+from ._user_funding_history import (
+    UserFunding,
+    UserFundingHistoryReader,
+    UserFundingHistoryResponse,
+)
+from ._user_notifications import (
+    NotificationMetadata,
+    NotificationType,
+    UserNotificationsReader,
+    UserNotificationWsMessage,
+)
+from ._user_open_orders import (
+    UserOpenOrder,
+    UserOpenOrdersReader,
+    UserOpenOrdersResponse,
+    UserOpenOrdersWsMessage,
+)
+from ._user_order_history import (
+    UserOrder,
+    UserOrderHistoryReader,
+    UserOrders,
+    UserOrdersWsMessage,
+)
+from ._user_positions import (
+    UserPosition,
+    UserPositionsReader,
+    UserPositionsWsMessage,
+)
+from ._user_subaccounts import UserSubaccount, UserSubaccountsReader
+from ._user_trade_history import (
+    UserTrade,
+    UserTradeAction,
+    UserTradeHistoryReader,
+    UserTradesResponse,
+    UserTradesWsMessage,
+)
+from ._user_twap_history import UserTwapHistoryReader, UserTwapHistoryResponse
+from ._vaults import (
+    UserOwnedVault,
+    UserOwnedVaultsResponse,
+    UserPerformanceOnVault,
+    Vault,
+    VaultDeposit,
+    VaultsReader,
+    VaultsResponse,
+    VaultType,
+    VaultWithdrawal,
+)
+from ._ws import DecibelWsSubscription, Unsubscribe
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from .._constants import DecibelConfig
+
+
+class DecibelReadDex:
+    def __init__(
+        self,
+        config: DecibelConfig,
+        *,
+        api_key: str | None = None,
+        on_ws_error: Callable[[Exception], None] | None = None,
+    ) -> None:
+        aptos = RestClient(config.fullnode_url)
+        ws = DecibelWsSubscription(config, api_key, on_ws_error)
+        deps = ReaderDeps(config=config, ws=ws, aptos=aptos, api_key=api_key)
+
+        self.ws = ws
+        self.account_overview = AccountOverviewReader(deps)
+        self.candlesticks = CandlesticksReader(deps)
+        self.delegations = DelegationsReader(deps)
+        self.leaderboard = LeaderboardReader(deps)
+        self.markets = MarketsReader(deps)
+        self.market_prices = MarketPricesReader(deps)
+        self.market_depth = MarketDepthReader(deps)
+        self.market_trades = MarketTradesReader(deps)
+        self.market_contexts = MarketContextsReader(deps)
+        self.portfolio_chart = PortfolioChartReader(deps)
+        self.user_positions = UserPositionsReader(deps)
+        self.user_open_orders = UserOpenOrdersReader(deps)
+        self.user_order_history = UserOrderHistoryReader(deps)
+        self.user_trade_history = UserTradeHistoryReader(deps)
+        self.user_bulk_orders = UserBulkOrdersReader(deps)
+        self.user_subaccounts = UserSubaccountsReader(deps)
+        self.user_fund_history = UserFundHistoryReader(deps)
+        self.user_funding_history = UserFundingHistoryReader(deps)
+        self.user_active_twaps = UserActiveTwapsReader(deps)
+        self.user_twap_history = UserTwapHistoryReader(deps)
+        self.user_notifications = UserNotificationsReader(deps)
+        self.vaults = VaultsReader(deps)
+        self.trading_points = TradingPointsReader(deps)
+
+
+__all__ = [
+    "AccountOverview",
+    "AccountOverviewWsMessage",
+    "ActivateVaultArgs",
+    "AllMarketPricesWsMessage",
+    "AssetType",
+    "BalanceTable",
+    "Candlestick",
+    "CandlestickInterval",
+    "CandlestickWsMessage",
+    "CollateralBalanceSheet",
+    "CreateVaultArgs",
+    "CrossedPosition",
+    "DecibelReadDex",
+    "Delegation",
+    "DepositToVaultArgs",
+    "FundMovementType",
+    "GlobalAccountsState",
+    "GlobalAccountsStateV1",
+    "LeaderboardItem",
+    "LeaderboardResponse",
+    "LeaderboardSortKey",
+    "LiquidationConfigV1",
+    "MarketContext",
+    "MarketDepth",
+    "MarketDepthAggregationSize",
+    "MarketDepthWsMessage",
+    "MarketMode",
+    "MarketModeConfig",
+    "MarketOrder",
+    "MarketPrice",
+    "MarketPriceWsMessage",
+    "MarketTrade",
+    "MarketTradesResponse",
+    "MarketTradeWsMessage",
+    "NotificationMetadata",
+    "NotificationType",
+    "OwnerTradingPoints",
+    "PerpMarket",
+    "PerpMarketConfig",
+    "PerpPosition",
+    "PortfolioChartItem",
+    "PortfolioChartTimeRange",
+    "PortfolioChartType",
+    "Precision",
+    "Store",
+    "StoreExtendRef",
+    "SubaccountPoints",
+    "SzPrecision",
+    "TradingPointsReader",
+    "TwapStatus",
+    "Unsubscribe",
+    "UserActiveTwap",
+    "UserActiveTwapsWsMessage",
+    "UserBulkOrder",
+    "UserBulkOrderWsMessage",
+    "UserFund",
+    "UserFundHistoryResponse",
+    "UserFunding",
+    "UserFundingHistoryResponse",
+    "UserNotificationWsMessage",
+    "UserOpenOrder",
+    "UserOpenOrdersResponse",
+    "UserOpenOrdersWsMessage",
+    "UserOrder",
+    "UserOrders",
+    "UserOrdersWsMessage",
+    "UserOwnedVault",
+    "UserOwnedVaultsResponse",
+    "UserPerformanceOnVault",
+    "UserPosition",
+    "UserPositionsWsMessage",
+    "UserSubaccount",
+    "UserTrade",
+    "UserTradeAction",
+    "UserTradesResponse",
+    "UserTradesWsMessage",
+    "UserTwapHistoryResponse",
+    "Vault",
+    "VaultDeposit",
+    "VaultsResponse",
+    "VaultType",
+    "VaultWithdrawal",
+    "VolumeWindow",
+    "WithdrawFromVaultArgs",
+]

decibel/read/_account_overview.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict
+
+from ._base import BaseReader
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from ._ws import Unsubscribe
+
+__all__ = [
+    "AccountOverview",
+    "AccountOverviewReader",
+    "AccountOverviewWsMessage",
+    "VolumeWindow",
+]
+
+
+class VolumeWindow(StrEnum):
+    SEVEN_DAYS = "7d"
+    FOURTEEN_DAYS = "14d"
+    THIRTY_DAYS = "30d"
+    NINETY_DAYS = "90d"
+
+
+class AccountOverview(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    perp_equity_balance: float
+    unrealized_pnl: float
+    unrealized_funding_cost: float
+    cross_margin_ratio: float
+    maintenance_margin: float
+    cross_account_leverage_ratio: float | None
+    volume: float | None
+    net_deposits: float | None = None
+    all_time_return: float | None
+    pnl_90d: float | None
+    sharpe_ratio: float | None
+    max_drawdown: float | None
+    weekly_win_rate_12w: float | None
+    average_cash_position: float | None
+    average_leverage: float | None
+    cross_account_position: float
+    total_margin: float
+    usdc_cross_withdrawable_balance: float
+    usdc_isolated_withdrawable_balance: float
+    realized_pnl: float | None
+    liquidation_fees_paid: float | None
+    liquidation_losses: float | None
+
+
+class _AccountOverviewWs(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    perp_equity_balance: float
+    unrealized_pnl: float
+    unrealized_funding_cost: float
+    cross_margin_ratio: float
+    maintenance_margin: float
+    cross_account_leverage_ratio: float | None
+    net_deposits: float | None = None
+    all_time_return: float | None
+    pnl_90d: float | None
+    sharpe_ratio: float | None
+    max_drawdown: float | None
+    weekly_win_rate_12w: float | None
+    average_cash_position: float | None
+    average_leverage: float | None
+    cross_account_position: float
+    total_margin: float
+    usdc_cross_withdrawable_balance: float
+    usdc_isolated_withdrawable_balance: float
+    realized_pnl: float | None
+    liquidation_fees_paid: float | None
+    liquidation_losses: float | None
+
+
+class AccountOverviewWsMessage(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    account_overview: _AccountOverviewWs
+
+
+class AccountOverviewReader(BaseReader):
+    async def get_by_addr(
+        self,
+        *,
+        sub_addr: str,
+        volume_window: VolumeWindow | None = None,
+        include_performance: bool = False,
+    ) -> AccountOverview:
+        params: dict[str, str] = {"account": sub_addr}
+        if volume_window is not None:
+            params["volume_window"] = volume_window.value
+        if include_performance:
+            params["include_performance"] = "true"
+
+        response, _, _ = await self.get_request(
+            model=AccountOverview,
+            url=f"{self.config.trading_http_url}/api/v1/account_overviews",
+            params=params,
+        )
+        return response
+
+    def subscribe_by_addr(
+        self,
+        sub_addr: str,
+        on_data: (
+            Callable[[AccountOverviewWsMessage], None]
+            | Callable[[AccountOverviewWsMessage], Awaitable[None]]
+        ),
+    ) -> Unsubscribe:
+        topic = f"account_overview:{sub_addr}"
+        return self.ws.subscribe(topic, AccountOverviewWsMessage, on_data)

decibel/read/_base.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from pydantic import BaseModel
+
+from .._utils import (
+    get_request,
+    get_request_sync,
+    patch_request,
+    patch_request_sync,
+    post_request,
+    post_request_sync,
+)
+
+if TYPE_CHECKING:
+    from aptos_sdk.async_client import RestClient
+
+    from .._constants import DecibelConfig
+    from ._ws import DecibelWsSubscription
+
+__all__ = [
+    "ReaderDeps",
+    "BaseReader",
+]
+
+T = TypeVar("T", bound=BaseModel)
+
+
+@dataclass
+class ReaderDeps:
+    config: DecibelConfig
+    ws: DecibelWsSubscription
+    aptos: RestClient
+    api_key: str | None = None
+
+
+class BaseReader:
+    def __init__(self, deps: ReaderDeps) -> None:
+        self._deps = deps
+
+    @property
+    def config(self) -> DecibelConfig:
+        return self._deps.config
+
+    @property
+    def ws(self) -> DecibelWsSubscription:
+        return self._deps.ws
+
+    @property
+    def aptos(self) -> RestClient:
+        return self._deps.aptos
+
+    async def get_request(
+        self,
+        model: type[T],
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+    ) -> tuple[T, int, str]:
+        return await get_request(
+            model=model,
+            url=url,
+            params=params,
+            api_key=self._deps.api_key,
+        )
+
+    async def post_request(
+        self,
+        model: type[T],
+        url: str,
+        *,
+        body: Any | None = None,
+    ) -> tuple[T, int, str]:
+        return await post_request(
+            model=model,
+            url=url,
+            body=body,
+            api_key=self._deps.api_key,
+        )
+
+    async def patch_request(
+        self,
+        model: type[T],
+        url: str,
+        *,
+        body: Any | None = None,
+    ) -> tuple[T, int, str]:
+        return await patch_request(
+            model=model,
+            url=url,
+            body=body,
+            api_key=self._deps.api_key,
+        )
+
+    def get_request_sync(
+        self,
+        model: type[T],
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+    ) -> tuple[T, int, str]:
+        return get_request_sync(
+            model=model,
+            url=url,
+            params=params,
+            api_key=self._deps.api_key,
+        )
+
+    def post_request_sync(
+        self,
+        model: type[T],
+        url: str,
+        *,
+        body: Any | None = None,
+    ) -> tuple[T, int, str]:
+        return post_request_sync(
+            model=model,
+            url=url,
+            body=body,
+            api_key=self._deps.api_key,
+        )
+
+    def patch_request_sync(
+        self,
+        model: type[T],
+        url: str,
+        *,
+        body: Any | None = None,
+    ) -> tuple[T, int, str]:
+        return patch_request_sync(
+            model=model,
+            url=url,
+            body=body,
+            api_key=self._deps.api_key,
+        )

decibel/read/_candlesticks.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field, RootModel
+
+from .._utils import get_market_addr
+from ._base import BaseReader
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from ._ws import Unsubscribe
+
+__all__ = [
+    "Candlestick",
+    "CandlestickInterval",
+    "CandlesticksReader",
+    "CandlestickWsMessage",
+]
+
+
+class CandlestickInterval(StrEnum):
+    ONE_MINUTE = "1m"
+    FIVE_MINUTES = "5m"
+    FIFTEEN_MINUTES = "15m"
+    THIRTY_MINUTES = "30m"
+    ONE_HOUR = "1h"
+    TWO_HOURS = "2h"
+    FOUR_HOURS = "4h"
+    EIGHT_HOURS = "8h"
+    TWELVE_HOURS = "12h"
+    ONE_DAY = "1d"
+    THREE_DAYS = "3d"
+    ONE_WEEK = "1w"
+    ONE_MONTH = "1mo"
+
+
+class Candlestick(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    time_end: int = Field(alias="T")
+    close: float = Field(alias="c")
+    high: float = Field(alias="h")
+    interval: str = Field(alias="i")
+    low: float = Field(alias="l")
+    open_price: float = Field(alias="o")
+    time_start: int = Field(alias="t")
+    volume: float = Field(alias="v")
+
+
+class _CandlesticksList(RootModel[list[Candlestick]]):
+    pass
+
+
+class CandlestickWsMessage(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    candle: Candlestick
+
+
+class CandlesticksReader(BaseReader):
+    async def get_by_name(
+        self,
+        market_name: str,
+        *,
+        interval: CandlestickInterval,
+        start_time: int,
+        end_time: int,
+    ) -> list[Candlestick]:
+        market_addr = get_market_addr(market_name, self.config.deployment.perp_engine_global)
+
+        response, _, _ = await self.get_request(
+            model=_CandlesticksList,
+            url=f"{self.config.trading_http_url}/api/v1/candlesticks",
+            params={
+                "market": market_addr,
+                "interval": interval.value,
+                "startTime": str(start_time),
+                "endTime": str(end_time),
+            },
+        )
+        return response.root
+
+    def subscribe_by_name(
+        self,
+        market_name: str,
+        interval: CandlestickInterval,
+        on_data: (
+            Callable[[CandlestickWsMessage], None]
+            | Callable[[CandlestickWsMessage], Awaitable[None]]
+        ),
+    ) -> Unsubscribe:
+        market_addr = get_market_addr(market_name, self.config.deployment.perp_engine_global)
+        topic = f"market_candlestick:{market_addr}:{interval.value}"
+        return self.ws.subscribe(topic, CandlestickWsMessage, on_data)

decibel/read/_delegations.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, RootModel
+
+from ._base import BaseReader
+
+__all__ = [
+    "Delegation",
+    "DelegationsReader",
+]
+
+
+class Delegation(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    delegated_account: str
+    permission_type: str
+    expiration_time_s: float | None
+
+
+class _DelegationsList(RootModel[list[Delegation]]):
+    pass
+
+
+class DelegationsReader(BaseReader):
+    async def get_all(self, *, sub_addr: str) -> list[Delegation]:
+        response, _, _ = await self.get_request(
+            model=_DelegationsList,
+            url=f"{self.config.trading_http_url}/api/v1/delegations",
+            params={"subaccount": sub_addr},
+        )
+        return response.root