compass_api_sdk 0.9.13__py3-none-any.whl → 0.9.14__py3-none-any.whl

compass_api_sdk/_version.py

@@ -3,10 +3,10 @@
 import importlib.metadata
 
 __title__: str = "compass_api_sdk"
-__version__: str = "0.9.13"
+__version__: str = "0.9.14"
 __openapi_doc_version__: str = "0.0.1"
-__gen_version__: str = "2.623.2"
-__user_agent__: str = "speakeasy-sdk/python 0.9.13 2.623.2 0.0.1 compass_api_sdk"
+__gen_version__: str = "2.628.0"
+__user_agent__: str = "speakeasy-sdk/python 0.9.14 2.628.0 0.0.1 compass_api_sdk"
 
 try:
     if __package__ is not None:

compass_api_sdk/models/__init__.py

@@ -79,6 +79,18 @@ if TYPE_CHECKING:
         AaveLiquidityChangeResponse,
         AaveLiquidityChangeResponseTypedDict,
     )
+    from .aavelooprequest import (
+        AaveLoopRequest,
+        AaveLoopRequestTypedDict,
+        InitialCollateralAmount,
+        InitialCollateralAmountTypedDict,
+        LoanToValue,
+        LoanToValueTypedDict,
+        MaxSlippagePercent,
+        MaxSlippagePercentTypedDict,
+        Multiplier,
+        MultiplierTypedDict,
+    )
     from .aaverateresponse import AaveRateResponse, AaveRateResponseTypedDict
     from .aaverepayparams import (
         AaveRepayParams,
@@ -525,6 +537,18 @@ if TYPE_CHECKING:
         MorphoWithdrawRequestTypedDict,
     )
     from .movement10percent import Movement10Percent, Movement10PercentTypedDict
+    from .multicallauthorizationrequest import (
+        MulticallAuthorizationRequest,
+        MulticallAuthorizationRequestTypedDict,
+    )
+    from .multicallauthorizationresponse import (
+        MulticallAuthorizationResponse,
+        MulticallAuthorizationResponseTypedDict,
+    )
+    from .multicallexecuterequest import (
+        MulticallExecuteRequest,
+        MulticallExecuteRequestTypedDict,
+    )
     from .openposition import OpenPosition, OpenPositionTypedDict
     from .pendle_marketop import (
         PendleMarketChain,
@@ -978,6 +1002,8 @@ __all__ = [
     "AaveLiquidityChangeResponse",
     "AaveLiquidityChangeResponseTypedDict",
     "AaveLiquidityChangeToken",
+    "AaveLoopRequest",
+    "AaveLoopRequestTypedDict",
     "AaveRateChain",
     "AaveRateRequest",
     "AaveRateRequestTypedDict",
@@ -1209,11 +1235,15 @@ __all__ = [
     "IncreaseAllowanceRequestToken",
     "IncreaseAllowanceRequestTokenTypedDict",
     "IncreaseAllowanceRequestTypedDict",
+    "InitialCollateralAmount",
+    "InitialCollateralAmountTypedDict",
     "InterestRateMode",
     "LiquidationCall",
     "LiquidationCallTypedDict",
     "Liquidity",
     "LiquidityTypedDict",
+    "LoanToValue",
+    "LoanToValueTypedDict",
     "Loc",
     "LocTypedDict",
     "LpBalance",
@@ -1222,6 +1252,8 @@ __all__ = [
     "MarketPosition",
     "MarketPositionTypedDict",
     "MarketTypedDict",
+    "MaxSlippagePercent",
+    "MaxSlippagePercentTypedDict",
     "Metadata",
     "MetadataTypedDict",
     "MorphoBorrowParams",
@@ -1320,6 +1352,14 @@ __all__ = [
     "MorphoWithdrawRequestTypedDict",
     "Movement10Percent",
     "Movement10PercentTypedDict",
+    "MulticallAuthorizationRequest",
+    "MulticallAuthorizationRequestTypedDict",
+    "MulticallAuthorizationResponse",
+    "MulticallAuthorizationResponseTypedDict",
+    "MulticallExecuteRequest",
+    "MulticallExecuteRequestTypedDict",
+    "Multiplier",
+    "MultiplierTypedDict",
     "OpenPosition",
     "OpenPositionTypedDict",
     "PendleAddLiquidityParams",
@@ -1689,6 +1729,16 @@ _dynamic_imports: dict[str, str] = {
     "TransactionTypedDict": ".aavehistoricaltransactionsresponse",
     "AaveLiquidityChangeResponse": ".aaveliquiditychangeresponse",
     "AaveLiquidityChangeResponseTypedDict": ".aaveliquiditychangeresponse",
+    "AaveLoopRequest": ".aavelooprequest",
+    "AaveLoopRequestTypedDict": ".aavelooprequest",
+    "InitialCollateralAmount": ".aavelooprequest",
+    "InitialCollateralAmountTypedDict": ".aavelooprequest",
+    "LoanToValue": ".aavelooprequest",
+    "LoanToValueTypedDict": ".aavelooprequest",
+    "MaxSlippagePercent": ".aavelooprequest",
+    "MaxSlippagePercentTypedDict": ".aavelooprequest",
+    "Multiplier": ".aavelooprequest",
+    "MultiplierTypedDict": ".aavelooprequest",
     "AaveRateResponse": ".aaverateresponse",
     "AaveRateResponseTypedDict": ".aaverateresponse",
     "AaveRepayParams": ".aaverepayparams",
@@ -2004,6 +2054,12 @@ _dynamic_imports: dict[str, str] = {
     "MorphoWithdrawRequestTypedDict": ".morphowithdrawrequest",
     "Movement10Percent": ".movement10percent",
     "Movement10PercentTypedDict": ".movement10percent",
+    "MulticallAuthorizationRequest": ".multicallauthorizationrequest",
+    "MulticallAuthorizationRequestTypedDict": ".multicallauthorizationrequest",
+    "MulticallAuthorizationResponse": ".multicallauthorizationresponse",
+    "MulticallAuthorizationResponseTypedDict": ".multicallauthorizationresponse",
+    "MulticallExecuteRequest": ".multicallexecuterequest",
+    "MulticallExecuteRequestTypedDict": ".multicallexecuterequest",
     "OpenPosition": ".openposition",
     "OpenPositionTypedDict": ".openposition",
     "PendleMarketChain": ".pendle_marketop",

compass_api_sdk/models/aavelooprequest.py

@@ -0,0 +1,113 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .chain import Chain
+from .signedauthorization import SignedAuthorization, SignedAuthorizationTypedDict
+from .token_enum import TokenEnum
+from compass_api_sdk.types import BaseModel
+from typing import Union
+from typing_extensions import TypeAliasType, TypedDict
+
+
+InitialCollateralAmountTypedDict = TypeAliasType(
+    "InitialCollateralAmountTypedDict", Union[float, str]
+)
+r"""Amount of collateral token to supply to Aave"""
+
+
+InitialCollateralAmount = TypeAliasType("InitialCollateralAmount", Union[float, str])
+r"""Amount of collateral token to supply to Aave"""
+
+
+MultiplierTypedDict = TypeAliasType("MultiplierTypedDict", Union[float, str])
+r"""Total loop collateral will be calculated as `multiplier` x `initial_collateral_amount`"""
+
+
+Multiplier = TypeAliasType("Multiplier", Union[float, str])
+r"""Total loop collateral will be calculated as `multiplier` x `initial_collateral_amount`"""
+
+
+MaxSlippagePercentTypedDict = TypeAliasType(
+    "MaxSlippagePercentTypedDict", Union[float, str]
+)
+r"""Maximum allowed slippage for token swaps in percentage"""
+
+
+MaxSlippagePercent = TypeAliasType("MaxSlippagePercent", Union[float, str])
+r"""Maximum allowed slippage for token swaps in percentage"""
+
+
+LoanToValueTypedDict = TypeAliasType("LoanToValueTypedDict", Union[float, str])
+r"""Loan To Value percentage of the loop"""
+
+
+LoanToValue = TypeAliasType("LoanToValue", Union[float, str])
+r"""Loan To Value percentage of the loop"""
+
+
+class AaveLoopRequestTypedDict(TypedDict):
+    r"""Request model for executing an Aave loop strategy."""
+
+    chain: Chain
+    r"""The chain to use."""
+    sender: str
+    r"""The address of the transaction sender."""
+    signed_authorization: SignedAuthorizationTypedDict
+    collateral_token: TokenEnum
+    r"""A class representing the token.
+
+    This class is used to represent the token in the system. Notice individual
+    endpoints' documentation where per chain tokens are presented.
+    """
+    borrow_token: TokenEnum
+    r"""A class representing the token.
+
+    This class is used to represent the token in the system. Notice individual
+    endpoints' documentation where per chain tokens are presented.
+    """
+    initial_collateral_amount: InitialCollateralAmountTypedDict
+    r"""Amount of collateral token to supply to Aave"""
+    multiplier: MultiplierTypedDict
+    r"""Total loop collateral will be calculated as `multiplier` x `initial_collateral_amount`"""
+    max_slippage_percent: MaxSlippagePercentTypedDict
+    r"""Maximum allowed slippage for token swaps in percentage"""
+    loan_to_value: LoanToValueTypedDict
+    r"""Loan To Value percentage of the loop"""
+
+
+class AaveLoopRequest(BaseModel):
+    r"""Request model for executing an Aave loop strategy."""
+
+    chain: Chain
+    r"""The chain to use."""
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    signed_authorization: SignedAuthorization
+
+    collateral_token: TokenEnum
+    r"""A class representing the token.
+
+    This class is used to represent the token in the system. Notice individual
+    endpoints' documentation where per chain tokens are presented.
+    """
+
+    borrow_token: TokenEnum
+    r"""A class representing the token.
+
+    This class is used to represent the token in the system. Notice individual
+    endpoints' documentation where per chain tokens are presented.
+    """
+
+    initial_collateral_amount: InitialCollateralAmount
+    r"""Amount of collateral token to supply to Aave"""
+
+    multiplier: Multiplier
+    r"""Total loop collateral will be calculated as `multiplier` x `initial_collateral_amount`"""
+
+    max_slippage_percent: MaxSlippagePercent
+    r"""Maximum allowed slippage for token swaps in percentage"""
+
+    loan_to_value: LoanToValue
+    r"""Loan To Value percentage of the loop"""

compass_api_sdk/models/compass_api_backend_models_morpho_read_response_get_market_marketstate.py

@@ -15,41 +15,61 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 class CompassAPIBackendModelsMorphoReadResponseGetMarketMarketStateTypedDict(TypedDict):
     utilization: str
-    collateral_assets: str
     borrow_assets: str
-    borrow_assets_usd: str
     liquidity_assets: str
-    liquidity_assets_usd: str
     total_liquidity: str
-    total_liquidity_usd: str
+    collateral_assets: NotRequired[Nullable[str]]
     collateral_assets_usd: NotRequired[Nullable[str]]
+    borrow_assets_usd: NotRequired[Nullable[str]]
+    liquidity_assets_usd: NotRequired[Nullable[str]]
+    total_liquidity_usd: NotRequired[Nullable[str]]
 
 
 class CompassAPIBackendModelsMorphoReadResponseGetMarketMarketState(BaseModel):
     utilization: str
 
-    collateral_assets: Annotated[str, pydantic.Field(alias="collateralAssets")]
-
     borrow_assets: Annotated[str, pydantic.Field(alias="borrowAssets")]
 
-    borrow_assets_usd: Annotated[str, pydantic.Field(alias="borrowAssetsUsd")]
-
     liquidity_assets: Annotated[str, pydantic.Field(alias="liquidityAssets")]
 
-    liquidity_assets_usd: Annotated[str, pydantic.Field(alias="liquidityAssetsUsd")]
-
     total_liquidity: Annotated[str, pydantic.Field(alias="totalLiquidity")]
 
-    total_liquidity_usd: Annotated[str, pydantic.Field(alias="totalLiquidityUsd")]
+    collateral_assets: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="collateralAssets")
+    ] = UNSET
 
     collateral_assets_usd: Annotated[
         OptionalNullable[str], pydantic.Field(alias="collateralAssetsUsd")
     ] = UNSET
 
+    borrow_assets_usd: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="borrowAssetsUsd")
+    ] = UNSET
+
+    liquidity_assets_usd: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="liquidityAssetsUsd")
+    ] = UNSET
+
+    total_liquidity_usd: Annotated[
+        OptionalNullable[str], pydantic.Field(alias="totalLiquidityUsd")
+    ] = UNSET
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["collateralAssetsUsd"]
-        nullable_fields = ["collateralAssetsUsd"]
+        optional_fields = [
+            "collateralAssets",
+            "collateralAssetsUsd",
+            "borrowAssetsUsd",
+            "liquidityAssetsUsd",
+            "totalLiquidityUsd",
+        ]
+        nullable_fields = [
+            "collateralAssets",
+            "collateralAssetsUsd",
+            "borrowAssetsUsd",
+            "liquidityAssetsUsd",
+            "totalLiquidityUsd",
+        ]
         null_default_fields = []
 
         serialized = handler(self)

compass_api_sdk/models/metadata.py

@@ -10,17 +10,11 @@ from typing_extensions import Annotated, TypedDict
 
 
 class MetadataTypedDict(TypedDict):
-    description: Nullable[str]
-    image: Nullable[str]
     forum_link: Nullable[str]
     curators: List[CuratorTypedDict]
 
 
 class Metadata(BaseModel):
-    description: Nullable[str]
-
-    image: Nullable[str]
-
     forum_link: Annotated[Nullable[str], pydantic.Field(alias="forumLink")]
 
     curators: List[Curator]
@@ -28,7 +22,7 @@ class Metadata(BaseModel):
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = []
-        nullable_fields = ["description", "image", "forumLink"]
+        nullable_fields = ["forumLink"]
         null_default_fields = []
 
         serialized = handler(self)

compass_api_sdk/models/multicallauthorizationrequest.py

@@ -0,0 +1,39 @@
+"""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
+from typing_extensions import TypedDict
+
+
+class MulticallAuthorizationRequestTypedDict(TypedDict):
+    r"""Request model for getting a multicall authorization.
+
+    This model is used to authorize a sender address to perform multicall operations,
+    allowing it to call multiple functions on multiple contracts in a single
+    transaction.
+
+    Only needs to be done once per an EOA.
+    """
+
+    chain: Chain
+    r"""The chain to use."""
+    sender: str
+    r"""The Ethereum address to use for authorization"""
+
+
+class MulticallAuthorizationRequest(BaseModel):
+    r"""Request model for getting a multicall authorization.
+
+    This model is used to authorize a sender address to perform multicall operations,
+    allowing it to call multiple functions on multiple contracts in a single
+    transaction.
+
+    Only needs to be done once per an EOA.
+    """
+
+    chain: Chain
+    r"""The chain to use."""
+
+    sender: str
+    r"""The Ethereum address to use for authorization"""

compass_api_sdk/models/multicallauthorizationresponse.py

@@ -0,0 +1,30 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from compass_api_sdk.types import BaseModel
+import pydantic
+from typing_extensions import Annotated, TypedDict
+
+
+class MulticallAuthorizationResponseTypedDict(TypedDict):
+    r"""Response model for multicall authorization."""
+
+    nonce: int
+    r"""A unique nonce value for this authorization"""
+    address: str
+    r"""The Ethereum address authorized for multicall"""
+    chain_id: int
+    r"""The chain ID for the blockchain network"""
+
+
+class MulticallAuthorizationResponse(BaseModel):
+    r"""Response model for multicall authorization."""
+
+    nonce: int
+    r"""A unique nonce value for this authorization"""
+
+    address: str
+    r"""The Ethereum address authorized for multicall"""
+
+    chain_id: Annotated[int, pydantic.Field(alias="chainId")]
+    r"""The chain ID for the blockchain network"""

compass_api_sdk/models/multicallexecuterequest.py

@@ -0,0 +1,36 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .chain import Chain
+from .signedauthorization import SignedAuthorization, SignedAuthorizationTypedDict
+from .useroperation import UserOperation, UserOperationTypedDict
+from compass_api_sdk.types import BaseModel
+from typing import List
+from typing_extensions import TypedDict
+
+
+class MulticallExecuteRequestTypedDict(TypedDict):
+    r"""Request model for executing a multicall."""
+
+    chain: Chain
+    r"""The chain to use."""
+    sender: str
+    r"""The address of the transaction sender."""
+    signed_authorization: SignedAuthorizationTypedDict
+    actions: List[UserOperationTypedDict]
+    r"""List of possible actions for multicall"""
+
+
+class MulticallExecuteRequest(BaseModel):
+    r"""Request model for executing a multicall."""
+
+    chain: Chain
+    r"""The chain to use."""
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    signed_authorization: SignedAuthorization
+
+    actions: List[UserOperation]
+    r"""List of possible actions for multicall"""

compass_api_sdk/sdk.py

@@ -21,6 +21,7 @@ if TYPE_CHECKING:
     from compass_api_sdk.sky import Sky
     from compass_api_sdk.smart_account import SmartAccount
     from compass_api_sdk.token_sdk import TokenSDK
+    from compass_api_sdk.transaction_batching import TransactionBatching
     from compass_api_sdk.uniswap_v3 import UniswapV3
     from compass_api_sdk.universal import Universal
 
@@ -36,6 +37,7 @@ class CompassAPI(BaseSDK):
     uniswap_v3: "UniswapV3"
     universal: "Universal"
     pendle: "Pendle"
+    transaction_batching: "TransactionBatching"
     smart_account: "SmartAccount"
     _sub_sdk_map = {
         "aave_v3": ("compass_api_sdk.aave_v3", "AaveV3"),
@@ -49,6 +51,10 @@ class CompassAPI(BaseSDK):
         "uniswap_v3": ("compass_api_sdk.uniswap_v3", "UniswapV3"),
         "universal": ("compass_api_sdk.universal", "Universal"),
         "pendle": ("compass_api_sdk.pendle", "Pendle"),
+        "transaction_batching": (
+            "compass_api_sdk.transaction_batching",
+            "TransactionBatching",
+        ),
         "smart_account": ("compass_api_sdk.smart_account", "SmartAccount"),
     }