bittensor-wallet 2.0.2__tar.gz → 2.0.3__tar.gz

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/.circleci/config.yml

@@ -33,6 +33,8 @@ jobs:
       - run:
           name: Set Up Virtual Environment
           command: |
+            curl https://sh.rustup.rs -sSf | sh -s -- -y
+            . "$HOME/.cargo/env"
             python -m venv .venv
             . .venv/bin/activate
             python -m pip install --upgrade pip

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/CHANGELOG.MD

@@ -5,6 +5,9 @@
 ## What's Changed
 
 * Add the ability to use environment variables to store hot/coldkey passwords by @roman-opentensor in https://github.com/opentensor/btwallet/pull/46
+* Fix wallet paths outside userhome by @camfairchild in https://github.com/opentensor/btwallet/pull/59
+* fix https://github.com/opentensor/btwallet/issues/51 by @camfairchild in https://github.com/opentensor/btwallet/pull/56
+* password fixes by @roman-opentensor 
 * fix/roman/fix-config-parsing by @roman-opentensor in https://github.com/opentensor/btwallet/pull/47
 
 **Full Changelog**: https://github.com/opentensor/btwallet/compare/v2.0.1...v2.0.2

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/Cargo.lock

@@ -352,7 +352,7 @@ checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "bittensor_wallet"
-version = "2.0.0"
+version = "2.0.3"
 dependencies = [
  "ansible-vault",
  "base64 0.22.1",
@@ -371,6 +371,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sha2 0.10.8",
+ "shellexpand",
  "sodiumoxide",
  "sp-core",
 ]
@@ -2230,6 +2231,15 @@ dependencies = [
  "lazy_static",
 ]
 
+[[package]]
+name = "shellexpand"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da03fa3b94cc19e3ebfc88c4229c49d8f08cdbd1228870a45f0ffdf84988e14b"
+dependencies = [
+ "dirs",
+]
+
 [[package]]
 name = "shlex"
 version = "1.3.0"

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bittensor_wallet"
-version = "2.0.0"
+version = "2.0.3"
 edition = "2021"
 
 [lib]
@@ -27,6 +27,7 @@ base64 = "0.22.1"
 scrypt = "0.11.0"
 pkcs8 = "0.10.2"
 schnorrkel = "0.11.4"
+shellexpand = "3.1.0"
 
 [features]
 extension-module = ["pyo3/extension-module"]

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bittensor-wallet
-Version: 2.0.2
+Version: 2.0.3
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Build Tools
@@ -19,7 +19,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: termcolor
 Requires-Dist: eth-utils <2.3.0
 Requires-Dist: password-strength
-Requires-Dist: cryptography ~=42.0.5
+Requires-Dist: cryptography ~=43.0.1
 Requires-Dist: ansible ~=6.7
 Requires-Dist: ansible-vault ~=2.1
 Requires-Dist: munch ~=2.5.0

bittensor_wallet-2.0.3/bittensor_wallet/__init__.py

@@ -0,0 +1,16 @@
+from bittensor_wallet.bittensor_wallet import (
+    # classes
+    Config as Config,
+    Keyfile as Keyfile,
+    Keypair as Keypair,
+    Wallet as Wallet,
+    # modules
+    config as config,
+    errors as errors,
+    keyfile as keyfile,
+    keypair as keypair,
+    utils as utils,
+    wallet as wallet,
+)
+
+__version__ = "2.0.0"

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/bittensor_wallet/errors/__init__.py

@@ -2,3 +2,4 @@ from bittensor_wallet.bittensor_wallet import errors as _
 
 ConfigurationError = _.ConfigurationError
 KeyFileError = _.KeyFileError
+PasswordError = _.PasswordError

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bittensor-wallet"
-version = "2.0.2"
+version = "2.0.3"
 description = ""
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -10,7 +10,7 @@ dependencies = [
     "termcolor",
     "eth-utils<2.3.0",
     "password_strength",
-    "cryptography~=42.0.5",
+    "cryptography~=43.0.1",
     "ansible~=6.7",
     "ansible_vault~=2.1",
     "munch~=2.5.0",

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/src/constants.rs

@@ -1,3 +1,3 @@
 pub const BT_WALLET_NAME: &str = "default";
 pub const BT_WALLET_HOTKEY: &str = "default";
-pub const BT_WALLET_PATH: &str = ".bittensor/wallets/";
+pub const BT_WALLET_PATH: &str = "~/.bittensor/wallets/";

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/src/errors.rs

@@ -2,13 +2,14 @@ use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
 use std::{error, fmt};
 
+// KeyFileError
 #[pyclass(extends=PyException)]
 #[derive(Debug)]
 pub struct KeyFileError {
     pub message: String,
 }
 
-/// Error thrown when the keyfile is corrupt, non-writable, non-readable or the password used to decrypt is invalid.
+/// Error thrown when the keyfile is corrupt, non-writable, non-readable.
 #[pymethods]
 impl KeyFileError {
     #[new]
@@ -31,6 +32,7 @@ impl fmt::Display for KeyFileError {
 
 impl error::Error for KeyFileError {}
 
+// ConfigurationError
 #[pyclass(extends=PyException)]
 #[derive(Debug)]
 pub struct ConfigurationError {
@@ -59,3 +61,33 @@ impl fmt::Display for ConfigurationError {
 }
 
 impl error::Error for ConfigurationError {}
+
+// PasswordError
+#[pyclass(extends=PyException)]
+#[derive(Debug)]
+pub struct PasswordError {
+    pub message: String,
+}
+
+/// PasswordError occurs if the password used for decryption is invalid.
+#[pymethods]
+impl PasswordError {
+    #[new]
+    #[pyo3(signature = (message=None))]
+    pub fn new(message: Option<String>) -> Self {
+        let msg = message.unwrap_or_default();
+        PasswordError { message: msg }
+    }
+
+    pub fn __str__(&self) -> String {
+        self.message.clone()
+    }
+}
+
+impl fmt::Display for PasswordError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "PasswordError: {}", self.message)
+    }
+}
+
+impl error::Error for PasswordError {}

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/src/keyfile.rs

@@ -9,7 +9,7 @@ use std::env;
 use std::fs;
 use std::io::{Read, Write};
 use std::os::unix::fs::PermissionsExt;
-use std::path::Path;
+use std::path::PathBuf;
 use std::str::from_utf8;
 
 use ansible_vault::{decrypt_vault, encrypt_vault};
@@ -19,7 +19,7 @@ use passwords::analyzer;
 use passwords::scorer;
 use serde_json::json;
 
-use crate::errors::KeyFileError;
+use crate::errors::{KeyFileError, PasswordError};
 use crate::keypair::Keypair;
 use crate::utils;
 
@@ -414,7 +414,7 @@ pub fn decrypt_keyfile_data(
             .ok_or(PyErr::new::<PyRuntimeError, _>("Invalid nonce."))?;
         let ciphertext = &data[secretbox::NONCEBYTES..];
         secretbox::open(ciphertext, &nonce, key)
-            .map_err(|_| PyErr::new::<KeyFileError, _>("Wrong password for nacl decryption."))
+            .map_err(|_| PyErr::new::<PasswordError, _>("Wrong password for nacl decryption."))
     }
 
     // decrypt of keyfile_data with legacy way
@@ -428,7 +428,7 @@ pub fn decrypt_keyfile_data(
         let keyfile_data_str = from_utf8(keyfile_data)?;
         fernet
             .decrypt(keyfile_data_str)
-            .map_err(|_| PyErr::new::<KeyFileError, _>("Wrong password for nacl decryption."))
+            .map_err(|_| PyErr::new::<PasswordError, _>("Wrong password for legacy decryption."))
     }
 
     let mut password = password;
@@ -453,21 +453,21 @@ pub fn decrypt_keyfile_data(
     if keyfile_data_is_encrypted_nacl(py, keyfile_data)? {
         let key = derive_key(password.as_bytes());
         let decrypted_data = nacl_decrypt(keyfile_data, &key)
-            .map_err(|_| PyErr::new::<KeyFileError, _>("Wrong password for decryption."))?;
+            .map_err(|_| PyErr::new::<PasswordError, _>("Wrong password for decryption."))?;
         return Ok(PyBytes::new_bound(py, &decrypted_data).into_py(py));
     }
 
     // Ansible Vault decryption
     if keyfile_data_is_encrypted_ansible(py, keyfile_data)? {
         let decrypted_data = decrypt_vault(keyfile_data, password.as_str())
-            .map_err(|_| PyErr::new::<KeyFileError, _>("Wrong password for decryption."))?;
+            .map_err(|_| PyErr::new::<PasswordError, _>("Wrong password for decryption."))?;
         return Ok(PyBytes::new_bound(py, &decrypted_data).into_py(py));
     }
 
     // Legacy decryption
     if keyfile_data_is_encrypted_legacy(py, keyfile_data)? {
         let decrypted_data = legacy_decrypt(&password, keyfile_data)
-            .map_err(|_| PyErr::new::<KeyFileError, _>("Wrong password for decryption."))?;
+            .map_err(|_| PyErr::new::<PasswordError, _>("Wrong password for decryption."))?;
         return Ok(PyBytes::new_bound(py, &decrypted_data).into_py(py));
     }
 
@@ -498,10 +498,6 @@ fn encrypt_password(key: String, value: String) -> String {
         let encrypted_char = (c as u8) ^ (key.chars().nth(i % key.len()).unwrap() as u8);
         encrypted.push(encrypted_char as char);
     }
-    println!(
-        ">>> key: {}, value: {}, encrypted: {}",
-        key, value, encrypted
-    );
     encrypted
 }
 
@@ -519,6 +515,7 @@ fn decrypt_password(data: String, key: String) -> String {
 #[pyclass(subclass)]
 pub struct Keyfile {
     path: String,
+    _path: PathBuf,
     name: String,
     should_save_to_env: bool,
 }
@@ -528,10 +525,11 @@ impl Keyfile {
     #[new]
     #[pyo3(signature = (path, name=None, should_save_to_env=false))]
     pub fn new(path: String, name: Option<String>, should_save_to_env: bool) -> PyResult<Self> {
-        let path = expand_tilde(&path);
+        let expanded_path: PathBuf = PathBuf::from(expand_tilde(&path));
         let name = name.unwrap_or_else(|| "Keyfile".to_string());
         Ok(Keyfile {
             path,
+            _path: expanded_path,
             name,
             should_save_to_env,
         })
@@ -653,9 +651,7 @@ impl Keyfile {
 
     /// Creates directories for the path if they do not exist.
     pub fn make_dirs(&self) -> PyResult<()> {
-        // convert String to Path
-        let path: &Path = self.path.as_ref();
-        if let Some(directory) = path.parent() {
+        if let Some(directory) = self._path.parent() {
             // check if the dir is exit already
             if !directory.exists() {
                 // create the dir if not
@@ -670,7 +666,7 @@ impl Keyfile {
     /// Returns:
     ///     readable (bool): ``True`` if the file is readable.
     pub fn exists_on_device(&self) -> PyResult<bool> {
-        Ok(Path::new(&self.path).exists())
+        Ok(self._path.exists())
     }
 
     /// Returns ``True`` if the file under path is readable.
@@ -681,7 +677,7 @@ impl Keyfile {
         }
 
         // get file metadata
-        let metadata = fs::metadata(&self.path).map_err(|e| {
+        let metadata = fs::metadata(&self._path).map_err(|e| {
             PyErr::new::<PyIOError, _>(format!("Failed to get metadata for file: {}.", e))
         })?;
 
@@ -703,7 +699,7 @@ impl Keyfile {
         }
 
         // get file metadata
-        let metadata = fs::metadata(&self.path).map_err(|e| {
+        let metadata = fs::metadata(&self._path).map_err(|e| {
             PyErr::new::<PyIOError, _>(format!("Failed to get metadata for file: {}", e))
         })?;
 
@@ -993,7 +989,7 @@ impl Keyfile {
         }
 
         // open and read the file
-        let mut file = fs::File::open(&self.path)
+        let mut file = fs::File::open(&self._path)
             .map_err(|e| PyErr::new::<PyOSError, _>(format!("Failed to open file: {}.", e)))?;
         let mut data_vec = Vec::new();
         file.read_to_end(&mut data_vec)
@@ -1029,7 +1025,7 @@ impl Keyfile {
             .write(true)
             .create(true)
             .truncate(true) // cleanup if rewrite
-            .open(&self.path)
+            .open(&self._path)
             .map_err(|e| PyErr::new::<PyIOError, _>(format!("Failed to open file: {}.", e)))?;
 
         // write data
@@ -1038,9 +1034,9 @@ impl Keyfile {
             .map_err(|e| PyErr::new::<PyIOError, _>(format!("Failed to write to file: {}.", e)))?;
 
         // set permissions
-        let mut permissions = fs::metadata(&self.path)?.permissions();
+        let mut permissions = fs::metadata(&self._path)?.permissions();
         permissions.set_mode(0o600); // just for owner
-        fs::set_permissions(&self.path, permissions).map_err(|e| {
+        fs::set_permissions(&self._path, permissions).map_err(|e| {
             PyErr::new::<PyPermissionError, _>(format!("Failed to set permissions: {}.", e))
         })?;
         Ok(())
@@ -1048,7 +1044,7 @@ impl Keyfile {
 
     /// Saves the key's password to the associated local environment variable.
     #[pyo3(signature = (password=None))]
-    fn save_password_to_env(&self, password: Option<String>, py: Python) -> PyResult<bool> {
+    fn save_password_to_env(&self, password: Option<String>, py: Python) -> PyResult<String> {
         // checking the password
         let password = match password {
             Some(pwd) => pwd,
@@ -1056,7 +1052,7 @@ impl Keyfile {
                 Ok(pwd) => pwd,
                 Err(e) => {
                     utils::print(format!("Error asking password: {:?}.\n", e));
-                    return Ok(false);
+                    return Ok("".parse()?);
                 }
             },
         };
@@ -1066,21 +1062,21 @@ impl Keyfile {
                 // encrypt password
                 let encrypted_password = encrypt_password(self.env_var_name()?, password);
                 // store encrypted password
-                env::set_var(&env_var_name, encrypted_password);
+                env::set_var(&env_var_name, &encrypted_password);
 
                 let message = format!(
                     "The password has been saved to environment variable '{}'.\n",
                     env_var_name
                 );
                 utils::print(message);
-                Ok(true)
+                Ok(encrypted_password)
             }
             Err(e) => {
                 utils::print(format!(
                     "Error saving environment variable name: {:?}.\n",
                     e
                 ));
-                Ok(false)
+                Ok("".parse()?)
             }
         }
     }

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/src/lib.rs

@@ -36,6 +36,7 @@ fn register_errors_module(main_module: &Bound<'_, PyModule>) -> PyResult<()> {
     let errors_module = PyModule::new_bound(main_module.py(), "errors")?;
     errors_module.add_class::<errors::ConfigurationError>()?;
     errors_module.add_class::<errors::KeyFileError>()?;
+    errors_module.add_class::<errors::PasswordError>()?;
     main_module.add_submodule(&errors_module)
 }
 

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/src/wallet.rs

@@ -4,6 +4,7 @@ use pyo3::types::{IntoPyDict, PyString, PyType};
 
 use colored::Colorize;
 use std::env;
+use std::path::PathBuf;
 
 use crate::config::Config;
 use crate::constants::{BT_WALLET_HOTKEY, BT_WALLET_NAME, BT_WALLET_PATH};
@@ -12,10 +13,6 @@ use crate::keyfile::Keyfile;
 use crate::keypair::Keypair;
 use crate::utils::{self, is_valid_bittensor_address_or_public_key};
 
-use dirs::home_dir;
-
-type PyRuntimeError = KeyFileError;
-
 /// Display the mnemonic and a warning message to keep the mnemonic safe.
 #[pyfunction]
 #[pyo3(signature = (mnemonic, key_type))]
@@ -34,7 +31,11 @@ pub fn display_mnemonic_msg(mnemonic: String, key_type: &str) {
 }
 
 // Function to safely retrieve attribute as Option<String> from passed python object
-fn get_attribute_string(py: Python, obj: &Bound<PyAny>, attr_name: &str) -> PyResult<Option<String>> {
+fn get_attribute_string(
+    py: Python,
+    obj: &Bound<PyAny>,
+    attr_name: &str,
+) -> PyResult<Option<String>> {
     match obj.getattr(attr_name) {
         Ok(attr) => {
             if attr.is_none() {
@@ -61,6 +62,8 @@ pub struct Wallet {
     pub path: String,
     pub hotkey: String,
 
+    _path: PathBuf,
+
     _coldkey: Option<Keypair>,
     _coldkeypub: Option<Keypair>,
     _hotkey: Option<Keypair>,
@@ -82,9 +85,8 @@ impl Wallet {
         hotkey: Option<String>,
         path: Option<String>,
         config: Option<PyObject>,
-        py: Python
+        py: Python,
     ) -> PyResult<Wallet> {
-
         // default config's values if config and config.wallet exist
         let mut conf_name: Option<String> = None;
         let mut conf_hotkey: Option<String> = None;
@@ -128,15 +130,19 @@ impl Wallet {
         let final_path = if let Some(path) = path {
             path
         } else if let Some(conf_path) = conf_path {
-            conf_path.strip_prefix("~/").unwrap_or(&conf_path).to_string()
+            conf_path
         } else {
             BT_WALLET_PATH.to_string()
         };
 
+        let expanded_path: PathBuf = PathBuf::from(shellexpand::tilde(&final_path).to_string());
+
         Ok(Wallet {
             name: final_name,
             hotkey: final_hotkey,
-            path: final_path,
+            path: final_path.clone(),
+
+            _path: expanded_path,
 
             _coldkey: None,
             _coldkeypub: None,
@@ -146,14 +152,14 @@ impl Wallet {
 
     fn __str__(&self) -> PyResult<String> {
         Ok(format!(
-            "Wallet (Name: '{:}', Hotkey: '{:}', Path: '~/{:}')",
+            "Wallet (Name: '{:}', Hotkey: '{:}', Path: '{:}')",
             self.name, self.hotkey, self.path
         ))
     }
 
     fn __repr__(&self) -> PyResult<String> {
         Ok(format!(
-            "name: '{:}', hotkey: '{:}', path: '~/{:}'",
+            "name: '{:}', hotkey: '{:}', path: '{:}'",
             self.name, self.hotkey, self.path
         ))
     }
@@ -183,8 +189,8 @@ impl Wallet {
             env::var("BT_WALLET_NAME").unwrap_or_else(|_| BT_WALLET_NAME.to_string());
         let default_hotkey =
             env::var("BT_WALLET_HOTKEY").unwrap_or_else(|_| BT_WALLET_HOTKEY.to_string());
-        let default_path =
-            env::var("BT_WALLET_PATH").unwrap_or_else(|_| format!("~/{}", BT_WALLET_PATH.to_string()));
+        let default_path = env::var("BT_WALLET_PATH")
+            .unwrap_or_else(|_| format!("~/{}", BT_WALLET_PATH.to_string()));
 
         let prefix_str = if let Some(value) = prefix {
             format!("\"{}\"", value)
@@ -383,12 +389,8 @@ except argparse.ArgumentError:
     /// Created Hot Keyfile for Keypair
     #[pyo3(signature = (save_hotkey_to_env=false))]
     pub fn create_hotkey_file(&self, save_hotkey_to_env: bool) -> PyResult<Keyfile> {
-        // get home dir
-        let home = home_dir()
-            .ok_or_else(|| PyErr::new::<PyRuntimeError, _>("Failed to get user home directory."))?;
-
         // concatenate wallet path
-        let wallet_path = home.join(&self.path).join(&self.name);
+        let wallet_path = self._path.join(&self.name);
 
         // concatenate hotkey path
         let hotkey_path = wallet_path.join("hotkeys").join(&self.hotkey);
@@ -409,12 +411,8 @@ except argparse.ArgumentError:
     /// Created Cold Keyfile for Keypair
     #[pyo3(signature = (save_coldkey_to_env=false))]
     pub fn create_coldkey_file(&self, save_coldkey_to_env: bool) -> PyResult<Keyfile> {
-        // get home dir
-        let home = home_dir()
-            .ok_or_else(|| PyErr::new::<PyRuntimeError, _>("Failed to get user home directory."))?;
-
         // concatenate wallet path
-        let wallet_path = home.join(&self.path).join(&self.name);
+        let wallet_path = PathBuf::from(&self._path).join(&self.name);
 
         // concatenate coldkey path
         let coldkey_path = wallet_path.join("coldkey");
@@ -428,12 +426,8 @@ except argparse.ArgumentError:
     /// Property that returns the coldkeypub file.
     #[getter]
     pub fn coldkeypub_file(&self) -> PyResult<Keyfile> {
-        // get home dir
-        let home = home_dir()
-            .ok_or_else(|| PyErr::new::<PyRuntimeError, _>("Failed to get user home directory."))?;
-
         // concatenate wallet path
-        let wallet_path = home.join(&self.path).join(&self.name);
+        let wallet_path = self._path.join(&self.name);
 
         // concatenate hotkey path
         let coldkeypub_path = wallet_path.join("coldkeypub.txt");
@@ -828,7 +822,7 @@ except argparse.ArgumentError:
 
         let keypair = Keypair::new(ss58_address, public_key, None, 42, None, 1)?;
 
-        self.set_coldkeypub(keypair, overwrite, false, py)?;
+        self.set_coldkeypub(keypair, false, overwrite, py)?;
         Ok(self.clone())
     }
 

{bittensor_wallet-2.0.2 → bittensor_wallet-2.0.3}/tests/test_keyfile.py

@@ -23,7 +23,6 @@ from unittest import mock
 
 import pytest
 from bip39 import bip39_validate
-from jedi.common import monkeypatch
 
 from bittensor_wallet.errors import ConfigurationError, KeyFileError
 from bittensor_wallet.keyfile import Keyfile

bittensor_wallet-2.0.2/bittensor_wallet/__init__.py

@@ -1,16 +0,0 @@
-from bittensor_wallet.bittensor_wallet import (
-    # classes
-    Config,
-    Keyfile,
-    Keypair,
-    Wallet,
-    # modules
-    config,
-    errors,
-    keyfile,
-    keypair,
-    utils,
-    wallet,
-)
-
-__version__ = "2.0.0"