hotstuff-python-sdk 0.0.1b1__py3-none-any.whl

hotstuff/apis/info.py

@@ -0,0 +1,291 @@
+"""Info API client."""
+from typing import Optional, Any, List
+import importlib
+
+GM = importlib.import_module("hotstuff.methods.info.global")
+AM = importlib.import_module("hotstuff.methods.info.account")
+VM = importlib.import_module("hotstuff.methods.info.vault")
+EM = importlib.import_module("hotstuff.methods.info.explorer")
+
+
+class InfoClient:
+    """Client for querying market data and account information."""
+    
+    def __init__(self, transport):
+        """
+        Initialize InfoClient.
+        
+        Args:
+            transport: The transport layer to use
+        """
+        self.transport = transport
+    
+    # Global Info Endpoints
+    
+    async def oracle(
+        self, params: GM.OracleParams, signal: Optional[Any] = None
+    ) -> GM.OracleResponse:
+        """Get oracle prices."""
+        request = {"method": "oracle", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return GM.OracleResponse.model_validate(response)
+    
+    async def supported_collateral(
+        self, params: GM.SupportedCollateralParams, signal: Optional[Any] = None
+    ) -> List[GM.SupportedCollateral]:
+        """Get supported collateral."""
+        request = {"method": "supportedCollateral", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return [GM.SupportedCollateral.model_validate(item) for item in response]
+    
+    async def instruments(
+        self, params: GM.InstrumentsParams, signal: Optional[Any] = None
+    ) -> GM.InstrumentsResponse:
+        """Get all instruments."""
+        request = {"method": "instruments", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return GM.InstrumentsResponse.model_validate(response)
+    
+    async def ticker(
+        self, params: GM.TickerParams, signal: Optional[Any] = None
+    ) -> List[GM.Ticker]:
+        """Get ticker for a specific symbol."""
+        request = {"method": "ticker", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return [GM.Ticker.model_validate(item) for item in response]
+    
+    async def orderbook(
+        self, params: GM.OrderbookParams, signal: Optional[Any] = None
+    ) -> GM.OrderbookResponse:
+        """Get orderbook with depth."""
+        request = {"method": "orderbook", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return GM.OrderbookResponse.model_validate(response)
+    
+    async def trades(
+        self, params: GM.TradesParams, signal: Optional[Any] = None
+    ) -> List[GM.Trade]:
+        """Get recent trades."""
+        request = {"method": "trades", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return [GM.Trade.model_validate(item) for item in response]
+    
+    async def mids(
+        self, params: GM.MidsParams, signal: Optional[Any] = None
+    ) -> List[GM.Mid]:
+        """Get mid prices for all instruments."""
+        request = {"method": "mids", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return [GM.Mid.model_validate(item) for item in response]
+    
+    async def bbo(
+        self, params: GM.BBOParams, signal: Optional[Any] = None
+    ) -> List[GM.BBO]:
+        """Get best bid/offer."""
+        request = {"method": "bbo", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return [GM.BBO.model_validate(item) for item in response]
+    
+    async def chart(
+        self, params: GM.ChartParams, signal: Optional[Any] = None
+    ) -> List[GM.ChartPoint]:
+        """Get chart data (candles or funding)."""
+        # Convert from_ to "from" for API
+        params_dict = params.model_dump(by_alias=True)
+        request = {"method": "chart", "params": params_dict}
+        response = await self.transport.request("info", request, signal)
+        return [GM.ChartPoint.model_validate(item) for item in response]
+    
+    # Account Info Endpoints
+    
+    async def open_orders(
+        self, params: AM.OpenOrdersParams, signal: Optional[Any] = None
+    ) -> AM.OpenOrdersResponse:
+        """Get open orders."""
+        request = {"method": "openOrders", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        if isinstance(response, dict) and "data" in response:
+            response = {"orders": response["data"]}
+        return AM.OpenOrdersResponse.model_validate(response)
+    
+    async def positions(
+        self, params: AM.PositionsParams, signal: Optional[Any] = None
+    ) -> AM.PositionsResponse:
+        """Get current positions."""
+        request = {"method": "positions", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.PositionsResponse.model_validate(response)
+    
+    async def account_summary(
+        self, params: AM.AccountSummaryParams, signal: Optional[Any] = None
+    ) -> AM.AccountSummaryResponse:
+        """Get account summary."""
+        request = {"method": "accountSummary", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.AccountSummaryResponse.model_validate(response)
+    
+    async def referral_summary(
+        self, params: AM.ReferralSummaryParams, signal: Optional[Any] = None
+    ) -> AM.ReferralSummaryResponse:
+        """Get referral summary."""
+        request = {"method": "referralSummary", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.ReferralSummaryResponse.model_validate(response)
+    
+    async def user_fee_info(
+        self, params: AM.UserFeeInfoParams, signal: Optional[Any] = None
+    ) -> AM.UserFeeInfoResponse:
+        """Get user fee information."""
+        request = {"method": "userFees", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.UserFeeInfoResponse.model_validate(response)
+    
+    async def account_history(
+        self, params: AM.AccountHistoryParams, signal: Optional[Any] = None
+    ) -> AM.AccountHistoryResponse:
+        """Get account history."""
+        request = {"method": "accountHistory", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.AccountHistoryResponse.model_validate(response)
+    
+    async def order_history(
+        self, params: AM.OrderHistoryParams, signal: Optional[Any] = None
+    ) -> AM.OrderHistoryResponse:
+        """Get order history."""
+        request = {"method": "orderHistory", "params": params.model_dump(by_alias=True)}
+        response = await self.transport.request("info", request, signal)
+        return AM.OrderHistoryResponse.model_validate(response)
+    
+    async def trade_history(
+        self, params: AM.TradeHistoryParams, signal: Optional[Any] = None
+    ) -> AM.TradeHistoryResponse:
+        """Get trade history (fills)."""
+        request = {"method": "fills", "params": params.model_dump(by_alias=True)}
+        response = await self.transport.request("info", request, signal)
+        return AM.TradeHistoryResponse.model_validate(response)
+    
+    async def funding_history(
+        self, params: AM.FundingHistoryParams, signal: Optional[Any] = None
+    ) -> AM.FundingHistoryResponse:
+        """Get funding history."""
+        request = {"method": "fundingHistory", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.FundingHistoryResponse.model_validate(response)
+    
+    async def transfer_history(
+        self, params: AM.TransferHistoryParams, signal: Optional[Any] = None
+    ) -> AM.TransferHistoryResponse:
+        """Get transfer history."""
+        request = {"method": "transferHistory", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.TransferHistoryResponse.model_validate(response)
+    
+    async def instrument_leverage(
+        self, params: AM.InstrumentLeverageParams, signal: Optional[Any] = None
+    ) -> AM.InstrumentLeverageResponse:
+        """Get instrument leverage settings."""
+        request = {"method": "instrumentLeverage", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.InstrumentLeverageResponse.model_validate(response)
+    
+    async def get_referral_info(
+        self, params: AM.ReferralInfoParams, signal: Optional[Any] = None
+    ) -> AM.ReferralInfoResponse:
+        """Get referral info."""
+        request = {"method": "referralInfo", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.ReferralInfoResponse.model_validate(response)
+    
+    async def sub_accounts_list(
+        self, params: AM.SubAccountsListParams, signal: Optional[Any] = None
+    ) -> AM.SubAccountsListResponse:
+        """Get sub-accounts list."""
+        request = {"method": "subAccountsList", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.SubAccountsListResponse.model_validate(response)
+    
+    async def agents(
+        self, params: AM.AgentsParams, signal: Optional[Any] = None
+    ) -> AM.AgentsResponse:
+        """Get agents."""
+        request = {"method": "allAgents", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        if isinstance(response, list):
+            return [AM.Agent.model_validate(item) for item in response]
+        return AM.AgentsResponse.model_validate(response)
+    
+    async def user_balance(
+        self, params: AM.UserBalanceInfoParams, signal: Optional[Any] = None
+    ) -> AM.UserBalanceInfoResponse:
+        """Get user balance."""
+        request = {"method": "userBalance", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return AM.UserBalanceInfoResponse.model_validate(response)
+    
+    async def account_info(
+        self, params: AM.AccountInfoParams, signal: Optional[Any] = None
+    ) -> AM.AccountInfoResponse:
+        """Get account info."""
+        request = {"method": "accountInfo", "params": params.model_dump(by_alias=True)}
+        response = await self.transport.request("info", request, signal)
+        return AM.AccountInfoResponse.model_validate(response)
+    
+    # Vault Info Endpoints
+    
+    async def vaults(
+        self, params: VM.VaultsParams, signal: Optional[Any] = None
+    ) -> VM.VaultsResponse:
+        """Get all vaults."""
+        request = {"method": "vaults", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return VM.VaultsResponse.model_validate(response)
+    
+    async def sub_vaults(
+        self, params: VM.SubVaultsParams, signal: Optional[Any] = None
+    ) -> VM.SubVaultsResponse:
+        """Get sub-vaults for a specific vault."""
+        request = {"method": "subVaults", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return VM.SubVaultsResponse.model_validate(response)
+    
+    async def vault_balances(
+        self, params: VM.VaultBalancesParams, signal: Optional[Any] = None
+    ) -> VM.VaultBalancesResponse:
+        """Get vault balances."""
+        request = {"method": "vaultBalance", "params": params.model_dump()}
+        response = await self.transport.request("info", request, signal)
+        return VM.VaultBalancesResponse.model_validate(response)
+    
+    # Explorer Info Endpoints
+    
+    async def blocks(
+        self, params: EM.BlocksParams, signal: Optional[Any] = None
+    ) -> EM.BlocksResponse:
+        """Get recent blocks."""
+        request = {"method": "blocks", "params": params.model_dump()}
+        response = await self.transport.request("explorer", request, signal)
+        return EM.BlocksResponse.model_validate(response)
+    
+    async def block_details(
+        self, params: EM.BlockDetailsParams, signal: Optional[Any] = None
+    ) -> EM.BlockDetailsResponse:
+        """Get specific block details."""
+        request = {"method": "block", "params": params.model_dump()}
+        response = await self.transport.request("explorer", request, signal)
+        return EM.BlockDetailsResponse.model_validate(response)
+    
+    async def transactions(
+        self, params: EM.TransactionsParams, signal: Optional[Any] = None
+    ) -> EM.TransactionsResponse:
+        """Get recent transactions."""
+        request = {"method": "transactions", "params": params.model_dump()}
+        response = await self.transport.request("explorer", request, signal)
+        return EM.TransactionsResponse.model_validate(response)
+    
+    async def transaction_details(
+        self, params: EM.TransactionDetailsParams, signal: Optional[Any] = None
+    ) -> EM.TransactionDetailsResponse:
+        """Get specific transaction details."""
+        request = {"method": "transaction", "params": params.model_dump()}
+        response = await self.transport.request("explorer", request, signal)
+        return EM.TransactionDetailsResponse.model_validate(response)

hotstuff/apis/subscription.py

@@ -0,0 +1,278 @@
+"""Subscription API client for real-time data."""
+from typing import Callable, Dict, Any
+import importlib
+
+SM = importlib.import_module("hotstuff.methods.subscription.global")
+
+
+class SubscriptionClient:
+    """Client for subscribing to real-time data streams."""
+    
+    def __init__(self, transport):
+        """
+        Initialize SubscriptionClient.
+        
+        Args:
+            transport: The WebSocket transport layer to use
+        """
+        self.transport = transport
+    
+    # Market Subscriptions
+    
+    async def ticker(
+        self,
+        params: SM.TickerSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to ticker updates.
+        
+        Args:
+            params: Subscription parameters (symbol)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        return await self.transport.subscribe("ticker", params.model_dump(), listener)
+    
+    async def mids(
+        self,
+        params: SM.MidsSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to mid prices.
+        
+        Args:
+            params: Subscription parameters (symbol)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        return await self.transport.subscribe("mids", params.model_dump(), listener)
+    
+    async def bbo(
+        self,
+        params: SM.BBOSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to best bid/offer.
+        
+        Args:
+            params: Subscription parameters (symbol)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        return await self.transport.subscribe("bbo", params.model_dump(), listener)
+    
+    async def orderbook(
+        self,
+        params: SM.OrderbookSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to orderbook updates.
+        
+        Args:
+            params: Subscription parameters (instrument_id)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        # Convert to format expected by API (both instrumentId and symbol)
+        params_dict = params.model_dump()
+        params_dict["symbol"] = params_dict["instrument_id"]
+        return await self.transport.subscribe("orderbook", params_dict, listener)
+    
+    async def trade(
+        self,
+        params: SM.TradeSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to trades.
+        
+        Args:
+            params: Subscription parameters (instrument_id)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        # Convert to format expected by API (both instrumentId and symbol)
+        params_dict = params.model_dump()
+        params_dict["symbol"] = params_dict["instrument_id"]
+        return await self.transport.subscribe("trade", params_dict, listener)
+    
+    async def index(
+        self,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to index prices.
+        
+        Args:
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        return await self.transport.subscribe("index", {}, listener)
+    
+    async def chart(
+        self,
+        params: SM.ChartSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to chart updates.
+        
+        Args:
+            params: Subscription parameters (symbol, chart_type, resolution)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        return await self.transport.subscribe("chart", params.model_dump(), listener)
+    
+    # Account Subscriptions
+    
+    async def account_order_updates(
+        self,
+        params: SM.AccountOrderUpdatesParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to order updates.
+        
+        Args:
+            params: Subscription parameters (address)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        # Convert to format expected by API (both address and user)
+        params_dict = params.model_dump()
+        params_dict["user"] = params_dict["address"]
+        return await self.transport.subscribe("accountOrderUpdates", params_dict, listener)
+    
+    async def account_balance_updates(
+        self,
+        params: SM.AccountBalanceUpdatesParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to balance updates.
+        
+        Args:
+            params: Subscription parameters (address)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        # Convert to format expected by API (both address and user)
+        params_dict = params.model_dump()
+        params_dict["user"] = params_dict["address"]
+        return await self.transport.subscribe("accountBalanceUpdates", params_dict, listener)
+    
+    async def positions(
+        self,
+        params: SM.PositionsSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to position updates.
+        
+        Args:
+            params: Subscription parameters (address)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        # Convert to format expected by API (both address and user)
+        params_dict = params.model_dump()
+        params_dict["user"] = params_dict["address"]
+        return await self.transport.subscribe("positions", params_dict, listener)
+    
+    async def fills(
+        self,
+        params: SM.FillsSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to fills.
+        
+        Args:
+            params: Subscription parameters (address)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        # Convert to format expected by API (both address and user)
+        params_dict = params.model_dump()
+        params_dict["user"] = params_dict["address"]
+        return await self.transport.subscribe("fills", params_dict, listener)
+    
+    async def account_summary(
+        self,
+        params: SM.AccountSummarySubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to account summary.
+        
+        Args:
+            params: Subscription parameters (user)
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        return await self.transport.subscribe("accountSummary", params.model_dump(), listener)
+    
+    # Explorer Subscriptions
+    
+    async def blocks(
+        self,
+        params: SM.BlocksSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to new blocks.
+        
+        Args:
+            params: Subscription parameters
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        return await self.transport.subscribe("blocks", params.model_dump(), listener)
+    
+    async def transactions(
+        self,
+        params: SM.TransactionsSubscriptionParams,
+        listener: Callable
+    ) -> Dict[str, Any]:
+        """
+        Subscribe to new transactions.
+        
+        Args:
+            params: Subscription parameters
+            listener: Callback function for updates
+            
+        Returns:
+            Subscription object with unsubscribe method
+        """
+        return await self.transport.subscribe("transactions", params.model_dump(), listener)

hotstuff/methods/__init__.py

@@ -0,0 +1,10 @@
+"""Method types organized by category."""
+from hotstuff.methods import info as InfoMethods
+from hotstuff.methods import exchange as ExchangeMethods
+from hotstuff.methods import subscription as SubscriptionMethods
+
+__all__ = [
+    "InfoMethods",
+    "ExchangeMethods",
+    "SubscriptionMethods",
+]

hotstuff/methods/exchange/__init__.py

@@ -0,0 +1,14 @@
+"""Exchange method types organized by category."""
+from hotstuff.methods.exchange import trading as TradingExchangeMethods
+from hotstuff.methods.exchange import account as AccountExchangeMethods
+from hotstuff.methods.exchange import collateral as CollateralExchangeMethods
+from hotstuff.methods.exchange import vault as VaultExchangeMethods
+from hotstuff.methods.exchange.op_codes import EXCHANGE_OP_CODES
+
+__all__ = [
+    "TradingExchangeMethods",
+    "AccountExchangeMethods",
+    "CollateralExchangeMethods",
+    "VaultExchangeMethods",
+    "EXCHANGE_OP_CODES",
+]