Skip to main content

zombienet_orchestrator/generators/
jam_validators.rs

1use configuration::types::JamNodeMode;
2use serde::{Deserialize, Serialize};
3
4use crate::network_spec::jamchain::JamchainSpec;
5
6/// A genesis validator, in the shape `jam-chainspec` reads under `genesis_validators`.
7#[derive(Debug, Clone, Default, Serialize, Deserialize)]
8pub struct GenesisValidator {
9    pub peer_id: String,
10    pub bandersnatch: String,
11    pub net_addr: String,
12}
13
14/// The genesis validator set: the network's validator nodes, in order.
15pub fn genesis_validators(jam_spec: &JamchainSpec) -> Vec<GenesisValidator> {
16    jam_spec
17        .nodes
18        .iter()
19        .filter_map(|n| {
20            if let JamNodeMode::Validator = n.mode {
21                Some(GenesisValidator {
22                    peer_id: n.peer_id.clone(),
23                    bandersnatch: n
24                        .accounts
25                        .accounts
26                        .get("bandersnatch")
27                        .expect("bandersnatch should be present.")
28                        .public_key
29                        .clone(),
30                    // The genesis validator set doubles as the p2p address book, so this
31                    // must be the port the node actually listens on (`--port`), not the
32                    // rpc one.
33                    net_addr: format!("127.0.0.1:{}", n.port.0),
34                })
35            } else {
36                None
37            }
38        })
39        .collect()
40}
41
42#[cfg(test)]
43mod tests {
44    use configuration::types::Chain;
45
46    use super::*;
47    use crate::{
48        network_spec::{jamchain::JamChainSpecSource, jamnode::JamNodeSpec},
49        shared::types::{NodeAccount, NodeAccounts, ParkedPort},
50    };
51
52    fn jam_node(name: &str, mode: JamNodeMode, p2p_port: u16, rpc_port: u16) -> JamNodeSpec {
53        JamNodeSpec {
54            name: name.to_string(),
55            mode,
56            peer_id: format!("peer-{name}"),
57            accounts: NodeAccounts {
58                seed: name.to_string(),
59                accounts: [(
60                    "bandersnatch".to_string(),
61                    NodeAccount::new(format!("addr-{name}"), format!("pub-{name}")),
62                )]
63                .into(),
64            },
65            port: ParkedPort(p2p_port, Default::default()),
66            rpc_port: ParkedPort(rpc_port, Default::default()),
67            ..Default::default()
68        }
69    }
70
71    fn jam_spec(nodes: Vec<JamNodeSpec>) -> JamchainSpec {
72        JamchainSpec {
73            id: Chain::try_from("dev").unwrap(),
74            default_command: None,
75            default_image: None,
76            default_resources: None,
77            default_args: vec![],
78            protocol_params_type: configuration::types::JamProtocolParameterType::Tiny,
79            chain_spec_source: JamChainSpecSource::JamBuilder(Box::default()),
80            nodes,
81        }
82    }
83
84    // The nodes dial each other using the addresses in the genesis validator set, so
85    // pointing them at the rpc port silently splits the network.
86    #[test]
87    fn genesis_validators_are_addressed_by_their_p2p_port() {
88        let spec = jam_spec(vec![
89            jam_node("alice", JamNodeMode::Validator, 40001, 9944),
90            jam_node("bob", JamNodeMode::Validator, 40002, 9945),
91        ]);
92
93        let validators = genesis_validators(&spec);
94
95        let addrs: Vec<&str> = validators.iter().map(|v| v.net_addr.as_str()).collect();
96        assert_eq!(addrs, vec!["127.0.0.1:40001", "127.0.0.1:40002"]);
97    }
98
99    #[test]
100    fn only_validators_are_included_in_genesis() {
101        let spec = jam_spec(vec![
102            jam_node("alice", JamNodeMode::Validator, 40001, 9944),
103            jam_node("dave", JamNodeMode::Ordinary, 40002, 9945),
104            jam_node("eve", JamNodeMode::Proxy, 40003, 9946),
105        ]);
106
107        let validators = genesis_validators(&spec);
108
109        assert_eq!(validators.len(), 1);
110        assert_eq!(validators[0].peer_id, "peer-alice");
111    }
112}