feat: specific to string and to bytes private key

Signed-off-by: exploreriii <[email protected]>

Author: exploreriii

src/hiero_sdk_python/crypto/private_key.py

@@ -288,15 +288,25 @@ def to_bytes_raw(self) -> bytes:
             # ECDSA => integer scalar in big-endian
             return self._private_key.private_numbers().private_value.to_bytes(32, "big")
 
-    def to_string(self) -> str:
+    def to_bytes_ed25519_raw(self) -> bytes:
         """
-        Returns the private key as a hex string (raw).
-        Matches old usage that calls to_string().
+        Return the raw 32-byte seed (Ed25519).
         """
-        return self.to_string_raw()
+        if self.is_ed25519():
+            return self._private_key.private_bytes(
+                encoding=serialization.Encoding.Raw,
+                format=serialization.PrivateFormat.Raw,
+                encryption_algorithm=serialization.NoEncryption()
+            )
+        raise ValueError("Not Ed25519).")
 
-    def to_string_raw(self) -> str:
-        return self.to_bytes_raw().hex()
+    def to_bytes_ecdsa_raw(self) -> bytes:
+        """
+        Return the raw 32-byte seed (ecdsa).
+        """
+        if self.is_ecdsa():
+            return self._private_key.private_numbers().private_value.to_bytes(32, "big")
+        raise ValueError("Not ecdsa).")
 
     def to_bytes_der(self) -> bytes:
         """
@@ -307,10 +317,25 @@ def to_bytes_der(self) -> bytes:
             format=serialization.PrivateFormat.PKCS8,
             encryption_algorithm=serialization.NoEncryption()
         )
+    
+    def to_string_raw(self) -> str:
+        return self.to_bytes_raw().hex()
+
+    def to_string_ed25519_raw(self) -> str:
+        return self.to_bytes_ed25519_raw().hex()
 
+    def to_string_ecdsa_raw(self) -> str:
+        return self.to_bytes_ecdsa_raw().hex()
+        
     def to_string_der(self) -> str:
         return self.to_bytes_der().hex()
 
+    def to_string(self) -> str:
+        """
+        Returns the private key as a hex string (raw).
+        Matches old usage that calls to_string().
+        """
+        return self.to_string_raw()
     #
     # ---------------------------------
     # is_ed25519 / is_ecdsa checks

tests/test_keys_private.py

@@ -29,11 +29,11 @@ def test_generate_ed25519():
     pub.verify(sig, data)  # should succeed if signature is valid
 
     # Check round-trip raw bytes
-    raw_bytes = priv.to_bytes_raw()
+    raw_bytes = priv.to_bytes_ed25519_raw()
     assert len(raw_bytes) == 32
 
     # Check hex string conversion
-    raw_hex = priv.to_string_raw()
+    raw_hex = priv.to_string_ed25519_raw()
     assert len(raw_hex) == 64
     assert raw_hex == raw_bytes.hex()
 
@@ -68,11 +68,11 @@ def test_generate_ecdsa():
     pub.verify(sig, data)  # should succeed
 
     # Check raw bytes
-    raw_bytes = priv.to_bytes_raw()
+    raw_bytes = priv.to_bytes_ecdsa_raw()
     assert len(raw_bytes) == 32
 
     # Check hex string
-    raw_hex = priv.to_string_raw()
+    raw_hex = priv.to_string_ecdsa_raw()
     assert len(raw_hex) == 64
     assert raw_hex == raw_bytes.hex()
 
@@ -167,7 +167,7 @@ def test_from_string_der_ecdsa_round_trip():
     assert loaded.is_ecdsa()
 
     # 4) Confirm the raw scalar round-trips perfectly
-    assert loaded.to_bytes_raw() == scalar_one
+    assert loaded.to_bytes_ecdsa_raw() == scalar_one
 
 
 def test_from_string_der_invalid_hex():
@@ -333,7 +333,7 @@ def test_from_bytes_ambiguity_prefers_ecdsa_when_ed25519_fails(monkeypatch):
 
     assert priv.is_ecdsa(), "from_bytes should have returned an ECDSA key"
     # And round-trip raw scalar
-    assert priv.to_bytes_raw() == ecdsa_scalar_one
+    assert priv.to_bytes_ecdsa_raw() == ecdsa_scalar_one
 
 
 def test_type_checks_are_mutually_exclusive():