compass_api_sdk 0.9.35__py3-none-any.whl → 2.0.21rc1__py3-none-any.whl

compass_api_sdk/models/morphorepayrequest.py

@@ -18,8 +18,9 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class MorphoRepayRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
 class MorphoRepayRequestTypedDict(TypedDict):
@@ -35,6 +36,8 @@ class MorphoRepayRequestTypedDict(TypedDict):
     r"""The address on behalf of whom the repayment is made. Defaults to sender."""
     callback_data: NotRequired[Nullable[bytes]]
     r"""An optional field for callback byte data that will be triggered upon successful repaying of debt."""
+    estimate_gas: NotRequired[bool]
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
 
 
 class MorphoRepayRequest(BaseModel):
@@ -63,9 +66,17 @@ class MorphoRepayRequest(BaseModel):
     callback_data: OptionalNullable[bytes] = UNSET
     r"""An optional field for callback byte data that will be triggered upon successful repaying of debt."""
 
+    estimate_gas: Optional[bool] = None
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["action_type", "on_behalf_of", "callback_data"]
+        optional_fields = [
+            "action_type",
+            "on_behalf_of",
+            "callback_data",
+            "estimate_gas",
+        ]
         nullable_fields = ["on_behalf_of", "callback_data"]
         null_default_fields = []
 

compass_api_sdk/models/morphosupplycollateralrequest.py

@@ -30,8 +30,9 @@ r"""Amount of the token to supply to the market as collateral."""
 
 
 class MorphoSupplyCollateralRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
 class MorphoSupplyCollateralRequestTypedDict(TypedDict):
@@ -47,6 +48,8 @@ class MorphoSupplyCollateralRequestTypedDict(TypedDict):
     r"""The address on behalf of whom the supplied collateral is made. Defaults to sender."""
     callback_data: NotRequired[Nullable[bytes]]
     r"""An optional field for callback byte data that will be triggered upon successful supplying of collateral."""
+    estimate_gas: NotRequired[bool]
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
 
 
 class MorphoSupplyCollateralRequest(BaseModel):
@@ -75,9 +78,17 @@ class MorphoSupplyCollateralRequest(BaseModel):
     callback_data: OptionalNullable[bytes] = UNSET
     r"""An optional field for callback byte data that will be triggered upon successful supplying of collateral."""
 
+    estimate_gas: Optional[bool] = None
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["action_type", "on_behalf_of", "callback_data"]
+        optional_fields = [
+            "action_type",
+            "on_behalf_of",
+            "callback_data",
+            "estimate_gas",
+        ]
         nullable_fields = ["on_behalf_of", "callback_data"]
         null_default_fields = []
 

compass_api_sdk/models/morphovault.py

@@ -2,13 +2,13 @@
 
 from __future__ import annotations
 from .chaininfo import ChainInfo, ChainInfoTypedDict
-from .compass_api_backend_models_morpho_read_response_get_vaults_asset import (
-    CompassAPIBackendModelsMorphoReadResponseGetVaultsAsset,
-    CompassAPIBackendModelsMorphoReadResponseGetVaultsAssetTypedDict,
+from .compass_api_backend_v1_models_morpho_read_response_get_vaults_asset import (
+    CompassAPIBackendV1ModelsMorphoReadResponseGetVaultsAsset,
+    CompassAPIBackendV1ModelsMorphoReadResponseGetVaultsAssetTypedDict,
 )
-from .compass_api_backend_models_morpho_read_response_get_vaults_vaultstate import (
-    CompassAPIBackendModelsMorphoReadResponseGetVaultsVaultState,
-    CompassAPIBackendModelsMorphoReadResponseGetVaultsVaultStateTypedDict,
+from .compass_api_backend_v1_models_morpho_read_response_get_vaults_vaultstate import (
+    CompassAPIBackendV1ModelsMorphoReadResponseGetVaultsVaultState,
+    CompassAPIBackendV1ModelsMorphoReadResponseGetVaultsVaultStateTypedDict,
 )
 from compass_api_sdk.types import BaseModel
 import pydantic
@@ -23,9 +23,9 @@ class MorphoVaultTypedDict(TypedDict):
     creation_timestamp: int
     creator_address: str
     whitelisted: bool
-    asset: CompassAPIBackendModelsMorphoReadResponseGetVaultsAssetTypedDict
+    asset: CompassAPIBackendV1ModelsMorphoReadResponseGetVaultsAssetTypedDict
     chain: ChainInfoTypedDict
-    state: CompassAPIBackendModelsMorphoReadResponseGetVaultsVaultStateTypedDict
+    state: CompassAPIBackendV1ModelsMorphoReadResponseGetVaultsVaultStateTypedDict
 
 
 class MorphoVault(BaseModel):
@@ -43,8 +43,8 @@ class MorphoVault(BaseModel):
 
     whitelisted: bool
 
-    asset: CompassAPIBackendModelsMorphoReadResponseGetVaultsAsset
+    asset: CompassAPIBackendV1ModelsMorphoReadResponseGetVaultsAsset
 
     chain: ChainInfo
 
-    state: CompassAPIBackendModelsMorphoReadResponseGetVaultsVaultState
+    state: CompassAPIBackendV1ModelsMorphoReadResponseGetVaultsVaultState

compass_api_sdk/models/morphowithdrawcollateralrequest.py

@@ -30,8 +30,9 @@ r"""Amount of the token to supply to the market as collateral."""
 
 
 class MorphoWithdrawCollateralRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
 class MorphoWithdrawCollateralRequestTypedDict(TypedDict):
@@ -47,6 +48,8 @@ class MorphoWithdrawCollateralRequestTypedDict(TypedDict):
     r"""The address on behalf of whom the withdraw is made. Defaults to sender."""
     receiver: NotRequired[Nullable[str]]
     r"""The address where the withdrawn collateral will be received. Defaults to sender."""
+    estimate_gas: NotRequired[bool]
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
 
 
 class MorphoWithdrawCollateralRequest(BaseModel):
@@ -75,9 +78,12 @@ class MorphoWithdrawCollateralRequest(BaseModel):
     receiver: OptionalNullable[str] = UNSET
     r"""The address where the withdrawn collateral will be received. Defaults to sender."""
 
+    estimate_gas: Optional[bool] = None
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["action_type", "on_behalf_of", "receiver"]
+        optional_fields = ["action_type", "on_behalf_of", "receiver", "estimate_gas"]
         nullable_fields = ["on_behalf_of", "receiver"]
         null_default_fields = []
 

compass_api_sdk/models/morphowithdrawrequest.py

@@ -18,8 +18,9 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class MorphoWithdrawRequestChain(str, Enum):
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    BASE_MAINNET = "base:mainnet"
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
 class MorphoWithdrawRequestTypedDict(TypedDict):
@@ -33,6 +34,8 @@ class MorphoWithdrawRequestTypedDict(TypedDict):
     action_type: Literal["MORPHO_WITHDRAW"]
     receiver: NotRequired[Nullable[str]]
     r"""The address which will receive the tokens withdrawn. Defaults to the sender."""
+    estimate_gas: NotRequired[bool]
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
 
 
 class MorphoWithdrawRequest(BaseModel):
@@ -58,9 +61,12 @@ class MorphoWithdrawRequest(BaseModel):
     receiver: OptionalNullable[str] = UNSET
     r"""The address which will receive the tokens withdrawn. Defaults to the sender."""
 
+    estimate_gas: Optional[bool] = None
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["action_type", "receiver"]
+        optional_fields = ["action_type", "receiver", "estimate_gas"]
         nullable_fields = ["receiver"]
         null_default_fields = []
 

compass_api_sdk/models/movement10percent.py

@@ -1,23 +1,78 @@
 """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.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
 import pydantic
-from typing_extensions import Annotated, TypedDict
+from pydantic import model_serializer
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class Movement10PercentTypedDict(TypedDict):
-    pt_movement_up_usd: float
-    pt_movement_down_usd: float
-    yt_movement_up_usd: float
-    yt_movement_down_usd: float
+    pt_movement_up_usd: NotRequired[Nullable[float]]
+    pt_movement_down_usd: NotRequired[Nullable[float]]
+    yt_movement_up_usd: NotRequired[Nullable[float]]
+    yt_movement_down_usd: NotRequired[Nullable[float]]
 
 
 class Movement10Percent(BaseModel):
-    pt_movement_up_usd: Annotated[float, pydantic.Field(alias="ptMovementUpUsd")]
+    pt_movement_up_usd: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="ptMovementUpUsd")
+    ] = UNSET
 
-    pt_movement_down_usd: Annotated[float, pydantic.Field(alias="ptMovementDownUsd")]
+    pt_movement_down_usd: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="ptMovementDownUsd")
+    ] = UNSET
 
-    yt_movement_up_usd: Annotated[float, pydantic.Field(alias="ytMovementUpUsd")]
+    yt_movement_up_usd: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="ytMovementUpUsd")
+    ] = UNSET
 
-    yt_movement_down_usd: Annotated[float, pydantic.Field(alias="ytMovementDownUsd")]
+    yt_movement_down_usd: Annotated[
+        OptionalNullable[float], pydantic.Field(alias="ytMovementDownUsd")
+    ] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "ptMovementUpUsd",
+            "ptMovementDownUsd",
+            "ytMovementUpUsd",
+            "ytMovementDownUsd",
+        ]
+        nullable_fields = [
+            "ptMovementUpUsd",
+            "ptMovementDownUsd",
+            "ytMovementUpUsd",
+            "ytMovementDownUsd",
+        ]
+        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/multicallauthorizationrequest.py

@@ -1,23 +1,26 @@
 """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 MulticallAuthorizationRequestChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
 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."""
+    chain: MulticallAuthorizationRequestChain
     sender: str
     r"""The Ethereum address to use for authorization"""
 
@@ -28,12 +31,9 @@ class MulticallAuthorizationRequest(BaseModel):
     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."""
+    chain: MulticallAuthorizationRequestChain
 
     sender: str
     r"""The Ethereum address to use for authorization"""

compass_api_sdk/models/multicallexecuterequest.py

@@ -1,36 +1,84 @@
 """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
+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, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class MulticallExecuteRequestChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
 
 class MulticallExecuteRequestTypedDict(TypedDict):
     r"""Request model for executing a multicall."""
 
-    chain: Chain
-    r"""The chain to use."""
+    chain: MulticallExecuteRequestChain
     sender: str
     r"""The address of the transaction sender."""
-    signed_authorization: SignedAuthorizationTypedDict
     actions: List[UserOperationTypedDict]
     r"""List of possible actions for multicall"""
+    estimate_gas: NotRequired[bool]
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
+    signed_authorization: NotRequired[Nullable[SignedAuthorizationTypedDict]]
+    r"""EIP-7702 authorization"""
 
 
 class MulticallExecuteRequest(BaseModel):
     r"""Request model for executing a multicall."""
 
-    chain: Chain
-    r"""The chain to use."""
+    chain: MulticallExecuteRequestChain
 
     sender: str
     r"""The address of the transaction sender."""
 
-    signed_authorization: SignedAuthorization
-
     actions: List[UserOperation]
     r"""List of possible actions for multicall"""
+
+    estimate_gas: Optional[bool] = None
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
+
+    signed_authorization: OptionalNullable[SignedAuthorization] = UNSET
+    r"""EIP-7702 authorization"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["estimate_gas", "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

compass_api_sdk/models/odosswapparams.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 compass_api_sdk.utils import validate_const
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
+
+
+OdosSwapParamsAmountInTypedDict = TypeAliasType(
+    "OdosSwapParamsAmountInTypedDict", Union[float, str]
+)
+r"""The amount of token_in to be sold."""
+
+
+OdosSwapParamsAmountIn = TypeAliasType("OdosSwapParamsAmountIn", Union[float, str])
+r"""The amount of token_in to be sold."""
+
+
+class OdosSwapParamsTypedDict(TypedDict):
+    token_in: str
+    r"""The symbol or address of the token that is to be sold."""
+    token_out: str
+    r"""The symbol or address of the token that is to be bought."""
+    amount_in: OdosSwapParamsAmountInTypedDict
+    r"""The amount of token_in to be sold."""
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1%` slippage allowed."""
+    action_type: Literal["ODOS_SWAP"]
+
+
+class OdosSwapParams(BaseModel):
+    token_in: str
+    r"""The symbol or address of the token that is to be sold."""
+
+    token_out: str
+    r"""The symbol or address of the token that is to be bought."""
+
+    amount_in: OdosSwapParamsAmountIn
+    r"""The amount of token_in to be sold."""
+
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1%` slippage allowed."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["ODOS_SWAP"]], AfterValidator(validate_const("ODOS_SWAP"))
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "ODOS_SWAP"

compass_api_sdk/models/odosswaprequest.py

@@ -0,0 +1,72 @@
+"""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, NotRequired, TypeAliasType, TypedDict
+
+
+OdosSwapRequestAmountInTypedDict = TypeAliasType(
+    "OdosSwapRequestAmountInTypedDict", Union[float, str]
+)
+r"""The amount of token_in to be sold."""
+
+
+OdosSwapRequestAmountIn = TypeAliasType("OdosSwapRequestAmountIn", Union[float, str])
+r"""The amount of token_in to be sold."""
+
+
+class OdosSwapRequestChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
+
+
+class OdosSwapRequestTypedDict(TypedDict):
+    token_in: str
+    r"""The symbol or address of the token that is to be sold."""
+    token_out: str
+    r"""The symbol or address of the token that is to be bought."""
+    amount_in: OdosSwapRequestAmountInTypedDict
+    r"""The amount of token_in to be sold."""
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1%` slippage allowed."""
+    chain: OdosSwapRequestChain
+    sender: str
+    r"""The address of the transaction sender."""
+    action_type: Literal["ODOS_SWAP"]
+    estimate_gas: NotRequired[bool]
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""
+
+
+class OdosSwapRequest(BaseModel):
+    token_in: str
+    r"""The symbol or address of the token that is to be sold."""
+
+    token_out: str
+    r"""The symbol or address of the token that is to be bought."""
+
+    amount_in: OdosSwapRequestAmountIn
+    r"""The amount of token_in to be sold."""
+
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1%` slippage allowed."""
+
+    chain: OdosSwapRequestChain
+
+    sender: str
+    r"""The address of the transaction sender."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["ODOS_SWAP"]], AfterValidator(validate_const("ODOS_SWAP"))
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "ODOS_SWAP"
+
+    estimate_gas: Optional[bool] = None
+    r"""Determines whether to estimate gas costs for transactions, also verifying that the transaction can be successfully executed."""

compass_api_sdk/models/odostransactionresponse.py

@@ -0,0 +1,37 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .unsignedtransaction import UnsignedTransaction, UnsignedTransactionTypedDict
+from .useroperationresponse import UserOperationResponse, UserOperationResponseTypedDict
+from compass_api_sdk.types import BaseModel
+from typing import Union
+from typing_extensions import TypeAliasType, TypedDict
+
+
+OdosTransactionResponseTransactionTypedDict = TypeAliasType(
+    "OdosTransactionResponseTransactionTypedDict",
+    Union[UserOperationResponseTypedDict, UnsignedTransactionTypedDict],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+OdosTransactionResponseTransaction = TypeAliasType(
+    "OdosTransactionResponseTransaction",
+    Union[UserOperationResponse, UnsignedTransaction],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+class OdosTransactionResponseTypedDict(TypedDict):
+    transaction: OdosTransactionResponseTransactionTypedDict
+    r"""The unsigned transaction data. User must sign and broadcast to network."""
+    amount_out_quote: str
+    r"""The estimated amount out for the transaction. The actual output amount for this transaction is guaranteed be within the acceptable threshold, defined by the `max_slippage_percent`, relative to this quote."""
+
+
+class OdosTransactionResponse(BaseModel):
+    transaction: OdosTransactionResponseTransaction
+    r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+    amount_out_quote: str
+    r"""The estimated amount out for the transaction. The actual output amount for this transaction is guaranteed be within the acceptable threshold, defined by the `max_slippage_percent`, relative to this quote."""

compass_api_sdk/models/oneinchswapparams.py

@@ -0,0 +1,59 @@
+"""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
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional, Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
+
+
+OneInchSwapParamsAmountInTypedDict = TypeAliasType(
+    "OneInchSwapParamsAmountInTypedDict", Union[float, str]
+)
+r"""The amount of token_in to be sold."""
+
+
+OneInchSwapParamsAmountIn = TypeAliasType(
+    "OneInchSwapParamsAmountIn", Union[float, str]
+)
+r"""The amount of token_in to be sold."""
+
+
+class OneInchSwapParamsTypedDict(TypedDict):
+    r"""Parameters for 1inch swap operations."""
+
+    token_in: str
+    r"""The symbol or address of the token that is to be sold."""
+    token_out: str
+    r"""The symbol or address of the token that is to be bought."""
+    amount_in: OneInchSwapParamsAmountInTypedDict
+    r"""The amount of token_in to be sold."""
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1%` slippage allowed."""
+    action_type: Literal["ONE_INCH_SWAP"]
+
+
+class OneInchSwapParams(BaseModel):
+    r"""Parameters for 1inch swap operations."""
+
+    token_in: str
+    r"""The symbol or address of the token that is to be sold."""
+
+    token_out: str
+    r"""The symbol or address of the token that is to be bought."""
+
+    amount_in: OneInchSwapParamsAmountIn
+    r"""The amount of token_in to be sold."""
+
+    max_slippage_percent: float
+    r"""The maximum slippage allowed in percent. e.g. `1` means `1%` slippage allowed."""
+
+    ACTION_TYPE: Annotated[
+        Annotated[
+            Optional[Literal["ONE_INCH_SWAP"]],
+            AfterValidator(validate_const("ONE_INCH_SWAP")),
+        ],
+        pydantic.Field(alias="action_type"),
+    ] = "ONE_INCH_SWAP"