compass_api_sdk 2.2.95__tar.gz → 2.2.96__tar.gz

{compass_api_sdk-2.2.95 → compass_api_sdk-2.2.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compass_api_sdk
-Version: 2.2.95
+Version: 2.2.96
 Summary: Compass API SDK.
 Author: royalnine
 Requires-Python: >=3.10
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: httpcore (>=1.0.9)
 Requires-Dist: httpx (>=0.28.1)
-Requires-Dist: pydantic (>=2.11.2,<2.13)
+Requires-Dist: pydantic (>=2.11.2)
 Project-URL: Repository, https://github.com/CompassLabs/mono.git
 Description-Content-Type: text/markdown
 

{compass_api_sdk-2.2.95 → compass_api_sdk-2.2.96}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "compass_api_sdk"
-version = "2.2.95"
+version = "2.2.96"
 description = "Compass API SDK."
 authors = [{ name = "royalnine" },]
 readme = "README-PYPI.md"
@@ -9,12 +9,12 @@ requires-python = ">=3.10"
 dependencies = [
     "httpcore >=1.0.9",
     "httpx >=0.28.1",
-    "pydantic >=2.11.2,<2.13",
+    "pydantic >=2.11.2",
 ]
 
 [tool.poetry]
 name = "compass_api_sdk"
-version = "2.2.95"
+version = "2.2.96"
 description = "Compass API SDK."
 authors = ["Compass Labs"]
 repository = "https://github.com/CompassLabs/mono.git"

{compass_api_sdk-2.2.95 → compass_api_sdk-2.2.96}/src/compass_api_sdk/_version.py

@@ -5,8 +5,8 @@ import importlib.metadata
 __title__: str = "compass_api_sdk"
 __version__: str = "2.0.0"
 __openapi_doc_version__: str = "0.0.1"
-__gen_version__: str = "2.924.0"
-__user_agent__: str = "speakeasy-sdk/python 2.0.0 2.924.0 0.0.1 compass_api_sdk"
+__gen_version__: str = "2.926.2"
+__user_agent__: str = "speakeasy-sdk/python 2.0.0 2.926.2 0.0.1 compass_api_sdk"
 
 try:
     if __package__ is not None:

{compass_api_sdk-2.2.95 → compass_api_sdk-2.2.96}/src/compass_api_sdk/models/chainmarketinfo.py

@@ -2,7 +2,13 @@
 
 from __future__ import annotations
 from .reserveinfo import ReserveInfo, ReserveInfoTypedDict
-from compass_api_sdk.types import BaseModel, UNSET_SENTINEL
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
 from pydantic import model_serializer
 from typing import List, Optional
 from typing_extensions import NotRequired, TypedDict
@@ -22,7 +28,7 @@ class ChainMarketInfoTypedDict(TypedDict):
     a_token_address: str
     r"""Aave aToken contract address on this chain. This is the interest-bearing token that represents the supply position."""
     supply_apy: str
-    r"""Variable rate APY for deposits, in percentage (e.g., 4.5 means 4.5%)."""
+    r"""Variable rate APY for deposits, in percentage (e.g., 4.5 means 4.5%). This is LENDING interest only — what borrowers pay. For a staked or wrapped asset it is not the whole yield; add `intrinsic_apy`."""
     borrow_apy: str
     r"""Variable rate APY for loans, in percentage (e.g., 6.2 means 6.2%)."""
     supply_apy_avg: str
@@ -39,6 +45,8 @@ class ChainMarketInfoTypedDict(TypedDict):
     r"""Maximum loan-to-value when this reserve is used as collateral, in percentage (e.g., 80.0 means 80%). This is the highest LTV you can borrow at against this asset; 0 means it cannot be used as collateral."""
     liquidation_threshold: str
     r"""Liquidation threshold when this reserve is used as collateral, in percentage (e.g., 82.5 means 82.5%). A position whose LTV crosses this can be liquidated; 0 means the asset cannot be used as collateral."""
+    intrinsic_apy: NotRequired[Nullable[str]]
+    r"""What holding this asset earns OUTSIDE the lending pool, in percentage: staking rewards or vault yield accruing inside the token's own exchange rate, which the pool neither pays nor observes. A trailing 7-day measurement. ABSENT when no measurement is available (the route omits null fields) — absent does not mean zero. For an asset that plainly earns beyond lending (wstETH, sUSDe, wstHYPE) `supply_apy` alone understates what it earns by percentage points, since almost nobody borrows these and their supply rate rounds to nothing: Hyperlend's wstHYPE reserve pays 0.00006% against a ~2.5% staking yield. Treat an absent value as unknown rather than as the asset earning nothing beyond `supply_apy`."""
     reserves: NotRequired[List[ReserveInfoTypedDict]]
     r"""Every Aave reserve for this token on this chain, ordered by liquidity (highest first). Identified by underlying `address`. For most tokens this has a single entry equal to the canonical reserve above; where a chain has multiple reserves for one symbol (e.g. Arbitrum native USDC and bridged USDC.e), all are listed with their individual rates."""
 
@@ -59,7 +67,7 @@ class ChainMarketInfo(BaseModel):
     r"""Aave aToken contract address on this chain. This is the interest-bearing token that represents the supply position."""
 
     supply_apy: str
-    r"""Variable rate APY for deposits, in percentage (e.g., 4.5 means 4.5%)."""
+    r"""Variable rate APY for deposits, in percentage (e.g., 4.5 means 4.5%). This is LENDING interest only — what borrowers pay. For a staked or wrapped asset it is not the whole yield; add `intrinsic_apy`."""
 
     borrow_apy: str
     r"""Variable rate APY for loans, in percentage (e.g., 6.2 means 6.2%)."""
@@ -85,21 +93,33 @@ class ChainMarketInfo(BaseModel):
     liquidation_threshold: str
     r"""Liquidation threshold when this reserve is used as collateral, in percentage (e.g., 82.5 means 82.5%). A position whose LTV crosses this can be liquidated; 0 means the asset cannot be used as collateral."""
 
+    intrinsic_apy: OptionalNullable[str] = UNSET
+    r"""What holding this asset earns OUTSIDE the lending pool, in percentage: staking rewards or vault yield accruing inside the token's own exchange rate, which the pool neither pays nor observes. A trailing 7-day measurement. ABSENT when no measurement is available (the route omits null fields) — absent does not mean zero. For an asset that plainly earns beyond lending (wstETH, sUSDe, wstHYPE) `supply_apy` alone understates what it earns by percentage points, since almost nobody borrows these and their supply rate rounds to nothing: Hyperlend's wstHYPE reserve pays 0.00006% against a ~2.5% staking yield. Treat an absent value as unknown rather than as the asset earning nothing beyond `supply_apy`."""
+
     reserves: Optional[List[ReserveInfo]] = None
     r"""Every Aave reserve for this token on this chain, ordered by liquidity (highest first). Identified by underlying `address`. For most tokens this has a single entry equal to the canonical reserve above; where a chain has multiple reserves for one symbol (e.g. Arbitrum native USDC and bridged USDC.e), all are listed with their individual rates."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = set(["reserves"])
+        optional_fields = set(["intrinsic_apy", "reserves"])
+        nullable_fields = set(["intrinsic_apy"])
         serialized = handler(self)
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k, serialized.get(n))
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
 
             if val != UNSET_SENTINEL:
-                if val is not None or k not in optional_fields:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
                     m[k] = val
 
         return m

compass_api_sdk-2.2.96/src/compass_api_sdk/models/loopedpositioncurrentstate.py

@@ -0,0 +1,171 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from enum import Enum
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
+
+
+class LoopedPositionCurrentStateHealthFactorScope(str, Enum):
+    r"""'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account — see aave_account_summary for the account-level figures."""
+
+    MARKET = "market"
+    ACCOUNT = "account"
+
+
+class LoopedPositionCurrentStateTypedDict(TypedDict):
+    r"""Live on-chain state of an OPEN looped position."""
+
+    collateral_amount: Nullable[str]
+    r"""Current on-chain collateral amount for this position. When multiple open Aave positions share one collateral reserve (Aave holds a single pooled aToken balance per reserve), that pooled balance is attributed across them pro-rata by each position's event-ledger contribution — bookkeeping, not protocol truth; liquidation sees the pooled account, not this per-position split."""
+    debt_amount: Nullable[str]
+    r"""Current on-chain debt amount for this position."""
+    health_factor_scope: LoopedPositionCurrentStateHealthFactorScope
+    r"""'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account — see aave_account_summary for the account-level figures."""
+    collateral_usd: NotRequired[Nullable[str]]
+    r"""Collateral value in USD (null if unpriced). Derived from the attributed collateral_amount for shared-reserve Aave positions."""
+    debt_usd: NotRequired[Nullable[str]]
+    r"""Debt value in USD (null if unpriced)."""
+    net_usd_value: NotRequired[Nullable[str]]
+    r"""Net position value in USD (collateral - debt); null if unpriced. For shared-reserve Aave positions the collateral side uses the pro-rata attributed balance (bookkeeping, not protocol truth)."""
+    leverage: NotRequired[Nullable[str]]
+    r"""Leverage multiplier: collateral_usd / (collateral_usd - debt_usd). Null when unpriced or net value is non-positive. For shared-reserve Aave positions this is derived from the pro-rata attributed collateral (bookkeeping, not protocol truth)."""
+    health_factor: NotRequired[Nullable[str]]
+    r"""Health factor. Above 1 is safe; below 1 risks liquidation. See health_factor_scope for what it covers."""
+    collateral_apy: NotRequired[Nullable[str]]
+    r"""What the collateral leg currently earns, in percentage (e.g. 6.12 = 6.12%) — the sum of collateral_lending_apy and collateral_intrinsic_apy where both apply. Null when the token earns a yield outside the lending pool (a staked or wrapped asset) and no source for that yield is available: the pool's supply APY alone would understate the leg by percentage points and can invert the sign of net_apy, so it is withheld rather than reported as the whole yield."""
+    collateral_lending_apy: NotRequired[Nullable[str]]
+    r"""The supply half of the collateral leg, in percentage: interest paid by borrowers of the collateral asset (Aave supply APY). Near zero for staked assets, which almost nobody borrows. Exactly 0 on Morpho, whose collateral is held rather than lent — which is why a Morpho position's whole collateral leg is its vault yield."""
+    collateral_intrinsic_apy: NotRequired[Nullable[str]]
+    r"""The yield the collateral token earns inside its own price, in percentage, independent of the lending pool — a liquid-staking token's staking rewards (wstHYPE against HYPE) or an ERC-4626 share's vault yield — which of the two follows from the position's protocol. Null when the token has none or none is indexed.
+
+    A TRAILING 7-DAY measurement, not a forward rate: a week is a short sample of a staking rate, so consecutive readings move around the longer-run average by a few tenths of a percent.
+
+    A null here alongside a null collateral_apy and a NON-null collateral_lending_apy is the meaningful case: the token does earn outside the pool, but no source for that yield is available, so the total is withheld rather than understated.
+    """
+    borrow_apy: NotRequired[Nullable[str]]
+    r"""What the debt leg currently costs, in percentage — the sum of borrow_lending_apy and borrow_intrinsic_apy where both apply. Debt owed in a token that appreciates inside its own price (a staked or wrapped asset) grows by that appreciation on top of the pool's interest, so the pool rate alone would understate the cost and overstate net_apy; for such a token with no yield source available this is null (withheld) rather than the pool rate. For ordinary debt assets it equals the market's spot borrow APY. Null also when the rate read was unavailable."""
+    borrow_lending_apy: NotRequired[Nullable[str]]
+    r"""The pool half of the debt leg, in percentage: the market's spot borrow APY (Morpho IRM rate / Aave variable borrow rate) — interest charged on the debt by the lending market itself."""
+    borrow_intrinsic_apy: NotRequired[Nullable[str]]
+    r"""The yield the DEBT token earns inside its own price, in percentage — which the borrower owes on top of pool interest, since the debt is denominated in an appreciating token. Same source and trailing 7-day window as collateral_intrinsic_apy. Null when the token has none or none is indexed; null alongside a null borrow_apy and a NON-null borrow_lending_apy means the debt token does earn outside the pool but no source is available, so the total cost is withheld rather than understated."""
+    net_apy: NotRequired[Nullable[str]]
+    r"""Levered net yield on the position's equity, in percentage: leverage x collateral_apy - (leverage - 1) x borrow_apy. Negative means the carry is upside down (borrowing costs more than the collateral earns). Null when leverage or either leg is unknown. This is a SNAPSHOT at today's rates, not a forecast, and it mixes a trailing collateral measurement with a spot borrow rate. It is also denominated in the debt asset, not USD: a wstHYPE/WHYPE loop earning a positive net_apy still loses USD value if HYPE falls. The borrow leg floats with the debt reserve's utilisation, so this figure can move without the position changing at all."""
+
+
+class LoopedPositionCurrentState(BaseModel):
+    r"""Live on-chain state of an OPEN looped position."""
+
+    collateral_amount: Nullable[str]
+    r"""Current on-chain collateral amount for this position. When multiple open Aave positions share one collateral reserve (Aave holds a single pooled aToken balance per reserve), that pooled balance is attributed across them pro-rata by each position's event-ledger contribution — bookkeeping, not protocol truth; liquidation sees the pooled account, not this per-position split."""
+
+    debt_amount: Nullable[str]
+    r"""Current on-chain debt amount for this position."""
+
+    health_factor_scope: LoopedPositionCurrentStateHealthFactorScope
+    r"""'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account — see aave_account_summary for the account-level figures."""
+
+    collateral_usd: OptionalNullable[str] = UNSET
+    r"""Collateral value in USD (null if unpriced). Derived from the attributed collateral_amount for shared-reserve Aave positions."""
+
+    debt_usd: OptionalNullable[str] = UNSET
+    r"""Debt value in USD (null if unpriced)."""
+
+    net_usd_value: OptionalNullable[str] = UNSET
+    r"""Net position value in USD (collateral - debt); null if unpriced. For shared-reserve Aave positions the collateral side uses the pro-rata attributed balance (bookkeeping, not protocol truth)."""
+
+    leverage: OptionalNullable[str] = UNSET
+    r"""Leverage multiplier: collateral_usd / (collateral_usd - debt_usd). Null when unpriced or net value is non-positive. For shared-reserve Aave positions this is derived from the pro-rata attributed collateral (bookkeeping, not protocol truth)."""
+
+    health_factor: OptionalNullable[str] = UNSET
+    r"""Health factor. Above 1 is safe; below 1 risks liquidation. See health_factor_scope for what it covers."""
+
+    collateral_apy: OptionalNullable[str] = UNSET
+    r"""What the collateral leg currently earns, in percentage (e.g. 6.12 = 6.12%) — the sum of collateral_lending_apy and collateral_intrinsic_apy where both apply. Null when the token earns a yield outside the lending pool (a staked or wrapped asset) and no source for that yield is available: the pool's supply APY alone would understate the leg by percentage points and can invert the sign of net_apy, so it is withheld rather than reported as the whole yield."""
+
+    collateral_lending_apy: OptionalNullable[str] = UNSET
+    r"""The supply half of the collateral leg, in percentage: interest paid by borrowers of the collateral asset (Aave supply APY). Near zero for staked assets, which almost nobody borrows. Exactly 0 on Morpho, whose collateral is held rather than lent — which is why a Morpho position's whole collateral leg is its vault yield."""
+
+    collateral_intrinsic_apy: OptionalNullable[str] = UNSET
+    r"""The yield the collateral token earns inside its own price, in percentage, independent of the lending pool — a liquid-staking token's staking rewards (wstHYPE against HYPE) or an ERC-4626 share's vault yield — which of the two follows from the position's protocol. Null when the token has none or none is indexed.
+
+    A TRAILING 7-DAY measurement, not a forward rate: a week is a short sample of a staking rate, so consecutive readings move around the longer-run average by a few tenths of a percent.
+
+    A null here alongside a null collateral_apy and a NON-null collateral_lending_apy is the meaningful case: the token does earn outside the pool, but no source for that yield is available, so the total is withheld rather than understated.
+    """
+
+    borrow_apy: OptionalNullable[str] = UNSET
+    r"""What the debt leg currently costs, in percentage — the sum of borrow_lending_apy and borrow_intrinsic_apy where both apply. Debt owed in a token that appreciates inside its own price (a staked or wrapped asset) grows by that appreciation on top of the pool's interest, so the pool rate alone would understate the cost and overstate net_apy; for such a token with no yield source available this is null (withheld) rather than the pool rate. For ordinary debt assets it equals the market's spot borrow APY. Null also when the rate read was unavailable."""
+
+    borrow_lending_apy: OptionalNullable[str] = UNSET
+    r"""The pool half of the debt leg, in percentage: the market's spot borrow APY (Morpho IRM rate / Aave variable borrow rate) — interest charged on the debt by the lending market itself."""
+
+    borrow_intrinsic_apy: OptionalNullable[str] = UNSET
+    r"""The yield the DEBT token earns inside its own price, in percentage — which the borrower owes on top of pool interest, since the debt is denominated in an appreciating token. Same source and trailing 7-day window as collateral_intrinsic_apy. Null when the token has none or none is indexed; null alongside a null borrow_apy and a NON-null borrow_lending_apy means the debt token does earn outside the pool but no source is available, so the total cost is withheld rather than understated."""
+
+    net_apy: OptionalNullable[str] = UNSET
+    r"""Levered net yield on the position's equity, in percentage: leverage x collateral_apy - (leverage - 1) x borrow_apy. Negative means the carry is upside down (borrowing costs more than the collateral earns). Null when leverage or either leg is unknown. This is a SNAPSHOT at today's rates, not a forecast, and it mixes a trailing collateral measurement with a spot borrow rate. It is also denominated in the debt asset, not USD: a wstHYPE/WHYPE loop earning a positive net_apy still loses USD value if HYPE falls. The borrow leg floats with the debt reserve's utilisation, so this figure can move without the position changing at all."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "collateral_usd",
+                "debt_usd",
+                "net_usd_value",
+                "leverage",
+                "health_factor",
+                "collateral_apy",
+                "collateral_lending_apy",
+                "collateral_intrinsic_apy",
+                "borrow_apy",
+                "borrow_lending_apy",
+                "borrow_intrinsic_apy",
+                "net_apy",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "collateral_amount",
+                "debt_amount",
+                "collateral_usd",
+                "debt_usd",
+                "net_usd_value",
+                "leverage",
+                "health_factor",
+                "collateral_apy",
+                "collateral_lending_apy",
+                "collateral_intrinsic_apy",
+                "borrow_apy",
+                "borrow_lending_apy",
+                "borrow_intrinsic_apy",
+                "net_apy",
+            ]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m

{compass_api_sdk-2.2.95 → compass_api_sdk-2.2.96}/src/compass_api_sdk/models/morpholendingmarket.py

@@ -49,6 +49,10 @@ class MorphoLendingMarketTypedDict(TypedDict):
     r"""Current supply APY for lending the loan token, in percentage (e.g. 3.5 means 3.5%). Null if the rate is unavailable."""
     borrow_apy: NotRequired[Nullable[str]]
     r"""Current borrow APY for the loan token, in percentage (e.g. 5.25 means 5.25%). Null if the rate is unavailable."""
+    collateral_intrinsic_apy: NotRequired[Nullable[str]]
+    r"""What the COLLATERAL token earns inside its own price, in percentage: an ERC-4626 share's vault yield or a staking token's rewards, trailing 7 days. Morpho holds collateral without lending it out, so this is the collateral leg's ENTIRE yield. Null means unmeasured, NOT zero — a plain token (WETH, cbBTC) earns nothing and a yield-bearing one may simply not be indexed yet."""
+    loan_intrinsic_apy: NotRequired[Nullable[str]]
+    r"""What the LOAN token earns inside its own price, in percentage, trailing 7 days. Debt owed in such a token grows by this on top of borrow_apy — a borrower's true cost is their sum. Null means unmeasured, NOT zero."""
     tvl_usd: NotRequired[Nullable[str]]
     r"""Total value locked (total supplied assets) in USD, sourced from the indexer. Null if the indexer hasn't priced this market yet."""
     liquidity_usd: NotRequired[Nullable[str]]
@@ -109,6 +113,12 @@ class MorphoLendingMarket(BaseModel):
     borrow_apy: OptionalNullable[str] = UNSET
     r"""Current borrow APY for the loan token, in percentage (e.g. 5.25 means 5.25%). Null if the rate is unavailable."""
 
+    collateral_intrinsic_apy: OptionalNullable[str] = UNSET
+    r"""What the COLLATERAL token earns inside its own price, in percentage: an ERC-4626 share's vault yield or a staking token's rewards, trailing 7 days. Morpho holds collateral without lending it out, so this is the collateral leg's ENTIRE yield. Null means unmeasured, NOT zero — a plain token (WETH, cbBTC) earns nothing and a yield-bearing one may simply not be indexed yet."""
+
+    loan_intrinsic_apy: OptionalNullable[str] = UNSET
+    r"""What the LOAN token earns inside its own price, in percentage, trailing 7 days. Debt owed in such a token grows by this on top of borrow_apy — a borrower's true cost is their sum. Null means unmeasured, NOT zero."""
+
     tvl_usd: OptionalNullable[str] = UNSET
     r"""Total value locked (total supplied assets) in USD, sourced from the indexer. Null if the indexer hasn't priced this market yet."""
 
@@ -117,8 +127,26 @@ class MorphoLendingMarket(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = set(["supply_apy", "borrow_apy", "tvl_usd", "liquidity_usd"])
-        nullable_fields = set(["supply_apy", "borrow_apy", "tvl_usd", "liquidity_usd"])
+        optional_fields = set(
+            [
+                "supply_apy",
+                "borrow_apy",
+                "collateral_intrinsic_apy",
+                "loan_intrinsic_apy",
+                "tvl_usd",
+                "liquidity_usd",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "supply_apy",
+                "borrow_apy",
+                "collateral_intrinsic_apy",
+                "loan_intrinsic_apy",
+                "tvl_usd",
+                "liquidity_usd",
+            ]
+        )
         serialized = handler(self)
         m = {}
 

{compass_api_sdk-2.2.95 → compass_api_sdk-2.2.96}/src/compass_api_sdk/models/reserveinfo.py

@@ -1,8 +1,15 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from compass_api_sdk.types import BaseModel
-from typing_extensions import TypedDict
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
 
 
 class ReserveInfoTypedDict(TypedDict):
@@ -19,7 +26,7 @@ class ReserveInfoTypedDict(TypedDict):
     a_token_address: str
     r"""Aave aToken contract address on this chain. This is the interest-bearing token that represents the supply position."""
     supply_apy: str
-    r"""Variable rate APY for deposits, in percentage (e.g., 4.5 means 4.5%)."""
+    r"""Variable rate APY for deposits, in percentage (e.g., 4.5 means 4.5%). This is LENDING interest only — what borrowers pay. For a staked or wrapped asset it is not the whole yield; add `intrinsic_apy`."""
     borrow_apy: str
     r"""Variable rate APY for loans, in percentage (e.g., 6.2 means 6.2%)."""
     supply_apy_avg: str
@@ -36,6 +43,8 @@ class ReserveInfoTypedDict(TypedDict):
     r"""Maximum loan-to-value when this reserve is used as collateral, in percentage (e.g., 80.0 means 80%). This is the highest LTV you can borrow at against this asset; 0 means it cannot be used as collateral."""
     liquidation_threshold: str
     r"""Liquidation threshold when this reserve is used as collateral, in percentage (e.g., 82.5 means 82.5%). A position whose LTV crosses this can be liquidated; 0 means the asset cannot be used as collateral."""
+    intrinsic_apy: NotRequired[Nullable[str]]
+    r"""What holding this asset earns OUTSIDE the lending pool, in percentage: staking rewards or vault yield accruing inside the token's own exchange rate, which the pool neither pays nor observes. A trailing 7-day measurement. ABSENT when no measurement is available (the route omits null fields) — absent does not mean zero. For an asset that plainly earns beyond lending (wstETH, sUSDe, wstHYPE) `supply_apy` alone understates what it earns by percentage points, since almost nobody borrows these and their supply rate rounds to nothing: Hyperlend's wstHYPE reserve pays 0.00006% against a ~2.5% staking yield. Treat an absent value as unknown rather than as the asset earning nothing beyond `supply_apy`."""
 
 
 class ReserveInfo(BaseModel):
@@ -54,7 +63,7 @@ class ReserveInfo(BaseModel):
     r"""Aave aToken contract address on this chain. This is the interest-bearing token that represents the supply position."""
 
     supply_apy: str
-    r"""Variable rate APY for deposits, in percentage (e.g., 4.5 means 4.5%)."""
+    r"""Variable rate APY for deposits, in percentage (e.g., 4.5 means 4.5%). This is LENDING interest only — what borrowers pay. For a staked or wrapped asset it is not the whole yield; add `intrinsic_apy`."""
 
     borrow_apy: str
     r"""Variable rate APY for loans, in percentage (e.g., 6.2 means 6.2%)."""
@@ -79,3 +88,31 @@ class ReserveInfo(BaseModel):
 
     liquidation_threshold: str
     r"""Liquidation threshold when this reserve is used as collateral, in percentage (e.g., 82.5 means 82.5%). A position whose LTV crosses this can be liquidated; 0 means the asset cannot be used as collateral."""
+
+    intrinsic_apy: OptionalNullable[str] = UNSET
+    r"""What holding this asset earns OUTSIDE the lending pool, in percentage: staking rewards or vault yield accruing inside the token's own exchange rate, which the pool neither pays nor observes. A trailing 7-day measurement. ABSENT when no measurement is available (the route omits null fields) — absent does not mean zero. For an asset that plainly earns beyond lending (wstETH, sUSDe, wstHYPE) `supply_apy` alone understates what it earns by percentage points, since almost nobody borrows these and their supply rate rounds to nothing: Hyperlend's wstHYPE reserve pays 0.00006% against a ~2.5% staking yield. Treat an absent value as unknown rather than as the asset earning nothing beyond `supply_apy`."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["intrinsic_apy"])
+        nullable_fields = set(["intrinsic_apy"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k, serialized.get(n))
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m

compass_api_sdk-2.2.95/src/compass_api_sdk/models/loopedpositioncurrentstate.py

@@ -1,133 +0,0 @@
-"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
-
-from __future__ import annotations
-from compass_api_sdk.types import (
-    BaseModel,
-    Nullable,
-    OptionalNullable,
-    UNSET,
-    UNSET_SENTINEL,
-)
-from enum import Enum
-from pydantic import model_serializer
-from typing_extensions import NotRequired, TypedDict
-
-
-class LoopedPositionCurrentStateHealthFactorScope(str, Enum):
-    r"""'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account — see aave_account_summary for the account-level figures."""
-
-    MARKET = "market"
-    ACCOUNT = "account"
-
-
-class LoopedPositionCurrentStateTypedDict(TypedDict):
-    r"""Live on-chain state of an OPEN looped position."""
-
-    collateral_amount: Nullable[str]
-    r"""Current on-chain collateral amount for this position. When multiple open Aave positions share one collateral reserve (Aave holds a single pooled aToken balance per reserve), that pooled balance is attributed across them pro-rata by each position's event-ledger contribution — bookkeeping, not protocol truth; liquidation sees the pooled account, not this per-position split."""
-    debt_amount: Nullable[str]
-    r"""Current on-chain debt amount for this position."""
-    health_factor_scope: LoopedPositionCurrentStateHealthFactorScope
-    r"""'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account — see aave_account_summary for the account-level figures."""
-    collateral_usd: NotRequired[Nullable[str]]
-    r"""Collateral value in USD (null if unpriced). Derived from the attributed collateral_amount for shared-reserve Aave positions."""
-    debt_usd: NotRequired[Nullable[str]]
-    r"""Debt value in USD (null if unpriced)."""
-    net_usd_value: NotRequired[Nullable[str]]
-    r"""Net position value in USD (collateral - debt); null if unpriced. For shared-reserve Aave positions the collateral side uses the pro-rata attributed balance (bookkeeping, not protocol truth)."""
-    leverage: NotRequired[Nullable[str]]
-    r"""Leverage multiplier: collateral_usd / (collateral_usd - debt_usd). Null when unpriced or net value is non-positive. For shared-reserve Aave positions this is derived from the pro-rata attributed collateral (bookkeeping, not protocol truth)."""
-    health_factor: NotRequired[Nullable[str]]
-    r"""Health factor. Above 1 is safe; below 1 risks liquidation. See health_factor_scope for what it covers."""
-    collateral_apy: NotRequired[Nullable[str]]
-    r"""What the collateral leg currently earns, in percentage (e.g. 6.12 = 6.12%). Aave: the collateral reserve's spot supply APY. Morpho: the collateral token's own yield — its 7d vault APY when it is an indexed vault share (e.g. steakUSDC); null otherwise, since Morpho collateral earns nothing from the market itself and an unindexed token's intrinsic yield is unknown."""
-    borrow_apy: NotRequired[Nullable[str]]
-    r"""What the debt leg currently costs, in percentage: the market's spot borrow APY (Morpho IRM rate / Aave variable borrow rate). Null when the rate read was unavailable."""
-    net_apy: NotRequired[Nullable[str]]
-    r"""Levered net yield on the position's equity, in percentage: leverage x collateral_apy - (leverage - 1) x borrow_apy. Negative means the carry is upside down (borrowing costs more than the collateral earns). Null when leverage or either leg is unknown. The collateral leg of a Morpho vault-share position is a 7d average while the borrow leg is spot."""
-
-
-class LoopedPositionCurrentState(BaseModel):
-    r"""Live on-chain state of an OPEN looped position."""
-
-    collateral_amount: Nullable[str]
-    r"""Current on-chain collateral amount for this position. When multiple open Aave positions share one collateral reserve (Aave holds a single pooled aToken balance per reserve), that pooled balance is attributed across them pro-rata by each position's event-ledger contribution — bookkeeping, not protocol truth; liquidation sees the pooled account, not this per-position split."""
-
-    debt_amount: Nullable[str]
-    r"""Current on-chain debt amount for this position."""
-
-    health_factor_scope: LoopedPositionCurrentStateHealthFactorScope
-    r"""'market' for Morpho (isolated per-market health). 'account' for Aave: collateral is pooled, so all collateral backs all debt and this health factor is shared by every Aave position on the account — see aave_account_summary for the account-level figures."""
-
-    collateral_usd: OptionalNullable[str] = UNSET
-    r"""Collateral value in USD (null if unpriced). Derived from the attributed collateral_amount for shared-reserve Aave positions."""
-
-    debt_usd: OptionalNullable[str] = UNSET
-    r"""Debt value in USD (null if unpriced)."""
-
-    net_usd_value: OptionalNullable[str] = UNSET
-    r"""Net position value in USD (collateral - debt); null if unpriced. For shared-reserve Aave positions the collateral side uses the pro-rata attributed balance (bookkeeping, not protocol truth)."""
-
-    leverage: OptionalNullable[str] = UNSET
-    r"""Leverage multiplier: collateral_usd / (collateral_usd - debt_usd). Null when unpriced or net value is non-positive. For shared-reserve Aave positions this is derived from the pro-rata attributed collateral (bookkeeping, not protocol truth)."""
-
-    health_factor: OptionalNullable[str] = UNSET
-    r"""Health factor. Above 1 is safe; below 1 risks liquidation. See health_factor_scope for what it covers."""
-
-    collateral_apy: OptionalNullable[str] = UNSET
-    r"""What the collateral leg currently earns, in percentage (e.g. 6.12 = 6.12%). Aave: the collateral reserve's spot supply APY. Morpho: the collateral token's own yield — its 7d vault APY when it is an indexed vault share (e.g. steakUSDC); null otherwise, since Morpho collateral earns nothing from the market itself and an unindexed token's intrinsic yield is unknown."""
-
-    borrow_apy: OptionalNullable[str] = UNSET
-    r"""What the debt leg currently costs, in percentage: the market's spot borrow APY (Morpho IRM rate / Aave variable borrow rate). Null when the rate read was unavailable."""
-
-    net_apy: OptionalNullable[str] = UNSET
-    r"""Levered net yield on the position's equity, in percentage: leverage x collateral_apy - (leverage - 1) x borrow_apy. Negative means the carry is upside down (borrowing costs more than the collateral earns). Null when leverage or either leg is unknown. The collateral leg of a Morpho vault-share position is a 7d average while the borrow leg is spot."""
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = set(
-            [
-                "collateral_usd",
-                "debt_usd",
-                "net_usd_value",
-                "leverage",
-                "health_factor",
-                "collateral_apy",
-                "borrow_apy",
-                "net_apy",
-            ]
-        )
-        nullable_fields = set(
-            [
-                "collateral_amount",
-                "debt_amount",
-                "collateral_usd",
-                "debt_usd",
-                "net_usd_value",
-                "leverage",
-                "health_factor",
-                "collateral_apy",
-                "borrow_apy",
-                "net_apy",
-            ]
-        )
-        serialized = handler(self)
-        m = {}
-
-        for n, f in type(self).model_fields.items():
-            k = f.alias or n
-            val = serialized.get(k, serialized.get(n))
-            is_nullable_and_explicitly_set = (
-                k in nullable_fields
-                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
-            )
-
-            if val != UNSET_SENTINEL:
-                if (
-                    val is not None
-                    or k not in optional_fields
-                    or is_nullable_and_explicitly_set
-                ):
-                    m[k] = val
-
-        return m