Integrate Rust Wallet — tests

bittensor_cli/src/bittensor/async_substrate_interface.py

@@ -12,7 +12,7 @@
 from scalecodec.base import ScaleBytes, ScaleType, RuntimeConfigurationObject
 from scalecodec.type_registry import load_type_registry_preset
 from scalecodec.types import GenericCall
-from substrateinterface import Keypair
+from bittensor_wallet import Keypair
 from substrateinterface.exceptions import (
     SubstrateRequestException,
     ExtrinsicNotFound,

bittensor_cli/src/bittensor/extrinsics/root.py

@@ -27,8 +27,8 @@
 from rich.prompt import Confirm
 from rich.table import Table, Column
 from scalecodec import ScaleBytes, U16, Vec
-from substrateinterface import Keypair
 
+from bittensor_wallet import Keypair
 from bittensor_cli.src.bittensor.subtensor_interface import SubtensorInterface
 from bittensor_cli.src.bittensor.extrinsics.registration import is_hotkey_registered
 from bittensor_cli.src.bittensor.utils import (

bittensor_cli/src/bittensor/extrinsics/transfer.py

@@ -121,10 +121,10 @@ async def do_transfer() -> tuple[bool, str, str]:
         print_verbose("Fetching existential and fee", status)
         block_hash = await subtensor.substrate.get_chain_head()
         account_balance_, existential_deposit = await asyncio.gather(
-            subtensor.get_balance(wallet.coldkey.ss58_address, block_hash=block_hash),
+            subtensor.get_balance(wallet.coldkeypub.ss58_address, block_hash=block_hash),
             subtensor.get_existential_deposit(block_hash=block_hash),
         )
-        account_balance = account_balance_[wallet.coldkey.ss58_address]
+        account_balance = account_balance_[wallet.coldkeypub.ss58_address]
         fee = await get_transfer_fee()
 
     if not keep_alive:
@@ -176,7 +176,7 @@ async def do_transfer() -> tuple[bool, str, str]:
     if success:
         with console.status(":satellite: Checking Balance...", spinner="aesthetic"):
             new_balance = await subtensor.get_balance(
-                wallet.coldkey.ss58_address, reuse_block=False
+                wallet.coldkeypub.ss58_address, reuse_block=False
             )
             console.print(
                 f"Balance:\n"

bittensor_cli/src/bittensor/utils.py

@@ -4,21 +4,24 @@
 import webbrowser
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Collection, Optional, Union, Callable
+from urllib.parse import urlparse
 
-import numpy as np
-import scalecodec
-import typer
-from bittensor_wallet import Wallet
-from bittensor_wallet.keyfile import Keypair
-from bittensor_wallet.utils import SS58_FORMAT, ss58
+from bittensor_wallet import Wallet, Keypair
+from bittensor_wallet.utils import SS58_FORMAT
+from bittensor_wallet import utils
 from jinja2 import Template
 from markupsafe import Markup
+import numpy as np
 from numpy.typing import NDArray
 from rich.console import Console
+import scalecodec
 from scalecodec.base import RuntimeConfiguration
 from scalecodec.type_registry import load_type_registry_preset
+import typer
+
+
 from bittensor_cli.src.bittensor.balances import Balance
-from urllib.parse import urlparse
+
 
 if TYPE_CHECKING:
     from bittensor_cli.src.bittensor.chain_data import SubnetHyperparameters
@@ -219,6 +222,7 @@ def get_hotkey_wallets_for_wallet(
         except (
             UnicodeDecodeError,
             AttributeError,
+            TypeError
         ):  # usually an unrelated file like .DS_Store
             continue
 
@@ -302,10 +306,8 @@ def is_valid_ss58_address(address: str) -> bool:
     :return: `True` if the address is a valid ss58 address for Bittensor, `False` otherwise.
     """
     try:
-        return ss58.is_valid_ss58_address(
-            address, valid_ss58_format=SS58_FORMAT
-        ) or ss58.is_valid_ss58_address(
-            address, valid_ss58_format=42
+        return utils.is_valid_ss58_address(
+            address
         )  # Default substrate ss58 format (legacy)
     except IndexError:
         return False

bittensor_cli/src/commands/wallets.py

@@ -78,7 +78,7 @@ async def regen_coldkey(
         wallet.regenerate_coldkey(
             mnemonic=mnemonic,
             seed=seed,
-            json=(json_str, json_password),
+            json=(json_str, json_password) if all([json_str, json_password]) else None,
             use_password=use_password,
             overwrite=False,
         )
@@ -123,7 +123,7 @@ async def regen_hotkey(
         wallet.regenerate_hotkey(
             mnemonic=mnemonic,
             seed=seed,
-            json=(json_str, json_password),
+            json=(json_str, json_password) if all([json_str, json_password]) else None,
             use_password=use_password,
             overwrite=False,
         )

requirements.txt

@@ -16,5 +16,5 @@ scalecodec==1.2.11
 substrate-interface~=1.7.9
 typer~=0.12
 websockets>=12.0
-bittensor-wallet==1.0.0
+bittensor-wallet==2.0.0
 bt-decode==0.2.0a0

tests/e2e_tests/test_root.py

@@ -1,7 +1,7 @@
 import time
 
 from bittensor_cli.src.bittensor.balances import Balance
-from tests.e2e_tests.utils import extract_coldkey_balance
+from .utils import extract_coldkey_balance
 
 """
 Verify commands:
@@ -217,10 +217,11 @@ def test_root_commands(local_chain, wallet_setup):
             "--delegate-ss58key",
             wallet_bob.hotkey.ss58_address,
             "--amount",
-            f"10",
+            "10",
             "--no-prompt",
         ],
     )
+    time.sleep(10)
     assert "✅ Finalized" in undelegate_alice.stdout
 
     check_balance(

tests/e2e_tests/test_wallet_creations.py

@@ -138,20 +138,28 @@ def extract_mnemonics_from_commands(output: str) -> Dict[str, Optional[str]]:
         dict: A dictionary keys 'coldkey' and 'hotkey', each containing their mnemonics.
     """
     mnemonics: Dict[str, Optional[str]] = {"coldkey": None, "hotkey": None}
-    lines = output.splitlines()
 
     key_types = ["coldkey", "hotkey"]
-    command_prefix = "btcli w regen-"
 
-    for line in lines:
-        line = line.strip().lower()
+    # We will assume the most recent match is the one we want
+    for key_type in key_types:
+        # Note: python's re needs this P before the group name
+        # See: https://stackoverflow.com/questions/10059673/named-regular-expression-group-pgroup-nameregexp-what-does-p-stand-for
+        pat = re.compile(rf"(?P<key_type>{key_type}).*?(?P<mnemonic>(\w+( |)){{12}})")
+        matches = pat.search(output)
+
+        groups = matches.groupdict()
+
+        if len(groups.keys()) == 0:
+            mnemonics[key_type] = None
+            continue
 
-        if line.startswith(command_prefix):
-            for key_type in key_types:
-                if line.startswith(f"{command_prefix}{key_type} --mnemonic "):
-                    mnemonic_phrase = line.split("--mnemonic ")[1].strip().strip('"')
-                    mnemonics[key_type] = mnemonic_phrase
-                    break
+        key_type_str = groups["key_type"]
+        if key_type != key_type_str:
+            continue
+
+        mnemonic_phrase = groups["mnemonic"]
+        mnemonics[key_type] = mnemonic_phrase
 
     return mnemonics
 
@@ -329,6 +337,11 @@ def test_wallet_regen(wallet_setup):
         ],
     )
 
+    # Check for an exception first
+    assert result.exception is None
+    # Verify the command has output, as expected
+    assert result.stdout is not None
+
     mnemonics = extract_mnemonics_from_commands(result.stdout)
 
     wallet_status, message = verify_wallet_dir(
@@ -364,7 +377,7 @@ def test_wallet_regen(wallet_setup):
     )
 
     # Wait a bit to ensure file system updates modification time
-    time.sleep(1)
+    time.sleep(0.01)
 
     new_coldkey_mod_time = os.path.getmtime(coldkey_path)
 

tests/e2e_tests/test_wallet_interactions.py

@@ -1,5 +1,7 @@
+from time import sleep
+
 from bittensor_cli.src.bittensor.balances import Balance
-from tests.e2e_tests.utils import (
+from .utils import (
     extract_coldkey_balance,
     validate_wallet_inspect,
     validate_wallet_overview,
@@ -58,6 +60,8 @@ def test_wallet_overview_inspect(local_chain, wallet_setup):
     )
     assert f"✅ Registered subnetwork with netuid: {netuid}" in result.stdout
 
+    sleep(3)
+
     # List all the subnets in the network
     subnets_list = exec_command(
         command="subnets",
@@ -68,6 +72,8 @@ def test_wallet_overview_inspect(local_chain, wallet_setup):
         ],
     )
 
+    sleep(3)
+
     # Assert using regex that the subnet is visible in subnets list
     assert verify_subnet_entry(subnets_list.stdout, netuid, keypair.ss58_address)
 
@@ -326,7 +332,7 @@ def test_wallet_transfer(local_chain, wallet_setup):
     )
 
     # This transfer is expected to fail due to low balance
-    assert "❌ Not enough balance" in result.stdout
+    assert "❌ Not enough balance" in result.stderr
     print("✅Passed wallet transfer, balance command")
 
 

tests/e2e_tests/utils.py

@@ -6,9 +6,8 @@
 from typing import List, Tuple, TYPE_CHECKING
 
 from bittensor_cli.cli import CLIManager
-from substrateinterface import Keypair
+from bittensor_wallet import Keypair, Wallet
 from typer.testing import CliRunner
-from bittensor_wallet import Wallet
 
 if TYPE_CHECKING:
     from bittensor_cli.src.bittensor.async_substrate_interface import (
@@ -34,7 +33,8 @@ def exec_command(
         inputs: List[str] = None,
     ):
         cli_manager = CLIManager()
-        runner = CliRunner()
+        # Capture stderr separately from stdout
+        runner = CliRunner(mix_stderr=False)
         # Prepare the command arguments
         args = [
             command,
@@ -48,7 +48,11 @@ def exec_command(
 
         input_text = "\n".join(inputs) + "\n" if inputs else None
         result = runner.invoke(
-            cli_manager.app, args, input=input_text, env={"COLUMNS": "700"}
+            cli_manager.app,
+            args,
+            input=input_text,
+            env={"COLUMNS": "700"},
+            catch_exceptions=False,
         )
         return result