Struct Wallet 

pub struct Wallet {
    pub name: String,
    pub hotkey_name: String,
    pub path: PathBuf,
    /* private fields */
}

Bittensor wallet for managing keys and signing transactions

A wallet contains:

• A hotkey (required) for signing transactions
• An optional coldkey for staking operations

Example

use bittensor_rs::wallet::Wallet;

// Load from default ~/.bittensor/wallets path
let wallet = Wallet::load("my_wallet", "my_hotkey")?;
println!("Hotkey: {}", wallet.hotkey());

Fields

name: String

Wallet name

hotkey_name: String

Hotkey name

path: PathBuf

Path to the wallet directory

Implementations

impl Wallet

pub fn load( wallet_name: &str, hotkey_name: &str, ) -> Result<Self, BittensorError>

Load a wallet from the default Bittensor wallet path

Wallets are stored in ~/.bittensor/wallets/<wallet_name>/hotkeys/<hotkey_name>

Arguments

• wallet_name - Name of the wallet directory
• hotkey_name - Name of the hotkey file

Returns

• Ok(Wallet) if the wallet was loaded successfully
• Err(BittensorError) if the wallet could not be loaded

Example

use bittensor_rs::wallet::Wallet;

let wallet = Wallet::load("default", "default")?;

pub fn load_from_path( wallet_name: &str, hotkey_name: &str, base_path: &Path, ) -> Result<Self, BittensorError>

Load a wallet from a custom path

Arguments

• wallet_name - Name of the wallet directory
• hotkey_name - Name of the hotkey file
• base_path - Base path where wallets are stored

Example

use bittensor_rs::wallet::Wallet;
use std::path::PathBuf;

let base_path = PathBuf::from("/custom/wallets");
let wallet = Wallet::load_from_path("my_wallet", "my_hotkey", &base_path)?;

pub fn create_random( wallet_name: &str, hotkey_name: &str, ) -> Result<Self, BittensorError>

Create a new wallet with a random seed

Arguments

• wallet_name - Name of the wallet
• hotkey_name - Name of the hotkey

Returns

A new wallet with a randomly generated keypair (not saved to disk)

Example

use bittensor_rs::wallet::Wallet;

let wallet = Wallet::create_random("test_wallet", "test_hotkey").unwrap();
assert!(!wallet.hotkey().as_str().is_empty());

pub fn from_mnemonic( wallet_name: &str, hotkey_name: &str, mnemonic: &str, ) -> Result<Self, BittensorError>

Create a wallet from a mnemonic phrase

Arguments

• wallet_name - Name of the wallet
• hotkey_name - Name of the hotkey
• mnemonic - BIP39 mnemonic phrase (12 or 24 words)

Example

use bittensor_rs::wallet::Wallet;

let mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
let wallet = Wallet::from_mnemonic("test", "test", mnemonic)?;

pub fn from_seed_hex( wallet_name: &str, hotkey_name: &str, seed_hex: &str, ) -> Result<Self, BittensorError>

Create a wallet from a hex seed

Arguments

• wallet_name - Name of the wallet
• hotkey_name - Name of the hotkey
• seed_hex - Hex-encoded seed (32 bytes, optionally prefixed with “0x”)

Example

use bittensor_rs::wallet::Wallet;

let seed = "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
let wallet = Wallet::from_seed_hex("test", "test", seed).unwrap();

pub fn hotkey(&self) -> Hotkey

Get the hotkey address as a Hotkey type

Example

use bittensor_rs::wallet::Wallet;

let wallet = Wallet::create_random("test", "test").unwrap();
let hotkey = wallet.hotkey();
println!("Address: {}", hotkey);

pub fn account_id(&self) -> AccountId

Get the hotkey as an AccountId

pub fn sign(&self, data: &[u8]) -> Vec<u8>

Sign data with the hotkey

Arguments

• data - The data to sign

Returns

A 64-byte signature

Example

use bittensor_rs::wallet::Wallet;

let wallet = Wallet::create_random("test", "test").unwrap();
let signature = wallet.sign(b"hello world");
assert_eq!(signature.len(), 64);

pub fn sign_hex(&self, data: &[u8]) -> String

Sign data and return hex-encoded signature

Example

use bittensor_rs::wallet::Wallet;

let wallet = Wallet::create_random("test", "test").unwrap();
let sig_hex = wallet.sign_hex(b"hello");
assert_eq!(sig_hex.len(), 128); // 64 bytes = 128 hex chars

pub fn signer(&self) -> WalletSigner

Get a subxt-compatible signer for this wallet

Example

use bittensor_rs::wallet::Wallet;

let wallet = Wallet::create_random("test", "test").unwrap();
let signer = wallet.signer();

pub fn keypair(&self) -> &Pair

Get the underlying keypair (for advanced usage)

pub fn verify(&self, data: &[u8], signature: &[u8]) -> bool

Verify a signature against this wallet’s hotkey

Arguments

• data - The original data that was signed
• signature - The 64-byte signature

Returns

true if the signature is valid, false otherwise

Example

use bittensor_rs::wallet::Wallet;

let wallet = Wallet::create_random("test", "test").unwrap();
let message = b"hello world";
let signature = wallet.sign(message);
assert!(wallet.verify(message, &signature));

pub fn unlock_coldkey(&mut self, password: &str) -> Result<(), BittensorError>

Load and unlock the coldkey with a password

The coldkey is stored in <wallet_path>/coldkey and is encrypted.

Arguments

• password - The password to decrypt the coldkey

Returns

• Ok(()) if the coldkey was loaded and decrypted
• Err(BittensorError) if loading or decryption failed

pub fn is_coldkey_unlocked(&self) -> bool

Check if the coldkey is unlocked

pub fn coldkey(&self) -> Option<Hotkey>

Get the coldkey address if unlocked

Trait Implementations

impl Clone for Wallet

fn clone(&self) -> Wallet

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Wallet

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.