[Node] address PR #3429 review comments

- Add WalletError hierarchy (errors.py): typed subclasses preserve ValueError/KeyError compat
- Add WalletInfo / WalletEntry TypedDicts for type-safe wallet dicts
- Add WalletStorageBackend enum (octobot/enums.py); use in build_wallet_storage factory
- Replace raw "iv"/"data" string literals with _WALLET_BLOB_IV_KEY/_WALLET_BLOB_DATA_KEY constants
- Replace fcntl-based file locking with filelock (cross-platform, pythonic); add to requirements.txt
- Upgrade init_sync_client_for_wallet log from info → error for KeyError/ValueError; re-raise on Exception
- Upgrade auto_init_sync_client ValueError log from info → warning with explicit message
- Move _filter_by_wallet to workflows_util.filter_by_wallet; reuse in scheduler.get_pending_tasks/get_results
- Replace ValueError message-string inspection in setup.py with typed WalletError except clauses
- Flip import priority in main.py, node_api.py, tasks.py, users.py: tentacles-first, bare fallback
- Drop stray test_core.py (simple_market_making) from this PR (unrelated to wallet architecture)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: Herklos

octobot/community/authentication.py

@@ -697,9 +697,10 @@ def init_sync_client_for_wallet(self, address: str) -> None:
                     replica_sync_interval_ms=constants.REPLICA_SYNC_INTERVAL_MS,
                 )
             except (KeyError, ValueError) as e:
-                self.logger.info(f"Sync client init skipped for {address}: {e}")
+                self.logger.error(f"Sync client init skipped for {address}: {e}")
             except Exception as e:
                 self.logger.exception(e, True, f"Failed to initialize sync client for wallet {address}: {e}")
+                raise
 
     def init_sync_client_with_passphrase(self, passphrase: str) -> None:
         """Initialize the sync client using the admin wallet passphrase."""
@@ -752,7 +753,7 @@ def auto_init_sync_client(self) -> bool:
                 )
             return True
         except ValueError as e:
-            self.logger.info(f"Bot auto-unlock not available: {e}")
+            self.logger.warning(f"Bot auto-unlock skipped — wallet unreachable or misconfigured: {e}")
             return False
         except Exception as e:
             self.logger.exception(e, True, f"Failed to auto-initialize sync client: {e}")

octobot/community/wallet_backend/__init__.py

@@ -18,6 +18,18 @@
 from octobot.community.wallet_backend.community_wallet import (
     WalletBackend,
 )
+from octobot.community.wallet_backend import errors
+from octobot.community.wallet_backend.errors import (
+    WalletError,
+    WalletAlreadyExistsError,
+    AdminWalletAlreadyExistsError,
+    WalletNotFoundError,
+    InvalidPassphraseError,
+    CannotRemoveLastWalletError,
+    CannotRemoveAdminWalletError,
+    InvalidPrivateKeyError,
+    PassphraseTooShortError,
+)
 from octobot.community.wallet_backend import wallet_storage
 from octobot.community.wallet_backend.wallet_storage import (
     WalletStorage,
@@ -29,6 +41,15 @@
 
 __all__ = [
     "WalletBackend",
+    "WalletError",
+    "WalletAlreadyExistsError",
+    "AdminWalletAlreadyExistsError",
+    "WalletNotFoundError",
+    "InvalidPassphraseError",
+    "CannotRemoveLastWalletError",
+    "CannotRemoveAdminWalletError",
+    "InvalidPrivateKeyError",
+    "PassphraseTooShortError",
     "WalletStorage",
     "ConfigJsonWalletStorage",
     "DedicatedFileWalletStorage",

octobot/community/wallet_backend/community_wallet.py

@@ -21,6 +21,16 @@
 import typing
 
 import octobot_sync.chain as sync_chain
+from octobot.community.wallet_backend.errors import (
+    AdminWalletAlreadyExistsError,
+    CannotRemoveAdminWalletError,
+    CannotRemoveLastWalletError,
+    InvalidPassphraseError,
+    InvalidPrivateKeyError,
+    PassphraseTooShortError,
+    WalletAlreadyExistsError,
+    WalletNotFoundError,
+)
 from octobot.community.wallet_backend.wallet_storage import (
     WalletStorage,
     build_wallet_storage,
@@ -30,6 +40,20 @@
 _PBKDF2_ALG = "sha256"
 
 
+class WalletInfo(typing.TypedDict):
+    address: str
+    name: typing.Optional[str]
+    is_admin: bool
+
+
+class WalletEntry(typing.TypedDict):
+    address: str
+    name: typing.Optional[str]
+    is_admin: bool
+    private_key: str
+    passphrase_hash: str
+
+
 def _hash_passphrase(passphrase: str) -> str:
     """Hash a passphrase with PBKDF2-HMAC-SHA256 for storage. Format: salt_b64:key_b64."""
     salt = secrets.token_bytes(32)
@@ -60,33 +84,33 @@ def __init__(self, sync_storage, logger, storage: typing.Optional[WalletStorage]
         self._wallet_lock = threading.Lock()
         self._storage: WalletStorage = storage if storage is not None else build_wallet_storage(sync_storage)
 
-    def _get_node_wallets_list(self) -> list:
+    def _get_node_wallets_list(self) -> list[WalletEntry]:
         return self._storage.load()
 
-    def _save_node_wallets_list(self, node_wallets: list) -> None:
+    def _save_node_wallets_list(self, node_wallets: list[WalletEntry]) -> None:
         self._storage.save(node_wallets)
 
-    def _build_entry_fields(self, private_key_hex: str, passphrase: str) -> dict:
+    def _build_entry_fields(self, private_key_hex: str, passphrase: str) -> dict[str, str]:
         return {
             "private_key": private_key_hex,
             "passphrase_hash": _hash_passphrase(passphrase),
         }
 
-    def _wallet_from_entry(self, entry: dict) -> sync_chain.Wallet:
+    def _wallet_from_entry(self, entry: WalletEntry) -> sync_chain.Wallet:
         return sync_chain.Wallet(private_key=entry["private_key"], address=entry["address"])
 
-    def _find_wallet_entry(self, address: str) -> typing.Optional[dict]:
+    def _find_wallet_entry(self, address: str) -> typing.Optional[WalletEntry]:
         # Addresses are stored lowercase; normalize input to match
         normalized = address.lower()
         for entry in self._get_node_wallets_list():
             if entry.get("address", "") == normalized:
                 return entry
         return None
 
-    def list_wallets(self) -> list:
+    def list_wallets(self) -> list[WalletInfo]:
         """Return public wallet info (no key material)."""
         return [
-            {"address": e["address"], "name": e.get("name"), "is_admin": e.get("is_admin", False)}
+            WalletInfo(address=e["address"], name=e.get("name"), is_admin=e.get("is_admin", False))
             for e in self._get_node_wallets_list()
         ]
 
@@ -109,7 +133,7 @@ def import_wallet(
         try:
             address = sync_chain.address_from_evm_key(private_key)
         except Exception as err:
-            raise ValueError(f"Invalid EVM private key: {err}") from err
+            raise InvalidPrivateKeyError(f"Invalid EVM private key: {err}") from err
         return self._add_wallet_entry(private_key, address, name, passphrase, is_admin)
 
     def _add_wallet_entry(
@@ -121,15 +145,15 @@ def _add_wallet_entry(
         is_admin: bool,
     ) -> sync_chain.Wallet:
         if len(passphrase) < 8:
-            raise ValueError("Passphrase must be at least 8 characters")
+            raise PassphraseTooShortError("Passphrase must be at least 8 characters")
         normalized = address.lower()
         with self._wallet_lock:
             node_wallets = self._get_node_wallets_list()
             if any(e.get("address", "") == normalized for e in node_wallets):
-                raise ValueError(f"Wallet {address} already exists")
+                raise WalletAlreadyExistsError(f"Wallet {address} already exists")
             if is_admin and any(e.get("is_admin") for e in node_wallets):
-                raise ValueError("An admin wallet already exists")
-            entry = {
+                raise AdminWalletAlreadyExistsError("An admin wallet already exists")
+            entry: WalletEntry = {
                 "address": normalized,  # always store lowercase
                 "name": name or None,
                 "is_admin": is_admin,
@@ -139,52 +163,52 @@ def _add_wallet_entry(
             self._save_node_wallets_list(node_wallets)
         return sync_chain.Wallet(private_key=private_key, address=address)
 
-    def authenticate(self, address: str, passphrase: str) -> dict:
+    def authenticate(self, address: str, passphrase: str) -> WalletInfo:
         """Verify passphrase and return wallet metadata in a single storage read.
 
-        Returns {"is_admin": bool, "name": Optional[str]}.
-        Raises KeyError if wallet not found, ValueError if passphrase incorrect.
+        Returns WalletInfo with is_admin and name.
+        Raises WalletNotFoundError if wallet not found, InvalidPassphraseError if passphrase incorrect.
         """
         entry = self._find_wallet_entry(address)
         if entry is None:
-            raise KeyError(f"Wallet {address} not found")
+            raise WalletNotFoundError(f"Wallet {address} not found")
         if not _verify_passphrase_hash(passphrase, entry.get("passphrase_hash", "")):
-            raise ValueError("Invalid passphrase")
-        return {"is_admin": entry.get("is_admin", False), "name": entry.get("name")}
+            raise InvalidPassphraseError("Invalid passphrase")
+        return WalletInfo(is_admin=entry.get("is_admin", False), name=entry.get("name"), address=entry["address"])
 
     def verify_wallet_passphrase(self, address: str, passphrase: str) -> bool:
         try:
             self.authenticate(address, passphrase)
             return True
-        except (KeyError, ValueError):
+        except (WalletNotFoundError, InvalidPassphraseError):
             return False
 
     def decrypt_wallet_by_address(self, address: str, passphrase: str) -> sync_chain.Wallet:
         entry = self._find_wallet_entry(address)
         if entry is None:
-            raise KeyError(f"Wallet {address} not found")
+            raise WalletNotFoundError(f"Wallet {address} not found")
         if not _verify_passphrase_hash(passphrase, entry.get("passphrase_hash", "")):
-            raise ValueError("Invalid passphrase")
+            raise InvalidPassphraseError("Invalid passphrase")
         return self._wallet_from_entry(entry)
 
     def get_wallet_for_bot(self, address: str) -> sync_chain.Wallet:
         """Return wallet without passphrase verification — for bot auto-unlock at startup."""
         entry = self._find_wallet_entry(address)
         if entry is None:
-            raise KeyError(f"Wallet {address} not found")
+            raise WalletNotFoundError(f"Wallet {address} not found")
         return self._wallet_from_entry(entry)
 
     def remove_wallet(self, address: str) -> None:
         normalized = address.lower()
         with self._wallet_lock:
             node_wallets = self._get_node_wallets_list()
             if len(node_wallets) <= 1:
-                raise ValueError("Cannot remove the last wallet")
+                raise CannotRemoveLastWalletError("Cannot remove the last wallet")
             entry = next((e for e in node_wallets if e.get("address", "") == normalized), None)
             if entry is None:
-                raise KeyError(f"Wallet {address} not found")
+                raise WalletNotFoundError(f"Wallet {address} not found")
             if entry.get("is_admin"):
-                raise ValueError("Cannot remove the admin wallet")
+                raise CannotRemoveAdminWalletError("Cannot remove the admin wallet")
             self._save_node_wallets_list([e for e in node_wallets if e.get("address", "") != normalized])
 
     def rename_wallet(self, address: str, name: typing.Optional[str]) -> None:
@@ -196,7 +220,7 @@ def rename_wallet(self, address: str, name: typing.Optional[str]) -> None:
                     entry["name"] = name or None
                     self._save_node_wallets_list(node_wallets)
                     return
-        raise KeyError(f"Wallet {address} not found")
+        raise WalletNotFoundError(f"Wallet {address} not found")
 
     def is_admin_wallet(self, address: str) -> bool:
         entry = self._find_wallet_entry(address)

octobot/community/wallet_backend/errors.py

@@ -0,0 +1,51 @@
+#  This file is part of OctoBot (https://github.com/Drakkar-Software/OctoBot)
+#  Copyright (c) 2025 Drakkar-Software, All rights reserved.
+#
+#  OctoBot is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either
+#  version 3.0 of the License, or (at your option) any later version.
+#
+#  OctoBot is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public
+#  License along with OctoBot. If not, see <https://www.gnu.org/licenses/>.
+
+
+class WalletError(Exception):
+    pass
+
+
+class WalletAlreadyExistsError(WalletError, ValueError):
+    pass
+
+
+class AdminWalletAlreadyExistsError(WalletError, ValueError):
+    pass
+
+
+class WalletNotFoundError(WalletError, KeyError):
+    pass
+
+
+class InvalidPassphraseError(WalletError, ValueError):
+    pass
+
+
+class CannotRemoveLastWalletError(WalletError, ValueError):
+    pass
+
+
+class CannotRemoveAdminWalletError(WalletError, ValueError):
+    pass
+
+
+class InvalidPrivateKeyError(WalletError, ValueError):
+    pass
+
+
+class PassphraseTooShortError(WalletError, ValueError):
+    pass