compass_api_sdk 2.2.117__tar.gz → 2.2.118__tar.gz

{compass_api_sdk-2.2.117 → compass_api_sdk-2.2.118}/PKG-INFO

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

{compass_api_sdk-2.2.117 → compass_api_sdk-2.2.118}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "compass_api_sdk"
-version = "2.2.117"
+version = "2.2.118"
 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.117"
+version = "2.2.118"
 description = "Compass API SDK."
 authors = ["Compass Labs"]
 repository = "https://github.com/CompassLabs/mono.git"

{compass_api_sdk-2.2.117 → compass_api_sdk-2.2.118}/src/compass_api_sdk/models/__init__.py

@@ -775,9 +775,11 @@ if TYPE_CHECKING:
     )
     from .loopedpositionhistoryentry import (
         Classification,
+        FlowBasis,
         LoopedPositionHistoryEntry,
         LoopedPositionHistoryEntryTypedDict,
     )
+    from .loopedpositionpnl import LoopedPositionPnl, LoopedPositionPnlTypedDict
     from .loopedpositiontotals import (
         LoopedPositionTotals,
         LoopedPositionTotalsTypedDict,
@@ -2527,6 +2529,7 @@ __all__ = [
     "FeeDenomination",
     "FeeEnum",
     "FeeTypedDict",
+    "FlowBasis",
     "InterestRateMode",
     "LiquidationCall",
     "LiquidationCallTypedDict",
@@ -2542,6 +2545,8 @@ __all__ = [
     "LoopedPositionCurrentStateTypedDict",
     "LoopedPositionHistoryEntry",
     "LoopedPositionHistoryEntryTypedDict",
+    "LoopedPositionPnl",
+    "LoopedPositionPnlTypedDict",
     "LoopedPositionStatus",
     "LoopedPositionTotals",
     "LoopedPositionTotalsTypedDict",
@@ -3951,8 +3956,11 @@ _dynamic_imports: dict[str, str] = {
     "LoopedPositionCurrentStateHealthFactorScope": ".loopedpositioncurrentstate",
     "LoopedPositionCurrentStateTypedDict": ".loopedpositioncurrentstate",
     "Classification": ".loopedpositionhistoryentry",
+    "FlowBasis": ".loopedpositionhistoryentry",
     "LoopedPositionHistoryEntry": ".loopedpositionhistoryentry",
     "LoopedPositionHistoryEntryTypedDict": ".loopedpositionhistoryentry",
+    "LoopedPositionPnl": ".loopedpositionpnl",
+    "LoopedPositionPnlTypedDict": ".loopedpositionpnl",
     "LoopedPositionTotals": ".loopedpositiontotals",
     "LoopedPositionTotalsTypedDict": ".loopedpositiontotals",
     "LoopLegPreview": ".looplegpreview",

{compass_api_sdk-2.2.117 → compass_api_sdk-2.2.118}/src/compass_api_sdk/models/loopedposition.py

@@ -10,6 +10,7 @@ from .loopedpositionhistoryentry import (
     LoopedPositionHistoryEntry,
     LoopedPositionHistoryEntryTypedDict,
 )
+from .loopedpositionpnl import LoopedPositionPnl, LoopedPositionPnlTypedDict
 from .loopedpositiontotals import LoopedPositionTotals, LoopedPositionTotalsTypedDict
 from compass_api_sdk.types import (
     BaseModel,
@@ -79,6 +80,8 @@ class LoopedPositionTypedDict(TypedDict):
     r"""Timestamp the position was fully closed; null while open."""
     current: NotRequired[Nullable[LoopedPositionCurrentStateTypedDict]]
     r"""Live on-chain state; null for CLOSED positions."""
+    pnl: NotRequired[Nullable[LoopedPositionPnlTypedDict]]
+    r"""Profit or loss since the position opened, for OPEN and CLOSED positions alike. Null when it cannot be stated honestly: the position's recorded history is incomplete (it starts after the opening, or does not add up to what the position holds now), a transaction could not be priced, the position's current value could not be read or separated from another position's, or a transaction's legs cannot be told apart from another position's."""
     history: NotRequired[List[LoopedPositionHistoryEntryTypedDict]]
     r"""All transactions for this position, chronological."""
 
@@ -144,6 +147,9 @@ class LoopedPosition(BaseModel):
     current: OptionalNullable[LoopedPositionCurrentState] = UNSET
     r"""Live on-chain state; null for CLOSED positions."""
 
+    pnl: OptionalNullable[LoopedPositionPnl] = UNSET
+    r"""Profit or loss since the position opened, for OPEN and CLOSED positions alike. Null when it cannot be stated honestly: the position's recorded history is incomplete (it starts after the opening, or does not add up to what the position holds now), a transaction could not be priced, the position's current value could not be read or separated from another position's, or a transaction's legs cannot be told apart from another position's."""
+
     history: Optional[List[LoopedPositionHistoryEntry]] = None
     r"""All transactions for this position, chronological."""
 
@@ -157,6 +163,7 @@ class LoopedPosition(BaseModel):
                 "borrow_vault",
                 "closed_at",
                 "current",
+                "pnl",
                 "history",
             ]
         )
@@ -168,6 +175,7 @@ class LoopedPosition(BaseModel):
                 "borrow_vault",
                 "closed_at",
                 "current",
+                "pnl",
             ]
         )
         serialized = handler(self)

{compass_api_sdk-2.2.117 → compass_api_sdk-2.2.118}/src/compass_api_sdk/models/loopedpositionhistoryentry.py

@@ -31,6 +31,11 @@ class Classification(str, Enum):
     MIXED = "mixed"
 
 
+class FlowBasis(str, Enum):
+    SWAP = "swap"
+    ORACLE = "oracle"
+
+
 class LoopedPositionHistoryEntryTypedDict(TypedDict):
     r"""One transaction in a looped position's lifetime."""
 
@@ -49,9 +54,13 @@ class LoopedPositionHistoryEntryTypedDict(TypedDict):
     iterations: NotRequired[Nullable[int]]
     r"""Loop transactions only: number of borrow legs in this transaction (one per loop iteration). Null for non-loop transactions."""
     swap: NotRequired[Nullable[SwapInfoTypedDict]]
-    r"""The swap leg detected in this transaction, if any."""
+    r"""The swap leg of a loop (debt sold for collateral) or an unwind (collateral sold for debt), when the transaction shows one."""
     events: NotRequired[List[CreditEventTypedDict]]
     r"""The raw lending events that make up this transaction (Morpho supply_collateral maps to 'supply', withdraw_collateral to 'withdraw')."""
+    equity_flow_quote: NotRequired[Nullable[str]]
+    r"""Equity this transaction put into the position (positive) or took out of it (negative), in the debt token, valued when it landed. 0 for a liquidation, whose loss stays in the position's equity. Null when the transaction could not be valued."""
+    flow_basis: NotRequired[Nullable[FlowBasis]]
+    r"""How equity_flow_quote was measured. 'swap': from this transaction's own swap, so the swap's cost shows up in PnL. 'oracle': from the net amounts at the market price; on a loop or unwind that folds the swap's cost into the flow instead. Null for a liquidation and for a transaction that could not be valued."""
 
 
 class LoopedPositionHistoryEntry(BaseModel):
@@ -79,15 +88,23 @@ class LoopedPositionHistoryEntry(BaseModel):
     r"""Loop transactions only: number of borrow legs in this transaction (one per loop iteration). Null for non-loop transactions."""
 
     swap: OptionalNullable[SwapInfo] = UNSET
-    r"""The swap leg detected in this transaction, if any."""
+    r"""The swap leg of a loop (debt sold for collateral) or an unwind (collateral sold for debt), when the transaction shows one."""
 
     events: Optional[List[CreditEvent]] = None
     r"""The raw lending events that make up this transaction (Morpho supply_collateral maps to 'supply', withdraw_collateral to 'withdraw')."""
 
+    equity_flow_quote: OptionalNullable[str] = UNSET
+    r"""Equity this transaction put into the position (positive) or took out of it (negative), in the debt token, valued when it landed. 0 for a liquidation, whose loss stays in the position's equity. Null when the transaction could not be valued."""
+
+    flow_basis: OptionalNullable[FlowBasis] = UNSET
+    r"""How equity_flow_quote was measured. 'swap': from this transaction's own swap, so the swap's cost shows up in PnL. 'oracle': from the net amounts at the market price; on a loop or unwind that folds the swap's cost into the flow instead. Null for a liquidation and for a transaction that could not be valued."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = set(["iterations", "swap", "events"])
-        nullable_fields = set(["iterations", "swap"])
+        optional_fields = set(
+            ["iterations", "swap", "events", "equity_flow_quote", "flow_basis"]
+        )
+        nullable_fields = set(["iterations", "swap", "equity_flow_quote", "flow_basis"])
         serialized = handler(self)
         m = {}
 

compass_api_sdk-2.2.118/src/compass_api_sdk/models/loopedpositionpnl.py

@@ -0,0 +1,81 @@
+"""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 pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
+
+
+class LoopedPositionPnlTypedDict(TypedDict):
+    r"""What a looped position has made or lost since it opened.
+
+    Measured in the position's debt token (the quote), with USD alongside.
+    Every transaction is an equity flow valued when it landed: a loop's
+    principal goes in, an unwind's proceeds come out. PnL is what the position
+    is worth now plus everything taken out, minus everything put in; each
+    history entry carries its own flow in equity_flow_quote.
+    """
+
+    total_pnl_quote: Nullable[str]
+    r"""Profit or loss since the position opened, in the position's debt token: what the position is worth now, plus everything taken out, minus everything put in, each valued when it happened. It includes the entry and exit swap costs, the carry (what the collateral earned minus the interest paid) and the collateral's price move against the debt token. Realized once the position is closed, unrealized while it is open. Where a loop or unwind's own swap could not be used (its history entry has flow_basis 'oracle'), that swap's cost is not counted and the figure reads higher by roughly that amount.
+
+    Measured in the debt token, not USD: on a correlated loop (wstHYPE against WHYPE, wstETH against WETH) a positive figure here can still be a USD loss when the debt token itself falls. total_pnl_usd carries that.
+    """
+    total_pnl_percent: NotRequired[Nullable[str]]
+    r"""total_pnl_quote as a percentage of the equity put in (e.g. 4.2 = 4.2%): the return on the capital contributed, not annualized."""
+    total_pnl_usd: NotRequired[Nullable[str]]
+    r"""Profit or loss since the position opened, in USD: each flow at the debt token's USD price when it happened, the position's current value at its price now. Unlike total_pnl_quote it includes the debt token's own USD move. Null when any of those prices is unavailable."""
+
+
+class LoopedPositionPnl(BaseModel):
+    r"""What a looped position has made or lost since it opened.
+
+    Measured in the position's debt token (the quote), with USD alongside.
+    Every transaction is an equity flow valued when it landed: a loop's
+    principal goes in, an unwind's proceeds come out. PnL is what the position
+    is worth now plus everything taken out, minus everything put in; each
+    history entry carries its own flow in equity_flow_quote.
+    """
+
+    total_pnl_quote: Nullable[str]
+    r"""Profit or loss since the position opened, in the position's debt token: what the position is worth now, plus everything taken out, minus everything put in, each valued when it happened. It includes the entry and exit swap costs, the carry (what the collateral earned minus the interest paid) and the collateral's price move against the debt token. Realized once the position is closed, unrealized while it is open. Where a loop or unwind's own swap could not be used (its history entry has flow_basis 'oracle'), that swap's cost is not counted and the figure reads higher by roughly that amount.
+
+    Measured in the debt token, not USD: on a correlated loop (wstHYPE against WHYPE, wstETH against WETH) a positive figure here can still be a USD loss when the debt token itself falls. total_pnl_usd carries that.
+    """
+
+    total_pnl_percent: OptionalNullable[str] = UNSET
+    r"""total_pnl_quote as a percentage of the equity put in (e.g. 4.2 = 4.2%): the return on the capital contributed, not annualized."""
+
+    total_pnl_usd: OptionalNullable[str] = UNSET
+    r"""Profit or loss since the position opened, in USD: each flow at the debt token's USD price when it happened, the position's current value at its price now. Unlike total_pnl_quote it includes the debt token's own USD move. Null when any of those prices is unavailable."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["total_pnl_percent", "total_pnl_usd"])
+        nullable_fields = set(["total_pnl_quote", "total_pnl_percent", "total_pnl_usd"])
+        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.117 → compass_api_sdk-2.2.118}/src/compass_api_sdk/models/swapinfo.py

@@ -13,23 +13,23 @@ from typing_extensions import NotRequired, TypedDict
 
 
 class SwapInfoTypedDict(TypedDict):
-    r"""The DEX swap leg detected inside a loop transaction.
+    r"""The swap leg detected inside a loop or unwind transaction.
 
-    Evidence is token-filtered and executor-proof: the sold (debt) token left the
-    account to a non-protocol counterparty and the bought (collateral) token
-    arrived from a non-protocol counterparty. Aggregator fills often settle from an
-    executor contract, so the router is recorded only when it happens to be the
-    outbound counterparty — it is never required for detection.
+    Evidence is token-filtered and executor-proof: the sold token left the
+    account to a non-protocol counterparty and the bought token arrived from a
+    non-protocol counterparty. Aggregator fills often settle from an executor
+    contract, so the router is recorded only when it happens to be the outbound
+    counterparty — it is never required for detection.
     """
 
     sold_token: str
-    r"""Token sold in the swap (the borrowed/debt token)."""
+    r"""The token leaving the account: the debt token on a loop, the collateral token on an unwind."""
     sold_symbol: str
     r"""Symbol of the sold token."""
     sold_amount: str
     r"""Amount of the sold token."""
     bought_token: str
-    r"""Token bought in the swap (the collateral token)."""
+    r"""The token arriving in the account: the collateral token on a loop, the debt token on an unwind."""
     bought_symbol: str
     r"""Symbol of the bought token."""
     bought_amount: str
@@ -39,17 +39,17 @@ class SwapInfoTypedDict(TypedDict):
 
 
 class SwapInfo(BaseModel):
-    r"""The DEX swap leg detected inside a loop transaction.
+    r"""The swap leg detected inside a loop or unwind transaction.
 
-    Evidence is token-filtered and executor-proof: the sold (debt) token left the
-    account to a non-protocol counterparty and the bought (collateral) token
-    arrived from a non-protocol counterparty. Aggregator fills often settle from an
-    executor contract, so the router is recorded only when it happens to be the
-    outbound counterparty — it is never required for detection.
+    Evidence is token-filtered and executor-proof: the sold token left the
+    account to a non-protocol counterparty and the bought token arrived from a
+    non-protocol counterparty. Aggregator fills often settle from an executor
+    contract, so the router is recorded only when it happens to be the outbound
+    counterparty — it is never required for detection.
     """
 
     sold_token: str
-    r"""Token sold in the swap (the borrowed/debt token)."""
+    r"""The token leaving the account: the debt token on a loop, the collateral token on an unwind."""
 
     sold_symbol: str
     r"""Symbol of the sold token."""
@@ -58,7 +58,7 @@ class SwapInfo(BaseModel):
     r"""Amount of the sold token."""
 
     bought_token: str
-    r"""Token bought in the swap (the collateral token)."""
+    r"""The token arriving in the account: the collateral token on a loop, the debt token on an unwind."""
 
     bought_symbol: str
     r"""Symbol of the bought token."""