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

hotstuff/methods/info/vault.py

@@ -0,0 +1,86 @@
+"""Vault info method types."""
+from typing import Optional, Annotated
+from pydantic import BaseModel, Field, field_validator
+from eth_utils import is_address, to_checksum_address
+
+
+def validate_ethereum_address(value: str) -> str:
+    """
+    Validate and normalize an Ethereum address.
+    
+    Args:
+        value: The address string to validate
+        
+    Returns:
+        Checksummed address string
+        
+    Raises:
+        ValueError: If the address is invalid
+    """
+    if not isinstance(value, str):
+        raise ValueError(f"Address must be a string, got {type(value)}")
+    
+    if not is_address(value):
+        raise ValueError(f"Invalid Ethereum address: {value}")
+    
+    # Return checksummed address (EIP-55)
+    return to_checksum_address(value)
+
+
+# Type alias for validated Ethereum addresses (similar to viem's Address type)
+EthereumAddress = Annotated[
+    str,
+    Field(
+        ...,
+        description="Ethereum address (validated and checksummed)",
+        examples=["0x1234567890123456789012345678901234567890"],
+    ),
+]
+
+
+# Vaults Method
+class VaultsParams(BaseModel):
+    """Parameters for vaults query."""
+    pass
+
+
+class VaultsResponse(BaseModel):
+    """Vaults response."""
+    pass 
+
+
+# Sub Vaults Method
+class SubVaultsParams(BaseModel):
+    """Parameters for sub vaults query."""
+    vault_address: EthereumAddress = Field(..., description="Vault address")
+    
+    @field_validator('vault_address', mode='before')
+    @classmethod
+    def validate_vault_address(cls, v: str) -> str:
+        """Validate and checksum the vault address."""
+        return validate_ethereum_address(v)
+
+
+class SubVaultsResponse(BaseModel):
+    """Sub vaults response."""
+    pass 
+
+
+# Vault Balances Method
+class VaultBalancesParams(BaseModel):
+    """Parameters for vault balances query."""
+    vault_address: EthereumAddress = Field(..., description="Vault address")
+    user: Optional[EthereumAddress] = Field(None, description="User address")
+    
+    @field_validator('vault_address', 'user', mode='before')
+    @classmethod
+    def validate_addresses(cls, v: Optional[str]) -> Optional[str]:
+        """Validate and checksum Ethereum addresses."""
+        if v is None:
+            return None
+        return validate_ethereum_address(v)
+
+
+class VaultBalancesResponse(BaseModel):
+    """Vault balances response."""
+    pass 

hotstuff/methods/subscription/__init__.py

@@ -0,0 +1,8 @@
+"""Subscription method types."""
+import importlib
+
+GlobalSubscriptionMethods = importlib.import_module("hotstuff.methods.subscription.global")
+
+__all__ = [
+    "GlobalSubscriptionMethods",
+]

hotstuff/methods/subscription/global.py

@@ -0,0 +1,200 @@
+"""Global subscription method types."""
+from typing import List, Literal, Optional
+from pydantic import BaseModel, Field, field_validator
+from eth_utils import is_address, to_checksum_address
+
+
+def validate_ethereum_address(value: str) -> str:
+    """
+    Validate and normalize an Ethereum address.
+    
+    Args:
+        value: The address string to validate
+        
+    Returns:
+        Checksummed address string
+        
+    Raises:
+        ValueError: If the address is invalid
+    """
+    if not isinstance(value, str):
+        raise ValueError(f"Address must be a string, got {type(value)}")
+    
+    if not is_address(value):
+        raise ValueError(f"Invalid Ethereum address: {value}")
+    
+    return to_checksum_address(value)
+
+
+# Chart types
+SupportedChartResolutions = Literal["1", "5", "15", "60", "240", "1D", "1W"]
+SupportedChartTypes = Literal["mark", "ltp", "index"]
+
+
+# Subscription parameter types
+class TickerSubscriptionParams(BaseModel):
+    """Parameters for ticker subscription."""
+    symbol: str = Field(..., description="Trading pair symbol")
+
+
+class MidsSubscriptionParams(BaseModel):
+    """Parameters for mids subscription."""
+    symbol: str = Field(..., description="Trading pair symbol")
+
+
+class BBOSubscriptionParams(BaseModel):
+    """Parameters for BBO subscription."""
+    symbol: str = Field(..., description="Trading pair symbol")
+
+
+class OrderbookSubscriptionParams(BaseModel):
+    """Parameters for orderbook subscription."""
+    instrument_id: str = Field(..., description="Instrument ID")
+
+
+class TradeSubscriptionParams(BaseModel):
+    """Parameters for trade subscription."""
+    instrument_id: str = Field(..., description="Instrument ID")
+
+
+class ChartSubscriptionParams(BaseModel):
+    """Parameters for chart subscription."""
+    symbol: str = Field(..., description="Trading pair symbol")
+    chart_type: SupportedChartTypes = Field(..., description="Chart type")
+    resolution: SupportedChartResolutions = Field(..., description="Chart resolution")
+
+
+class AccountOrderUpdatesParams(BaseModel):
+    """Parameters for account order updates subscription."""
+    address: str = Field(..., description="User address")
+    
+    @field_validator('address', mode='before')
+    @classmethod
+    def validate_address(cls, v: str) -> str:
+        """Validate and checksum the user address."""
+        return validate_ethereum_address(v)
+
+
+class AccountBalanceUpdatesParams(BaseModel):
+    """Parameters for account balance updates subscription."""
+    address: str = Field(..., description="User address")
+    
+    @field_validator('address', mode='before')
+    @classmethod
+    def validate_address(cls, v: str) -> str:
+        """Validate and checksum the user address."""
+        return validate_ethereum_address(v)
+
+
+class PositionsSubscriptionParams(BaseModel):
+    """Parameters for positions subscription."""
+    address: str = Field(..., description="User address")
+    
+    @field_validator('address', mode='before')
+    @classmethod
+    def validate_address(cls, v: str) -> str:
+        """Validate and checksum the user address."""
+        return validate_ethereum_address(v)
+
+
+class FillsSubscriptionParams(BaseModel):
+    """Parameters for fills subscription."""
+    address: str = Field(..., description="User address")
+    
+    @field_validator('address', mode='before')
+    @classmethod
+    def validate_address(cls, v: str) -> str:
+        """Validate and checksum the user address."""
+        return validate_ethereum_address(v)
+
+
+class AccountSummarySubscriptionParams(BaseModel):
+    """Parameters for account summary subscription."""
+    user: str = Field(..., description="User address")
+    
+    @field_validator('user', mode='before')
+    @classmethod
+    def validate_user_address(cls, v: str) -> str:
+        """Validate and checksum the user address."""
+        return validate_ethereum_address(v)
+
+
+class BlocksSubscriptionParams(BaseModel):
+    """Parameters for blocks subscription."""
+    pass
+
+
+class TransactionsSubscriptionParams(BaseModel):
+    """Parameters for transactions subscription."""
+    pass
+
+
+# Orderbook subscription
+class OrderbookItem(BaseModel):
+    """Orderbook item."""
+    price: float
+    size: float
+    amount: Optional[float] = None  # Alternative field name
+
+
+class Orderbook(BaseModel):
+    """Orderbook subscription data."""
+    instrument_id: str
+    instrument_name: Optional[str] = None  # Alternative field name
+    asks: List[OrderbookItem]
+    bids: List[OrderbookItem]
+    timestamp: int
+
+
+# Trade subscription
+class Trade(BaseModel):
+    """Trade subscription data."""
+    id: str
+    instrument: str
+    instrument_name: Optional[str] = None
+    maker: str
+    taker: str
+    price: float
+    size: float
+    timestamp: int
+    side: Literal["buy", "sell"]
+
+
+# Order update subscription
+class OrderUpdate(BaseModel):
+    """Order update subscription data."""
+    id: str
+    account: str
+    instrument: str
+    price: float
+    size: float
+    side: Literal["buy", "sell"]
+    status: str
+    timestamp: int
+
+
+# Account balance update subscription
+class BalanceItem(BaseModel):
+    """Balance item."""
+    asset: str
+    total: float
+    available: float
+    locked: float
+
+
+class AccountBalanceUpdate(BaseModel):
+    """Account balance update subscription data."""
+    account: str
+    balances: List[BalanceItem]
+    timestamp: int
+
+
+# Chart update subscription
+class ChartUpdate(BaseModel):
+    """Chart update subscription data."""
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: float
+    time: int  # in milliseconds

hotstuff/transports/__init__.py

@@ -0,0 +1,9 @@
+"""Transports package."""
+from hotstuff.transports.http import HttpTransport
+from hotstuff.transports.websocket import WebSocketTransport
+
+__all__ = [
+    "HttpTransport",
+    "WebSocketTransport",
+]
+

hotstuff/transports/http.py

@@ -0,0 +1,142 @@
+"""HTTP transport implementation."""
+import json
+from typing import Optional, Any, Dict, Callable, Awaitable
+import aiohttp
+
+from hotstuff.types import HttpTransportOptions
+from hotstuff.utils import ENDPOINTS_URLS
+
+
+class HttpTransport:
+    """HTTP transport for making API requests."""
+    
+    def __init__(self, options: Optional[HttpTransportOptions] = None):
+        """
+        Initialize HTTP transport.
+        
+        Args:
+            options: Transport configuration options
+        """
+        options = options or HttpTransportOptions()
+        
+        self.is_testnet = options.is_testnet
+        self.timeout = options.timeout
+        
+        # Setup server endpoints
+        self.server = {
+            "mainnet": {
+                "api": ENDPOINTS_URLS["mainnet"]["api"],
+                "rpc": ENDPOINTS_URLS["mainnet"]["rpc"],
+            },
+            "testnet": {
+                "api": ENDPOINTS_URLS["testnet"]["api"],
+                "rpc": ENDPOINTS_URLS["testnet"]["rpc"],
+            },
+        }
+        
+        if options.server:
+            if "mainnet" in options.server:
+                self.server["mainnet"].update(options.server["mainnet"])
+            if "testnet" in options.server:
+                self.server["testnet"].update(options.server["testnet"])
+        
+        self.headers = options.headers or {}
+        self.on_request = options.on_request
+        self.on_response = options.on_response
+        
+        # Session will be created lazily
+        self._session: Optional[aiohttp.ClientSession] = None
+    
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Get or create aiohttp session."""
+        if self._session is None or self._session.closed:
+            timeout = aiohttp.ClientTimeout(total=self.timeout) if self.timeout else None
+            self._session = aiohttp.ClientSession(timeout=timeout)
+        return self._session
+    
+    async def request(
+        self,
+        endpoint: str,
+        payload: Any,
+        signal: Optional[Any] = None,
+        method: str = "POST"
+    ) -> Any:
+        """
+        Make an HTTP request.
+        
+        Args:
+            endpoint: The endpoint to call ('info', 'exchange', or 'explorer')
+            payload: The request payload
+            signal: Optional abort signal
+            method: HTTP method (GET or POST)
+            
+        Returns:
+            The response data
+            
+        Raises:
+            Exception: If the request fails
+        """
+        try:
+            # Determine the base URL
+            network = "testnet" if self.is_testnet else "mainnet"
+            base_url = self.server[network]["rpc" if endpoint == "explorer" else "api"]
+            url = f"{base_url}{endpoint}"
+            
+            # Prepare headers
+            headers = {
+                "Accept-Encoding": "gzip, deflate, br",
+                "Content-Type": "application/json",
+                **self.headers,
+            }
+            
+            # Get session
+            session = await self._get_session()
+            
+            # Prepare request kwargs
+            kwargs: Dict[str, Any] = {
+                "headers": headers,
+            }
+            
+            if method == "POST":
+                kwargs["json"] = payload
+            
+            # Make request
+            async with session.request(method, url, **kwargs) as response:
+                # Check if response is OK
+                if not response.ok:
+                    text = await response.text()
+                    raise Exception(text or f"HTTP {response.status}")
+                
+                # Check content type
+                content_type = response.headers.get("Content-Type", "")
+                if "application/json" not in content_type:
+                    text = await response.text()
+                    raise Exception(text)
+                
+                # Parse response
+                body = await response.json()
+                
+                # Check for error in response
+                if isinstance(body, dict) and body.get("type") == "error":
+                    raise Exception(body.get("message", "Unknown error"))
+                
+                return body
+        
+        except aiohttp.ClientError as e:
+            raise Exception(f"HTTP request failed: {str(e)}")
+        except Exception as e:
+            raise e
+    
+    async def close(self):
+        """Close the HTTP session."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+