implement sign_raw for all other chains, fix formatting and imports

Author: MHHukiewitz

src/aleph/sdk/chains/common.py

@@ -62,7 +62,6 @@ def _setup_sender(self, message: Dict) -> Dict:
         else:
             raise ValueError("Message sender does not match the account's public key.")
 
-    @abstractmethod
     async def sign_message(self, message: Dict) -> Dict:
         """
         Returns a signed message from an Aleph message.
@@ -72,19 +71,19 @@ async def sign_message(self, message: Dict) -> Dict:
             Dict: Signed message
         """
         message = self._setup_sender(message)
-        sig = await self.sign_raw(get_verification_buffer(message))
-        message["signature"] = sig.hex()
+        message["signature"] = await self.sign_raw(get_verification_buffer(message))
         return message
-    
-    async def sign_raw(self, buffer: bytes) -> bytes:
+
+    @abstractmethod
+    async def sign_raw(self, buffer: bytes) -> str:
         """
         Returns a signed message from a raw buffer.
         Args:
             buffer: Buffer to sign
         Returns:
-            bytes: Signed buffer
+            str: Signature in preferred format
         """
-        
+        raise NotImplementedError
 
     @abstractmethod
     def get_address(self) -> str:

src/aleph/sdk/chains/cosmos.py

@@ -51,27 +51,27 @@ def __init__(self, private_key=None, hrp=DEFAULT_HRP):
 
     async def sign_message(self, message):
         message = self._setup_sender(message)
-
         verif = get_verification_string(message)
-
-        privkey = ecdsa.SigningKey.from_string(self.private_key, curve=ecdsa.SECP256k1)
-        signature_compact = privkey.sign_deterministic(
-            verif.encode("utf-8"),
-            hashfunc=hashlib.sha256,
-            sigencode=ecdsa.util.sigencode_string_canonize,
-        )
-        signature_base64_str = base64.b64encode(signature_compact).decode("utf-8")
         base64_pubkey = base64.b64encode(self.get_public_key().encode()).decode("utf-8")
 
         sig = {
-            "signature": signature_base64_str,
+            "signature": self.sign_raw(verif.encode("utf-8")),
             "pub_key": {"type": "tendermint/PubKeySecp256k1", "value": base64_pubkey},
             "account_number": str(0),
             "sequence": str(0),
         }
         message["signature"] = json.dumps(sig)
         return message
 
+    async def sign_raw(self, buffer: bytes) -> str:
+        privkey = ecdsa.SigningKey.from_string(self.private_key, curve=ecdsa.SECP256k1)
+        signature_compact = privkey.sign_deterministic(
+            buffer,
+            hashfunc=hashlib.sha256,
+            sigencode=ecdsa.util.sigencode_string_canonize,
+        )
+        return base64.b64encode(signature_compact).decode("utf-8")
+
     def get_address(self) -> str:
         return privkey_to_address(self.private_key)
 

src/aleph/sdk/chains/ethereum.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 from eth_account import Account
 from eth_account.messages import encode_defunct
@@ -11,7 +11,6 @@
     BaseAccount,
     get_fallback_private_key,
     get_public_key,
-    get_verification_buffer,
 )
 
 
@@ -23,12 +22,12 @@ class ETHAccount(BaseAccount):
     def __init__(self, private_key: bytes):
         self.private_key = private_key
         self._account = Account.from_key(self.private_key)
-    
-    async def sign_raw(self, buffer: bytes) -> bytes:
+
+    async def sign_raw(self, buffer: bytes) -> str:
         """Sign a raw buffer."""
         msghash = encode_defunct(text=buffer.decode("utf-8"))
         sig = self._account.sign_message(msghash)
-        return sig["signature"]
+        return sig["signature"].hex()
 
     def get_address(self) -> str:
         return self._account.address

src/aleph/sdk/chains/nuls1.py

@@ -315,6 +315,10 @@ async def sign_message(self, message):
         message["signature"] = sig.serialize().hex()
         return message
 
+    async def sign_raw(self, buffer: bytes) -> str:
+        sig = NulsSignature.sign_data(self.private_key, buffer)
+        return sig.serialize().hex()
+
     def get_address(self):
         return address_from_hash(
             public_key_to_hash(self.get_public_key(), chain_id=self.chain_id)

src/aleph/sdk/chains/nuls2.py

@@ -12,7 +12,6 @@
     BaseAccount,
     get_fallback_private_key,
     get_public_key,
-    get_verification_buffer,
 )
 
 
@@ -37,16 +36,9 @@ def __init__(self, private_key=None, chain_id=1, prefix=None):
         else:
             self.prefix = prefix
 
-    async def sign_message(self, message):
-        # sig = NulsSignature.sign_message(self.private_key,
-        #                                  get_verification_buffer(message))
-        message = self._setup_sender(message)
-
-        sig = sign_recoverable_message(
-            self.private_key, get_verification_buffer(message)
-        )
-        message["signature"] = base64.b64encode(sig).decode()
-        return message
+    async def sign_raw(self, buffer: bytes) -> str:
+        sig = sign_recoverable_message(self.private_key, buffer)
+        return base64.b64encode(sig).decode()
 
     def get_address(self):
         return address_from_hash(

src/aleph/sdk/chains/remote.py

@@ -77,6 +77,9 @@ async def sign_message(self, message: Dict) -> Dict:
             response.raise_for_status()
             return await response.json()
 
+    async def sign_raw(self, buffer: bytes) -> str:
+        raise NotImplementedError()
+
     def get_address(self) -> str:
         return self._address
 

src/aleph/sdk/chains/sol.py

@@ -32,15 +32,15 @@ async def sign_message(self, message: Dict) -> Dict:
         verif = get_verification_buffer(message)
         sig = {
             "publicKey": self.get_address(),
-            "signature": encode(self.sign_raw(verif)),
+            "signature": self.sign_raw(verif),
         }
         message["signature"] = json.dumps(sig)
         return message
 
-    async def sign_raw(self, buffer: bytes) -> bytes:
+    async def sign_raw(self, buffer: bytes) -> str:
         """Sign a raw buffer."""
         sig = self._signing_key.sign(buffer)
-        return sig.signature
+        return encode(sig.signature)
 
     def get_address(self) -> str:
         return encode(self._signing_key.verify_key)

src/aleph/sdk/chains/substrate.py

@@ -25,6 +25,10 @@ async def sign_message(self, message):
         message["signature"] = json.dumps(sig)
         return message
 
+    async def sign_raw(self, buffer: bytes) -> str:
+        sig = self._account.sign(buffer)
+        return sig.hex()
+
     def get_address(self):
         return self._account.ss58_address
 

src/aleph/sdk/chains/tezos.py

@@ -27,12 +27,15 @@ async def sign_message(self, message: Dict) -> Dict:
         verif = get_verification_buffer(message)
         sig = {
             "publicKey": self.get_public_key(),
-            "signature": self._account.sign(verif),
+            "signature": self.sign_raw(verif),
         }
 
         message["signature"] = json.dumps(sig)
         return message
 
+    async def sign_raw(self, buffer: bytes) -> str:
+        return self._account.sign(buffer)
+
     def get_address(self) -> str:
         return self._account.public_key_hash()