nado-protocol 0.1.7__py3-none-any.whl → 0.2.2__py3-none-any.whl

nado_protocol/indexer_client/query.py

@@ -49,6 +49,8 @@ from nado_protocol.indexer_client.types.query import (
     IndexerMerkleProofsData,
     IndexerInterestAndFundingParams,
     IndexerInterestAndFundingData,
+    IndexerAccountSnapshotsParams,
+    IndexerAccountSnapshotsData,
     IndexerTickersData,
     IndexerPerpContractsData,
     IndexerHistoricalTradesData,
@@ -459,3 +461,24 @@ class IndexerQueryClient:
         if max_trade_id is not None:
             url += f"&max_trade_id={max_trade_id}"
         return ensure_data_type(self._query_v2(url), list)
+
+    def get_multi_subaccount_snapshots(
+        self, params: IndexerAccountSnapshotsParams
+    ) -> IndexerAccountSnapshotsData:
+        """
+        Retrieves subaccount snapshots at specified timestamps.
+        Each snapshot is a view of the subaccount's balances at that point in time,
+        with tracked variables for interest, funding, etc.
+
+        Args:
+            params (IndexerAccountSnapshotsParams): Parameters specifying subaccounts,
+                timestamps, and whether to include isolated positions.
+
+        Returns:
+            IndexerAccountSnapshotsData: Dict mapping subaccount hex -> timestamp -> snapshot data.
+                Each snapshot contains balances with trackedVars including netEntryUnrealized.
+        """
+        return ensure_data_type(
+            self.query(IndexerAccountSnapshotsParams.parse_obj(params)).data,
+            IndexerAccountSnapshotsData,
+        )

nado_protocol/indexer_client/types/models.py

@@ -182,7 +182,7 @@ class IndexerEventTrackedData(NadoBaseModel):
     net_funding_cumulative: str
     net_entry_unrealized: str
     net_entry_cumulative: str
-    cumulative_volume: str
+    quote_volume_cumulative: str
 
 
 class IndexerEvent(IndexerBaseModel, IndexerEventTrackedData):

nado_protocol/indexer_client/types/query.py

@@ -49,6 +49,7 @@ class IndexerQueryType(StrEnum):
     REFERRAL_CODE = "referral_code"
     SUBACCOUNTS = "subaccounts"
     USDC_PRICE = "usdc_price"
+    ACCOUNT_SNAPSHOTS = "account_snapshots"
     # TODO: revise once this endpoint is live
     TOKEN_MERKLE_PROOFS = "token_merkle_proofs"
     FOUNDATION_REWARDS_MERKLE_PROOFS = "foundation_rewards_merkle_proofs"
@@ -292,6 +293,17 @@ class IndexerInterestAndFundingParams(NadoBaseModel):
     limit: int
 
 
+class IndexerAccountSnapshotsParams(NadoBaseModel):
+    """
+    Parameters for querying account snapshots.
+    """
+
+    subaccounts: list[str]
+    timestamps: list[int]
+    isolated: Optional[bool] = None
+    active: Optional[bool] = None
+
+
 IndexerParams = Union[
     IndexerSubaccountHistoricalOrdersParams,
     IndexerHistoricalOrdersByDigestParams,
@@ -314,6 +326,7 @@ IndexerParams = Union[
     IndexerTokenMerkleProofsParams,
     IndexerFoundationRewardsMerkleProofsParams,
     IndexerInterestAndFundingParams,
+    IndexerAccountSnapshotsParams,
 ]
 
 
@@ -487,6 +500,14 @@ class IndexerInterestAndFundingRequest(NadoBaseModel):
     interest_and_funding: IndexerInterestAndFundingParams
 
 
+class IndexerAccountSnapshotsRequest(NadoBaseModel):
+    """
+    Request object for querying account snapshots.
+    """
+
+    account_snapshots: IndexerAccountSnapshotsParams
+
+
 IndexerRequest = Union[
     IndexerHistoricalOrdersRequest,
     IndexerMatchesRequest,
@@ -508,6 +529,7 @@ IndexerRequest = Union[
     IndexerTokenMerkleProofsRequest,
     IndexerFoundationRewardsMerkleProofsRequest,
     IndexerInterestAndFundingRequest,
+    IndexerAccountSnapshotsRequest,
 ]
 
 
@@ -681,6 +703,14 @@ class IndexerInterestAndFundingData(NadoBaseModel):
 IndexerLiquidationFeedData = list[IndexerLiquidatableAccount]
 
 
+class IndexerAccountSnapshotsData(NadoBaseModel):
+    """
+    Data object for subaccount snapshots grouped by subaccount and timestamp.
+    """
+
+    snapshots: Dict[str, Dict[str, list[IndexerEvent]]]
+
+
 IndexerResponseData = Union[
     IndexerHistoricalOrdersData,
     IndexerMatchesData,
@@ -702,6 +732,7 @@ IndexerResponseData = Union[
     IndexerInterestAndFundingData,
     IndexerLiquidationFeedData,
     IndexerFundingRatesData,
+    IndexerAccountSnapshotsData,
 ]
 
 
@@ -809,6 +840,10 @@ def to_indexer_request(params: IndexerParams) -> IndexerRequest:
             IndexerInterestAndFundingRequest,
             IndexerQueryType.INTEREST_AND_FUNDING.value,
         ),
+        IndexerAccountSnapshotsParams: (
+            IndexerAccountSnapshotsRequest,
+            IndexerQueryType.ACCOUNT_SNAPSHOTS.value,
+        ),
     }
 
     RequestClass, field_name = indexer_request_mapping[type(params)]

nado_protocol/utils/backend.py

@@ -14,9 +14,9 @@ class NadoBackendURL(StrEnum):
     DEVNET_TRIGGER = "http://localhost:8080"
 
     # testnets
-    TESTNET_GATEWAY = "https://gateway.test.nado-backend.xyz/v1"
-    TESTNET_INDEXER = "https://archive.test.nado-backend.xyz/v1"
-    TESTNET_TRIGGER = "https://trigger.test.nado-backend.xyz/v1"
+    TESTNET_GATEWAY = "https://gateway.test.nado.xyz/v1"
+    TESTNET_INDEXER = "https://archive.test.nado.xyz/v1"
+    TESTNET_TRIGGER = "https://trigger.test.nado.xyz/v1"
 
 
 PrivateKey = str

nado_protocol/utils/balance.py

@@ -0,0 +1,249 @@
+"""
+Balance Value Calculation Utilities
+"""
+
+from decimal import Decimal
+from typing import Union
+from nado_protocol.engine_client.types.models import (
+    SpotProduct,
+    PerpProduct,
+    SpotProductBalance,
+    PerpProductBalance,
+)
+from nado_protocol.utils.math import from_x18
+
+
+def calculate_spot_balance_value(
+    amount: Union[Decimal, float, str], oracle_price: Union[Decimal, float, str]
+) -> Decimal:
+    """
+    Calculate the quote value of a spot balance.
+
+    Formula: amount * oracle_price
+
+    This is used for:
+    - Calculating health contributions
+    - Determining deposits vs borrows
+    - Portfolio value calculations
+
+    Args:
+        amount: Token amount (can be negative for borrows)
+        oracle_price: Oracle price in quote currency
+
+    Returns:
+        Value in quote currency (positive for deposits, negative for borrows)
+
+    Example:
+        >>> calculate_spot_balance_value(100, 2000)  # 100 ETH at $2000
+        Decimal('200000')
+        >>> calculate_spot_balance_value(-50, 2000)  # 50 ETH borrowed
+        Decimal('-100000')
+    """
+    amount_dec = Decimal(str(amount))
+    price_dec = Decimal(str(oracle_price))
+    return amount_dec * price_dec
+
+
+def calculate_perp_balance_notional_value(
+    amount: Union[Decimal, float, str], oracle_price: Union[Decimal, float, str]
+) -> Decimal:
+    """
+    Calculate the notional value of a perp position.
+
+    Formula: abs(amount * oracle_price)
+
+    This represents the total size of the position in quote currency terms,
+    regardless of direction (long or short).
+
+    Args:
+        amount: Position size (positive for long, negative for short)
+        oracle_price: Oracle price in quote currency
+
+    Returns:
+        Absolute notional value in quote currency
+
+    Example:
+        >>> calculate_perp_balance_notional_value(10, 50000)  # 10 BTC long
+        Decimal('500000')
+        >>> calculate_perp_balance_notional_value(-10, 50000)  # 10 BTC short
+        Decimal('500000')
+    """
+    amount_dec = Decimal(str(amount))
+    price_dec = Decimal(str(oracle_price))
+    return abs(amount_dec * price_dec)
+
+
+def calculate_perp_balance_value(
+    amount: Union[Decimal, float, str],
+    oracle_price: Union[Decimal, float, str],
+    v_quote_balance: Union[Decimal, float, str],
+) -> Decimal:
+    """
+    Calculate the true quote value of a perp balance (unrealized PnL).
+
+    Formula: (amount * oracle_price) + v_quote_balance
+
+    The v_quote_balance represents:
+    - Unrealized PnL from price changes
+    - Accumulated funding payments
+    - Entry cost adjustments
+
+    This value is what would be added to your balance if the position were closed.
+
+    Args:
+        amount: Position size
+        oracle_price: Oracle price in quote currency
+        v_quote_balance: Virtual quote balance (unsettled PnL)
+
+    Returns:
+        Total value in quote currency (can be positive or negative)
+
+    Example:
+        >>> # Long 10 BTC at $50k, now at $51k, with funding
+        >>> calculate_perp_balance_value(10, 51000, -500000)
+        Decimal('10000')  # $10k profit
+    """
+    amount_dec = Decimal(str(amount))
+    price_dec = Decimal(str(oracle_price))
+    v_quote_dec = Decimal(str(v_quote_balance))
+    return (amount_dec * price_dec) + v_quote_dec
+
+
+def parse_spot_balance_value(
+    balance: SpotProductBalance, product: SpotProduct
+) -> Decimal:
+    """
+    Parse spot balance value from raw SDK types.
+
+    This is a convenience function that extracts values from the SDK types
+    and calls calculate_spot_balance_value.
+
+    Args:
+        balance: Spot balance from subaccount info
+        product: Spot product information
+
+    Returns:
+        Balance value in quote currency
+    """
+    amount = Decimal(from_x18(int(balance.balance.amount)))
+    oracle_price = Decimal(from_x18(int(product.oracle_price_x18)))
+    return calculate_spot_balance_value(amount, oracle_price)
+
+
+def parse_perp_balance_notional_value(
+    balance: PerpProductBalance, product: PerpProduct
+) -> Decimal:
+    """
+    Parse perp notional value from raw SDK types.
+
+    Args:
+        balance: Perp balance from subaccount info
+        product: Perp product information
+
+    Returns:
+        Notional value in quote currency
+    """
+    amount = Decimal(from_x18(int(balance.balance.amount)))
+    oracle_price = Decimal(from_x18(int(product.oracle_price_x18)))
+    return calculate_perp_balance_notional_value(amount, oracle_price)
+
+
+def parse_perp_balance_value(
+    balance: PerpProductBalance, product: PerpProduct
+) -> Decimal:
+    """
+    Parse perp balance value (unrealized PnL) from raw SDK types.
+
+    Args:
+        balance: Perp balance from subaccount info
+        product: Perp product information
+
+    Returns:
+        Balance value in quote currency
+    """
+    amount = Decimal(from_x18(int(balance.balance.amount)))
+    oracle_price = Decimal(from_x18(int(product.oracle_price_x18)))
+    v_quote = Decimal(from_x18(int(balance.balance.v_quote_balance)))
+    return calculate_perp_balance_value(amount, oracle_price, v_quote)
+
+
+def calculate_total_spot_deposits_and_borrows(
+    balances: list[tuple[SpotProductBalance, SpotProduct]]
+) -> tuple[Decimal, Decimal]:
+    """
+    Calculate total spot deposits and borrows across all balances.
+
+    Args:
+        balances: List of (balance, product) tuples
+
+    Returns:
+        Tuple of (total_deposits, total_borrows) in quote currency
+        Both values are positive (borrows is absolute value)
+
+    Example:
+        >>> balances = [(usdt_balance, usdt_product), (eth_balance, eth_product)]
+        >>> deposits, borrows = calculate_total_spot_deposits_and_borrows(balances)
+        >>> deposits  # Total deposits
+        Decimal('10000')
+        >>> borrows   # Total borrows (absolute value)
+        Decimal('5000')
+    """
+    total_deposits = Decimal(0)
+    total_borrows = Decimal(0)
+
+    for balance, product in balances:
+        value = parse_spot_balance_value(balance, product)
+        if value > 0:
+            total_deposits += value
+        else:
+            total_borrows += abs(value)
+
+    return total_deposits, total_borrows
+
+
+def calculate_total_perp_notional(
+    balances: list[tuple[PerpProductBalance, PerpProduct]]
+) -> Decimal:
+    """
+    Calculate total notional value across all perp positions.
+
+    Args:
+        balances: List of (balance, product) tuples
+
+    Returns:
+        Total notional value in quote currency
+
+    Example:
+        >>> balances = [(btc_perp_balance, btc_perp_product)]
+        >>> total = calculate_total_perp_notional(balances)
+        >>> total
+        Decimal('500000')  # Total position size
+    """
+    total = Decimal(0)
+    for balance, product in balances:
+        total += parse_perp_balance_notional_value(balance, product)
+    return total
+
+
+def calculate_total_perp_value(
+    balances: list[tuple[PerpProductBalance, PerpProduct]]
+) -> Decimal:
+    """
+    Calculate total unrealized PnL across all perp positions.
+
+    Args:
+        balances: List of (balance, product) tuples
+
+    Returns:
+        Total unrealized PnL in quote currency (can be positive or negative)
+
+    Example:
+        >>> balances = [(btc_perp_balance, btc_perp_product)]
+        >>> total_pnl = calculate_total_perp_value(balances)
+        >>> total_pnl
+        Decimal('10000')  # $10k unrealized profit
+    """
+    total = Decimal(0)
+    for balance, product in balances:
+        total += parse_perp_balance_value(balance, product)
+    return total

nado_protocol/utils/margin_manager.py

@@ -0,0 +1,841 @@
+"""
+Margin Manager - Comprehensive margin calculations for Nado Protocol.
+
+This module calculates all margin-related metrics including health, margin usage,
+leverage, and position-level details. All calculations use oracle prices.
+
+Key Concepts:
+- Health Types: Initial (strictest), Maintenance (liquidation), Unweighted (raw)
+- Cross Margin: Shared across all positions
+- Isolated Margin: Dedicated per position (perp only, USDT only)
+- Health = Assets - Liabilities, calculated per balance using oracle_price * weight
+"""
+
+from decimal import Decimal
+from time import time
+from typing import Optional, Union, TYPE_CHECKING
+from pydantic import BaseModel
+from nado_protocol.engine_client.types.models import (
+    SpotProduct,
+    PerpProduct,
+    SpotProductBalance,
+    PerpProductBalance,
+    SubaccountHealth,
+    IsolatedPosition,
+)
+from nado_protocol.engine_client.types.query import SubaccountInfoData
+from nado_protocol.indexer_client.types.models import IndexerEvent
+from nado_protocol.indexer_client.types.query import IndexerAccountSnapshotsParams
+from nado_protocol.utils.bytes32 import subaccount_to_hex
+
+if TYPE_CHECKING:
+    from nado_protocol.client import NadoClient
+
+
+TEN_TO_18 = Decimal(10) ** 18
+
+
+def _from_x18_decimal(value: Union[int, str]) -> Decimal:
+    """Convert an x18 fixed-point integer (str or int) to Decimal without precision loss."""
+    return Decimal(str(value)) / TEN_TO_18
+
+
+class HealthMetrics(BaseModel):
+    """Initial and maintenance health metrics."""
+
+    initial: Decimal
+    maintenance: Decimal
+
+
+class MarginUsageFractions(BaseModel):
+    """Margin usage as a fraction [0, 1]."""
+
+    initial: Decimal
+    maintenance: Decimal
+
+
+class BalanceWithProduct(BaseModel):
+    """Balance combined with its product information."""
+
+    product_id: int
+    amount: Decimal
+    oracle_price: Decimal
+    long_weight_initial: Decimal
+    long_weight_maintenance: Decimal
+    short_weight_initial: Decimal
+    short_weight_maintenance: Decimal
+    balance_type: str  # "spot" or "perp"
+    v_quote_balance: Optional[Decimal] = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class CrossPositionMetrics(BaseModel):
+    """Metrics for a cross margin position."""
+
+    product_id: int
+    symbol: str
+    position_size: Decimal
+    notional_value: Decimal
+    est_pnl: Optional[Decimal]  # Estimated PnL (requires indexer data)
+    unsettled: Decimal  # Unsettled quote (v_quote_balance)
+    margin_used: Decimal
+    initial_health: Decimal
+    maintenance_health: Decimal
+    long_weight_initial: Decimal
+    long_weight_maintenance: Decimal
+    short_weight_initial: Decimal
+    short_weight_maintenance: Decimal
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class IsolatedPositionMetrics(BaseModel):
+    """Metrics for an isolated margin position."""
+
+    product_id: int
+    symbol: str
+    position_size: Decimal
+    notional_value: Decimal
+    net_margin: Decimal
+    leverage: Decimal
+    initial_health: Decimal
+    maintenance_health: Decimal
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class AccountSummary(BaseModel):
+    """Complete account margin summary."""
+
+    # Overall health
+    initial_health: Decimal
+    maintenance_health: Decimal
+    unweighted_health: Decimal
+
+    # Margin usage [0, 1]
+    margin_usage_fraction: Decimal
+    maint_margin_usage_fraction: Decimal
+
+    # Available margins
+    funds_available: Decimal
+    funds_until_liquidation: Decimal
+
+    # Portfolio metrics
+    portfolio_value: Decimal
+    account_leverage: Decimal
+
+    # Positions
+    cross_positions: list[CrossPositionMetrics]
+    isolated_positions: list[IsolatedPositionMetrics]
+    spot_positions: list[BalanceWithProduct]
+
+    # Spot balances
+    total_spot_deposits: Decimal
+    total_spot_borrows: Decimal
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class MarginManager:
+    """
+    Comprehensive margin calculator for Nado Protocol.
+
+    Calculates all margin metrics for a subaccount including health, margin usage,
+    leverage, and position-level details. Matches TypeScript SDK implementation.
+    """
+
+    QUOTE_PRODUCT_ID = 0  # USDT product ID
+
+    def __init__(
+        self,
+        subaccount_info: SubaccountInfoData,
+        isolated_positions: Optional[list[IsolatedPosition]] = None,
+        indexer_snapshot_events: Optional[list[IndexerEvent]] = None,
+    ):
+        """
+        Initialize margin manager with subaccount data.
+
+        Args:
+            subaccount_info: Subaccount information from engine
+            isolated_positions: List of isolated positions (if any)
+            indexer_snapshot_events: Optional indexer events for Est. PnL calculations
+        """
+        self.subaccount_info = subaccount_info
+        self.isolated_positions = isolated_positions or []
+        self.indexer_events = indexer_snapshot_events or []
+
+    @classmethod
+    def from_client(
+        cls,
+        client: "NadoClient",
+        *,
+        subaccount: Optional[str] = None,
+        subaccount_name: str = "default",
+        include_indexer_events: bool = True,
+        snapshot_timestamp: Optional[int] = None,
+        snapshot_isolated: Optional[bool] = False,
+        snapshot_active_only: bool = True,
+    ) -> "MarginManager":
+        """
+        Initialize a MarginManager by fetching data via a NadoClient.
+
+        Args:
+            client: Configured Nado client with engine/indexer connectivity.
+            subaccount: Optional subaccount hex (bytes32). If omitted, derives the default
+                subaccount using the client's signer and ``subaccount_name``.
+            subaccount_name: Subaccount suffix (e.g. ``default``) used when deriving the
+                subaccount hex. Ignored when ``subaccount`` is provided.
+            include_indexer_events: When True (default), fetch indexer snapshot balances
+                for estimated PnL calculations.
+            snapshot_timestamp: Epoch seconds to request from the indexer. Defaults to
+                ``int(time.time())`` when indexer data is requested.
+            snapshot_isolated: Passed through to the indexer request to limit snapshots
+                to isolated (True), cross (False), or all (None) balances. Defaults to
+                ``False`` to match cross-margin behaviour.
+            snapshot_active_only: When True (default), enables the indexer's ``active``
+                filter so only live balances are returned.
+
+        Returns:
+            MarginManager instance populated with fresh engine and optional indexer data.
+        """
+
+        engine_client = client.context.engine_client
+
+        resolved_subaccount = subaccount
+        if resolved_subaccount is None:
+            signer = client.context.signer
+            if signer is None:
+                raise ValueError(
+                    "subaccount must be provided when the client has no signer"
+                )
+            resolved_subaccount = subaccount_to_hex(signer.address, subaccount_name)
+
+        subaccount_info = engine_client.get_subaccount_info(resolved_subaccount)
+        isolated_positions_data = engine_client.get_isolated_positions(
+            resolved_subaccount
+        )
+        isolated_positions = isolated_positions_data.isolated_positions
+
+        indexer_events: list[IndexerEvent] = []
+        if include_indexer_events:
+            requested_timestamp = snapshot_timestamp or int(time())
+            indexer_events = cls._fetch_snapshot_events(
+                client,
+                resolved_subaccount,
+                requested_timestamp,
+                snapshot_isolated,
+                snapshot_active_only,
+            )
+
+        return cls(
+            subaccount_info,
+            isolated_positions,
+            indexer_snapshot_events=indexer_events,
+        )
+
+    @staticmethod
+    def _fetch_snapshot_events(
+        client: "NadoClient",
+        subaccount: str,
+        timestamp: int,
+        isolated: Optional[bool],
+        active_only: bool,
+    ) -> list[IndexerEvent]:
+        snapshot_response = (
+            client.context.indexer_client.get_multi_subaccount_snapshots(
+                IndexerAccountSnapshotsParams(
+                    subaccounts=[subaccount],
+                    timestamps=[timestamp],
+                    isolated=isolated,
+                    active=active_only,
+                )
+            )
+        )
+
+        snapshots_map = snapshot_response.snapshots or {}
+        if not snapshots_map:
+            return []
+
+        snapshots_for_subaccount = snapshots_map.get(subaccount) or next(
+            iter(snapshots_map.values())
+        )
+        if not snapshots_for_subaccount:
+            return []
+
+        latest_key = max(snapshots_for_subaccount.keys(), key=int)
+        events = snapshots_for_subaccount.get(latest_key, [])
+        return list(events) if events else []
+
+    def calculate_account_summary(self) -> AccountSummary:
+        """
+        Calculate complete account margin summary.
+
+        Returns:
+            AccountSummary with all margin calculations
+        """
+        # Parse health from subaccount info
+        # healths is a list: [initial, maintenance, unweighted]
+        initial_health = self._parse_health(self.subaccount_info.healths[0])
+        maint_health = self._parse_health(self.subaccount_info.healths[1])
+        unweighted_health = self._parse_health(self.subaccount_info.healths[2])
+
+        # Calculate margin usage
+        margin_usage = self.calculate_margin_usage_fractions(
+            initial_health, maint_health, unweighted_health
+        )
+
+        # Process all balances
+        spot_balances = self._create_spot_balances()
+        perp_balances = self._create_perp_balances()
+
+        # Calculate cross position metrics
+        cross_positions: list[CrossPositionMetrics] = []
+        for balance in perp_balances:
+            if balance.amount != 0:
+                cross_metric = self.calculate_cross_position_metrics(balance)
+                cross_positions.append(cross_metric)
+
+        # Calculate isolated position metrics
+        isolated_position_metrics: list[IsolatedPositionMetrics] = []
+        total_iso_net_margin = Decimal(0)
+        for iso_pos in self.isolated_positions:
+            isolated_metric = self.calculate_isolated_position_metrics(iso_pos)
+            isolated_position_metrics.append(isolated_metric)
+            total_iso_net_margin += isolated_metric.net_margin
+
+        # Calculate spot metrics
+        total_deposits = Decimal(0)
+        total_borrows = Decimal(0)
+        for balance in spot_balances:
+            value = self.calculate_spot_balance_value(balance)
+            if value > 0:
+                total_deposits += value
+            else:
+                total_borrows += abs(value)
+
+        # Calculate leverage
+        leverage = self.calculate_account_leverage(
+            spot_balances + perp_balances, unweighted_health
+        )
+
+        # Portfolio value = cross value + isolated net margins
+        portfolio_value = unweighted_health + total_iso_net_margin
+
+        return AccountSummary(
+            initial_health=initial_health,
+            maintenance_health=maint_health,
+            unweighted_health=unweighted_health,
+            margin_usage_fraction=margin_usage.initial,
+            maint_margin_usage_fraction=margin_usage.maintenance,
+            funds_available=max(Decimal(0), initial_health),
+            funds_until_liquidation=max(Decimal(0), maint_health),
+            portfolio_value=portfolio_value,
+            account_leverage=leverage,
+            cross_positions=cross_positions,
+            isolated_positions=isolated_position_metrics,
+            spot_positions=spot_balances,
+            total_spot_deposits=total_deposits,
+            total_spot_borrows=total_borrows,
+        )
+
+    def calculate_spot_balance_value(self, balance: BalanceWithProduct) -> Decimal:
+        """
+        Calculate quote value of a spot balance.
+
+        Formula: amount * oracle_price
+        """
+        return balance.amount * balance.oracle_price
+
+    def calculate_perp_balance_notional_value(
+        self, balance: BalanceWithProduct
+    ) -> Decimal:
+        """
+        Calculate notional value of a perp position.
+
+        Formula: abs(amount * oracle_price)
+        """
+        return abs(balance.amount * balance.oracle_price)
+
+    def calculate_perp_balance_value(self, balance: BalanceWithProduct) -> Decimal:
+        """
+        Calculate true quote value of a perp balance (unrealized PnL).
+
+        Formula: (amount * oracle_price) + v_quote_balance
+        """
+        if balance.v_quote_balance is None:
+            raise ValueError("Perp balance must have v_quote_balance")
+        return (balance.amount * balance.oracle_price) + balance.v_quote_balance
+
+    def calculate_spot_balance_health(
+        self, balance: BalanceWithProduct
+    ) -> HealthMetrics:
+        """
+        Calculate health contribution for a spot balance.
+
+        Formula: amount * oracle_price * weight
+        (weight is long_weight if amount >= 0, else short_weight)
+        """
+        weights = self._get_health_weights(balance)
+        value = balance.amount * balance.oracle_price
+
+        return HealthMetrics(
+            initial=value * weights.initial, maintenance=value * weights.maintenance
+        )
+
+    def calculate_perp_balance_health_without_pnl(
+        self, balance: BalanceWithProduct
+    ) -> HealthMetrics:
+        """
+        Calculate perp balance health WITHOUT the impact of unsettled PnL.
+
+        Shows "margin used" by the position, excluding PnL.
+        Formula: -1 * abs(notional_value) * (1 - long_weight)
+        """
+        initial_leverage_adjustment = Decimal(1) - balance.long_weight_initial
+        maint_leverage_adjustment = Decimal(1) - balance.long_weight_maintenance
+
+        base_margin_value = abs(balance.amount) * balance.oracle_price
+
+        return HealthMetrics(
+            initial=base_margin_value * initial_leverage_adjustment * Decimal(-1),
+            maintenance=base_margin_value * maint_leverage_adjustment * Decimal(-1),
+        )
+
+    def calculate_cross_position_margin_without_pnl(
+        self, balance: BalanceWithProduct
+    ) -> Decimal:
+        """
+        Calculate margin used for a cross position excluding unsettled PnL impact.
+
+        Used in margin manager "Margin Used" column.
+        Formula: max(0, -(initial_health - perp_value))
+        """
+        health_with_pnl = self.calculate_spot_balance_health(balance).initial
+        perp_value = self.calculate_perp_balance_value(balance)
+
+        without_unsettled_pnl = health_with_pnl - perp_value
+        return max(Decimal(0), -without_unsettled_pnl)
+
+    def calculate_isolated_position_net_margin(
+        self, base_balance: BalanceWithProduct, quote_balance: BalanceWithProduct
+    ) -> Decimal:
+        """
+        Calculate net margin in an isolated position.
+
+        Formula: quote_amount + (base_amount * oracle_price + v_quote_balance)
+        """
+        total_margin = quote_balance.amount
+        unsettled_quote = self.calculate_perp_balance_value(base_balance)
+        return total_margin + unsettled_quote
+
+    def calculate_isolated_position_leverage(
+        self, base_balance: BalanceWithProduct, net_margin: Decimal
+    ) -> Decimal:
+        """
+        Calculate leverage for an isolated position.
+
+        Formula: notional_value / net_margin
+        """
+        if net_margin == 0:
+            return Decimal(0)
+
+        notional_value = self.calculate_perp_balance_notional_value(base_balance)
+        return notional_value / net_margin
+
+    def calculate_margin_usage_fractions(
+        self, initial_health: Decimal, maint_health: Decimal, unweighted_health: Decimal
+    ) -> MarginUsageFractions:
+        """
+        Calculate margin usage fractions bounded to [0, 1].
+
+        Formula: (unweighted_health - health) / unweighted_health
+        Returns 0 if no borrows/perps or unweighted_health is 0.
+        """
+        if unweighted_health == 0:
+            return MarginUsageFractions(initial=Decimal(0), maintenance=Decimal(0))
+
+        if not self._has_borrows_or_perps():
+            return MarginUsageFractions(initial=Decimal(0), maintenance=Decimal(0))
+
+        initial_usage = (unweighted_health - initial_health) / unweighted_health
+        maint_usage = (unweighted_health - maint_health) / unweighted_health
+
+        # If health is negative, max out margin usage
+        return MarginUsageFractions(
+            initial=(
+                Decimal(1) if initial_health < 0 else min(initial_usage, Decimal(1))
+            ),
+            maintenance=(
+                Decimal(1) if maint_health < 0 else min(maint_usage, Decimal(1))
+            ),
+        )
+
+    def calculate_account_leverage(
+        self, balances: list[BalanceWithProduct], unweighted_health: Decimal
+    ) -> Decimal:
+        """
+        Calculate overall account leverage.
+
+        Formula: sum(abs(unweighted health for non-quote balances)) / unweighted_health
+        """
+        if unweighted_health == 0:
+            return Decimal(0)
+
+        if not self._has_borrows_or_perps():
+            return Decimal(0)
+
+        numerator = Decimal(0)
+        for balance in balances:
+            if balance.product_id == self.QUOTE_PRODUCT_ID:
+                continue
+
+            if self._is_zero_health(balance):
+                continue
+
+            if balance.balance_type == "spot":
+                value = abs(balance.amount * balance.oracle_price)
+            else:
+                value = self.calculate_perp_balance_notional_value(balance)
+
+            numerator += value
+
+        return numerator / unweighted_health
+
+    def calculate_cross_position_metrics(
+        self, balance: BalanceWithProduct
+    ) -> CrossPositionMetrics:
+        """Calculate all metrics for a cross margin position."""
+        notional = self.calculate_perp_balance_notional_value(balance)
+        health_metrics = self.calculate_spot_balance_health(balance)
+        margin_used = abs(
+            self.calculate_perp_balance_health_without_pnl(balance).initial
+        )
+
+        # Unsettled = full perp balance value (amount × oracle_price + v_quote_balance)
+        # This represents the unrealized PnL
+        unsettled = self.calculate_perp_balance_value(balance)
+
+        # Calculate Est. PnL if indexer data is available
+        # Formula: (amount × oracle_price) - netEntryUnrealized
+        # where netEntryUnrealized excludes funding, fees, slippage
+        est_pnl = self._calculate_est_pnl(balance)
+
+        return CrossPositionMetrics(
+            product_id=balance.product_id,
+            symbol=f"Product_{balance.product_id}",
+            position_size=balance.amount,
+            notional_value=notional,
+            est_pnl=est_pnl,
+            unsettled=unsettled,
+            margin_used=margin_used,
+            initial_health=health_metrics.initial,
+            maintenance_health=health_metrics.maintenance,
+            long_weight_initial=balance.long_weight_initial,
+            long_weight_maintenance=balance.long_weight_maintenance,
+            short_weight_initial=balance.short_weight_initial,
+            short_weight_maintenance=balance.short_weight_maintenance,
+        )
+
+    def _calculate_est_pnl(self, balance: BalanceWithProduct) -> Optional[Decimal]:
+        """
+        Calculate estimated PnL if indexer snapshot is available.
+
+        Formula: (position_amount × oracle_price) - netEntryUnrealized
+
+        Returns None if indexer data is not available.
+        """
+        if not self.indexer_events or balance.product_id == self.QUOTE_PRODUCT_ID:
+            return None
+
+        for event in self.indexer_events:
+            if event.product_id != balance.product_id:
+                continue
+            if event.isolated:
+                continue
+
+            try:
+                net_entry_int = int(event.net_entry_unrealized)
+            except (TypeError, ValueError):
+                continue
+
+            net_entry_unrealized = Decimal(net_entry_int) / Decimal(10**18)
+
+            current_value = balance.amount * balance.oracle_price
+            return current_value - net_entry_unrealized
+
+        return None
+
+    def calculate_isolated_position_metrics(
+        self, iso_pos: IsolatedPosition
+    ) -> IsolatedPositionMetrics:
+        """Calculate all metrics for an isolated position."""
+        base_balance = self._create_balance_from_isolated(iso_pos, is_base=True)
+        quote_balance = self._create_balance_from_isolated(iso_pos, is_base=False)
+
+        net_margin = self.calculate_isolated_position_net_margin(
+            base_balance, quote_balance
+        )
+        leverage = self.calculate_isolated_position_leverage(base_balance, net_margin)
+        notional = self.calculate_perp_balance_notional_value(base_balance)
+
+        initial_health = (
+            self._parse_health(iso_pos.healths[0]) if iso_pos.healths else Decimal(0)
+        )
+        maint_health = (
+            self._parse_health(iso_pos.healths[1])
+            if len(iso_pos.healths) > 1
+            else Decimal(0)
+        )
+
+        return IsolatedPositionMetrics(
+            product_id=base_balance.product_id,
+            symbol=f"Product_{base_balance.product_id}",
+            position_size=base_balance.amount,
+            notional_value=notional,
+            net_margin=net_margin,
+            leverage=leverage,
+            initial_health=initial_health,
+            maintenance_health=maint_health,
+        )
+
+    # Helper methods
+
+    def _get_health_weights(self, balance: BalanceWithProduct) -> HealthMetrics:
+        """Get appropriate weights based on position direction."""
+        if balance.amount >= 0:
+            return HealthMetrics(
+                initial=balance.long_weight_initial,
+                maintenance=balance.long_weight_maintenance,
+            )
+        else:
+            return HealthMetrics(
+                initial=balance.short_weight_initial,
+                maintenance=balance.short_weight_maintenance,
+            )
+
+    def _has_borrows_or_perps(self) -> bool:
+        """Check if account has any borrows or perp positions."""
+        for spot_bal in self.subaccount_info.spot_balances:
+            amount = _from_x18_decimal(spot_bal.balance.amount)
+            if amount < 0:
+                return True
+
+        for perp_bal in self.subaccount_info.perp_balances:
+            amount = _from_x18_decimal(perp_bal.balance.amount)
+            if amount != 0:
+                return True
+
+        return False
+
+    def _is_zero_health(self, balance: BalanceWithProduct) -> bool:
+        """Check if product has zero health (long_weight=0, short_weight=2)."""
+        return balance.long_weight_initial == 0 and balance.short_weight_initial == 2
+
+    def _parse_health(self, health: SubaccountHealth) -> Decimal:
+        """Parse health from SubaccountHealth model."""
+        return _from_x18_decimal(health.health)
+
+    def _create_spot_balances(self) -> list[BalanceWithProduct]:
+        """Create BalanceWithProduct objects for all spot balances."""
+        balances: list[BalanceWithProduct] = []
+        for spot_bal, spot_prod in zip(
+            self.subaccount_info.spot_balances, self.subaccount_info.spot_products
+        ):
+            balance = self._create_balance_with_product(spot_bal, spot_prod, "spot")
+            balances.append(balance)
+        return balances
+
+    def _create_perp_balances(self) -> list[BalanceWithProduct]:
+        """Create BalanceWithProduct objects for all perp balances."""
+        balances: list[BalanceWithProduct] = []
+        for perp_bal, perp_prod in zip(
+            self.subaccount_info.perp_balances, self.subaccount_info.perp_products
+        ):
+            balance = self._create_balance_with_product(perp_bal, perp_prod, "perp")
+            balances.append(balance)
+        return balances
+
+    def _create_balance_with_product(
+        self,
+        balance: Union[SpotProductBalance, PerpProductBalance],
+        product: Union[SpotProduct, PerpProduct],
+        balance_type: str,
+    ) -> BalanceWithProduct:
+        """Create a BalanceWithProduct from raw balance and product data."""
+        amount = _from_x18_decimal(balance.balance.amount)
+        oracle_price = _from_x18_decimal(product.oracle_price_x18)
+
+        v_quote = None
+        if balance_type == "perp":
+            assert isinstance(
+                balance, PerpProductBalance
+            ), "Perp balances must be PerpProductBalance"
+            v_quote = _from_x18_decimal(balance.balance.v_quote_balance)
+
+        return BalanceWithProduct(
+            product_id=balance.product_id,
+            amount=amount,
+            oracle_price=oracle_price,
+            long_weight_initial=_from_x18_decimal(product.risk.long_weight_initial_x18),
+            long_weight_maintenance=_from_x18_decimal(
+                product.risk.long_weight_maintenance_x18
+            ),
+            short_weight_initial=_from_x18_decimal(
+                product.risk.short_weight_initial_x18
+            ),
+            short_weight_maintenance=_from_x18_decimal(
+                product.risk.short_weight_maintenance_x18
+            ),
+            balance_type=balance_type,
+            v_quote_balance=v_quote,
+        )
+
+    def _create_balance_from_isolated(
+        self, iso_pos: IsolatedPosition, is_base: bool
+    ) -> BalanceWithProduct:
+        """Create BalanceWithProduct from isolated position data."""
+        if is_base:
+            perp_balance: PerpProductBalance = iso_pos.base_balance
+            perp_product: PerpProduct = iso_pos.base_product
+            return self._create_balance_with_product(perp_balance, perp_product, "perp")
+
+        spot_balance: SpotProductBalance = iso_pos.quote_balance
+        spot_product: SpotProduct = iso_pos.quote_product
+        return self._create_balance_with_product(spot_balance, spot_product, "spot")
+
+
+def print_account_summary(summary: AccountSummary) -> None:
+    """Print formatted account summary matching UI layout."""
+    print("\n" + "=" * 80)
+    print("MARGIN MANAGER")
+    print("=" * 80)
+
+    # Overview
+    initial_margin_used = summary.unweighted_health - summary.initial_health
+    print("\n━━━ Overview ━━━")
+    print(f"Total Equity:              ${summary.portfolio_value:,.2f}")
+    print(f"Initial Margin Used:       ${initial_margin_used:,.2f}")
+    print(f"Initial Margin Available:  ${summary.funds_available:,.2f}")
+    print(f"Leverage:                  {summary.account_leverage:.2f}x")
+
+    # 1. Unified Margin Section
+    print("\n━━━ UNIFIED MARGIN ━━━")
+    print(f"Margin Usage:              {summary.margin_usage_fraction * 100:.2f}%")
+    print(
+        f"Maint. Margin Usage:       {summary.maint_margin_usage_fraction * 100:.2f}%"
+    )
+    print(f"Available Margin:          ${summary.funds_available:,.2f}")
+    print(f"Funds Until Liquidation:   ${summary.funds_until_liquidation:,.2f}")
+
+    # USDT0 Balance
+    total_unsettled = sum(pos.unsettled for pos in summary.cross_positions)
+    cash_balance = summary.total_spot_deposits - summary.total_spot_borrows
+    net_balance = cash_balance + total_unsettled
+
+    print("\n┌─ USDT0 Balance")
+    print(f"│  Cash Balance:           ${cash_balance:,.2f}")
+    print(f"│  Unsettled PnL:          ${total_unsettled:,.2f}")
+    print(f"│  Net Balance:            ${net_balance:,.2f}")
+    print(f"│  Init. Weight / Margin:  1.00 / ${net_balance:,.2f}")
+    print(f"│  Maint. Weight / Margin: 1.00 / ${net_balance:,.2f}")
+
+    # 2. Spot Balances
+    print("\n┌─ Balances")
+    spot_shown = False
+    for spot_pos in summary.spot_positions:
+        if spot_pos.amount == 0:
+            continue
+        spot_shown = True
+        balance_type = "Deposit" if spot_pos.amount > 0 else "Borrow"
+        value = abs(spot_pos.amount * spot_pos.oracle_price)
+
+        # Use appropriate weight based on position direction
+        if spot_pos.amount > 0:  # Deposit (asset)
+            init_weight = spot_pos.long_weight_initial
+            maint_weight = spot_pos.long_weight_maintenance
+        else:  # Borrow (liability)
+            init_weight = spot_pos.short_weight_initial
+            maint_weight = spot_pos.short_weight_maintenance
+
+        init_margin = value * init_weight
+        maint_margin = value * maint_weight
+
+        print(f"│  Product_{spot_pos.product_id} ({balance_type})")
+        print(f"│    Balance:                {abs(spot_pos.amount):,.4f}")
+        print(f"│    Value:                  ${value:,.2f}")
+        print(f"│    Init. Weight / Margin:  {init_weight:.2f} / ${init_margin:,.2f}")
+        print(f"│    Maint. Weight / Margin: {maint_weight:.2f} / ${maint_margin:,.2f}")
+
+    if not spot_shown:
+        print("│  No spot balances")
+
+    # 3. Perps
+    print("\n┌─ Perps")
+    if summary.cross_positions:
+        for cross_pos in summary.cross_positions:
+            position_type = "Long" if cross_pos.position_size > 0 else "Short"
+            print(f"│  {cross_pos.symbol} ({position_type} / Cross)")
+            print(f"│    Position:             {cross_pos.position_size:,.3f}")
+            print(f"│    Notional:             ${cross_pos.notional_value:,.2f}")
+
+            if cross_pos.est_pnl is not None:
+                pnl_sign = "+" if cross_pos.est_pnl >= 0 else ""
+                print(f"│    Est. PnL:             {pnl_sign}${cross_pos.est_pnl:,.2f}")
+            else:
+                print(f"│    Est. PnL:             N/A")
+
+            print(f"│    Unsettled:            {cross_pos.unsettled:,.2f} USDT0")
+
+            # Use correct weight based on position direction
+            if cross_pos.position_size > 0:  # Long
+                init_weight = cross_pos.long_weight_initial
+                maint_weight = cross_pos.long_weight_maintenance
+            else:  # Short
+                init_weight = cross_pos.short_weight_initial
+                maint_weight = cross_pos.short_weight_maintenance
+
+            # Margin = notional × |1 - weight|
+            # For longs: weight < 1, so (1 - weight) > 0
+            # For shorts: weight > 1, so (1 - weight) < 0, we need abs
+            init_margin = cross_pos.notional_value * abs(1 - init_weight)
+            maint_margin = cross_pos.notional_value * abs(1 - maint_weight)
+
+            print(
+                f"│    Init. Weight / Margin:  {init_weight:.2f} / ${init_margin:,.2f}"
+            )
+            print(
+                f"│    Maint. Weight / Margin: {maint_weight:.2f} / ${maint_margin:,.2f}"
+            )
+    else:
+        print("│  No perp positions")
+
+    # Spreads
+    print("\n┌─ Spreads")
+    print("│  No spreads")
+
+    # 4. Isolated Positions
+    print("\n━━━ ISOLATED POSITIONS ━━━")
+    total_isolated_margin = sum(pos.net_margin for pos in summary.isolated_positions)
+    print(f"Total Margin in Isolated Positions: ${total_isolated_margin:,.2f}")
+
+    if summary.isolated_positions:
+        print("\n┌─ Perps")
+        for iso_pos in summary.isolated_positions:
+            position_type = "Long" if iso_pos.position_size > 0 else "Short"
+            print(f"│  {iso_pos.symbol} ({position_type} / Isolated)")
+            print(f"│    Position:             {iso_pos.position_size:,.3f}")
+            print(f"│    Notional:             ${iso_pos.notional_value:,.2f}")
+            print(f"│    Margin:               ${iso_pos.net_margin:,.2f}")
+            print(f"│    Leverage:             {iso_pos.leverage:.2f}x")
+            print(f"│    Init. Health:         ${iso_pos.initial_health:,.2f}")
+            print(f"│    Maint. Health:        ${iso_pos.maintenance_health:,.2f}")
+    else:
+        print("\n┌─ Perps")
+        print("│  No isolated positions")
+
+    print("\n" + "=" * 80)

{nado_protocol-0.1.7.dist-info → nado_protocol-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nado-protocol
-Version: 0.1.7
+Version: 0.2.2
 Summary: Nado Protocol SDK
 Keywords: nado protocol,nado sdk,nado protocol api
 Author: Jeury Mejia

{nado_protocol-0.1.7.dist-info → nado_protocol-0.2.2.dist-info}/RECORD

@@ -47,10 +47,10 @@ nado_protocol/engine_client/types/models.py,sha256=hf9HD8rct2XZIqPznfydBq7jqKiJ3
 nado_protocol/engine_client/types/query.py,sha256=N6kPuWSUowMeZnUKpxF9NnMKZBKKe-0Q_B9ccFZkjQA,12185
 nado_protocol/engine_client/types/stream.py,sha256=F_AKqU4pClzUcM6D9Dc79f6RmraahJzj2-hQSXtQ0vQ,159
 nado_protocol/indexer_client/__init__.py,sha256=ea2exePtguCxJsBlisOQPtnFk8hRmFugeQAuSAaPhoc,922
-nado_protocol/indexer_client/query.py,sha256=onhEAoKtBIB_fPJcNLKJg8PnEiQ5qLtTGDwHRryLXhE,16124
+nado_protocol/indexer_client/query.py,sha256=Tm4IYmU0T_9ayFTce8SMRPi_NN8QgyHDr4rFC3h7hSw,17102
 nado_protocol/indexer_client/types/__init__.py,sha256=r3-jxMjrFNbA1nMRSGZjsE3qypmyWab6k20_gasdwL4,3548
-nado_protocol/indexer_client/types/models.py,sha256=sh65JwaOeV8r2lENaVHopnoyP3-9VeqUa0qF4k84Tes,7527
-nado_protocol/indexer_client/types/query.py,sha256=WX7CzVzh239wbv4tQdPBKVal5wH6JPOEN0Bd_DPvzdI,18939
+nado_protocol/indexer_client/types/models.py,sha256=vD1YHHeK15hcU5_O4al7001Fi-gTl6EARMuR-Y8stOc,7533
+nado_protocol/indexer_client/types/query.py,sha256=JlI2TXjezTSgvaP8zzb3bO9GADzeQkay1CScO954RAw,19857
 nado_protocol/trigger_client/__init__.py,sha256=kD_WJWGOCDwX7GvGF5VGZibWR2uPYRcWpIWht31PYR4,545
 nado_protocol/trigger_client/execute.py,sha256=VkVla3SF6MX-ZJC_wZG72em41MPAKX-jv1_Lh4ydezU,15089
 nado_protocol/trigger_client/query.py,sha256=7M7opYEddNo0Wf9VQ7rha-WaoFQVv5F5OI-YLSRWrpk,2705
@@ -59,13 +59,15 @@ nado_protocol/trigger_client/types/execute.py,sha256=Ij_gCl3ZzhouWF7JxEY_U6hUbe9
 nado_protocol/trigger_client/types/models.py,sha256=ZVDF3MFWoR39JBaTmSOTl1WnRnw46hjX-WN_a-g6zKk,1638
 nado_protocol/trigger_client/types/query.py,sha256=O6qhFLL2IREHc_mf-jFMyuVSzH1RuwjM-8noolLmEaQ,5288
 nado_protocol/utils/__init__.py,sha256=heFEgVHHce8nAqQcmEMR69aZ8aaJAYXukJ2-W_KTFwY,1446
-nado_protocol/utils/backend.py,sha256=UqmHN_jmTAOnRiUQcUTZUyTGeM7FwjauwSH5h8UxiLQ,3781
+nado_protocol/utils/backend.py,sha256=aYSmXuY8fO2Xmsem1UaVkjwSBm_--IkP2nLaRFFggAk,3757
+nado_protocol/utils/balance.py,sha256=Pf6tdcxZSn2Ou8M3XJnBIhsMB85-E7VkZDUIaMuEIbg,7435
 nado_protocol/utils/bytes32.py,sha256=FHeHs9Sf-S7GdFTF6ikuz_sEkM-fpRW-g3kbZawlMd4,5299
 nado_protocol/utils/enum.py,sha256=_Ij7Ai1H_Bj0OPBjmLhGvQjATXYyqD0DLqpUC-br99s,99
 nado_protocol/utils/exceptions.py,sha256=j5U-7JEQRnMTe_nFOrF2x-9kaYKgTrPBG9XkwXVm0cI,1644
 nado_protocol/utils/execute.py,sha256=zK3j2oTzFQlm-075thB_53iePjXpBnKF02RMEAqzl8I,11794
 nado_protocol/utils/expiration.py,sha256=8g0KI8v-Vnoj8rr-8ik3RxmGp9fXdiVbCVGof_2CDm4,532
 nado_protocol/utils/interest.py,sha256=pl5N2s7sux9Z0orPthdmFkldljIPwFTpLx1XC9k1oQk,2498
+nado_protocol/utils/margin_manager.py,sha256=N5jFrcOZLLARWKi4JHwarKcxBqWsw-uPjMeOVdl20bo,31792
 nado_protocol/utils/math.py,sha256=TyuMb9ZpwfjLh5fMrNnr_QQWSl3bVZnjODglcxT_XTI,1771
 nado_protocol/utils/model.py,sha256=feU7cp0mSgNp-Z0dmC6VSFA6Mkjv3rNfoXdqsoZ7uGU,2087
 nado_protocol/utils/nonce.py,sha256=DHNn5mzXdJRope8QLcDCMFe7Bk4PXLoR9VaFopfse7I,886
@@ -73,7 +75,7 @@ nado_protocol/utils/order.py,sha256=Q9TlcotvnB395dPhaKpn0EeN1WNTkpYBTUovlirr1_Y,
 nado_protocol/utils/subaccount.py,sha256=WJ7lgU2RekuzJAZH-hhCTbIBlRsl2oHozBm7OEMRV74,495
 nado_protocol/utils/time.py,sha256=tEwmrkc5VdzKLlgkJIAq2ce-nhrduJZNtVPydrrnTHs,360
 nado_protocol/utils/twap.py,sha256=hfBVK0CBa8m4uBArxTnNRoJr3o1rJucyopR_8_9gkOo,6197
-nado_protocol-0.1.7.dist-info/METADATA,sha256=AFlOXkYb9J5SwHQbJp0ZClgJr77ccxgvY4I1M7YaeHI,9558
-nado_protocol-0.1.7.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-nado_protocol-0.1.7.dist-info/entry_points.txt,sha256=7xMbwQYtf2zfvzWdBaw5d5hp5TTv5Xia5WPsqxkvKuU,300
-nado_protocol-0.1.7.dist-info/RECORD,,
+nado_protocol-0.2.2.dist-info/METADATA,sha256=1AfhycOzMdvGX7EfySXt4szIMP1dbl5R80mSNKXy-hI,9558
+nado_protocol-0.2.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+nado_protocol-0.2.2.dist-info/entry_points.txt,sha256=Df0O9lFc-m0SyOh6_d9FHeG1OT-esxGm-p_z7rTT9h0,340
+nado_protocol-0.2.2.dist-info/RECORD,,

{nado_protocol-0.1.7.dist-info → nado_protocol-0.2.2.dist-info}/entry_points.txt

@@ -3,6 +3,7 @@ client-sanity=sanity.nado_client:run
 contracts-sanity=sanity.contracts:run
 engine-sanity=sanity.engine_client:run
 indexer-sanity=sanity.indexer_client:run
+margin-sanity=sanity.margin_manager:run
 rewards-sanity=sanity.rewards:run
 signing-sanity=sanity.signing:run
 test=pytest:main