Migrate to Pydantic v2, update model validation and fix async issues

- Migrated to Pydantic v2:
  - Replaced deprecated `parse_obj()` and `parse_raw()` with
`model_validate()` and `model_validate_json()`.
  - Replaced `.dict()` with `.model_dump()` for serializing models to dictionaries.
  - Updated `validator` to `field_validator` and `root_validator` to
`model_validator` to comply with Pydantic v2 syntax changes.

- Fixed asyncio issues:
  - Added `await` for asynchronous methods like `raise_for_status()`
in `RemoteAccount` and other HTTP operations to avoid `RuntimeWarning`.

- Updated config handling:
  - Used `ClassVar` for constants in `Settings` and other configuration classes.
  - Replaced `Config` with `ConfigDict` in Pydantic models
to follow v2 conventions.
  - Added default values for missing fields in chain configurations
(`CHAINS_SEPOLIA_ACTIVE`, etc.).

- Adjusted signature handling:
  - Updated the signing logic to prepend `0x` in the `BaseAccount` signature
generation to ensure correct Ethereum address formatting.

- Minor fixes:
  - Resolved issue with extra fields not being allowed by default
by specifying `extra="allow"` or `extra="forbid"` where necessary.
  - Fixed tests to account for changes in model validation and
serialization behavior.
  - Added `pydantic-settings` as a new dependency for configuration management.

Author: Antonyjin

pyproject.toml

@@ -29,6 +29,7 @@ dependencies = [
     "eth_abi>=4.0.0; python_version>=\"3.11\"",
     "jwcrypto==1.5.6",
     "python-magic",
+    "pydantic-settings",
     "typing_extensions",
     "aioresponses>=0.7.6",
     "aleph-superfluid>=0.2.1",

src/aleph/sdk/chains/common.py

@@ -72,7 +72,7 @@ async def sign_message(self, message: Dict) -> Dict:
         """
         message = self._setup_sender(message)
         signature = await self.sign_raw(get_verification_buffer(message))
-        message["signature"] = signature.hex()
+        message["signature"] = "0x" + signature.hex()
         return message
 
     @abstractmethod

src/aleph/sdk/chains/remote.py

@@ -52,7 +52,7 @@ async def from_crypto_host(
             session = aiohttp.ClientSession(connector=connector)
 
         async with session.get(f"{host}/properties") as response:
-            response.raise_for_status()
+            await response.raise_for_status()
             data = await response.json()
             properties = AccountProperties(**data)
 
@@ -75,7 +75,7 @@ def private_key(self):
     async def sign_message(self, message: Dict) -> Dict:
         """Sign a message inplace."""
         async with self._session.post(f"{self._host}/sign", json=message) as response:
-            response.raise_for_status()
+            await response.raise_for_status()
             return await response.json()
 
     async def sign_raw(self, buffer: bytes) -> bytes:

src/aleph/sdk/client/authenticated_http.py

@@ -259,7 +259,7 @@ async def _broadcast(
         url = "/api/v0/messages"
         logger.debug(f"Posting message on {url}")
 
-        message_dict = message.dict(include=self.BROADCAST_MESSAGE_FIELDS)
+        message_dict = message.model_dump(include=self.BROADCAST_MESSAGE_FIELDS)
         async with self.http_session.post(
             url,
             json={
@@ -301,7 +301,7 @@ async def create_post(
         )
 
         message, status, _ = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.post,
             channel=channel,
             allow_inlining=inline,
@@ -329,7 +329,7 @@ async def create_aggregate(
         )
 
         message, status, _ = await self.submit(
-            content=content_.dict(exclude_none=True),
+            content=content_.model_dump(exclude_none=True),
             message_type=MessageType.aggregate,
             channel=channel,
             allow_inlining=inline,
@@ -403,7 +403,7 @@ async def create_store(
         content = StoreContent(**values)
 
         message, status, _ = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.store,
             channel=channel,
             allow_inlining=True,
@@ -496,7 +496,7 @@ async def create_program(
         assert content.on.persistent == persistent
 
         message, status, _ = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.program,
             channel=channel,
             storage_engine=storage_engine,
@@ -572,7 +572,7 @@ async def create_instance(
             payment=payment,
         )
         message, status, response = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.instance,
             channel=channel,
             storage_engine=storage_engine,
@@ -618,7 +618,7 @@ async def forget(
         )
 
         message, status, _ = await self.submit(
-            content=content.dict(exclude_none=True),
+            content=content.model_dump(exclude_none=True),
             message_type=MessageType.forget,
             channel=channel,
             storage_engine=storage_engine,
@@ -662,11 +662,11 @@ async def _storage_push_file_with_message(
         # Prepare the STORE message
         message = await self.generate_signed_message(
             message_type=MessageType.store,
-            content=store_content.dict(exclude_none=True),
+            content=store_content.model_dump(exclude_none=True),
             channel=channel,
         )
         metadata = {
-            "message": message.dict(exclude_none=True),
+            "message": message.model_dump(exclude_none=True),
             "sync": sync,
         }
         data.add_field(

src/aleph/sdk/client/http.py

@@ -180,7 +180,7 @@ async def get_posts(
             posts: List[Post] = []
             for post_raw in posts_raw:
                 try:
-                    posts.append(Post.parse_obj(post_raw))
+                    posts.append(Post.model_validate(post_raw))
                 except ValidationError as e:
                     if not ignore_invalid_messages:
                         raise e

src/aleph/sdk/client/vm_confidential_client.py

@@ -105,7 +105,7 @@ async def measurement(self, vm_id: ItemHash) -> SEVMeasurement:
         status, text = await self.perform_operation(
             vm_id, "confidential/measurement", method="GET"
         )
-        sev_measurement = SEVMeasurement.parse_raw(text)
+        sev_measurement = SEVMeasurement.model_validate_json(text)
         return sev_measurement
 
     async def validate_measure(

src/aleph/sdk/conf.py

@@ -3,11 +3,13 @@
 import os
 from pathlib import Path
 from shutil import which
-from typing import Dict, Optional, Union
+from typing import ClassVar, Dict, Optional, Union
+
+from pydantic_settings import BaseSettings
 
 from aleph_message.models import Chain
 from aleph_message.models.execution.environment import HypervisorType
-from pydantic import BaseModel, BaseSettings, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from aleph.sdk.types import ChainInfo
 
@@ -41,7 +43,7 @@ class Settings(BaseSettings):
     REMOTE_CRYPTO_HOST: Optional[str] = None
     REMOTE_CRYPTO_UNIX_SOCKET: Optional[str] = None
     ADDRESS_TO_USE: Optional[str] = None
-    HTTP_REQUEST_TIMEOUT = 10.0
+    HTTP_REQUEST_TIMEOUT: ClassVar[float] = 10.0
 
     DEFAULT_CHANNEL: str = "ALEPH-CLOUDSOLUTIONS"
     DEFAULT_RUNTIME_ID: str = (
@@ -83,12 +85,12 @@ class Settings(BaseSettings):
 
     CODE_USES_SQUASHFS: bool = which("mksquashfs") is not None  # True if command exists
 
-    VM_URL_PATH = "https://aleph.sh/vm/{hash}"
-    VM_URL_HOST = "https://{hash_base32}.aleph.sh"
+    VM_URL_PATH: ClassVar[str] = "https://aleph.sh/vm/{hash}"
+    VM_URL_HOST: ClassVar[str] = "https://{hash_base32}.aleph.sh"
 
     # Web3Provider settings
-    TOKEN_DECIMALS = 18
-    TX_TIMEOUT = 60 * 3
+    TOKEN_DECIMALS: ClassVar[int] = 18
+    TX_TIMEOUT: ClassVar[int] = 60 * 3
     CHAINS: Dict[Union[Chain, str], ChainInfo] = {
         # TESTNETS
         "SEPOLIA": ChainInfo(
@@ -124,28 +126,29 @@ class Settings(BaseSettings):
         ),
     }
     # Add all placeholders to allow easy dynamic setup of CHAINS
-    CHAINS_SEPOLIA_ACTIVE: Optional[bool]
-    CHAINS_ETH_ACTIVE: Optional[bool]
-    CHAINS_AVAX_ACTIVE: Optional[bool]
-    CHAINS_BASE_ACTIVE: Optional[bool]
-    CHAINS_BSC_ACTIVE: Optional[bool]
-    CHAINS_SEPOLIA_RPC: Optional[str]
-    CHAINS_ETH_RPC: Optional[str]
-    CHAINS_AVAX_RPC: Optional[str]
-    CHAINS_BASE_RPC: Optional[str]
-    CHAINS_BSC_RPC: Optional[str]
+    CHAINS_SEPOLIA_ACTIVE: Optional[bool] = None
+    CHAINS_ETH_ACTIVE: Optional[bool] = None
+    CHAINS_AVAX_ACTIVE: Optional[bool] = None
+    CHAINS_BASE_ACTIVE: Optional[bool] = None
+    CHAINS_BSC_ACTIVE: Optional[bool] = None
+    CHAINS_SEPOLIA_RPC: Optional[str] = None
+    CHAINS_ETH_RPC: Optional[str] = None
+    CHAINS_AVAX_RPC: Optional[str] = None
+    CHAINS_BASE_RPC: Optional[str] = None
+    CHAINS_BSC_RPC: Optional[str] = None
 
     # Dns resolver
-    DNS_IPFS_DOMAIN = "ipfs.public.aleph.sh"
-    DNS_PROGRAM_DOMAIN = "program.public.aleph.sh"
-    DNS_INSTANCE_DOMAIN = "instance.public.aleph.sh"
-    DNS_STATIC_DOMAIN = "static.public.aleph.sh"
-    DNS_RESOLVERS = ["9.9.9.9", "1.1.1.1"]
-
-    class Config:
-        env_prefix = "ALEPH_"
-        case_sensitive = False
-        env_file = ".env"
+    DNS_IPFS_DOMAIN: ClassVar[str] = "ipfs.public.aleph.sh"
+    DNS_PROGRAM_DOMAIN: ClassVar[str] = "program.public.aleph.sh"
+    DNS_INSTANCE_DOMAIN: ClassVar[str] = "instance.public.aleph.sh"
+    DNS_STATIC_DOMAIN: ClassVar[str] = "static.public.aleph.sh"
+    DNS_RESOLVERS: ClassVar[str] = ["9.9.9.9", "1.1.1.1"]
+
+    model_config = ConfigDict(
+       env_prefix="ALEPH_",
+       case_sensitive=False,
+       env_file=".env"
+    )
 
 
 class MainConfiguration(BaseModel):
@@ -156,8 +159,7 @@ class MainConfiguration(BaseModel):
     path: Path
     chain: Chain
 
-    class Config:
-        use_enum_values = True
+    model_config = ConfigDict(use_enum_values = True)
 
 
 # Settings singleton
@@ -213,7 +215,7 @@ def save_main_configuration(file_path: Path, data: MainConfiguration):
     Synchronously save a single ChainAccount object as JSON to a file.
     """
     with file_path.open("w") as file:
-        data_serializable = data.dict()
+        data_serializable = data.model_dump()
         data_serializable["path"] = str(data_serializable["path"])
         json.dump(data_serializable, file, indent=4)
 

src/aleph/sdk/query/responses.py

@@ -9,7 +9,7 @@
     ItemType,
     MessageConfirmation,
 )
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class Post(BaseModel):
@@ -48,9 +48,9 @@ class Post(BaseModel):
     ref: Optional[Union[str, Any]] = Field(
         description="Other message referenced by this one"
     )
+    address: Optional[str] = Field(description="Address of the sender")
 
-    class Config:
-        allow_extra = False
+    model_config = ConfigDict(extra="forbid")
 
 
 class PaginationResponse(BaseModel):
@@ -64,14 +64,14 @@ class PostsResponse(PaginationResponse):
     """Response from an aleph.im node API on the path /api/v0/posts.json"""
 
     posts: List[Post]
-    pagination_item = "posts"
+    pagination_item: str = "posts"
 
 
 class MessagesResponse(PaginationResponse):
     """Response from an aleph.im node API on the path /api/v0/messages.json"""
 
     messages: List[AlephMessage]
-    pagination_item = "messages"
+    pagination_item: str = "messages"
 
 
 class PriceResponse(BaseModel):

src/aleph/sdk/utils.py

@@ -28,13 +28,15 @@
 from uuid import UUID
 from zipfile import BadZipFile, ZipFile
 
+from pydantic import BaseModel
+
 from aleph_message.models import ItemHash, MessageType
 from aleph_message.models.execution.program import Encoding
 from aleph_message.models.execution.volume import MachineVolume
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 from jwcrypto.jwa import JWA
-from pydantic.json import pydantic_encoder
+import pydantic_core
 
 from aleph.sdk.conf import settings
 from aleph.sdk.types import GenericMessage, SEVInfo, SEVMeasurement
@@ -173,7 +175,7 @@ def extended_json_encoder(obj: Any) -> Any:
     elif isinstance(obj, time):
         return obj.hour * 3600 + obj.minute * 60 + obj.second + obj.microsecond / 1e6
     else:
-        return pydantic_encoder(obj)
+        return pydantic_core.to_jsonable_python(obj)
 
 
 def parse_volume(volume_dict: Union[Mapping, MachineVolume]) -> MachineVolume:
@@ -185,7 +187,7 @@ def parse_volume(volume_dict: Union[Mapping, MachineVolume]) -> MachineVolume:
         return volume_dict
     for volume_type in get_args(MachineVolume):
         try:
-            return volume_type.parse_obj(volume_dict)
+            return volume_type.model_validate(volume_dict)
         except ValueError:
             continue
     else: