Struct hotshot_orchestrator::config::NetworkConfig

pub struct NetworkConfig<KEY: SignatureKey> {

    pub rounds: usize,
    pub indexed_da: bool,
    pub transactions_per_round: usize,
    pub manual_start_password: Option<String>,
    pub num_bootrap: usize,
    pub next_view_timeout: u64,
    pub view_sync_timeout: Duration,
    pub builder_timeout: Duration,
    pub data_request_delay: Duration,
    pub node_index: u64,
    pub seed: [u8; 32],
    pub transaction_size: usize,
    pub start_delay_seconds: u64,
    pub key_type_name: String,
    pub libp2p_config: Option<Libp2pConfig>,
    pub config: HotShotConfig<KEY>,
    pub cdn_marshal_address: Option<String>,
    pub combined_network_config: Option<CombinedNetworkConfig>,
    pub commit_sha: String,
    pub builder: BuilderType,
    pub random_builder: Option<RandomBuilderConfig>,
    pub public_keys: HashSet<KEY>,
    pub enable_registration_verification: bool,
}

a network configuration

Fields

rounds: usize

number of views to run

indexed_da: bool

whether DA membership is determined by index. if true, the first k nodes to register form the DA committee if false, DA membership is requested by the nodes

transactions_per_round: usize

number of transactions per view

manual_start_password: Option<String>

password to have the orchestrator start the network, regardless of the number of nodes connected.

num_bootrap: usize

number of bootstrap nodes

next_view_timeout: u64

timeout before starting the next view

view_sync_timeout: Duration

timeout before starting next view sync round

builder_timeout: Duration

The maximum amount of time a leader can wait to get a block from a builder

data_request_delay: Duration

time to wait until we request data associated with a proposal

node_index: u64

global index of node (for testing purposes a uid)

seed: [u8; 32]

unique seed (for randomness? TODO)

transaction_size: usize

size of transactions

start_delay_seconds: u64

delay before beginning consensus

key_type_name: String

name of the key type (for debugging)

libp2p_config: Option<Libp2pConfig>

the libp2p config

config: HotShotConfig<KEY>

the hotshot config

cdn_marshal_address: Option<String>

The address for the Push CDN’s “marshal”, A.K.A. load balancer

combined_network_config: Option<CombinedNetworkConfig>

combined network config

commit_sha: String

the commit this run is based on

builder: BuilderType

builder to use

random_builder: Option<RandomBuilderConfig>

random builder config

public_keys: HashSet<KEY>

The list of public keys that are allowed to connect to the orchestrator

enable_registration_verification: bool

Whether or not to disable registration verification.

Implementations

impl<K: SignatureKey> NetworkConfig<K>

pub async fn from_file_or_orchestrator( client: &OrchestratorClient, file: Option<String>, libp2p_address: Option<SocketAddr>, libp2p_public_key: Option<PeerId> ) -> Result<(NetworkConfig<K>, NetworkConfigSource)>

Asynchronously retrieves a NetworkConfig either from a file or from an orchestrator.

This function takes an OrchestratorClient, an optional file path, and Libp2p-specific parameters.

If a file path is provided, the function will first attempt to load the NetworkConfig from the file. If the file does not exist or cannot be read, the function will fall back to retrieving the NetworkConfig from the orchestrator. In this case, if the path to the file does not exist, it will be created. The retrieved NetworkConfig is then saved back to the file for future use.

If no file path is provided, the function will directly retrieve the NetworkConfig from the orchestrator.

Errors

If we were unable to load the configuration.

Arguments

• client - An OrchestratorClient used to retrieve the NetworkConfig from the orchestrator.
• identity - A string representing the identity for which to retrieve the NetworkConfig.
• file - An optional string representing the path to the file from which to load the NetworkConfig.
• libp2p_address - An optional address specifying where other Libp2p nodes can reach us
• libp2p_public_key - The public key in which other Libp2p nodes can reach us with

Returns

This function returns a tuple containing a NetworkConfig and a NetworkConfigSource. The NetworkConfigSource indicates whether the NetworkConfig was loaded from a file or retrieved from the orchestrator.

pub async fn generate_init_validator_config( client: &OrchestratorClient, is_da: bool ) -> ValidatorConfig<K>

Get a temporary node index for generating a validator config

pub async fn get_complete_config( client: &OrchestratorClient, my_own_validator_config: ValidatorConfig<K>, libp2p_address: Option<SocketAddr>, libp2p_public_key: Option<PeerId> ) -> Result<(NetworkConfig<K>, NetworkConfigSource)>

Asynchronously retrieves a NetworkConfig from an orchestrator. The retrieved one includes correct node_index and peer’s public config.

Errors

If we are unable to get the configuration from the orchestrator

pub fn from_file(file: String) -> Result<Self, NetworkConfigError>

Loads a NetworkConfig from a file.

This function takes a file path as a string, reads the file, and then deserializes the contents into a NetworkConfig.

Arguments

• file - A string representing the path to the file from which to load the NetworkConfig.

Returns

This function returns a Result that contains a NetworkConfig if the file was successfully read and deserialized, or a NetworkConfigError if an error occurred.

Errors

This function will return an error if the file cannot be read or if the contents cannot be deserialized into a NetworkConfig.

Examples

// # use hotshot::traits::election::static_committee::StaticElectionConfig;
let file = "/path/to/my/config".to_string();
// NOTE: broken due to staticelectionconfig not being importable
// cannot import staticelectionconfig from hotshot without creating circular dependency
// making this work probably involves the `types` crate implementing a dummy
// electionconfigtype just ot make this example work
let config = NetworkConfig::<BLSPubKey, StaticElectionConfig>::from_file(file).unwrap();

pub fn to_file(&self, file: String) -> Result<(), NetworkConfigError>

Serializes the NetworkConfig and writes it to a file.

This function takes a file path as a string, serializes the NetworkConfig into JSON format using serde_json and then writes the serialized data to the file.

Arguments

• file - A string representing the path to the file where the NetworkConfig should be saved.

Returns

This function returns a Result that contains () if the NetworkConfig was successfully serialized and written to the file, or a NetworkConfigError if an error occurred.

Errors

This function will return an error if the NetworkConfig cannot be serialized or if the file cannot be written.

Examples

let file = "/path/to/my/config".to_string();
let config = NetworkConfig::from_file(file);
config.to_file(file).unwrap();

Trait Implementations

impl<KEY: Clone + SignatureKey> Clone for NetworkConfig<KEY>

fn clone(&self) -> NetworkConfig<KEY>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<KEY: Debug + SignatureKey> Debug for NetworkConfig<KEY>

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

Formats the value using the given formatter.

impl<K: SignatureKey> Default for NetworkConfig<K>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, KEY: SignatureKey> Deserialize<'de> for NetworkConfig<KEY>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K: SignatureKey> From<NetworkConfigFile<K>> for NetworkConfig<K>

fn from(val: NetworkConfigFile<K>) -> Self

Converts to this type from the input type.

impl<KEY> Serialize for NetworkConfig<KEY>

where KEY: Serialize + SignatureKey,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.