Post-SOL fixes

src/aleph/sdk/account.py

@@ -21,8 +21,8 @@ def load_chain_account_type(chain: Chain) -> Type[AccountFromPrivateKey]:
     chain_account_map: Dict[Chain, Type[AccountFromPrivateKey]] = {
         Chain.ETH: ETHAccount,
         Chain.AVAX: ETHAccount,
-        Chain.SOL: SOLAccount,
         Chain.BASE: ETHAccount,
+        Chain.SOL: SOLAccount,
     }
     return chain_account_map.get(chain) or ETHAccount
 
@@ -43,34 +43,29 @@ def _load_account(
     private_key_path: Optional[Path] = None,
     account_type: Optional[Type[AccountFromPrivateKey]] = None,
 ) -> AccountFromPrivateKey:
-    """Load private key from a string or a file. takes the string argument in priority"""
-    if private_key_str or (private_key_path and private_key_path.is_file()):
-        if account_type:
-            if private_key_path and private_key_path.is_file():
-                return account_from_file(private_key_path, account_type)
-            elif private_key_str:
-                return account_from_hex_string(private_key_str, account_type)
-            else:
-                raise ValueError("Any private key specified")
+    """Load an account from a private key string or file, or from the configuration file."""
+
+    # Loads configuration if no account_type is specified
+    if not account_type:
+        config = load_main_configuration(settings.CONFIG_FILE)
+        if config and hasattr(config, "chain"):
+            account_type = load_chain_account_type(config.chain)
+            logger.debug(
+                f"Detected {config.chain} account for path {settings.CONFIG_FILE}"
+            )
         else:
-            main_configuration = load_main_configuration(settings.CONFIG_FILE)
-            if main_configuration:
-                account_type = load_chain_account_type(main_configuration.chain)
-                logger.debug(
-                    f"Detected {main_configuration.chain} account for path {settings.CONFIG_FILE}"
-                )
-            else:
-                account_type = ETHAccount  # Defaults to ETHAccount
-                logger.warning(
-                    f"No main configuration data found in {settings.CONFIG_FILE}, defaulting to {account_type.__name__}"
-                )
-            if private_key_path and private_key_path.is_file():
-                return account_from_file(private_key_path, account_type)
-            elif private_key_str:
-                return account_from_hex_string(private_key_str, account_type)
-            else:
-                raise ValueError("Any private key specified")
+            account_type = ETHAccount  # Defaults to ETHAccount
+            logger.warning(
+                f"No main configuration data found in {settings.CONFIG_FILE}, defaulting to {account_type.__name__}"
+            )
 
+    # Loads private key from a string
+    if private_key_str:
+        return account_from_hex_string(private_key_str, account_type)
+    # Loads private key from a file
+    elif private_key_path and private_key_path.is_file():
+        return account_from_file(private_key_path, account_type)
+    # For ledger keys
     elif settings.REMOTE_CRYPTO_HOST:
         logger.debug("Using remote account")
         loop = asyncio.get_event_loop()
@@ -80,8 +75,8 @@ def _load_account(
                 unix_socket=settings.REMOTE_CRYPTO_UNIX_SOCKET,
             )
         )
+    # Fallback: config.path if set, else generate a new private key
     else:
-        account_type = ETHAccount  # Defaults to ETHAccount
         new_private_key = get_fallback_private_key()
         account = account_type(private_key=new_private_key)
         logger.info(

src/aleph/sdk/chains/ethereum.py

@@ -1,4 +1,5 @@
 import asyncio
+import base64
 from decimal import Decimal
 from pathlib import Path
 from typing import Awaitable, Optional, Union
@@ -61,6 +62,10 @@ def from_mnemonic(mnemonic: str, chain: Optional[Chain] = None) -> "ETHAccount":
             private_key=Account.from_mnemonic(mnemonic=mnemonic).key, chain=chain
         )
 
+    def export_private_key(self) -> str:
+        """Export the private key using standard format."""
+        return f"0x{base64.b16encode(self.private_key).decode().lower()}"
+
     def get_address(self) -> str:
         return self._account.address
 

src/aleph/sdk/chains/solana.py

@@ -43,6 +43,12 @@ async def sign_raw(self, buffer: bytes) -> bytes:
         sig = self._signing_key.sign(buffer)
         return sig.signature
 
+    def export_private_key(self) -> str:
+        """Export the private key using Phantom format."""
+        return base58.b58encode(
+            self.private_key + self._signing_key.verify_key.encode()
+        ).decode()
+
     def get_address(self) -> str:
         return encode(self._signing_key.verify_key)
 

src/aleph/sdk/client/vm_client.py

@@ -5,10 +5,11 @@
 from urllib.parse import urlparse
 
 import aiohttp
-from aleph_message.models import ItemHash
+from aleph_message.models import Chain, ItemHash
 from eth_account.messages import encode_defunct
 from jwcrypto import jwk
 
+from aleph.sdk.chains.solana import SOLAccount
 from aleph.sdk.types import Account
 from aleph.sdk.utils import (
     create_vm_control_payload,
@@ -36,11 +37,13 @@ def __init__(
         self.account = account
         self.ephemeral_key = jwk.JWK.generate(kty="EC", crv="P-256")
         self.node_url = node_url.rstrip("/")
-        self.pubkey_payload = self._generate_pubkey_payload()
+        self.pubkey_payload = self._generate_pubkey_payload(
+            Chain.SOL if isinstance(account, SOLAccount) else Chain.ETH
+        )
         self.pubkey_signature_header = ""
         self.session = session or aiohttp.ClientSession()
 
-    def _generate_pubkey_payload(self) -> Dict[str, Any]:
+    def _generate_pubkey_payload(self, chain: Chain = Chain.ETH) -> Dict[str, Any]:
         return {
             "pubkey": json.loads(self.ephemeral_key.export_public()),
             "alg": "ECDSA",
@@ -50,12 +53,16 @@ def _generate_pubkey_payload(self) -> Dict[str, Any]:
                 datetime.datetime.utcnow() + datetime.timedelta(days=1)
             ).isoformat()
             + "Z",
+            "chain": chain.value,
         }
 
     async def _generate_pubkey_signature_header(self) -> str:
         pubkey_payload = json.dumps(self.pubkey_payload).encode("utf-8").hex()
-        signable_message = encode_defunct(hexstr=pubkey_payload)
-        buffer_to_sign = signable_message.body
+        if isinstance(self.account, SOLAccount):
+            buffer_to_sign = bytes(pubkey_payload, encoding="utf-8")
+        else:
+            signable_message = encode_defunct(hexstr=pubkey_payload)
+            buffer_to_sign = signable_message.body
 
         signed_message = await self.account.sign_raw(buffer_to_sign)
         pubkey_signature = to_0x_hex(signed_message)

src/aleph/sdk/types.py

@@ -39,6 +39,8 @@ def __init__(self, private_key: bytes): ...
 
     async def sign_raw(self, buffer: bytes) -> bytes: ...
 
+    def export_private_key(self) -> str: ...
+
 
 GenericMessage = TypeVar("GenericMessage", bound=AlephMessage)