compass_api_sdk 2.2.70rc2__tar.gz → 2.2.71__tar.gz

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compass_api_sdk
-Version: 2.2.70rc2
+Version: 2.2.71
 Summary: Compass API SDK.
 Author: royalnine
 Requires-Python: >=3.10

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "compass_api_sdk"
-version = "2.2.70rc2"
+version = "2.2.71"
 description = "Compass API SDK."
 authors = [{ name = "royalnine" },]
 readme = "README-PYPI.md"
@@ -14,7 +14,7 @@ dependencies = [
 
 [tool.poetry]
 name = "compass_api_sdk"
-version = "2.2.70rc2"
+version = "2.2.71"
 description = "Compass API SDK."
 authors = ["Compass Labs"]
 repository = "https://github.com/CompassLabs/mono.git"

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/src/compass_api_sdk/credit.py

@@ -608,6 +608,9 @@ class Credit(BaseSDK):
         chain: models.Chain,
         borrow_token: str,
         borrow_amount: Union[models.BorrowAmount, models.BorrowAmountTypedDict],
+        protocol: Optional[models.CreditProtocol] = None,
+        collateral_vault: OptionalNullable[str] = UNSET,
+        borrow_vault: OptionalNullable[str] = UNSET,
         token_in: OptionalNullable[str] = UNSET,
         amount_in: OptionalNullable[
             Union[
@@ -650,6 +653,13 @@ class Credit(BaseSDK):
         :param chain: The chain to use.
         :param borrow_token: Asset to borrow from Aave.
         :param borrow_amount: Amount to borrow (in token units, not wei).
+        :param protocol: Which lending protocol a credit action targets.
+
+            ``AAVE`` is the default so existing callers (which never send a ``protocol``
+            field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+            Euler V2 path, where the market is identified by EVK vault address(es).
+        :param collateral_vault: Euler only: the EVK collateral vault to supply into. Required when protocol=EULER and supplying collateral.
+        :param borrow_vault: Euler only: the EVK vault to borrow from. Required when protocol=EULER.
         :param token_in: Token currently held in the Credit Account to use as input. If the same as collateral_token, no swap is performed. Omit together with amount_in and collateral_token to borrow against existing collateral.
         :param amount_in: Amount of token_in to use (in token units, not wei). Omit together with token_in and collateral_token for borrow-only mode.
         :param collateral_token: Aave reserve token to supply as collateral. Omit together with token_in and amount_in for borrow-only mode.
@@ -680,6 +690,9 @@ class Credit(BaseSDK):
         request = models.CreditBorrowRequest(
             owner=owner,
             chain=chain,
+            protocol=protocol,
+            collateral_vault=collateral_vault,
+            borrow_vault=borrow_vault,
             token_in=token_in,
             amount_in=amount_in,
             collateral_token=collateral_token,
@@ -759,6 +772,9 @@ class Credit(BaseSDK):
         chain: models.Chain,
         borrow_token: str,
         borrow_amount: Union[models.BorrowAmount, models.BorrowAmountTypedDict],
+        protocol: Optional[models.CreditProtocol] = None,
+        collateral_vault: OptionalNullable[str] = UNSET,
+        borrow_vault: OptionalNullable[str] = UNSET,
         token_in: OptionalNullable[str] = UNSET,
         amount_in: OptionalNullable[
             Union[
@@ -801,6 +817,13 @@ class Credit(BaseSDK):
         :param chain: The chain to use.
         :param borrow_token: Asset to borrow from Aave.
         :param borrow_amount: Amount to borrow (in token units, not wei).
+        :param protocol: Which lending protocol a credit action targets.
+
+            ``AAVE`` is the default so existing callers (which never send a ``protocol``
+            field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+            Euler V2 path, where the market is identified by EVK vault address(es).
+        :param collateral_vault: Euler only: the EVK collateral vault to supply into. Required when protocol=EULER and supplying collateral.
+        :param borrow_vault: Euler only: the EVK vault to borrow from. Required when protocol=EULER.
         :param token_in: Token currently held in the Credit Account to use as input. If the same as collateral_token, no swap is performed. Omit together with amount_in and collateral_token to borrow against existing collateral.
         :param amount_in: Amount of token_in to use (in token units, not wei). Omit together with token_in and collateral_token for borrow-only mode.
         :param collateral_token: Aave reserve token to supply as collateral. Omit together with token_in and amount_in for borrow-only mode.
@@ -831,6 +854,9 @@ class Credit(BaseSDK):
         request = models.CreditBorrowRequest(
             owner=owner,
             chain=chain,
+            protocol=protocol,
+            collateral_vault=collateral_vault,
+            borrow_vault=borrow_vault,
             token_in=token_in,
             amount_in=amount_in,
             collateral_token=collateral_token,
@@ -1154,6 +1180,9 @@ class Credit(BaseSDK):
         chain: models.Chain,
         repay_token: str,
         repay_amount: Union[models.RepayAmount, models.RepayAmountTypedDict],
+        protocol: Optional[models.CreditProtocol] = None,
+        borrow_vault: OptionalNullable[str] = UNSET,
+        collateral_vault: OptionalNullable[str] = UNSET,
         interest_rate_mode: Optional[models.InterestRateMode] = None,
         withdraw_token: OptionalNullable[str] = UNSET,
         withdraw_amount: OptionalNullable[
@@ -1191,6 +1220,13 @@ class Credit(BaseSDK):
         :param chain: The chain to use.
         :param repay_token: The borrowed asset to repay (e.g. WETH). Must match the debt position's token.
         :param repay_amount: Amount of repay_token to repay (in token units, not wei).
+        :param protocol: Which lending protocol a credit action targets.
+
+            ``AAVE`` is the default so existing callers (which never send a ``protocol``
+            field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+            Euler V2 path, where the market is identified by EVK vault address(es).
+        :param borrow_vault: Euler only: the EVK vault the debt is owed to (repay target). Required when protocol=EULER.
+        :param collateral_vault: Euler only: the EVK collateral vault to withdraw from. Required when protocol=EULER and withdrawing collateral.
         :param interest_rate_mode: On AAVE there are 2 different interest modes.
 
             A stable (but typically higher rate), or a variable rate.
@@ -1220,6 +1256,9 @@ class Credit(BaseSDK):
         request = models.CreditRepayRequest(
             owner=owner,
             chain=chain,
+            protocol=protocol,
+            borrow_vault=borrow_vault,
+            collateral_vault=collateral_vault,
             repay_token=repay_token,
             repay_amount=repay_amount,
             interest_rate_mode=interest_rate_mode,
@@ -1298,6 +1337,9 @@ class Credit(BaseSDK):
         chain: models.Chain,
         repay_token: str,
         repay_amount: Union[models.RepayAmount, models.RepayAmountTypedDict],
+        protocol: Optional[models.CreditProtocol] = None,
+        borrow_vault: OptionalNullable[str] = UNSET,
+        collateral_vault: OptionalNullable[str] = UNSET,
         interest_rate_mode: Optional[models.InterestRateMode] = None,
         withdraw_token: OptionalNullable[str] = UNSET,
         withdraw_amount: OptionalNullable[
@@ -1335,6 +1377,13 @@ class Credit(BaseSDK):
         :param chain: The chain to use.
         :param repay_token: The borrowed asset to repay (e.g. WETH). Must match the debt position's token.
         :param repay_amount: Amount of repay_token to repay (in token units, not wei).
+        :param protocol: Which lending protocol a credit action targets.
+
+            ``AAVE`` is the default so existing callers (which never send a ``protocol``
+            field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+            Euler V2 path, where the market is identified by EVK vault address(es).
+        :param borrow_vault: Euler only: the EVK vault the debt is owed to (repay target). Required when protocol=EULER.
+        :param collateral_vault: Euler only: the EVK collateral vault to withdraw from. Required when protocol=EULER and withdrawing collateral.
         :param interest_rate_mode: On AAVE there are 2 different interest modes.
 
             A stable (but typically higher rate), or a variable rate.
@@ -1364,6 +1413,9 @@ class Credit(BaseSDK):
         request = models.CreditRepayRequest(
             owner=owner,
             chain=chain,
+            protocol=protocol,
+            borrow_vault=borrow_vault,
+            collateral_vault=collateral_vault,
             repay_token=repay_token,
             repay_amount=repay_amount,
             interest_rate_mode=interest_rate_mode,

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/src/compass_api_sdk/models/__init__.py

@@ -463,6 +463,7 @@ if TYPE_CHECKING:
         CreditPositionsResponse,
         CreditPositionsResponseTypedDict,
     )
+    from .creditprotocol import CreditProtocol
     from .creditrepayparams import (
         CreditRepayParams,
         CreditRepayParamsAmount,
@@ -2130,6 +2131,7 @@ __all__ = [
     "CreditFeeTypedDict",
     "CreditPositionsResponse",
     "CreditPositionsResponseTypedDict",
+    "CreditProtocol",
     "CreditRepayParams",
     "CreditRepayParamsAmount",
     "CreditRepayParamsAmountTypedDict",
@@ -3432,6 +3434,7 @@ _dynamic_imports: dict[str, str] = {
     "CreditFeeTypedDict": ".creditfee",
     "CreditPositionsResponse": ".creditpositionsresponse",
     "CreditPositionsResponseTypedDict": ".creditpositionsresponse",
+    "CreditProtocol": ".creditprotocol",
     "CreditRepayParams": ".creditrepayparams",
     "CreditRepayParamsAmount": ".creditrepayparams",
     "CreditRepayParamsAmountTypedDict": ".creditrepayparams",

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/src/compass_api_sdk/models/accountsummary.py

@@ -1,6 +1,7 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .creditprotocol import CreditProtocol
 from compass_api_sdk.types import (
     BaseModel,
     Nullable,
@@ -14,7 +15,12 @@ from typing_extensions import NotRequired, TypedDict
 
 
 class AccountSummaryTypedDict(TypedDict):
-    r"""Aave account-level summary from getUserAccountData()."""
+    r"""Account-level summary for one lending protocol.
+
+    Populated from Aave ``getUserAccountData()`` or, for Euler, from the
+    controller vault's risk engine (``accountLiquidity``). The E-Mode fields are
+    Aave-only and stay at their defaults for Euler.
+    """
 
     health_factor: str
     r"""Health factor. Above 1 is safe; below 1 risks liquidation."""
@@ -26,6 +32,13 @@ class AccountSummaryTypedDict(TypedDict):
     r"""Available borrow capacity in USD."""
     ltv: str
     r"""Current loan-to-value ratio."""
+    protocol: NotRequired[CreditProtocol]
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
     emode_category_id: NotRequired[int]
     r"""E-Mode category ID. 0 = disabled. E-Mode gives higher LTV when collateral and debt are price-correlated (e.g. stablecoin-to-stablecoin or ETH-to-ETH-derivative)."""
     emode_label: NotRequired[Nullable[str]]
@@ -33,7 +46,12 @@ class AccountSummaryTypedDict(TypedDict):
 
 
 class AccountSummary(BaseModel):
-    r"""Aave account-level summary from getUserAccountData()."""
+    r"""Account-level summary for one lending protocol.
+
+    Populated from Aave ``getUserAccountData()`` or, for Euler, from the
+    controller vault's risk engine (``accountLiquidity``). The E-Mode fields are
+    Aave-only and stay at their defaults for Euler.
+    """
 
     health_factor: str
     r"""Health factor. Above 1 is safe; below 1 risks liquidation."""
@@ -50,6 +68,14 @@ class AccountSummary(BaseModel):
     ltv: str
     r"""Current loan-to-value ratio."""
 
+    protocol: Optional[CreditProtocol] = None
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+
     emode_category_id: Optional[int] = None
     r"""E-Mode category ID. 0 = disabled. E-Mode gives higher LTV when collateral and debt are price-correlated (e.g. stablecoin-to-stablecoin or ETH-to-ETH-derivative)."""
 
@@ -58,7 +84,7 @@ class AccountSummary(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = set(["emode_category_id", "emode_label"])
+        optional_fields = set(["protocol", "emode_category_id", "emode_label"])
         nullable_fields = set(["emode_label"])
         serialized = handler(self)
         m = {}

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/src/compass_api_sdk/models/collateralposition.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .creditevent import CreditEvent, CreditEventTypedDict
+from .creditprotocol import CreditProtocol
 from compass_api_sdk.types import (
     BaseModel,
     Nullable,
@@ -22,7 +23,16 @@ class CollateralPositionTypedDict(TypedDict):
     symbol: str
     r"""Symbol of the collateral token (e.g. USDC)."""
     amount_supplied: Nullable[str]
-    r"""Current on-chain aToken balance for the collateral."""
+    r"""Current on-chain collateral balance (the vault's underlying asset for Euler)."""
+    protocol: NotRequired[CreditProtocol]
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+    vault: NotRequired[Nullable[str]]
+    r"""Euler only: the EVK collateral vault holding this position."""
     usd_value: NotRequired[Nullable[str]]
     r"""Collateral value in USD."""
     supply_apy: NotRequired[Nullable[str]]
@@ -49,7 +59,18 @@ class CollateralPosition(BaseModel):
     r"""Symbol of the collateral token (e.g. USDC)."""
 
     amount_supplied: Nullable[str]
-    r"""Current on-chain aToken balance for the collateral."""
+    r"""Current on-chain collateral balance (the vault's underlying asset for Euler)."""
+
+    protocol: Optional[CreditProtocol] = None
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+
+    vault: OptionalNullable[str] = UNSET
+    r"""Euler only: the EVK collateral vault holding this position."""
 
     usd_value: OptionalNullable[str] = UNSET
     r"""Collateral value in USD."""
@@ -76,6 +97,8 @@ class CollateralPosition(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "protocol",
+                "vault",
                 "usd_value",
                 "supply_apy",
                 "total_deposited",
@@ -87,6 +110,7 @@ class CollateralPosition(BaseModel):
         )
         nullable_fields = set(
             [
+                "vault",
                 "amount_supplied",
                 "usd_value",
                 "supply_apy",

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/src/compass_api_sdk/models/creditborrowparams.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .creditfee import CreditFee, CreditFeeTypedDict
+from .creditprotocol import CreditProtocol
 from .interestratemode import InterestRateMode
 from compass_api_sdk.types import (
     BaseModel,
@@ -43,6 +44,15 @@ class CreditBorrowParamsTypedDict(TypedDict):
     """
     fee: NotRequired[Nullable[CreditFeeTypedDict]]
     r"""Optional fee on the borrowed amount."""
+    protocol: NotRequired[CreditProtocol]
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+    borrow_vault: NotRequired[Nullable[str]]
+    r"""Euler only: the EVK vault to borrow from. Required when protocol=EULER."""
 
 
 class CreditBorrowParams(BaseModel):
@@ -71,10 +81,23 @@ class CreditBorrowParams(BaseModel):
     fee: OptionalNullable[CreditFee] = UNSET
     r"""Optional fee on the borrowed amount."""
 
+    protocol: Optional[CreditProtocol] = None
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+
+    borrow_vault: OptionalNullable[str] = UNSET
+    r"""Euler only: the EVK vault to borrow from. Required when protocol=EULER."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = set(["action_type", "interest_rate_mode", "fee"])
-        nullable_fields = set(["fee"])
+        optional_fields = set(
+            ["action_type", "interest_rate_mode", "fee", "protocol", "borrow_vault"]
+        )
+        nullable_fields = set(["fee", "borrow_vault"])
         serialized = handler(self)
         m = {}
 

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/src/compass_api_sdk/models/creditborrowrequest.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 from .chain import Chain
 from .creditfee import CreditFee, CreditFeeTypedDict
+from .creditprotocol import CreditProtocol
 from .interestratemode import InterestRateMode
 from compass_api_sdk.types import (
     BaseModel,
@@ -57,6 +58,17 @@ class CreditBorrowRequestTypedDict(TypedDict):
     r"""Asset to borrow from Aave."""
     borrow_amount: BorrowAmountTypedDict
     r"""Amount to borrow (in token units, not wei)."""
+    protocol: NotRequired[CreditProtocol]
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+    collateral_vault: NotRequired[Nullable[str]]
+    r"""Euler only: the EVK collateral vault to supply into. Required when protocol=EULER and supplying collateral."""
+    borrow_vault: NotRequired[Nullable[str]]
+    r"""Euler only: the EVK vault to borrow from. Required when protocol=EULER."""
     token_in: NotRequired[Nullable[str]]
     r"""Token currently held in the Credit Account to use as input. If the same as collateral_token, no swap is performed. Omit together with amount_in and collateral_token to borrow against existing collateral."""
     amount_in: NotRequired[Nullable[CreditBorrowRequestAmountInTypedDict]]
@@ -95,6 +107,20 @@ class CreditBorrowRequest(BaseModel):
     borrow_amount: BorrowAmount
     r"""Amount to borrow (in token units, not wei)."""
 
+    protocol: Optional[CreditProtocol] = None
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+
+    collateral_vault: OptionalNullable[str] = UNSET
+    r"""Euler only: the EVK collateral vault to supply into. Required when protocol=EULER and supplying collateral."""
+
+    borrow_vault: OptionalNullable[str] = UNSET
+    r"""Euler only: the EVK vault to borrow from. Required when protocol=EULER."""
+
     token_in: OptionalNullable[str] = UNSET
     r"""Token currently held in the Credit Account to use as input. If the same as collateral_token, no swap is performed. Omit together with amount_in and collateral_token to borrow against existing collateral."""
 
@@ -132,6 +158,9 @@ class CreditBorrowRequest(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "protocol",
+                "collateral_vault",
+                "borrow_vault",
                 "token_in",
                 "amount_in",
                 "collateral_token",
@@ -146,6 +175,8 @@ class CreditBorrowRequest(BaseModel):
         )
         nullable_fields = set(
             [
+                "collateral_vault",
+                "borrow_vault",
                 "token_in",
                 "amount_in",
                 "collateral_token",

{compass_api_sdk-2.2.70rc2 → compass_api_sdk-2.2.71}/src/compass_api_sdk/models/creditenablecollateralparams.py

@@ -1,13 +1,20 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from compass_api_sdk.types import BaseModel, UNSET_SENTINEL
+from .creditprotocol import CreditProtocol
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
 from compass_api_sdk.utils import validate_const
 import pydantic
 from pydantic import model_serializer
 from pydantic.functional_validators import AfterValidator
 from typing import Literal, Optional
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class CreditEnableCollateralParamsTypedDict(TypedDict):
@@ -20,6 +27,15 @@ class CreditEnableCollateralParamsTypedDict(TypedDict):
     token: str
     r"""The underlying reserve token to enable as collateral (e.g. USDC, not aUSDC)."""
     action_type: Literal["CREDIT_ENABLE_COLLATERAL"]
+    protocol: NotRequired[CreditProtocol]
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+    collateral_vault: NotRequired[Nullable[str]]
+    r"""Euler only: the EVK collateral vault to enable. Required when protocol=EULER."""
 
 
 class CreditEnableCollateralParams(BaseModel):
@@ -40,18 +56,38 @@ class CreditEnableCollateralParams(BaseModel):
         pydantic.Field(alias="action_type"),
     ] = "CREDIT_ENABLE_COLLATERAL"
 
+    protocol: Optional[CreditProtocol] = None
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+
+    collateral_vault: OptionalNullable[str] = UNSET
+    r"""Euler only: the EVK collateral vault to enable. Required when protocol=EULER."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = set(["action_type"])
+        optional_fields = set(["action_type", "protocol", "collateral_vault"])
+        nullable_fields = set(["collateral_vault"])
         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.70rc2 → compass_api_sdk-2.2.71}/src/compass_api_sdk/models/creditpositionsresponse.py

@@ -21,11 +21,18 @@ class CreditPositionsResponseTypedDict(TypedDict):
     r"""Credit account positions response with per-reserve positions and account summary."""
 
     account_summary: AccountSummaryTypedDict
-    r"""Aave account-level summary from getUserAccountData()."""
+    r"""Account-level summary for one lending protocol.
+
+    Populated from Aave ``getUserAccountData()`` or, for Euler, from the
+    controller vault's risk engine (``accountLiquidity``). The E-Mode fields are
+    Aave-only and stay at their defaults for Euler.
+    """
     collateral_positions: NotRequired[List[CollateralPositionTypedDict]]
     r"""All collateral positions, one per reserve."""
     debt_positions: NotRequired[List[DebtPositionTypedDict]]
     r"""All debt positions, one per reserve."""
+    euler_account_summary: NotRequired[Nullable[AccountSummaryTypedDict]]
+    r"""Euler account-level summary (health factor, LTV, etc.), present only when the account holds Euler positions. Null for Aave-only accounts."""
     borrowable_tokens: NotRequired[List[BorrowableTokenTypedDict]]
     r"""All tokens available for borrowing with max amounts based on current collateral."""
     total_usd_value: NotRequired[Nullable[str]]
@@ -36,7 +43,12 @@ class CreditPositionsResponse(BaseModel):
     r"""Credit account positions response with per-reserve positions and account summary."""
 
     account_summary: AccountSummary
-    r"""Aave account-level summary from getUserAccountData()."""
+    r"""Account-level summary for one lending protocol.
+
+    Populated from Aave ``getUserAccountData()`` or, for Euler, from the
+    controller vault's risk engine (``accountLiquidity``). The E-Mode fields are
+    Aave-only and stay at their defaults for Euler.
+    """
 
     collateral_positions: Optional[List[CollateralPosition]] = None
     r"""All collateral positions, one per reserve."""
@@ -44,6 +56,9 @@ class CreditPositionsResponse(BaseModel):
     debt_positions: Optional[List[DebtPosition]] = None
     r"""All debt positions, one per reserve."""
 
+    euler_account_summary: OptionalNullable[AccountSummary] = UNSET
+    r"""Euler account-level summary (health factor, LTV, etc.), present only when the account holds Euler positions. Null for Aave-only accounts."""
+
     borrowable_tokens: Optional[List[BorrowableToken]] = None
     r"""All tokens available for borrowing with max amounts based on current collateral."""
 
@@ -56,11 +71,12 @@ class CreditPositionsResponse(BaseModel):
             [
                 "collateral_positions",
                 "debt_positions",
+                "euler_account_summary",
                 "borrowable_tokens",
                 "total_usd_value",
             ]
         )
-        nullable_fields = set(["total_usd_value"])
+        nullable_fields = set(["euler_account_summary", "total_usd_value"])
         serialized = handler(self)
         m = {}
 

compass_api_sdk-2.2.71/src/compass_api_sdk/models/creditprotocol.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from enum import Enum
+
+
+class CreditProtocol(str, Enum):
+    r"""Which lending protocol a credit action targets.
+
+    ``AAVE`` is the default so existing callers (which never send a ``protocol``
+    field) keep hitting the unchanged Aave code path. ``EULER`` opts in to the
+    Euler V2 path, where the market is identified by EVK vault address(es).
+    """
+
+    AAVE = "AAVE"
+    EULER = "EULER"