dev: Cleanup comments

Author: Abeeujah

starknet_py/constants.py

@@ -35,7 +35,6 @@
 EC_ORDER = 0x800000000000010FFFFFFFFFFFFFFFFB781126DCAE7B2321E66A241ADC64D2F
 
 # From cairo-lang
-# int_from_bytes(b"STARKNET_CONTRACT_ADDRESS")
 CONTRACT_ADDRESS_PREFIX = 523065374597054866729014270389667305596563390979550329787219
 L2_ADDRESS_UPPER_BOUND = 2**251 - 256
 

starknet_py/hash/address.py

@@ -2,13 +2,14 @@
 
 from starknet_py.constants import CONTRACT_ADDRESS_PREFIX, L2_ADDRESS_UPPER_BOUND
 from starknet_py.hash.utils import (
-    # HEX_PREFIX,
     _starknet_keccak,
     compute_hash_on_elements,
     encode_uint,
     get_bytes_length,
 )
 
+HEX_PREFIX = "0x"
+
 
 def compute_address(
     *,
@@ -51,7 +52,7 @@ def get_checksum_address(address: str) -> str:
     :param address: Address to encode
     :return: Checksum address
     """
-    if not address.lower().startswith("0x"):
+    if not address.lower().startswith(HEX_PREFIX):
         raise ValueError(f"{address} is not a valid hexadecimal address.")
 
     int_address = int(address, 16)
@@ -69,7 +70,7 @@ def get_checksum_address(address: str) -> str:
         for i, char in enumerate(string_address)
     )
 
-    return f"0x{result}"
+    return f"{HEX_PREFIX}{result}"
 
 
 def is_checksum_address(address: str) -> bool:

starknet_py/hash/utils.py

@@ -10,11 +10,9 @@
     cpp_verify,
 )
 
-# from starknet_py.common import int_from_bytes
 from starknet_py.constants import EC_ORDER
 
 MASK_250 = 2**250 - 1
-HEX_PREFIX = "0x"
 
 
 def _starknet_keccak(data: bytes) -> int:

starknet_py/net/models/typed_data.py

@@ -2,8 +2,8 @@
 TypedDict structures for TypedData
 """
 
-from enum import Enum
 import sys
+from enum import Enum
 from typing import Any, Dict, List, Optional, TypedDict
 
 # from starknet_py.net.schemas.common import Revision
@@ -24,7 +24,7 @@ class ParameterDict(TypedDict):
     contains: NotRequired[str]
 
 
-class Revisionx(Enum):
+class Revision(Enum):
     """
     Enum representing the revision of the specification to be used.
     """
@@ -41,7 +41,7 @@ class DomainDict(TypedDict):
     name: str
     version: str
     chainId: str
-    revision: Optional[Revisionx]
+    revision: Optional[Revision]
 
 
 class TypedDataDict(TypedDict):

starknet_py/net/schemas/common.py

@@ -1,6 +1,6 @@
 import re
 import sys
-from enum import Enum
+
 from typing import Any, Mapping, Optional, Union
 
 from marshmallow import Schema, ValidationError, fields, post_load
@@ -19,7 +19,7 @@
     TransactionStatusWithoutL1,
     TransactionType,
 )
-from starknet_py.net.models.typed_data import Revisionx
+from starknet_py.net.models.typed_data import Revision
 
 # pylint: disable=unused-argument
 
@@ -380,33 +380,24 @@ def make_dataclass(self, data, **kwargs):
         return StorageEntry(**data)
 
 
-class Revision(Enum):
-    """
-    Enum representing the revision of the specification to be used.
-    """
-
-    V0 = 0
-    V1 = 1
-
-
 class RevisionField(fields.Field):
     def _serialize(self, value: Any, attr: Optional[str], obj: Any, **kwargs):
-        if value is None or value == Revisionx.V0:
-            return str(Revisionx.V0.value)
+        if value is None or value == Revision.V0:
+            return str(Revision.V0.value)
         return value.value
 
-    def _deserialize(self, value, attr, data, **kwargs) -> Revisionx:
+    def _deserialize(self, value, attr, data, **kwargs) -> Revision:
         if isinstance(value, str):
             value = int(value)
 
-        if isinstance(value, Revisionx):
+        if isinstance(value, Revision):
             value = value.value
 
-        revisions = [revision.value for revision in Revisionx]
+        revisions = [revision.value for revision in Revision]
         if value not in revisions:
             allowed_revisions_str = "".join(list(map(str, revisions)))
             raise ValidationError(
                 f"Invalid value provided for Revision: {value}. Allowed values are {allowed_revisions_str}."
             )
 
-        return Revisionx(value)
+        return Revision(value)

starknet_py/utils/typed_data.py

@@ -11,7 +11,7 @@
 from starknet_py.hash.hash_method import HashMethod
 from starknet_py.hash.selector import get_selector_from_name
 from starknet_py.net.client_utils import _to_rpc_felt
-from starknet_py.net.models.typed_data import DomainDict, Revisionx, TypedDataDict
+from starknet_py.net.models.typed_data import DomainDict, Revision, TypedDataDict
 from starknet_py.net.schemas.common import RevisionField
 from starknet_py.serialization.data_serializers import ByteArraySerializer
 from starknet_py.utils.merkle_tree import MerkleTree
@@ -49,16 +49,16 @@ class Domain:
     name: str
     version: str
     chain_id: Union[str, int]
-    revision: Optional[Revisionx] = None
+    revision: Optional[Revision] = None
 
     def __post_init__(self):
         self.resolved_revision = (
-            Revisionx(self.revision) if self.revision else Revisionx.V0
+            Revision(self.revision) if self.revision else Revision.V0
         )
         self.separator_name = self._resolve_separator_name()
 
     def _resolve_separator_name(self):
-        if self.resolved_revision == Revisionx.V0:
+        if self.resolved_revision == Revision.V0:
             return "StarkNetDomain"
         return "StarknetDomain"
 
@@ -136,7 +136,7 @@ def _all_types(self):
 
     @property
     def _hash_method(self) -> HashMethod:
-        if self.domain.resolved_revision == Revisionx.V0:
+        if self.domain.resolved_revision == Revision.V0:
             return HashMethod.PEDERSEN
         return HashMethod.POSEIDON
 
@@ -230,11 +230,11 @@ def _encode_value(
         basic_type = BasicType(type_name)
 
         encoded_value = None
-        if self.domain.resolved_revision == Revisionx.V0 and isinstance(
+        if self.domain.resolved_revision == Revision.V0 and isinstance(
             value, (str, int)
         ):
             encoded_value = self._encode_value_v0(basic_type, value)
-        elif self.domain.resolved_revision == Revisionx.V1 and isinstance(
+        elif self.domain.resolved_revision == Revision.V1 and isinstance(
             value, (str, int, dict)
         ):
             encoded_value = self._encode_value_v1(basic_type, value, type_name, context)
@@ -328,7 +328,7 @@ def _verify_types(self):
                     self._validate_enum_type()
 
     def _validate_enum_type(self):
-        if self.domain.resolved_revision != Revisionx.V1:
+        if self.domain.resolved_revision != Revision.V1:
             raise ValueError(
                 f"'{BasicType.ENUM.name}' basic type is not supported in revision "
                 f"{self.domain.resolved_revision.value}."
@@ -369,7 +369,7 @@ def _encode_type(self, type_name: str) -> str:
 
         def encode_dependency(dependency: str) -> str:
             def escape(s: str) -> str:
-                if self.domain.resolved_revision == Revisionx.V0:
+                if self.domain.resolved_revision == Revision.V0:
                     return s
                 return f'"{s}"'
 
@@ -381,7 +381,7 @@ def escape(s: str) -> str:
                 target_type = (
                     param.contains
                     if isinstance(param, EnumParameter)
-                    and self.domain.resolved_revision == Revisionx.V1
+                    and self.domain.resolved_revision == Revision.V1
                     else param.type
                 )
 
@@ -617,7 +617,7 @@ def is_in_range(n: int):
     raise ValueError(f"Value [{value}] is out of range for '{BasicType.I128}'.")
 
 
-def _get_basic_type_names(revision: Revisionx) -> List[str]:
+def _get_basic_type_names(revision: Revision) -> List[str]:
     basic_types_v0 = [
         BasicType.FELT,
         BasicType.SELECTOR,
@@ -628,14 +628,14 @@ def _get_basic_type_names(revision: Revisionx) -> List[str]:
 
     basic_types_v1 = list(BasicType)
 
-    basic_types = basic_types_v0 if revision == Revisionx.V0 else basic_types_v1
+    basic_types = basic_types_v0 if revision == Revision.V0 else basic_types_v1
     return [basic_type.value for basic_type in basic_types]
 
 
 def _get_preset_types(
-    revision: Revisionx,
+    revision: Revision,
 ) -> Dict[str, List[StandardParameter]]:
-    if revision == Revisionx.V0:
+    if revision == Revision.V0:
         return {}
 
     return {