Struct BittensorConfig 

pub struct BittensorConfig {
    pub wallet_name: String,
    pub hotkey_name: String,
    pub network: String,
    pub netuid: u16,
    pub chain_endpoint: Option<String>,
    pub fallback_endpoints: Vec<String>,
    pub weight_interval_secs: u64,
    pub read_only: bool,
    pub connection_pool_size: Option<usize>,
    pub health_check_interval: Option<Duration>,
    pub circuit_breaker_threshold: Option<u32>,
    pub circuit_breaker_recovery: Option<Duration>,
}

Bittensor network configuration

Example

use bittensor_rs::config::BittensorConfig;

let config = BittensorConfig::default();
assert_eq!(config.network, "finney");

Fields

wallet_name: String

Wallet name for operations

hotkey_name: String

Hotkey name for the neuron

network: String

Network to connect to (“finney”, “test”, or “local”)

netuid: u16

Subnet netuid

chain_endpoint: Option<String>

Optional chain endpoint override

fallback_endpoints: Vec<String>

Optional fallback chain endpoints for failover

weight_interval_secs: u64

Weight setting interval in seconds

read_only: bool

Read-only mode (default: false) When true, wallet is only used for querying metagraph, not signing transactions

connection_pool_size: Option<usize>

Connection pool size (default: 3)

health_check_interval: Option<Duration>

Health check interval (default: 60 seconds)

circuit_breaker_threshold: Option<u32>

Circuit breaker failure threshold (default: 5)

circuit_breaker_recovery: Option<Duration>

Circuit breaker recovery timeout (default: 60 seconds)

Implementations

impl BittensorConfig

pub fn finney(wallet_name: &str, hotkey_name: &str, netuid: u16) -> Self

Create a new configuration for the finney network

Example

use bittensor_rs::config::BittensorConfig;

let config = BittensorConfig::finney("my_wallet", "my_hotkey", 1);
assert_eq!(config.network, "finney");

pub fn testnet(wallet_name: &str, hotkey_name: &str, netuid: u16) -> Self

Create a new configuration for the test network

Example

use bittensor_rs::config::BittensorConfig;

let config = BittensorConfig::testnet("my_wallet", "my_hotkey", 1);
assert_eq!(config.network, "test");

pub fn local(wallet_name: &str, hotkey_name: &str, netuid: u16) -> Self

Create a new configuration for a local network

Example

use bittensor_rs::config::BittensorConfig;

let config = BittensorConfig::local("my_wallet", "my_hotkey", 1);
assert_eq!(config.network, "local");

pub fn get_chain_endpoint(&self) -> String

Get the chain endpoint, auto-detecting based on network if not explicitly configured

Panics

Panics if the network is not one of: finney, test, local

Example

use bittensor_rs::config::BittensorConfig;

let config = BittensorConfig::default();
let endpoint = config.get_chain_endpoint();
assert!(endpoint.starts_with("wss://"));

pub fn get_chain_endpoints(&self) -> Vec<String>

Get all chain endpoints including fallbacks

Returns the primary endpoint followed by any configured fallback endpoints. If no fallbacks are configured, network-specific defaults are added.

Example

use bittensor_rs::config::BittensorConfig;

let config = BittensorConfig::default();
let endpoints = config.get_chain_endpoints();
assert!(!endpoints.is_empty());

pub fn validate(&self) -> Result<(), String>

Validate the configuration

Returns

• Ok(()) if the configuration is valid
• Err(String) with a description of the validation error

Example

use bittensor_rs::config::BittensorConfig;

let config = BittensorConfig::default();
assert!(config.validate().is_ok());

pub fn with_endpoint(self, endpoint: &str) -> Self

Set a custom chain endpoint

pub fn with_fallback_endpoints(self, endpoints: Vec<String>) -> Self

Set fallback endpoints

pub fn with_pool_size(self, size: usize) -> Self

Set connection pool size

pub fn with_read_only(self, read_only: bool) -> Self

Set read-only mode

Trait Implementations

impl Clone for BittensorConfig

fn clone(&self) -> BittensorConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BittensorConfig

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

Formats the value using the given formatter.

impl Default for BittensorConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BittensorConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BittensorConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.