compass_api_sdk 2.0.21rc1__py3-none-any.whl → 2.2.1rc3__py3-none-any.whl

compass_api_sdk/models/pendleptposition.py

@@ -0,0 +1,111 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .pendledepositevent import PendleDepositEvent, PendleDepositEventTypedDict
+from .pendlewithdrawalevent import PendleWithdrawalEvent, PendleWithdrawalEventTypedDict
+from .positionpnl import PositionPnL, PositionPnLTypedDict
+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 List, Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class PendlePTPositionTypedDict(TypedDict):
+    r"""Pendle Principal Token position."""
+
+    market_address: str
+    r"""The Pendle market address."""
+    pt_address: str
+    r"""The PT (Principal Token) contract address."""
+    underlying_symbol: str
+    r"""Symbol of the underlying asset (e.g., rsETH, weETH)."""
+    pt_balance: str
+    r"""The user's PT token balance."""
+    expiry: int
+    r"""Market expiry timestamp (Unix seconds)."""
+    current_pt_to_sy_rate: str
+    r"""Current PT-to-SY exchange rate (SY received per PT if sold now)."""
+    type: Literal["PENDLE_PT"]
+    r"""The market type discriminator."""
+    pnl: NotRequired[Nullable[PositionPnLTypedDict]]
+    r"""PnL metrics (in SY terms) for this position."""
+    deposits: NotRequired[List[PendleDepositEventTypedDict]]
+    r"""All buy PT events for this position."""
+    withdrawals: NotRequired[List[PendleWithdrawalEventTypedDict]]
+    r"""All sell/redeem PT events for this position."""
+
+
+class PendlePTPosition(BaseModel):
+    r"""Pendle Principal Token position."""
+
+    market_address: str
+    r"""The Pendle market address."""
+
+    pt_address: str
+    r"""The PT (Principal Token) contract address."""
+
+    underlying_symbol: str
+    r"""Symbol of the underlying asset (e.g., rsETH, weETH)."""
+
+    pt_balance: str
+    r"""The user's PT token balance."""
+
+    expiry: int
+    r"""Market expiry timestamp (Unix seconds)."""
+
+    current_pt_to_sy_rate: str
+    r"""Current PT-to-SY exchange rate (SY received per PT if sold now)."""
+
+    TYPE: Annotated[
+        Annotated[Literal["PENDLE_PT"], AfterValidator(validate_const("PENDLE_PT"))],
+        pydantic.Field(alias="type"),
+    ] = "PENDLE_PT"
+    r"""The market type discriminator."""
+
+    pnl: OptionalNullable[PositionPnL] = UNSET
+    r"""PnL metrics (in SY terms) for this position."""
+
+    deposits: Optional[List[PendleDepositEvent]] = None
+    r"""All buy PT events for this position."""
+
+    withdrawals: Optional[List[PendleWithdrawalEvent]] = None
+    r"""All sell/redeem PT events for this position."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["pnl", "deposits", "withdrawals"]
+        nullable_fields = ["pnl"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

compass_api_sdk/models/pendleptvenue.py

@@ -0,0 +1,78 @@
+"""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 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, NotRequired, TypedDict
+
+
+class PendlePTVenueTypedDict(TypedDict):
+    r"""Venue for Pendle Principal Token (PT) positions."""
+
+    market_address: str
+    r"""The Pendle market address identifying which PT to trade."""
+    type: Literal["PENDLE_PT"]
+    r"""The venue type discriminator."""
+    token: NotRequired[Nullable[str]]
+    r"""The token to exchange for PT (only used for DEPOSIT/buy). For WITHDRAW/sell, this field must not be provided - withdrawals always return the underlying asset to ensure accurate yield fee calculation."""
+    max_slippage_percent: NotRequired[float]
+    r"""Maximum slippage allowed in percent (e.g., 1 means 1% slippage)."""
+
+
+class PendlePTVenue(BaseModel):
+    r"""Venue for Pendle Principal Token (PT) positions."""
+
+    market_address: str
+    r"""The Pendle market address identifying which PT to trade."""
+
+    TYPE: Annotated[
+        Annotated[Literal["PENDLE_PT"], AfterValidator(validate_const("PENDLE_PT"))],
+        pydantic.Field(alias="type"),
+    ] = "PENDLE_PT"
+    r"""The venue type discriminator."""
+
+    token: OptionalNullable[str] = UNSET
+    r"""The token to exchange for PT (only used for DEPOSIT/buy). For WITHDRAW/sell, this field must not be provided - withdrawals always return the underlying asset to ensure accurate yield fee calculation."""
+
+    max_slippage_percent: Optional[float] = None
+    r"""Maximum slippage allowed in percent (e.g., 1 means 1% slippage)."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["token", "max_slippage_percent"]
+        nullable_fields = ["token"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

compass_api_sdk/models/pendlewithdrawalevent.py

@@ -0,0 +1,54 @@
+"""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
+
+
+class PendleWithdrawalEventTypedDict(TypedDict):
+    r"""Pendle PT withdrawal event with cost basis at time of withdrawal."""
+
+    block_number: int
+    r"""Block number when withdrawal occurred"""
+    transaction_hash: str
+    r"""Transaction hash of the withdrawal"""
+    input_amount: str
+    r"""PT tokens sold/redeemed"""
+    input_symbol: str
+    r"""Symbol (PT)"""
+    output_amount: str
+    r"""Amount received (SY or token)"""
+    output_symbol: str
+    r"""Symbol of token received"""
+    realized_pnl: str
+    r"""Profit/loss: output value - cost basis consumed"""
+    cost_per_unit: str
+    r"""Cost basis per PT at withdrawal (SY received per PT sold)"""
+
+
+class PendleWithdrawalEvent(BaseModel):
+    r"""Pendle PT withdrawal event with cost basis at time of withdrawal."""
+
+    block_number: int
+    r"""Block number when withdrawal occurred"""
+
+    transaction_hash: str
+    r"""Transaction hash of the withdrawal"""
+
+    input_amount: str
+    r"""PT tokens sold/redeemed"""
+
+    input_symbol: str
+    r"""Symbol (PT)"""
+
+    output_amount: str
+    r"""Amount received (SY or token)"""
+
+    output_symbol: str
+    r"""Symbol of token received"""
+
+    realized_pnl: str
+    r"""Profit/loss: output value - cost basis consumed"""
+
+    cost_per_unit: str
+    r"""Cost basis per PT at withdrawal (SY received per PT sold)"""

compass_api_sdk/models/positionpnl.py

@@ -0,0 +1,52 @@
+"""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
+
+
+class PositionPnLTypedDict(TypedDict):
+    r"""Simplified PnL metrics for API response.
+
+    Historical events (deposits/withdrawals) are now at the position level, not inside
+    PnL.
+    """
+
+    total_deposited: str
+    r"""Total assets deposited over all time"""
+    current_value: str
+    r"""Current position value in underlying"""
+    unrealized_pnl: str
+    r"""current_value - cost_basis_remaining"""
+    realized_pnl: str
+    r"""Sum of profits/losses from all withdrawals"""
+    total_pnl: str
+    r"""unrealized_pnl + realized_pnl"""
+    total_pnl_percent: str
+    r"""(total_pnl / total_deposited) * 100"""
+
+
+class PositionPnL(BaseModel):
+    r"""Simplified PnL metrics for API response.
+
+    Historical events (deposits/withdrawals) are now at the position level, not inside
+    PnL.
+    """
+
+    total_deposited: str
+    r"""Total assets deposited over all time"""
+
+    current_value: str
+    r"""Current position value in underlying"""
+
+    unrealized_pnl: str
+    r"""current_value - cost_basis_remaining"""
+
+    realized_pnl: str
+    r"""Sum of profits/losses from all withdrawals"""
+
+    total_pnl: str
+    r"""unrealized_pnl + realized_pnl"""
+
+    total_pnl_percent: str
+    r"""(total_pnl / total_deposited) * 100"""

compass_api_sdk/models/safetxmessage.py

@@ -8,7 +8,7 @@ from typing_extensions import Annotated, TypedDict
 
 
 class SafeTxMessageTypedDict(TypedDict):
-    r"""The message data for a Safe transaction."""
+    r"""The message data for the transaction."""
 
     to: str
     r"""Destination address"""
@@ -19,7 +19,7 @@ class SafeTxMessageTypedDict(TypedDict):
     operation: OperationType
     r"""Safe operation types."""
     safe_tx_gas: str
-    r"""Gas for the Safe transaction"""
+    r"""Gas for the transaction"""
     base_gas: str
     r"""Base gas costs"""
     gas_price: str
@@ -29,11 +29,11 @@ class SafeTxMessageTypedDict(TypedDict):
     refund_receiver: str
     r"""Address to receive gas refund"""
     nonce: str
-    r"""Safe transaction nonce"""
+    r"""Transaction nonce"""
 
 
 class SafeTxMessage(BaseModel):
-    r"""The message data for a Safe transaction."""
+    r"""The message data for the transaction."""
 
     to: str
     r"""Destination address"""
@@ -48,7 +48,7 @@ class SafeTxMessage(BaseModel):
     r"""Safe operation types."""
 
     safe_tx_gas: Annotated[str, pydantic.Field(alias="safeTxGas")]
-    r"""Gas for the Safe transaction"""
+    r"""Gas for the transaction"""
 
     base_gas: Annotated[str, pydantic.Field(alias="baseGas")]
     r"""Base gas costs"""
@@ -63,4 +63,4 @@ class SafeTxMessage(BaseModel):
     r"""Address to receive gas refund"""
 
     nonce: str
-    r"""Safe transaction nonce"""
+    r"""Transaction nonce"""

compass_api_sdk/models/sponsorgasrequest.py

@@ -43,7 +43,7 @@ r"""The EIP-712 typed data that was signed."""
 
 class SponsorGasRequestTypedDict(TypedDict):
     owner: str
-    r"""The owner of the smart account's address."""
+    r"""The wallet address that owns the Earn Account."""
     chain: Chain
     r"""The chain to use."""
     eip_712: SponsorGasRequestEip712TypedDict
@@ -56,7 +56,7 @@ class SponsorGasRequestTypedDict(TypedDict):
 
 class SponsorGasRequest(BaseModel):
     owner: str
-    r"""The owner of the smart account's address."""
+    r"""The wallet address that owns the Earn Account."""
 
     chain: Chain
     r"""The chain to use."""

compass_api_sdk/models/v2_earn_pendle_marketsop.py

@@ -0,0 +1,105 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .chain import Chain
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from compass_api_sdk.utils import FieldMetadata, QueryParamMetadata
+from enum import Enum
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class V2EarnPendleMarketsDirection(str, Enum):
+    r"""The direction to order the results by."""
+
+    ASC = "asc"
+    DESC = "desc"
+
+
+class V2EarnPendleMarketsRequestTypedDict(TypedDict):
+    order_by: str
+    r"""The field to order the results by."""
+    direction: NotRequired[V2EarnPendleMarketsDirection]
+    r"""The direction to order the results by."""
+    offset: NotRequired[int]
+    r"""The offset of the first item to return."""
+    limit: NotRequired[int]
+    r"""The number of items to return."""
+    chain: NotRequired[Nullable[Chain]]
+    r"""Optional chain filter. If not provided, returns markets for all chains."""
+    underlying_symbol: NotRequired[Nullable[str]]
+    r"""Filter markets by underlying asset symbol (e.g., 'USDC', 'WETH')."""
+
+
+class V2EarnPendleMarketsRequest(BaseModel):
+    order_by: Annotated[
+        str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
+    ]
+    r"""The field to order the results by."""
+
+    direction: Annotated[
+        Optional[V2EarnPendleMarketsDirection],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""The direction to order the results by."""
+
+    offset: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""The offset of the first item to return."""
+
+    limit: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = None
+    r"""The number of items to return."""
+
+    chain: Annotated[
+        OptionalNullable[Chain],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
+    r"""Optional chain filter. If not provided, returns markets for all chains."""
+
+    underlying_symbol: Annotated[
+        OptionalNullable[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
+    r"""Filter markets by underlying asset symbol (e.g., 'USDC', 'WETH')."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["direction", "offset", "limit", "chain", "underlying_symbol"]
+        nullable_fields = ["chain", "underlying_symbol"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

compass_api_sdk/models/v2_earn_positionsop.py

@@ -4,8 +4,7 @@ from __future__ import annotations
 from compass_api_sdk.types import BaseModel
 from compass_api_sdk.utils import FieldMetadata, QueryParamMetadata
 from enum import Enum
-from typing import Optional
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import Annotated, TypedDict
 
 
 class V2EarnPositionsChain(str, Enum):
@@ -16,14 +15,8 @@ class V2EarnPositionsChain(str, Enum):
 
 class V2EarnPositionsRequestTypedDict(TypedDict):
     chain: V2EarnPositionsChain
-    user_address: str
-    r"""The address of the user to get vault positions for."""
-    offset: NotRequired[int]
-    r"""The offset of the first item to return."""
-    limit: NotRequired[int]
-    r"""The number of items to return."""
-    days: NotRequired[int]
-    r"""How many days back from the current time to include in the blockchain scan."""
+    owner: str
+    r"""The address of the owner of the earn account to get positions for."""
 
 
 class V2EarnPositionsRequest(BaseModel):
@@ -32,25 +25,7 @@ class V2EarnPositionsRequest(BaseModel):
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ]
 
-    user_address: Annotated[
+    owner: Annotated[
         str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))
     ]
-    r"""The address of the user to get vault positions for."""
-
-    offset: Annotated[
-        Optional[int],
-        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = None
-    r"""The offset of the first item to return."""
-
-    limit: Annotated[
-        Optional[int],
-        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = None
-    r"""The number of items to return."""
-
-    days: Annotated[
-        Optional[int],
-        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = None
-    r"""How many days back from the current time to include in the blockchain scan."""
+    r"""The address of the owner of the earn account to get positions for."""

compass_api_sdk/models/v2_earn_vaultsop.py

@@ -16,7 +16,7 @@ from typing import Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class Direction(str, Enum):
+class V2EarnVaultsDirection(str, Enum):
     r"""The direction to order the results by."""
 
     ASC = "asc"
@@ -26,7 +26,7 @@ class Direction(str, Enum):
 class V2EarnVaultsRequestTypedDict(TypedDict):
     order_by: str
     r"""The field to order the results by."""
-    direction: NotRequired[Direction]
+    direction: NotRequired[V2EarnVaultsDirection]
     r"""The direction to order the results by."""
     offset: NotRequired[int]
     r"""The offset of the first item to return."""
@@ -45,7 +45,7 @@ class V2EarnVaultsRequest(BaseModel):
     r"""The field to order the results by."""
 
     direction: Annotated[
-        Optional[Direction],
+        Optional[V2EarnVaultsDirection],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = None
     r"""The direction to order the results by."""

compass_api_sdk/models/withdrawalevent.py

@@ -0,0 +1,61 @@
+"""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
+
+
+class WithdrawalEventTypedDict(TypedDict):
+    r"""Historical withdrawal event with realized PnL.
+
+    Uses generic input/output format:
+    - Vault: input=shares, output=underlying
+    - Aave: input=aTokens, output=underlying
+    - Pendle: input=PT, output=token (varies)
+    """
+
+    block_number: int
+    r"""Block number when withdrawal occurred"""
+    transaction_hash: str
+    r"""Transaction hash of the withdrawal"""
+    input_amount: str
+    r"""Units withdrawn (shares, aTokens, PT)"""
+    input_symbol: str
+    r"""Symbol of units withdrawn"""
+    output_amount: str
+    r"""Amount received (underlying or token)"""
+    output_symbol: str
+    r"""Symbol of token received"""
+    realized_pnl: str
+    r"""Profit/loss: output value - cost basis consumed"""
+
+
+class WithdrawalEvent(BaseModel):
+    r"""Historical withdrawal event with realized PnL.
+
+    Uses generic input/output format:
+    - Vault: input=shares, output=underlying
+    - Aave: input=aTokens, output=underlying
+    - Pendle: input=PT, output=token (varies)
+    """
+
+    block_number: int
+    r"""Block number when withdrawal occurred"""
+
+    transaction_hash: str
+    r"""Transaction hash of the withdrawal"""
+
+    input_amount: str
+    r"""Units withdrawn (shares, aTokens, PT)"""
+
+    input_symbol: str
+    r"""Symbol of units withdrawn"""
+
+    output_amount: str
+    r"""Amount received (underlying or token)"""
+
+    output_symbol: str
+    r"""Symbol of token received"""
+
+    realized_pnl: str
+    r"""Profit/loss: output value - cost basis consumed"""

compass_api_sdk/types/basemodel.py

@@ -2,7 +2,8 @@
 
 from pydantic import ConfigDict, model_serializer
 from pydantic import BaseModel as PydanticBaseModel
-from typing import TYPE_CHECKING, Literal, Optional, TypeVar, Union
+from pydantic_core import core_schema
+from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, Union
 from typing_extensions import TypeAliasType, TypeAlias
 
 
@@ -35,5 +36,42 @@ else:
         "OptionalNullable", Union[Optional[Nullable[T]], Unset], type_params=(T,)
     )
 
-UnrecognizedInt: TypeAlias = int
-UnrecognizedStr: TypeAlias = str
+
+class UnrecognizedStr(str):
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+        # Make UnrecognizedStr only work in lax mode, not strict mode
+        # This makes it a "fallback" option when more specific types (like Literals) don't match
+        def validate_lax(v: Any) -> 'UnrecognizedStr':
+            if isinstance(v, cls):
+                return v
+            return cls(str(v))
+
+        # Use lax_or_strict_schema where strict always fails
+        # This forces Pydantic to prefer other union members in strict mode
+        # and only fall back to UnrecognizedStr in lax mode
+        return core_schema.lax_or_strict_schema(
+            lax_schema=core_schema.chain_schema([
+                core_schema.str_schema(),
+                core_schema.no_info_plain_validator_function(validate_lax)
+            ]),
+            strict_schema=core_schema.none_schema(),  # Always fails in strict mode
+        )
+
+
+class UnrecognizedInt(int):
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+        # Make UnrecognizedInt only work in lax mode, not strict mode
+        # This makes it a "fallback" option when more specific types (like Literals) don't match
+        def validate_lax(v: Any) -> 'UnrecognizedInt':
+            if isinstance(v, cls):
+                return v
+            return cls(int(v))
+        return core_schema.lax_or_strict_schema(
+            lax_schema=core_schema.chain_schema([
+                core_schema.int_schema(),
+                core_schema.no_info_plain_validator_function(validate_lax)
+            ]),
+            strict_schema=core_schema.none_schema(),  # Always fails in strict mode
+        )