Update private/public keys API + fix Timestamp proto conversions

Signed-off-by: Alexander Shenshin <[email protected]>

Author: AlexanderShenshin

src/hedera_sdk_python/crypto/private_key.py

@@ -9,7 +9,7 @@ class PrivateKey:
     Represents a private key that can be either Ed25519 or ECDSA (secp256k1).
     """
 
-    def __init__(self, private_key):
+    def __init__(self, private_key: ec.EllipticCurvePrivateKey | ed25519.Ed25519PrivateKey):
         """
         Initializes a PrivateKey from a cryptography PrivateKey object.
         """
@@ -56,26 +56,21 @@ def generate_ecdsa(cls):
         return cls(private_key)
 
     @classmethod
-    def from_string(cls, key_str):
+    def from_bytes(cls, key_bytes: bytes):
         """
-        Load a private key from a hex-encoded string. For Ed25519, expects 32 bytes.
+        Load a private key from bytes. For Ed25519, expects 32 bytes.
         For ECDSA (secp256k1), also expects 32 bytes (raw scalar).
-        If it's DER-encoded, tries to parse and detect Ed25519 vs ECDSA.
+        If the key is DER-encoded, tries to parse and detect Ed25519 vs ECDSA.
 
         Args:
-            key_str (str): The hex-encoded private key string.
+            key_bytes (bytes): Private key bytes.
 
         Returns:
             PrivateKey: A new instance of PrivateKey.
 
         Raises:
             ValueError: If the key is invalid or unsupported.
         """
-        try:
-            key_bytes = bytes.fromhex(key_str)
-        except ValueError:
-            raise ValueError("Invalid hex-encoded private key string.")
-
         if len(key_bytes) == 32:
             try:
                 ed_priv = ed25519.Ed25519PrivateKey.from_private_bytes(key_bytes)
@@ -104,6 +99,30 @@ def from_string(cls, key_str):
 
         raise ValueError("Unsupported private key type.")
 
+    @classmethod
+    def from_string(cls, key_str):
+        """
+        Load a private key from a hex-encoded string. For Ed25519, expects 32 bytes.
+        For ECDSA (secp256k1), also expects 32 bytes (raw scalar).
+        If the key is DER-encoded, tries to parse and detect Ed25519 vs ECDSA.
+
+        Args:
+            key_str (str): The hex-encoded private key string.
+
+        Returns:
+            PrivateKey: A new instance of PrivateKey.
+
+        Raises:
+            ValueError: If the key is invalid or unsupported.
+        """
+        try:
+            key_bytes = bytes.fromhex(key_str.removeprefix("0x"))
+        except ValueError:
+            raise ValueError("Invalid hex-encoded private key string.")
+
+        return cls.from_bytes(key_bytes)
+
+
     def sign(self, data: bytes) -> bytes:
         """
         Signs the given data using this private key (Ed25519 or ECDSA).

src/hedera_sdk_python/crypto/public_key.py

@@ -6,12 +6,76 @@ class PublicKey:
     Represents a public key that can be either Ed25519 or ECDSA (secp256k1).
     """
 
-    def __init__(self, public_key):
+    def __init__(self, public_key: ec.EllipticCurvePublicKey | ed25519.Ed25519PublicKey):
         """
         Initializes a PublicKey from a cryptography PublicKey object.
         """
         self._public_key = public_key
 
+    @classmethod
+    def from_bytes(cls, key_bytes: bytes):
+        """
+        Load a public key from bytes.
+        For Ed25519, expects 32 bytes. Raw bytes for ECDSA are not supported for now.
+        If the key is DER-encoded, tries to parse and detect Ed25519 vs ECDSA.
+
+        Args:
+            key_bytes (bytes): Public key bytes.
+
+        Returns:
+            PublicKey: A new instance of PublicKey.
+
+        Raises:
+            ValueError: If the key is invalid or unsupported.
+        """
+
+        if len(key_bytes) == 32:
+            ed_public = ed25519.Ed25519PublicKey.from_public_bytes(key_bytes)
+            return cls(ed_public)
+        # TODO: Consider adding support for creating ECDSA public key instance from raw encoded point
+        # Java SDK example: https://github.com/hiero-ledger/hiero-sdk-java/blob/main/sdk-java/src/main/java/org/hiero/sdk/java/PublicKeyECDSA.java#L46
+        #
+        # Potential approach for Python:
+        # ec_public = ec.EllipticCurvePublicKey.from_encoded_point(ec.SECP256K1(), key_bytes)
+
+        try:
+            public_key = serialization.load_der_public_key(key_bytes)
+        except Exception as e:
+            raise ValueError(f"Failed to load public key (DER): {e}")
+
+        if isinstance(public_key, ed25519.Ed25519PublicKey):
+            return cls(public_key)
+
+        if isinstance(public_key, ec.EllipticCurvePublicKey):
+            if not isinstance(public_key.curve, ec.SECP256K1):
+                raise ValueError("Only secp256k1 ECDSA is supported.")
+            return cls(public_key)
+
+        raise ValueError("Unsupported public key type.")
+
+    @classmethod
+    def from_string(cls, key_str):
+        """
+        Load a public key from a hex-encoded string.
+        For Ed25519, expects 32 bytes. Raw bytes string for ECDSA is not supported for now.
+        If the key is DER-encoded, tries to parse and detect Ed25519 vs ECDSA.
+
+        Args:
+            key_str (str): The hex-encoded public key string.
+
+        Returns:
+            PublicKey: A new instance of PublicKey.
+
+        Raises:
+            ValueError: If the key is invalid or unsupported.
+        """
+        try:
+            key_bytes = bytes.fromhex(key_str.removeprefix("0x"))
+        except ValueError:
+            raise ValueError("Invalid hex-encoded public key string.")
+
+        return cls.from_bytes(key_bytes)
+
     def verify(self, signature: bytes, data: bytes) -> None:
         """
         Verifies a signature for the given data using this public key.

src/hedera_sdk_python/timestamp.py

@@ -1,7 +1,9 @@
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 import random
 import time
 
+from hedera_sdk_python.hapi.services.timestamp_pb2 import Timestamp as TimestampProto
+
 
 class Timestamp:
     """
@@ -72,7 +74,7 @@ def to_date(self) -> datetime:
         Returns:
             datetime: A `datetime` instance.
         """
-        return datetime.fromtimestamp(self.seconds) + timedelta(
+        return datetime.fromtimestamp(self.seconds, tz=timezone.utc) + timedelta(
             microseconds=self.nanos // 1000
         )
 
@@ -92,29 +94,28 @@ def plus_nanos(self, nanos: int) -> "Timestamp":
 
         return Timestamp(new_seconds, new_nanos)
 
-    def to_protobuf(self) -> dict:
+    def to_protobuf(self) -> TimestampProto:
         """
-        Convert the `Timestamp` to a protobuf-compatible dictionary.
+        Convert the `Timestamp` to corresponding protobuf object.
 
         Returns:
-            dict: A dictionary representation of the `Timestamp`.
+            dict: A protobuf representation of the `Timestamp`.
         """
-        return {"seconds": self.seconds, "nanos": self.nanos}
+        return TimestampProto(seconds=self.seconds, nanos=self.nanos)
 
     @staticmethod
-    def from_protobuf(pb_obj) -> "Timestamp":
+    def from_protobuf(pb_obj: TimestampProto) -> "Timestamp":
         """
         Create a `Timestamp` from a protobuf object.
 
         Args:
-            pb_obj (dict): A protobuf-like dictionary with `seconds` and `nanos`.
+            pb_obj (timestamp_pb2.Timestamp): A protobuf Timestamp object.
 
         Returns:
             Timestamp: A `Timestamp` instance.
         """
-        seconds = pb_obj.get("seconds", 0)
-        nanos = pb_obj.get("nanos", 0)
-        return Timestamp(seconds, nanos)
+
+        return Timestamp(pb_obj.seconds, pb_obj.nanos)
 
     def __str__(self) -> str:
         """