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

compass_api_sdk/models/{morphoborrowrequest.py → compass_api_backend_models_morpho_transact_request_borrow_morphoborrowrequest.py}

@@ -17,29 +17,38 @@ from typing import Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
-MorphoBorrowRequestAmountTypedDict = TypeAliasType(
-    "MorphoBorrowRequestAmountTypedDict", Union[float, str]
+CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestAmountTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestAmountTypedDict",
+    Union[float, str],
 )
 r"""Amount of the token to borrow from the market."""
 
 
-MorphoBorrowRequestAmount = TypeAliasType(
-    "MorphoBorrowRequestAmount", Union[float, str]
+CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestAmount = (
+    TypeAliasType(
+        "CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestAmount",
+        Union[float, str],
+    )
 )
 r"""Amount of the token to borrow from the market."""
 
 
-class MorphoBorrowRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+class CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
-class MorphoBorrowRequestTypedDict(TypedDict):
-    amount: MorphoBorrowRequestAmountTypedDict
+class CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestTypedDict(
+    TypedDict
+):
+    amount: CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestAmountTypedDict
     r"""Amount of the token to borrow from the market."""
     unique_market_key: str
     r"""The key that uniquely identifies the market. This can be found using the 'Get Markets' endpoint."""
-    chain: MorphoBorrowRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["MORPHO_BORROW"]
@@ -49,14 +58,14 @@ class MorphoBorrowRequestTypedDict(TypedDict):
     r"""The address of the receiver of the tokens borrowed. Defaults to the transaction sender."""
 
 
-class MorphoBorrowRequest(BaseModel):
-    amount: MorphoBorrowRequestAmount
+class CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequest(BaseModel):
+    amount: CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestAmount
     r"""Amount of the token to borrow from the market."""
 
     unique_market_key: str
     r"""The key that uniquely identifies the market. This can be found using the 'Get Markets' endpoint."""
 
-    chain: MorphoBorrowRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestBorrowMorphoBorrowRequestChain
 
     sender: str
     r"""The address of the transaction sender."""

compass_api_sdk/models/{morphodepositrequest.py → compass_api_backend_models_morpho_transact_request_deposit_morphodepositrequest.py}

@@ -17,29 +17,38 @@ from typing import Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
-MorphoDepositRequestAmountTypedDict = TypeAliasType(
-    "MorphoDepositRequestAmountTypedDict", Union[float, str]
+CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestAmountTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestAmountTypedDict",
+    Union[float, str],
 )
 r"""The amount of tokens to deposit into the vault."""
 
 
-MorphoDepositRequestAmount = TypeAliasType(
-    "MorphoDepositRequestAmount", Union[float, str]
+CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestAmount = (
+    TypeAliasType(
+        "CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestAmount",
+        Union[float, str],
+    )
 )
 r"""The amount of tokens to deposit into the vault."""
 
 
-class MorphoDepositRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+class CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
-class MorphoDepositRequestTypedDict(TypedDict):
+class CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestTypedDict(
+    TypedDict
+):
     vault_address: str
     r"""The vault address you are depositing to."""
-    amount: MorphoDepositRequestAmountTypedDict
+    amount: CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestAmountTypedDict
     r"""The amount of tokens to deposit into the vault."""
-    chain: MorphoDepositRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["MORPHO_DEPOSIT"]
@@ -47,14 +56,18 @@ class MorphoDepositRequestTypedDict(TypedDict):
     r"""The address which will receive the shares from the vault representing their proportional ownership of the vault's assets. Defaults to the sender."""
 
 
-class MorphoDepositRequest(BaseModel):
+class CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequest(
+    BaseModel
+):
     vault_address: str
     r"""The vault address you are depositing to."""
 
-    amount: MorphoDepositRequestAmount
+    amount: (
+        CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestAmount
+    )
     r"""The amount of tokens to deposit into the vault."""
 
-    chain: MorphoDepositRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestDepositMorphoDepositRequestChain
 
     sender: str
     r"""The address of the transaction sender."""

compass_api_sdk/models/{morphorepayrequest.py → compass_api_backend_models_morpho_transact_request_repay_morphorepayrequest.py}

@@ -17,17 +17,22 @@ from typing import Any, Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class MorphoRepayRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+class CompassAPIBackendModelsMorphoTransactRequestRepayMorphoRepayRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
-class MorphoRepayRequestTypedDict(TypedDict):
+class CompassAPIBackendModelsMorphoTransactRequestRepayMorphoRepayRequestTypedDict(
+    TypedDict
+):
     amount: Any
     r"""Amount of the token to repay to the market. If set to 'ALL', all debt plus interest will be paid back if the user has a sufficient token balance in their wallet."""
     unique_market_key: str
     r"""The key that uniquely identifies the market. This can be found using the 'Get Markets' endpoint."""
-    chain: MorphoRepayRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestRepayMorphoRepayRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["MORPHO_REPAY"]
@@ -37,14 +42,14 @@ class MorphoRepayRequestTypedDict(TypedDict):
     r"""An optional field for callback byte data that will be triggered upon successful repaying of debt."""
 
 
-class MorphoRepayRequest(BaseModel):
+class CompassAPIBackendModelsMorphoTransactRequestRepayMorphoRepayRequest(BaseModel):
     amount: Any
     r"""Amount of the token to repay to the market. If set to 'ALL', all debt plus interest will be paid back if the user has a sufficient token balance in their wallet."""
 
     unique_market_key: str
     r"""The key that uniquely identifies the market. This can be found using the 'Get Markets' endpoint."""
 
-    chain: MorphoRepayRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestRepayMorphoRepayRequestChain
 
     sender: str
     r"""The address of the transaction sender."""

compass_api_sdk/models/{morphosupplycollateralrequest.py → compass_api_backend_models_morpho_transact_request_supply_collateral_morphosupplycollateralrequest.py}

@@ -17,29 +17,36 @@ from typing import Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
-MorphoSupplyCollateralRequestAmountTypedDict = TypeAliasType(
-    "MorphoSupplyCollateralRequestAmountTypedDict", Union[float, str]
+CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestAmountTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestAmountTypedDict",
+    Union[float, str],
 )
 r"""Amount of the token to supply to the market as collateral."""
 
 
-MorphoSupplyCollateralRequestAmount = TypeAliasType(
-    "MorphoSupplyCollateralRequestAmount", Union[float, str]
+CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestAmount = TypeAliasType(
+    "CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestAmount",
+    Union[float, str],
 )
 r"""Amount of the token to supply to the market as collateral."""
 
 
-class MorphoSupplyCollateralRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+class CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
-class MorphoSupplyCollateralRequestTypedDict(TypedDict):
-    amount: MorphoSupplyCollateralRequestAmountTypedDict
+class CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestTypedDict(
+    TypedDict
+):
+    amount: CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestAmountTypedDict
     r"""Amount of the token to supply to the market as collateral."""
     unique_market_key: str
     r"""The key that uniquely identifies the market. This can be found using the 'Get Markets' endpoint."""
-    chain: MorphoSupplyCollateralRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["MORPHO_SUPPLY_COLLATERAL"]
@@ -49,14 +56,16 @@ class MorphoSupplyCollateralRequestTypedDict(TypedDict):
     r"""An optional field for callback byte data that will be triggered upon successful supplying of collateral."""
 
 
-class MorphoSupplyCollateralRequest(BaseModel):
-    amount: MorphoSupplyCollateralRequestAmount
+class CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequest(
+    BaseModel
+):
+    amount: CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestAmount
     r"""Amount of the token to supply to the market as collateral."""
 
     unique_market_key: str
     r"""The key that uniquely identifies the market. This can be found using the 'Get Markets' endpoint."""
 
-    chain: MorphoSupplyCollateralRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestSupplyCollateralMorphoSupplyCollateralRequestChain
 
     sender: str
     r"""The address of the transaction sender."""

compass_api_sdk/models/{morphowithdrawcollateralrequest.py → compass_api_backend_models_morpho_transact_request_withdraw_collateral_morphowithdrawcollateralrequest.py}

@@ -17,29 +17,36 @@ from typing import Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
-MorphoWithdrawCollateralRequestAmountTypedDict = TypeAliasType(
-    "MorphoWithdrawCollateralRequestAmountTypedDict", Union[float, str]
+CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestAmountTypedDict = TypeAliasType(
+    "CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestAmountTypedDict",
+    Union[float, str],
 )
 r"""Amount of the token to supply to the market as collateral."""
 
 
-MorphoWithdrawCollateralRequestAmount = TypeAliasType(
-    "MorphoWithdrawCollateralRequestAmount", Union[float, str]
+CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestAmount = TypeAliasType(
+    "CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestAmount",
+    Union[float, str],
 )
 r"""Amount of the token to supply to the market as collateral."""
 
 
-class MorphoWithdrawCollateralRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+class CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
-class MorphoWithdrawCollateralRequestTypedDict(TypedDict):
-    amount: MorphoWithdrawCollateralRequestAmountTypedDict
+class CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestTypedDict(
+    TypedDict
+):
+    amount: CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestAmountTypedDict
     r"""Amount of the token to supply to the market as collateral."""
     unique_market_key: str
     r"""The key that uniquely identifies the market. This can be found using the 'Get Markets' endpoint."""
-    chain: MorphoWithdrawCollateralRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestChain
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["MORPHO_WITHDRAW_COLLATERAL"]
@@ -49,14 +56,16 @@ class MorphoWithdrawCollateralRequestTypedDict(TypedDict):
     r"""The address where the withdrawn collateral will be received. Defaults to sender."""
 
 
-class MorphoWithdrawCollateralRequest(BaseModel):
-    amount: MorphoWithdrawCollateralRequestAmount
+class CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequest(
+    BaseModel
+):
+    amount: CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestAmount
     r"""Amount of the token to supply to the market as collateral."""
 
     unique_market_key: str
     r"""The key that uniquely identifies the market. This can be found using the 'Get Markets' endpoint."""
 
-    chain: MorphoWithdrawCollateralRequestChain
+    chain: CompassAPIBackendModelsMorphoTransactRequestWithdrawCollateralMorphoWithdrawCollateralRequestChain
 
     sender: str
     r"""The address of the transaction sender."""

compass_api_sdk/models/{morphowithdrawrequest.py → compass_api_backend_models_morpho_transact_request_withdraw_morphowithdrawrequest.py}

@@ -17,17 +17,24 @@ from typing import Any, Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class MorphoWithdrawRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+class CompassAPIBackendModelsMorphoTransactRequestWithdrawMorphoWithdrawRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
-class MorphoWithdrawRequestTypedDict(TypedDict):
+class CompassAPIBackendModelsMorphoTransactRequestWithdrawMorphoWithdrawRequestTypedDict(
+    TypedDict
+):
     vault_address: str
     r"""The vault address you are withdrawing from."""
     amount: Any
     r"""The amount of tokens to withdraw from the vault. If set to 'ALL', your total deposited token amount will be withdrawn."""
-    chain: MorphoWithdrawRequestChain
+    chain: (
+        CompassAPIBackendModelsMorphoTransactRequestWithdrawMorphoWithdrawRequestChain
+    )
     sender: str
     r"""The address of the transaction sender."""
     action_type: Literal["MORPHO_WITHDRAW"]
@@ -35,14 +42,18 @@ class MorphoWithdrawRequestTypedDict(TypedDict):
     r"""The address which will receive the tokens withdrawn. Defaults to the sender."""
 
 
-class MorphoWithdrawRequest(BaseModel):
+class CompassAPIBackendModelsMorphoTransactRequestWithdrawMorphoWithdrawRequest(
+    BaseModel
+):
     vault_address: str
     r"""The vault address you are withdrawing from."""
 
     amount: Any
     r"""The amount of tokens to withdraw from the vault. If set to 'ALL', your total deposited token amount will be withdrawn."""
 
-    chain: MorphoWithdrawRequestChain
+    chain: (
+        CompassAPIBackendModelsMorphoTransactRequestWithdrawMorphoWithdrawRequestChain
+    )
 
     sender: str
     r"""The address of the transaction sender."""

compass_api_sdk/models/{multicallauthorizationrequest.py → compass_api_backend_models_multicall_read_request_get_authorization_multicallauthorizationrequest.py}

@@ -1,12 +1,22 @@
 """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 enum import Enum
 from typing_extensions import TypedDict
 
 
-class MulticallAuthorizationRequestTypedDict(TypedDict):
+class CompassAPIBackendModelsMulticallReadRequestGetAuthorizationMulticallAuthorizationRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
+class CompassAPIBackendModelsMulticallReadRequestGetAuthorizationMulticallAuthorizationRequestTypedDict(
+    TypedDict
+):
     r"""Request model for getting a multicall authorization.
 
     This model is used to authorize a sender address to perform multicall operations,
@@ -16,13 +26,14 @@ class MulticallAuthorizationRequestTypedDict(TypedDict):
     Only needs to be done once per an EOA.
     """
 
-    chain: Chain
-    r"""The chain to use."""
+    chain: CompassAPIBackendModelsMulticallReadRequestGetAuthorizationMulticallAuthorizationRequestChain
     sender: str
     r"""The Ethereum address to use for authorization"""
 
 
-class MulticallAuthorizationRequest(BaseModel):
+class CompassAPIBackendModelsMulticallReadRequestGetAuthorizationMulticallAuthorizationRequest(
+    BaseModel
+):
     r"""Request model for getting a multicall authorization.
 
     This model is used to authorize a sender address to perform multicall operations,
@@ -32,8 +43,7 @@ class MulticallAuthorizationRequest(BaseModel):
     Only needs to be done once per an EOA.
     """
 
-    chain: Chain
-    r"""The chain to use."""
+    chain: CompassAPIBackendModelsMulticallReadRequestGetAuthorizationMulticallAuthorizationRequestChain
 
     sender: str
     r"""The Ethereum address to use for authorization"""

compass_api_sdk/models/{aavelooprequest.py → compass_api_backend_models_multicall_transact_request_aave_loop_request_aavelooprequest.py}

@@ -1,12 +1,27 @@
 """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
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from enum import Enum
+from pydantic import model_serializer
+from typing import Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+class CompassAPIBackendModelsMulticallTransactRequestAaveLoopRequestAaveLoopRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
 InitialCollateralAmountTypedDict = TypeAliasType(
@@ -45,14 +60,14 @@ LoanToValue = TypeAliasType("LoanToValue", Union[float, str])
 r"""Loan To Value percentage of the loop"""
 
 
-class AaveLoopRequestTypedDict(TypedDict):
+class CompassAPIBackendModelsMulticallTransactRequestAaveLoopRequestAaveLoopRequestTypedDict(
+    TypedDict
+):
     r"""Request model for executing an Aave loop strategy."""
 
-    chain: Chain
-    r"""The chain to use."""
+    chain: CompassAPIBackendModelsMulticallTransactRequestAaveLoopRequestAaveLoopRequestChain
     sender: str
     r"""The address of the transaction sender."""
-    signed_authorization: SignedAuthorizationTypedDict
     collateral_token: TokenEnum
     r"""A class representing the token.
 
@@ -73,19 +88,22 @@ class AaveLoopRequestTypedDict(TypedDict):
     r"""Maximum allowed slippage for token swaps in percentage"""
     loan_to_value: LoanToValueTypedDict
     r"""Loan To Value percentage of the loop"""
+    signed_authorization: NotRequired[Nullable[SignedAuthorizationTypedDict]]
+    r"""EIP-7702 authorization. Required when `is_account_abstraction` is False."""
+    is_account_abstraction: NotRequired[bool]
+    r"""Whether to use account abstraction for the transaction."""
 
 
-class AaveLoopRequest(BaseModel):
+class CompassAPIBackendModelsMulticallTransactRequestAaveLoopRequestAaveLoopRequest(
+    BaseModel
+):
     r"""Request model for executing an Aave loop strategy."""
 
-    chain: Chain
-    r"""The chain to use."""
+    chain: CompassAPIBackendModelsMulticallTransactRequestAaveLoopRequestAaveLoopRequestChain
 
     sender: str
     r"""The address of the transaction sender."""
 
-    signed_authorization: SignedAuthorization
-
     collateral_token: TokenEnum
     r"""A class representing the token.
 
@@ -111,3 +129,39 @@ class AaveLoopRequest(BaseModel):
 
     loan_to_value: LoanToValue
     r"""Loan To Value percentage of the loop"""
+
+    signed_authorization: OptionalNullable[SignedAuthorization] = UNSET
+    r"""EIP-7702 authorization. Required when `is_account_abstraction` is False."""
+
+    is_account_abstraction: Optional[bool] = False
+    r"""Whether to use account abstraction for the transaction."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["signed_authorization", "is_account_abstraction"]
+        nullable_fields = ["signed_authorization"]
+        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/compass_api_backend_models_multicall_transact_request_multicall_execution_request_multicallexecuterequest.py

@@ -0,0 +1,92 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .compass_api_backend_models_multicall_transact_request_multicall_execution_request_useroperation import (
+    CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestUserOperation,
+    CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestUserOperationTypedDict,
+)
+from .signedauthorization import SignedAuthorization, SignedAuthorizationTypedDict
+from compass_api_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from enum import Enum
+from pydantic import model_serializer
+from typing import List
+from typing_extensions import NotRequired, TypedDict
+
+
+class CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestMulticallExecuteRequestChain(
+    str, Enum
+):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
+class CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestMulticallExecuteRequestTypedDict(
+    TypedDict
+):
+    r"""Request model for executing a multicall."""
+
+    chain: CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestMulticallExecuteRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    actions: List[
+        CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestUserOperationTypedDict
+    ]
+    r"""List of possible actions for multicall"""
+    signed_authorization: NotRequired[Nullable[SignedAuthorizationTypedDict]]
+    r"""EIP-7702 authorization"""
+
+
+class CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestMulticallExecuteRequest(
+    BaseModel
+):
+    r"""Request model for executing a multicall."""
+
+    chain: CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestMulticallExecuteRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    actions: List[
+        CompassAPIBackendModelsMulticallTransactRequestMulticallExecutionRequestUserOperation
+    ]
+    r"""List of possible actions for multicall"""
+
+    signed_authorization: OptionalNullable[SignedAuthorization] = UNSET
+    r"""EIP-7702 authorization"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["signed_authorization"]
+        nullable_fields = ["signed_authorization"]
+        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