i dont know how it works

selfprivacy_api/repositories/tokens/json_tokens_repository.py

@@ -1,7 +1,6 @@
 """
 temporary legacy
 """
-from secrets import token_bytes
 from typing import Optional
 from datetime import datetime
 
@@ -13,6 +12,7 @@ from selfprivacy_api.repositories.tokens.exceptions import TokenNotFoundError
 from selfprivacy_api.repositories.tokens.abstract_tokens_repository import (
     AbstractTokensRepository,
 )
+from mnemonic import Mnemonic
 
 
 class JsonTokensRepository(AbstractTokensRepository):
@@ -106,10 +106,10 @@ class JsonTokensRepository(AbstractTokensRepository):
                 return
 
             recovery_key = RecoveryKey(
-                key=tokens_file["recovery_token"]["token"],
-                created_at=tokens_file["recovery_token"]["date"],
-                expires_at=tokens_file["recovery_token"]["expitation"],
-                uses_left=tokens_file["recovery_token"]["uses_left"],
+                key=tokens_file["recovery_token"].get("token"),
+                created_at=tokens_file["recovery_token"].get("date"),
+                expires_at=tokens_file["recovery_token"].get("expitation"),
+                uses_left=tokens_file["recovery_token"].get("uses_left"),
             )
 
             return recovery_key
@@ -121,7 +121,7 @@ class JsonTokensRepository(AbstractTokensRepository):
     ) -> RecoveryKey:
         """Create the recovery key"""
 
-        recovery_key = RecoveryKey.generate(expiration=None, uses_left=None)
+        recovery_key = RecoveryKey.generate(expiration=expiration, uses_left=uses_left)
 
         with ReadUserData(UserDataFiles.TOKENS) as tokens_file:
             tokens_file["recovery_key"] = {
@@ -135,7 +135,43 @@ class JsonTokensRepository(AbstractTokensRepository):
 
     def use_mnemonic_recovery_key(self, mnemonic_phrase: str, name: str) -> Token:
         """Use the mnemonic recovery key and create a new token with the given name"""
-        ...
+        recovery_key = self.get_recovery_key()  # self ?
+
+        if recovery_key is None:
+            return None
+
+        if not recovery_key.is_valid():
+            return None
+
+        if recovery_key is None:
+            return None
+
+        recovery_token = bytes.fromhex(recovery_key.key)
+
+        if not Mnemonic(language="english").check(mnemonic_phrase):
+            return None
+
+        phrase_bytes = Mnemonic(language="english").to_entropy(mnemonic_phrase)
+        if phrase_bytes != recovery_token:
+            return None
+
+        new_recovery_key = RecoveryKey.generate()
+
+        with WriteUserData(UserDataFiles.TOKENS) as tokens:
+            tokens["tokens"].append(
+                {
+                    "token": new_recovery_key.key,
+                    # "name": new_recovery_key.name, what???? there is no name
+                    "date": str(datetime.now()),
+                }
+            )
+            if "recovery_token" in tokens:
+                if (
+                    "uses_left" in tokens["recovery_token"]
+                    and tokens["recovery_token"]["uses_left"] is not None
+                ):
+                    tokens["recovery_token"]["uses_left"] -= 1
+        return new_recovery_key
 
     def get_new_device_key(self) -> NewDeviceKey:
         """Creates and returns the new device key"""
@@ -153,7 +189,8 @@ class JsonTokensRepository(AbstractTokensRepository):
     def delete_new_device_key(self) -> None:
         """Delete the new device key"""
         with WriteUserData(UserDataFiles.TOKENS) as tokens_file:
-            tokens_file.pop("new_device")
+            if "new_device" in tokens_file:
+                del tokens_file["new_device"]
 
     def use_mnemonic_new_device_key(self, mnemonic_phrase: str, name: str) -> None:
         """Use the mnemonic new device key"""