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

compass_api_sdk/models/{tokentransferrequest.py → tokentransferparams.py}

@@ -1,7 +1,6 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .chain import Chain
 from .token_enum import TokenEnum
 from compass_api_sdk.types import BaseModel
 from compass_api_sdk.utils import validate_const
@@ -11,64 +10,54 @@ from typing import Literal, Optional, Union
 from typing_extensions import Annotated, TypeAliasType, TypedDict
 
 
-TokenTransferRequestAmountTypedDict = TypeAliasType(
-    "TokenTransferRequestAmountTypedDict", Union[float, str]
+TokenTransferParamsAmountTypedDict = TypeAliasType(
+    "TokenTransferParamsAmountTypedDict", Union[float, str]
 )
 r"""Amount of token to transfer"""
 
 
-TokenTransferRequestAmount = TypeAliasType(
-    "TokenTransferRequestAmount", Union[float, str]
+TokenTransferParamsAmount = TypeAliasType(
+    "TokenTransferParamsAmount", Union[float, str]
 )
 r"""Amount of token to transfer"""
 
 
-TokenTransferRequestTokenTypedDict = TypeAliasType(
-    "TokenTransferRequestTokenTypedDict", Union[TokenEnum, str]
+TokenTransferParamsTokenTypedDict = TypeAliasType(
+    "TokenTransferParamsTokenTypedDict", Union[TokenEnum, str]
 )
 r"""The symbol of the token to transfer.."""
 
 
-TokenTransferRequestToken = TypeAliasType(
-    "TokenTransferRequestToken", Union[TokenEnum, str]
+TokenTransferParamsToken = TypeAliasType(
+    "TokenTransferParamsToken", Union[TokenEnum, str]
 )
 r"""The symbol of the token to transfer.."""
 
 
-class TokenTransferRequestTypedDict(TypedDict):
-    r"""Request model for transferring ETH or ERC20 tokens."""
+class TokenTransferParamsTypedDict(TypedDict):
+    r"""Parameters model for transferring ETH or ERC20 tokens."""
 
-    amount: TokenTransferRequestAmountTypedDict
+    amount: TokenTransferParamsAmountTypedDict
     r"""Amount of token to transfer"""
-    token: TokenTransferRequestTokenTypedDict
+    token: TokenTransferParamsTokenTypedDict
     r"""The symbol of the token to transfer.."""
     to: str
     r"""The recipient of the tokens."""
-    chain: Chain
-    r"""The chain to use."""
-    sender: str
-    r"""The address of the transaction sender."""
     action_type: Literal["TOKEN_TRANSFER"]
 
 
-class TokenTransferRequest(BaseModel):
-    r"""Request model for transferring ETH or ERC20 tokens."""
+class TokenTransferParams(BaseModel):
+    r"""Parameters model for transferring ETH or ERC20 tokens."""
 
-    amount: TokenTransferRequestAmount
+    amount: TokenTransferParamsAmount
     r"""Amount of token to transfer"""
 
-    token: TokenTransferRequestToken
+    token: TokenTransferParamsToken
     r"""The symbol of the token to transfer.."""
 
     to: str
     r"""The recipient of the tokens."""
 
-    chain: Chain
-    r"""The chain to use."""
-
-    sender: str
-    r"""The address of the transaction sender."""
-
     ACTION_TYPE: Annotated[
         Annotated[
             Optional[Literal["TOKEN_TRANSFER"]],

compass_api_sdk/models/transactionresponse.py

@@ -0,0 +1,40 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .unsignedmulticalltransaction import (
+    UnsignedMulticallTransaction,
+    UnsignedMulticallTransactionTypedDict,
+)
+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
+
+
+TransactionResponseTransactionTypedDict = TypeAliasType(
+    "TransactionResponseTransactionTypedDict",
+    Union[
+        UserOperationResponseTypedDict,
+        UnsignedTransactionTypedDict,
+        UnsignedMulticallTransactionTypedDict,
+    ],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+TransactionResponseTransaction = TypeAliasType(
+    "TransactionResponseTransaction",
+    Union[UserOperationResponse, UnsignedTransaction, UnsignedMulticallTransaction],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+class TransactionResponseTypedDict(TypedDict):
+    transaction: TransactionResponseTransactionTypedDict
+    r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+class TransactionResponse(BaseModel):
+    transaction: TransactionResponseTransaction
+    r"""The unsigned transaction data. User must sign and broadcast to network."""

compass_api_sdk/models/uniswapbuyexactlyparams.py

@@ -8,70 +8,68 @@ 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, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import Annotated, TypeAliasType, TypedDict
 
 
 UniswapBuyExactlyParamsTokenInTypedDict = TypeAliasType(
     "UniswapBuyExactlyParamsTokenInTypedDict", Union[TokenEnum, str]
 )
-r"""The symbol of the token to swap from."""
+r"""The symbol or address of the token to swap from."""
 
 
 UniswapBuyExactlyParamsTokenIn = TypeAliasType(
     "UniswapBuyExactlyParamsTokenIn", Union[TokenEnum, str]
 )
-r"""The symbol of the token to swap from."""
+r"""The symbol or address of the token to swap from."""
 
 
 UniswapBuyExactlyParamsTokenOutTypedDict = TypeAliasType(
     "UniswapBuyExactlyParamsTokenOutTypedDict", Union[TokenEnum, str]
 )
-r"""The symbol of the token to swap to."""
+r"""The symbol or address of the token to swap to."""
 
 
 UniswapBuyExactlyParamsTokenOut = TypeAliasType(
     "UniswapBuyExactlyParamsTokenOut", Union[TokenEnum, str]
 )
-r"""The symbol of the token to swap to."""
+r"""The symbol or address of the token to swap to."""
 
 
-UniswapBuyExactlyParamsAmountTypedDict = TypeAliasType(
-    "UniswapBuyExactlyParamsAmountTypedDict", Union[float, str]
+UniswapBuyExactlyParamsAmountOutTypedDict = TypeAliasType(
+    "UniswapBuyExactlyParamsAmountOutTypedDict", Union[float, str]
 )
-r"""The amount of the token to swap to"""
+r"""The amount of 'token_out' to buy."""
 
 
-UniswapBuyExactlyParamsAmount = TypeAliasType(
-    "UniswapBuyExactlyParamsAmount", Union[float, str]
+UniswapBuyExactlyParamsAmountOut = TypeAliasType(
+    "UniswapBuyExactlyParamsAmountOut", Union[float, str]
 )
-r"""The amount of the token to swap to"""
+r"""The amount of 'token_out' to buy."""
 
 
 class UniswapBuyExactlyParamsTypedDict(TypedDict):
     token_in: UniswapBuyExactlyParamsTokenInTypedDict
-    r"""The symbol of the token to swap from."""
+    r"""The symbol or address of the token to swap from."""
     token_out: UniswapBuyExactlyParamsTokenOutTypedDict
-    r"""The symbol of the token to swap to."""
+    r"""The symbol or address of the token to swap to."""
     fee: FeeEnum
     r"""The transaction fee of a Uniswap pool in bips.
 
     Uniswap supports 4 different fee levels.
     """
-    amount: UniswapBuyExactlyParamsAmountTypedDict
-    r"""The amount of the token to swap to"""
+    amount_out: UniswapBuyExactlyParamsAmountOutTypedDict
+    r"""The amount of 'token_out' to buy."""
     max_slippage_percent: float
     r"""The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed."""
     action_type: Literal["UNISWAP_BUY_EXACTLY"]
-    wrap_eth: NotRequired[bool]
-    r"""Whether to wrap ETH to WETH, only use when swapping WETH into something"""
 
 
 class UniswapBuyExactlyParams(BaseModel):
     token_in: UniswapBuyExactlyParamsTokenIn
-    r"""The symbol of the token to swap from."""
+    r"""The symbol or address of the token to swap from."""
 
     token_out: UniswapBuyExactlyParamsTokenOut
-    r"""The symbol of the token to swap to."""
+    r"""The symbol or address of the token to swap to."""
 
     fee: FeeEnum
     r"""The transaction fee of a Uniswap pool in bips.
@@ -79,8 +77,8 @@ class UniswapBuyExactlyParams(BaseModel):
     Uniswap supports 4 different fee levels.
     """
 
-    amount: UniswapBuyExactlyParamsAmount
-    r"""The amount of the token to swap to"""
+    amount_out: UniswapBuyExactlyParamsAmountOut
+    r"""The amount of 'token_out' to buy."""
 
     max_slippage_percent: float
     r"""The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed."""
@@ -92,6 +90,3 @@ class UniswapBuyExactlyParams(BaseModel):
         ],
         pydantic.Field(alias="action_type"),
     ] = "UNISWAP_BUY_EXACTLY"
-
-    wrap_eth: Optional[bool] = False
-    r"""Whether to wrap ETH to WETH, only use when swapping WETH into something"""

compass_api_sdk/models/uniswapbuyexactlytransactionresponse.py

@@ -0,0 +1,45 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .unsignedmulticalltransaction import (
+    UnsignedMulticallTransaction,
+    UnsignedMulticallTransactionTypedDict,
+)
+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
+
+
+UniswapBuyExactlyTransactionResponseTransactionTypedDict = TypeAliasType(
+    "UniswapBuyExactlyTransactionResponseTransactionTypedDict",
+    Union[
+        UserOperationResponseTypedDict,
+        UnsignedTransactionTypedDict,
+        UnsignedMulticallTransactionTypedDict,
+    ],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+UniswapBuyExactlyTransactionResponseTransaction = TypeAliasType(
+    "UniswapBuyExactlyTransactionResponseTransaction",
+    Union[UserOperationResponse, UnsignedTransaction, UnsignedMulticallTransaction],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+class UniswapBuyExactlyTransactionResponseTypedDict(TypedDict):
+    transaction: UniswapBuyExactlyTransactionResponseTransactionTypedDict
+    r"""The unsigned transaction data. User must sign and broadcast to network."""
+    amount_in_quote: str
+    r"""The estimated amount in for the transaction. The actual input amount for this transaction is guaranteed be within the acceptable threshold, defined by the `max_slippage_percent`, relative to this quote."""
+
+
+class UniswapBuyExactlyTransactionResponse(BaseModel):
+    transaction: UniswapBuyExactlyTransactionResponseTransaction
+    r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+    amount_in_quote: str
+    r"""The estimated amount in for the transaction. The actual input 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/uniswapsellexactlyparams.py

@@ -8,66 +8,72 @@ 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, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import Annotated, TypeAliasType, TypedDict
 
 
-UniswapSellExactlyParamsAmountTypedDict = TypeAliasType(
-    "UniswapSellExactlyParamsAmountTypedDict", Union[float, str]
+UniswapSellExactlyParamsTokenInTypedDict = TypeAliasType(
+    "UniswapSellExactlyParamsTokenInTypedDict", Union[TokenEnum, str]
 )
-r"""The amount of the token to swap from"""
+r"""The symbol or address of the token to sell.."""
 
 
-UniswapSellExactlyParamsAmount = TypeAliasType(
-    "UniswapSellExactlyParamsAmount", Union[float, str]
+UniswapSellExactlyParamsTokenIn = TypeAliasType(
+    "UniswapSellExactlyParamsTokenIn", Union[TokenEnum, str]
 )
-r"""The amount of the token to swap from"""
+r"""The symbol or address of the token to sell.."""
 
 
-class UniswapSellExactlyParamsTypedDict(TypedDict):
-    r"""Parameters model for selling exactly an amount of tokens."""
+UniswapSellExactlyParamsTokenOutTypedDict = TypeAliasType(
+    "UniswapSellExactlyParamsTokenOutTypedDict", Union[TokenEnum, str]
+)
+r"""The symbol or address of the token to buy.."""
 
-    token_in: 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.
-    """
-    token_out: TokenEnum
-    r"""A class representing the token.
+UniswapSellExactlyParamsTokenOut = TypeAliasType(
+    "UniswapSellExactlyParamsTokenOut", Union[TokenEnum, str]
+)
+r"""The symbol or address of the token to buy.."""
 
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
+
+UniswapSellExactlyParamsAmountInTypedDict = TypeAliasType(
+    "UniswapSellExactlyParamsAmountInTypedDict", Union[float, str]
+)
+r"""The amount of the `token_in` to sell"""
+
+
+UniswapSellExactlyParamsAmountIn = TypeAliasType(
+    "UniswapSellExactlyParamsAmountIn", Union[float, str]
+)
+r"""The amount of the `token_in` to sell"""
+
+
+class UniswapSellExactlyParamsTypedDict(TypedDict):
+    r"""Parameters model for selling exactly an amount of tokens."""
+
+    token_in: UniswapSellExactlyParamsTokenInTypedDict
+    r"""The symbol or address of the token to sell.."""
+    token_out: UniswapSellExactlyParamsTokenOutTypedDict
+    r"""The symbol or address of the token to buy.."""
     fee: FeeEnum
     r"""The transaction fee of a Uniswap pool in bips.
 
     Uniswap supports 4 different fee levels.
     """
-    amount: UniswapSellExactlyParamsAmountTypedDict
-    r"""The amount of the token to swap from"""
+    amount_in: UniswapSellExactlyParamsAmountInTypedDict
+    r"""The amount of the `token_in` to sell"""
     max_slippage_percent: float
     r"""The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed."""
     action_type: Literal["UNISWAP_SELL_EXACTLY"]
-    wrap_eth: NotRequired[bool]
-    r"""Whether to wrap ETH to WETH, only use when swapping WETH into something"""
 
 
 class UniswapSellExactlyParams(BaseModel):
     r"""Parameters model for selling exactly an amount of tokens."""
 
-    token_in: TokenEnum
-    r"""A class representing the token.
+    token_in: UniswapSellExactlyParamsTokenIn
+    r"""The symbol or address of the token to sell.."""
 
-    This class is used to represent the token in the system. Notice individual
-    endpoints' documentation where per chain tokens are presented.
-    """
-
-    token_out: 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.
-    """
+    token_out: UniswapSellExactlyParamsTokenOut
+    r"""The symbol or address of the token to buy.."""
 
     fee: FeeEnum
     r"""The transaction fee of a Uniswap pool in bips.
@@ -75,8 +81,8 @@ class UniswapSellExactlyParams(BaseModel):
     Uniswap supports 4 different fee levels.
     """
 
-    amount: UniswapSellExactlyParamsAmount
-    r"""The amount of the token to swap from"""
+    amount_in: UniswapSellExactlyParamsAmountIn
+    r"""The amount of the `token_in` to sell"""
 
     max_slippage_percent: float
     r"""The maximum slippage allowed in percent. e.g. `1` means `1 %` slippage allowed."""
@@ -88,6 +94,3 @@ class UniswapSellExactlyParams(BaseModel):
         ],
         pydantic.Field(alias="action_type"),
     ] = "UNISWAP_SELL_EXACTLY"
-
-    wrap_eth: Optional[bool] = False
-    r"""Whether to wrap ETH to WETH, only use when swapping WETH into something"""

compass_api_sdk/models/uniswapsellexactlytransactionresponse.py

@@ -0,0 +1,45 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .unsignedmulticalltransaction import (
+    UnsignedMulticallTransaction,
+    UnsignedMulticallTransactionTypedDict,
+)
+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
+
+
+UniswapSellExactlyTransactionResponseTransactionTypedDict = TypeAliasType(
+    "UniswapSellExactlyTransactionResponseTransactionTypedDict",
+    Union[
+        UserOperationResponseTypedDict,
+        UnsignedTransactionTypedDict,
+        UnsignedMulticallTransactionTypedDict,
+    ],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+UniswapSellExactlyTransactionResponseTransaction = TypeAliasType(
+    "UniswapSellExactlyTransactionResponseTransaction",
+    Union[UserOperationResponse, UnsignedTransaction, UnsignedMulticallTransaction],
+)
+r"""The unsigned transaction data. User must sign and broadcast to network."""
+
+
+class UniswapSellExactlyTransactionResponseTypedDict(TypedDict):
+    transaction: UniswapSellExactlyTransactionResponseTransactionTypedDict
+    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 UniswapSellExactlyTransactionResponse(BaseModel):
+    transaction: UniswapSellExactlyTransactionResponseTransaction
+    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/{aave_aave_supported_tokensop.py → v1_aave_aave_supported_tokensop.py}

@@ -14,27 +14,23 @@ from pydantic import model_serializer
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class AaveAaveSupportedTokensChain(str, Enum):
-    r"""The chain to use."""
+class V1AaveAaveSupportedTokensChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
-    BASE_MAINNET = "base:mainnet"
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    ARBITRUM_MAINNET = "arbitrum:mainnet"
 
-
-class AaveAaveSupportedTokensRequestTypedDict(TypedDict):
-    chain: AaveAaveSupportedTokensChain
-    r"""The chain to use."""
+class V1AaveAaveSupportedTokensRequestTypedDict(TypedDict):
+    chain: V1AaveAaveSupportedTokensChain
     block: NotRequired[Nullable[int]]
     r"""Optional block number (defaults to latest)."""
 
 
-class AaveAaveSupportedTokensRequest(BaseModel):
+class V1AaveAaveSupportedTokensRequest(BaseModel):
     chain: Annotated[
-        AaveAaveSupportedTokensChain,
+        V1AaveAaveSupportedTokensChain,
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = AaveAaveSupportedTokensChain.ARBITRUM_MAINNET
-    r"""The chain to use."""
+    ] = V1AaveAaveSupportedTokensChain.ARBITRUM
 
     block: Annotated[
         OptionalNullable[int],

compass_api_sdk/models/{aave_avg_rateop.py → v1_aave_avg_rateop.py}

@@ -14,15 +14,13 @@ from pydantic import model_serializer
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class AaveAvgRateChain(str, Enum):
-    r"""The chain to use."""
+class V1AaveAvgRateChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
-    BASE_MAINNET = "base:mainnet"
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    ARBITRUM_MAINNET = "arbitrum:mainnet"
 
-
-class AaveAvgRateToken(str, Enum):
+class V1AaveAvgRateToken(str, Enum):
     r"""A class representing the token.
 
     This class is used to represent the token in the system. Notice individual
@@ -70,29 +68,44 @@ class AaveAvgRateToken(str, Enum):
     EURS = "EURS"
     MAI = "MAI"
     USD_CE = "USDCe"
+    ETH = "ETH"
     AERO = "AERO"
     EUR = "EUR"
     VIRTUAL = "VIRTUAL"
     EZ_ETH = "ezETH"
-
-
-class AaveAvgRateRequestTypedDict(TypedDict):
-    chain: AaveAvgRateChain
-    r"""The chain to use."""
+    CYBER = "CYBER"
+    WRS_ETH = "wrsETH"
+    E_BTC = "eBTC"
+    EURC = "EURC"
+    E_US_DE = "eUSDe"
+    FBTC = "FBTC"
+    LBTC = "LBTC"
+    PT_E_USDE_14_AUG2025 = "PT-eUSDE-14AUG2025"
+    PT_E_USDE_29_MAY2025 = "PT-eUSDE-29MAY2025"
+    PT_S_USDE_25_SEP2025 = "PT-sUSDE-25SEP2025"
+    PT_S_USDE_31_JUL2025 = "PT-sUSDE-31JUL2025"
+    PT_US_DE_31_JUL2025 = "PT-USDe-31JUL2025"
+    RLUSD = "RLUSD"
+    USD_0 = "USD₮0"
+    US_DB_C = "USDbC"
+    US_DTB = "USDtb"
+
+
+class V1AaveAvgRateRequestTypedDict(TypedDict):
+    chain: V1AaveAvgRateChain
     block: NotRequired[Nullable[int]]
     r"""Optional block number (defaults to latest)."""
-    token: AaveAvgRateToken
+    token: V1AaveAvgRateToken
     r"""The symbol of the token.."""
     days: int
     r"""The number of days for which the average shall be calculated."""
 
 
-class AaveAvgRateRequest(BaseModel):
+class V1AaveAvgRateRequest(BaseModel):
     chain: Annotated[
-        AaveAvgRateChain,
+        V1AaveAvgRateChain,
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = AaveAvgRateChain.ETHEREUM_MAINNET
-    r"""The chain to use."""
+    ] = V1AaveAvgRateChain.ETHEREUM
 
     block: Annotated[
         OptionalNullable[int],
@@ -101,9 +114,9 @@ class AaveAvgRateRequest(BaseModel):
     r"""Optional block number (defaults to latest)."""
 
     token: Annotated[
-        AaveAvgRateToken,
+        V1AaveAvgRateToken,
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = AaveAvgRateToken.USDC
+    ] = V1AaveAvgRateToken.USDC
     r"""The symbol of the token.."""
 
     days: Annotated[

compass_api_sdk/models/{aave_historical_transactionsop.py → v1_aave_historical_transactionsop.py}

@@ -8,26 +8,23 @@ from typing import Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-class AaveHistoricalTransactionsChain(str, Enum):
-    r"""The chain to use."""
+class V1AaveHistoricalTransactionsChain(str, Enum):
+    ARBITRUM = "arbitrum"
+    BASE = "base"
+    ETHEREUM = "ethereum"
 
-    BASE_MAINNET = "base:mainnet"
-    ETHEREUM_MAINNET = "ethereum:mainnet"
-    ARBITRUM_MAINNET = "arbitrum:mainnet"
 
-
-class AaveHistoricalTransactionsRequestTypedDict(TypedDict):
+class V1AaveHistoricalTransactionsRequestTypedDict(TypedDict):
     offset: NotRequired[int]
     r"""The offset of the first item to return."""
     limit: NotRequired[int]
     r"""The number of items to return."""
-    chain: AaveHistoricalTransactionsChain
-    r"""The chain to use."""
+    chain: V1AaveHistoricalTransactionsChain
     user_address: str
     r"""The address of the user to get historical transactions for."""
 
 
-class AaveHistoricalTransactionsRequest(BaseModel):
+class V1AaveHistoricalTransactionsRequest(BaseModel):
     offset: Annotated[
         Optional[int],
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
@@ -41,10 +38,9 @@ class AaveHistoricalTransactionsRequest(BaseModel):
     r"""The number of items to return."""
 
     chain: Annotated[
-        AaveHistoricalTransactionsChain,
+        V1AaveHistoricalTransactionsChain,
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
-    ] = AaveHistoricalTransactionsChain.BASE_MAINNET
-    r"""The chain to use."""
+    ] = V1AaveHistoricalTransactionsChain.BASE
 
     user_address: Annotated[
         str, FieldMetadata(query=QueryParamMetadata(style="form", explode=True))