compass_api_sdk 0.9.52__py3-none-any.whl → 1.0.1__py3-none-any.whl

compass_api_sdk/models/{compass_api_backend_models_aerodrome_slipstream_transact_request_liquidity_provision_mint_aerodromeslipstreammintliquidityprovisionrequest.py → aerodromeslipstreammintliquidityprovisionrequest.py}

@@ -18,71 +18,63 @@ from typing import Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0DesiredTypedDict = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0DesiredTypedDict",
+AerodromeSlipstreamMintLiquidityProvisionRequestAmount0DesiredTypedDict = TypeAliasType(
+    "AerodromeSlipstreamMintLiquidityProvisionRequestAmount0DesiredTypedDict",
     Union[float, str],
 )
 r"""The desired amount of the first token to deposit"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0Desired = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0Desired",
-    Union[float, str],
+AerodromeSlipstreamMintLiquidityProvisionRequestAmount0Desired = TypeAliasType(
+    "AerodromeSlipstreamMintLiquidityProvisionRequestAmount0Desired", Union[float, str]
 )
 r"""The desired amount of the first token to deposit"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1DesiredTypedDict = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1DesiredTypedDict",
+AerodromeSlipstreamMintLiquidityProvisionRequestAmount1DesiredTypedDict = TypeAliasType(
+    "AerodromeSlipstreamMintLiquidityProvisionRequestAmount1DesiredTypedDict",
     Union[float, str],
 )
 r"""The desired amount of the second token to deposit"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1Desired = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1Desired",
-    Union[float, str],
+AerodromeSlipstreamMintLiquidityProvisionRequestAmount1Desired = TypeAliasType(
+    "AerodromeSlipstreamMintLiquidityProvisionRequestAmount1Desired", Union[float, str]
 )
 r"""The desired amount of the second token to deposit"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0MinTypedDict = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0MinTypedDict",
+AerodromeSlipstreamMintLiquidityProvisionRequestAmount0MinTypedDict = TypeAliasType(
+    "AerodromeSlipstreamMintLiquidityProvisionRequestAmount0MinTypedDict",
     Union[float, str],
 )
 r"""The minimum amount of the first token to deposit"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0Min = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0Min",
-    Union[float, str],
+AerodromeSlipstreamMintLiquidityProvisionRequestAmount0Min = TypeAliasType(
+    "AerodromeSlipstreamMintLiquidityProvisionRequestAmount0Min", Union[float, str]
 )
 r"""The minimum amount of the first token to deposit"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1MinTypedDict = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1MinTypedDict",
+AerodromeSlipstreamMintLiquidityProvisionRequestAmount1MinTypedDict = TypeAliasType(
+    "AerodromeSlipstreamMintLiquidityProvisionRequestAmount1MinTypedDict",
     Union[float, str],
 )
 r"""The minimum amount of the second token to deposit"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1Min = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1Min",
-    Union[float, str],
+AerodromeSlipstreamMintLiquidityProvisionRequestAmount1Min = TypeAliasType(
+    "AerodromeSlipstreamMintLiquidityProvisionRequestAmount1Min", Union[float, str]
 )
 r"""The minimum amount of the second token to deposit"""
 
 
-class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestChain(
-    str, Enum
-):
+class AerodromeSlipstreamMintLiquidityProvisionRequestChain(str, Enum):
     BASE = "base"
 
 
-class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestTypedDict(
-    TypedDict
-):
+class AerodromeSlipstreamMintLiquidityProvisionRequestTypedDict(TypedDict):
     r"""Request model for minting a new liquidity position."""
 
     token0: TokenEnum
@@ -103,15 +95,19 @@ class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisio
     r"""The lower tick of the range to mint the position in"""
     tick_upper: int
     r"""The upper tick of the range to mint the position in"""
-    amount0_desired: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0DesiredTypedDict
+    amount0_desired: (
+        AerodromeSlipstreamMintLiquidityProvisionRequestAmount0DesiredTypedDict
+    )
     r"""The desired amount of the first token to deposit"""
-    amount1_desired: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1DesiredTypedDict
+    amount1_desired: (
+        AerodromeSlipstreamMintLiquidityProvisionRequestAmount1DesiredTypedDict
+    )
     r"""The desired amount of the second token to deposit"""
-    amount0_min: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0MinTypedDict
+    amount0_min: AerodromeSlipstreamMintLiquidityProvisionRequestAmount0MinTypedDict
     r"""The minimum amount of the first token to deposit"""
-    amount1_min: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1MinTypedDict
+    amount1_min: AerodromeSlipstreamMintLiquidityProvisionRequestAmount1MinTypedDict
     r"""The minimum amount of the second token to deposit"""
-    chain: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestChain
+    chain: AerodromeSlipstreamMintLiquidityProvisionRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["AERODROME_SLIPSTREAM_MINT_LIQUIDITY_PROVISION"]
@@ -119,9 +115,7 @@ class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisio
     r"""The address that will receive the LP tokens"""
 
 
-class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequest(
-    BaseModel
-):
+class AerodromeSlipstreamMintLiquidityProvisionRequest(BaseModel):
     r"""Request model for minting a new liquidity position."""
 
     token0: TokenEnum
@@ -147,19 +141,19 @@ class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisio
     tick_upper: int
     r"""The upper tick of the range to mint the position in"""
 
-    amount0_desired: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0Desired
+    amount0_desired: AerodromeSlipstreamMintLiquidityProvisionRequestAmount0Desired
     r"""The desired amount of the first token to deposit"""
 
-    amount1_desired: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1Desired
+    amount1_desired: AerodromeSlipstreamMintLiquidityProvisionRequestAmount1Desired
     r"""The desired amount of the second token to deposit"""
 
-    amount0_min: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount0Min
+    amount0_min: AerodromeSlipstreamMintLiquidityProvisionRequestAmount0Min
     r"""The minimum amount of the first token to deposit"""
 
-    amount1_min: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestAmount1Min
+    amount1_min: AerodromeSlipstreamMintLiquidityProvisionRequestAmount1Min
     r"""The minimum amount of the second token to deposit"""
 
-    chain: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestLiquidityProvisionMintAerodromeSlipstreamMintLiquidityProvisionRequestChain
+    chain: AerodromeSlipstreamMintLiquidityProvisionRequestChain
 
     sender: str
     r"""The address of the transaction sender."""

compass_api_sdk/models/{compass_api_backend_models_aerodrome_slipstream_transact_request_swap_sell_exactly_aerodromeslipstreamsellexactlyrequest.py → aerodromeslipstreamsellexactlyrequest.py}

@@ -11,43 +11,35 @@ from typing import Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountInTypedDict = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountInTypedDict",
-    Union[float, str],
+AerodromeSlipstreamSellExactlyRequestAmountInTypedDict = TypeAliasType(
+    "AerodromeSlipstreamSellExactlyRequestAmountInTypedDict", Union[float, str]
 )
 r"""The amount of the token to swap from"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountIn = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountIn",
-    Union[float, str],
+AerodromeSlipstreamSellExactlyRequestAmountIn = TypeAliasType(
+    "AerodromeSlipstreamSellExactlyRequestAmountIn", Union[float, str]
 )
 r"""The amount of the token to swap from"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountOutMinimumTypedDict = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountOutMinimumTypedDict",
-    Union[float, str],
+AerodromeSlipstreamSellExactlyRequestAmountOutMinimumTypedDict = TypeAliasType(
+    "AerodromeSlipstreamSellExactlyRequestAmountOutMinimumTypedDict", Union[float, str]
 )
 r"""The minimum amount of the token to swap to, defaults to 0"""
 
 
-CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountOutMinimum = TypeAliasType(
-    "CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountOutMinimum",
-    Union[float, str],
+AerodromeSlipstreamSellExactlyRequestAmountOutMinimum = TypeAliasType(
+    "AerodromeSlipstreamSellExactlyRequestAmountOutMinimum", Union[float, str]
 )
 r"""The minimum amount of the token to swap to, defaults to 0"""
 
 
-class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestChain(
-    str, Enum
-):
+class AerodromeSlipstreamSellExactlyRequestChain(str, Enum):
     BASE = "base"
 
 
-class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestTypedDict(
-    TypedDict
-):
+class AerodromeSlipstreamSellExactlyRequestTypedDict(TypedDict):
     r"""Request model for selling exactly an amount of tokens."""
 
     token_in: TokenEnum
@@ -64,21 +56,19 @@ class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAe
     """
     tick_spacing: int
     r"""The tick spacing of the pool"""
-    amount_in: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountInTypedDict
+    amount_in: AerodromeSlipstreamSellExactlyRequestAmountInTypedDict
     r"""The amount of the token to swap from"""
-    chain: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestChain
+    chain: AerodromeSlipstreamSellExactlyRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["AERODROME_SLIPSTREAM_SELL_EXACTLY"]
     amount_out_minimum: NotRequired[
-        CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountOutMinimumTypedDict
+        AerodromeSlipstreamSellExactlyRequestAmountOutMinimumTypedDict
     ]
     r"""The minimum amount of the token to swap to, defaults to 0"""
 
 
-class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequest(
-    BaseModel
-):
+class AerodromeSlipstreamSellExactlyRequest(BaseModel):
     r"""Request model for selling exactly an amount of tokens."""
 
     token_in: TokenEnum
@@ -98,10 +88,10 @@ class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAe
     tick_spacing: int
     r"""The tick spacing of the pool"""
 
-    amount_in: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountIn
+    amount_in: AerodromeSlipstreamSellExactlyRequestAmountIn
     r"""The amount of the token to swap from"""
 
-    chain: CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestChain
+    chain: AerodromeSlipstreamSellExactlyRequestChain
 
     sender: str
     r"""The address of the transaction sender."""
@@ -115,6 +105,6 @@ class CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAe
     ] = "AERODROME_SLIPSTREAM_SELL_EXACTLY"
 
     amount_out_minimum: Optional[
-        CompassAPIBackendModelsAerodromeSlipstreamTransactRequestSwapSellExactlyAerodromeSlipstreamSellExactlyRequestAmountOutMinimum
+        AerodromeSlipstreamSellExactlyRequestAmountOutMinimum
     ] = None
     r"""The minimum amount of the token to swap to, defaults to 0"""

compass_api_sdk/models/aerodromeslipstreamwithdrawliquidityprovisionrequest.py

@@ -0,0 +1,66 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from compass_api_sdk.types import BaseModel
+from compass_api_sdk.utils import validate_const
+from enum import Enum
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
+
+
+AerodromeSlipstreamWithdrawLiquidityProvisionRequestPercentageForWithdrawalTypedDict = TypeAliasType(
+    "AerodromeSlipstreamWithdrawLiquidityProvisionRequestPercentageForWithdrawalTypedDict",
+    Union[float, str],
+)
+r"""How much liquidity to take out in percentage."""
+
+
+AerodromeSlipstreamWithdrawLiquidityProvisionRequestPercentageForWithdrawal = (
+    TypeAliasType(
+        "AerodromeSlipstreamWithdrawLiquidityProvisionRequestPercentageForWithdrawal",
+        Union[float, str],
+    )
+)
+r"""How much liquidity to take out in percentage."""
+
+
+class AerodromeSlipstreamWithdrawLiquidityProvisionRequestChain(str, Enum):
+    BASE = "base"
+
+
+class AerodromeSlipstreamWithdrawLiquidityProvisionRequestTypedDict(TypedDict):
+    token_id: int
+    r"""Token ID of the NFT representing the liquidity provisioned position."""
+    percentage_for_withdrawal: AerodromeSlipstreamWithdrawLiquidityProvisionRequestPercentageForWithdrawalTypedDict
+    r"""How much liquidity to take out in percentage."""
+    chain: AerodromeSlipstreamWithdrawLiquidityProvisionRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    action_type: Literal["AERODROME_SLIPSTREAM_WITHDRAW_LIQUIDITY_PROVISION"]
+
+
+class AerodromeSlipstreamWithdrawLiquidityProvisionRequest(BaseModel):
+    token_id: int
+    r"""Token ID of the NFT representing the liquidity provisioned position."""
+
+    percentage_for_withdrawal: (
+        AerodromeSlipstreamWithdrawLiquidityProvisionRequestPercentageForWithdrawal
+    )
+    r"""How much liquidity to take out in percentage."""
+
+    chain: AerodromeSlipstreamWithdrawLiquidityProvisionRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["AERODROME_SLIPSTREAM_WITHDRAW_LIQUIDITY_PROVISION"]],
+            AfterValidator(
+                validate_const("AERODROME_SLIPSTREAM_WITHDRAW_LIQUIDITY_PROVISION")
+            ),
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "AERODROME_SLIPSTREAM_WITHDRAW_LIQUIDITY_PROVISION"

compass_api_sdk/models/batcheduseroperationsrequest.py

@@ -0,0 +1,36 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .useroperation import UserOperation, UserOperationTypedDict
+from compass_api_sdk.types import BaseModel
+from enum import Enum
+from typing import List
+from typing_extensions import TypedDict
+
+
+class BatchedUserOperationsRequestChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
+class BatchedUserOperationsRequestTypedDict(TypedDict):
+    r"""Request model for batching user operations."""
+
+    chain: BatchedUserOperationsRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    operations: List[UserOperationTypedDict]
+    r"""List of possible user operations"""
+
+
+class BatchedUserOperationsRequest(BaseModel):
+    r"""Request model for batching user operations."""
+
+    chain: BatchedUserOperationsRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    operations: List[UserOperation]
+    r"""List of possible user operations"""

compass_api_sdk/models/{compass_api_backend_models_aave_read_response_historical_transactions_borrow.py → borrow.py}

@@ -18,9 +18,7 @@ class Borrowratemode(int, Enum):
     TWO = 2
 
 
-class CompassAPIBackendModelsAaveReadResponseHistoricalTransactionsBorrowTypedDict(
-    TypedDict
-):
+class BorrowTypedDict(TypedDict):
     id: str
     r"""The id of a historical transaction on aave"""
     timestamp: int
@@ -39,7 +37,7 @@ class CompassAPIBackendModelsAaveReadResponseHistoricalTransactionsBorrowTypedDi
     r"""The type of transaction"""
 
 
-class CompassAPIBackendModelsAaveReadResponseHistoricalTransactionsBorrow(BaseModel):
+class Borrow(BaseModel):
     id: str
     r"""The id of a historical transaction on aave"""
 

compass_api_sdk/models/bundlertransactionresponse.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .unsignedmulticalltransaction import (
+    UnsignedMulticallTransaction,
+    UnsignedMulticallTransactionTypedDict,
+)
+from compass_api_sdk.types import BaseModel
+from typing_extensions import TypedDict
+
+
+class BundlerTransactionResponseTypedDict(TypedDict):
+    transaction: UnsignedMulticallTransactionTypedDict
+
+
+class BundlerTransactionResponse(BaseModel):
+    transaction: UnsignedMulticallTransaction

compass_api_sdk/models/{compass_api_backend_config_chain_chain.py → chain.py}

@@ -4,7 +4,7 @@ from __future__ import annotations
 from enum import Enum
 
 
-class CompassAPIBackendConfigChainChain(str, Enum):
+class Chain(str, Enum):
     r"""The chain to use."""
 
     BASE = "base"

compass_api_sdk/models/compass_api_backend_models_vaults_read_response_vault_userposition.py

@@ -6,11 +6,15 @@ from typing_extensions import TypedDict
 
 
 class CompassAPIBackendModelsVaultsReadResponseVaultUserPositionTypedDict(TypedDict):
-    shares: int
-    token_amount: str
+    amount_of_shares: str
+    r"""The number of vault share tokens representing the user’s proportional ownership of the assets in the vault."""
+    amount_in_underlying_token: str
+    r"""The equivalent value of the user’s vault shares, denominated in the vault’s underlying asset (deposit token)."""
 
 
 class CompassAPIBackendModelsVaultsReadResponseVaultUserPosition(BaseModel):
-    shares: int
+    amount_of_shares: str
+    r"""The number of vault share tokens representing the user’s proportional ownership of the assets in the vault."""
 
-    token_amount: str
+    amount_in_underlying_token: str
+    r"""The equivalent value of the user’s vault shares, denominated in the vault’s underlying asset (deposit token)."""

compass_api_sdk/models/cooldownposition.py

@@ -0,0 +1,35 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from compass_api_sdk.types import BaseModel
+from datetime import datetime
+from typing import Union
+from typing_extensions import TypeAliasType, TypedDict
+
+
+CooldownEndTypedDict = TypeAliasType("CooldownEndTypedDict", Union[datetime, bool])
+r"""When the cooldown period ends. ISO 8601 format. UTC timezone."""
+
+
+CooldownEnd = TypeAliasType("CooldownEnd", Union[datetime, bool])
+r"""When the cooldown period ends. ISO 8601 format. UTC timezone."""
+
+
+class CooldownPositionTypedDict(TypedDict):
+    amount_in_underlying_asset: str
+    r"""The amount of USDe currently in a cooldown period."""
+    cooldown_end: CooldownEndTypedDict
+    r"""When the cooldown period ends. ISO 8601 format. UTC timezone."""
+    can_be_withdrawn: bool
+    r"""Whether the USDe in cooldown can be withdrawn at this moment."""
+
+
+class CooldownPosition(BaseModel):
+    amount_in_underlying_asset: str
+    r"""The amount of USDe currently in a cooldown period."""
+
+    cooldown_end: CooldownEnd
+    r"""When the cooldown period ends. ISO 8601 format. UTC timezone."""
+
+    can_be_withdrawn: bool
+    r"""Whether the USDe in cooldown can be withdrawn at this moment."""

compass_api_sdk/models/ethenadepositparams.py

@@ -0,0 +1,82 @@
+"""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, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+EthenaDepositParamsAmountTypedDict = TypeAliasType(
+    "EthenaDepositParamsAmountTypedDict", Union[float, str]
+)
+r"""The amount of USDe to deposit into Ethena's vault."""
+
+
+EthenaDepositParamsAmount = TypeAliasType(
+    "EthenaDepositParamsAmount", Union[float, str]
+)
+r"""The amount of USDe to deposit into Ethena's vault."""
+
+
+class EthenaDepositParamsTypedDict(TypedDict):
+    amount: EthenaDepositParamsAmountTypedDict
+    r"""The amount of USDe to deposit into Ethena's vault."""
+    action_type: Literal["ETHENA_DEPOSIT"]
+    receiver: NotRequired[Nullable[str]]
+    r"""The address which will receive the shares (sUSDe) from Ethena's vault representing their proportional ownership of the vault's assets. Defaults to the sender."""
+
+
+class EthenaDepositParams(BaseModel):
+    amount: EthenaDepositParamsAmount
+    r"""The amount of USDe to deposit into Ethena's vault."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["ETHENA_DEPOSIT"]],
+            AfterValidator(validate_const("ETHENA_DEPOSIT")),
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "ETHENA_DEPOSIT"
+
+    receiver: OptionalNullable[str] = UNSET
+    r"""The address which will receive the shares (sUSDe) from Ethena's vault representing their proportional ownership of the vault's assets. Defaults to the sender."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["action_type", "receiver"]
+        nullable_fields = ["receiver"]
+        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/ethenadepositrequest.py

@@ -0,0 +1,95 @@
+"""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
+from enum import Enum
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+EthenaDepositRequestAmountTypedDict = TypeAliasType(
+    "EthenaDepositRequestAmountTypedDict", Union[float, str]
+)
+r"""The amount of USDe to deposit into Ethena's vault."""
+
+
+EthenaDepositRequestAmount = TypeAliasType(
+    "EthenaDepositRequestAmount", Union[float, str]
+)
+r"""The amount of USDe to deposit into Ethena's vault."""
+
+
+class EthenaDepositRequestChain(str, Enum):
+    ETHEREUM = "ethereum"
+
+
+class EthenaDepositRequestTypedDict(TypedDict):
+    amount: EthenaDepositRequestAmountTypedDict
+    r"""The amount of USDe to deposit into Ethena's vault."""
+    chain: EthenaDepositRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    action_type: Literal["ETHENA_DEPOSIT"]
+    receiver: NotRequired[Nullable[str]]
+    r"""The address which will receive the shares (sUSDe) from Ethena's vault representing their proportional ownership of the vault's assets. Defaults to the sender."""
+
+
+class EthenaDepositRequest(BaseModel):
+    amount: EthenaDepositRequestAmount
+    r"""The amount of USDe to deposit into Ethena's vault."""
+
+    chain: EthenaDepositRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["ETHENA_DEPOSIT"]],
+            AfterValidator(validate_const("ETHENA_DEPOSIT")),
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "ETHENA_DEPOSIT"
+
+    receiver: OptionalNullable[str] = UNSET
+    r"""The address which will receive the shares (sUSDe) from Ethena's vault representing their proportional ownership of the vault's assets. Defaults to the sender."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["action_type", "receiver"]
+        nullable_fields = ["receiver"]
+        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