revert(configs): Add port parameter to ConsensusConfig (#2986) (#3046)

This reverts commit 25112df.

## What ❔

<!-- What are the changes this PR brings about? -->
<!-- Example: This PR adds a PR template to the repo. -->
<!-- (For bigger PRs adding more context is appreciated) -->

## Why ❔

<!-- Why are these changes done? What goal do they contribute to? What
are the principles behind them? -->
<!-- Example: PR templates ensure PR reviewers, observers, and future
iterators are in context about the evolution of repos. -->

## Checklist

<!-- Check your PR fulfills the following items. -->
<!-- For draft PRs check the boxes as you complete them. -->

- [ ] PR title corresponds to the body of PR (we generate changelog
entries from PRs).
- [ ] Tests for the changes have been added / updated.
- [ ] Documentation comments have been added / updated.
- [ ] Code has been formatted via `zk_supervisor fmt` and `zk_supervisor
lint`.

core/lib/config/src/configs/consensus.rs

@@ -115,7 +115,6 @@ impl RpcConfig {
 /// Config (shared between main node and external node).
 #[derive(Clone, Debug, PartialEq)]
 pub struct ConsensusConfig {
-    pub port: u16,
     /// Local socket address to listen for the incoming connections.
     pub server_addr: std::net::SocketAddr,
     /// Public address of this node (should forward to `server_addr`)

core/lib/config/src/testonly.rs

@@ -802,7 +802,6 @@ impl Distribution<configs::consensus::ConsensusConfig> for EncodeDist {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> configs::consensus::ConsensusConfig {
         use configs::consensus::{ConsensusConfig, Host, NodePublicKey};
         ConsensusConfig {
-            port: self.sample(rng),
             server_addr: self.sample(rng),
             public_addr: Host(self.sample(rng)),
             max_payload_size: self.sample(rng),

core/lib/protobuf_config/src/consensus.rs

@@ -148,9 +148,6 @@ impl ProtoRepr for proto::Config {
         };
 
         Ok(Self::Type {
-            port: required(&self.port)
-                .and_then(|x| Ok((*x).try_into()?))
-                .context("port")?,
             server_addr: required(&self.server_addr)
                 .and_then(|x| Ok(x.parse()?))
                 .context("server_addr")?,
@@ -185,7 +182,6 @@ impl ProtoRepr for proto::Config {
 
     fn build(this: &Self::Type) -> Self {
         Self {
-            port: Some(this.port.into()),
             server_addr: Some(this.server_addr.to_string()),
             public_addr: Some(this.public_addr.0.clone()),
             max_payload_size: Some(this.max_payload_size.try_into().unwrap()),

core/lib/protobuf_config/src/proto/core/consensus.proto

@@ -70,9 +70,6 @@ message Config {
   reserved 3;
   reserved "validators";
 
-  // Port to listen on, for incoming TCP connections.
-  optional uint32 port = 12; // required
-
   // IP:port to listen on, for incoming TCP connections.
   // Use `0.0.0.0:<port>` to listen on all network interfaces (i.e. on all IPs exposed by this VM).
   optional string server_addr = 1; // required; IpAddr

core/node/consensus/src/testonly.rs

@@ -154,7 +154,6 @@ fn make_config(
     genesis_spec: Option<config::GenesisSpec>,
 ) -> config::ConsensusConfig {
     config::ConsensusConfig {
-        port: cfg.server_addr.port(),
         server_addr: *cfg.server_addr,
         public_addr: config::Host(cfg.public_addr.0.clone()),
         max_payload_size: usize::MAX,

etc/env/consensus_config.yaml

@@ -1,4 +1,3 @@
-port: 3054
 server_addr: "127.0.0.1:3054"
 public_addr: "127.0.0.1:3054"
 max_payload_size: 2500000

etc/env/en_consensus_config.yaml

@@ -1,4 +1,3 @@
-port: 3055
 server_addr: '127.0.0.1:3055'
 public_addr: '127.0.0.1:3055'
 max_payload_size: 2500000

etc/env/file_based/general.yaml

@@ -375,10 +375,3 @@ da_dispatcher:
 
 external_proof_integration_api:
   http_port: 3073
-
-consensus:
-  port: 3054
-  server_addr: "127.0.0.1:3054"
-  public_addr: "127.0.0.1:3054"
-  max_payload_size: 2500000
-  gossip_dynamic_inbound_limit: 100

zk_toolbox/crates/config/src/consts.rs

@@ -62,6 +62,8 @@ pub const DEFAULT_EXPLORER_WORKER_PORT: u16 = 3001;
 pub const DEFAULT_EXPLORER_API_PORT: u16 = 3002;
 /// Default port for the explorer data fetcher service
 pub const DEFAULT_EXPLORER_DATA_FETCHER_PORT: u16 = 3040;
+/// Default port for consensus service
+pub const DEFAULT_CONSENSUS_PORT: u16 = 3054;
 
 pub const EXPLORER_API_DOCKER_IMAGE: &str = "matterlabs/block-explorer-api";
 pub const EXPLORER_DATA_FETCHER_DOCKER_IMAGE: &str = "matterlabs/block-explorer-data-fetcher";

zk_toolbox/crates/zk_inception/src/commands/chain/init/configs.rs

@@ -2,7 +2,7 @@ use anyhow::Context;
 use common::logger;
 use config::{
     copy_configs, set_l1_rpc_url, traits::SaveConfigWithBasePath, update_from_chain_config,
-    ChainConfig, ContractsConfig, EcosystemConfig,
+    ChainConfig, ContractsConfig, EcosystemConfig, DEFAULT_CONSENSUS_PORT,
 };
 use ethers::types::Address;
 use xshell::Shell;
@@ -15,12 +15,13 @@ use crate::{
         },
         portal::update_portal_config,
     },
+    defaults::PORT_RANGE_END,
     messages::{
-        MSG_CHAIN_CONFIGS_INITIALIZED, MSG_CHAIN_NOT_FOUND_ERR, MSG_CONSENSUS_CONFIG_MISSING_ERR,
+        MSG_CHAIN_CONFIGS_INITIALIZED, MSG_CHAIN_NOT_FOUND_ERR,
         MSG_PORTAL_FAILED_TO_CREATE_CONFIG_ERR,
     },
     utils::{
-        consensus::{generate_consensus_keys, get_consensus_secrets, get_genesis_specs},
+        consensus::{generate_consensus_keys, get_consensus_config, get_consensus_secrets},
         ports::EcosystemPortsScanner,
     },
 };
@@ -56,14 +57,22 @@ pub async fn init_configs(
         )?;
     }
 
+    // Initialize general config
     let mut general_config = chain_config.get_general_config()?;
-    let mut consensus_config = general_config
-        .consensus_config
-        .context(MSG_CONSENSUS_CONFIG_MISSING_ERR)?;
 
-    let consensus_keys = generate_consensus_keys();
-    consensus_config.genesis_spec = Some(get_genesis_specs(chain_config, &consensus_keys));
+    // TODO: This is a temporary solution. We should allocate consensus port using `EcosystemPorts::allocate_ports_in_yaml`
+    let offset = ((chain_config.id - 1) * 100) as u16;
+    let consensus_port_range = DEFAULT_CONSENSUS_PORT + offset..PORT_RANGE_END;
+    let consensus_port =
+        ecosystem_ports.allocate_port(consensus_port_range, "Consensus".to_string())?;
 
+    let consensus_keys = generate_consensus_keys();
+    let consensus_config = get_consensus_config(
+        chain_config,
+        consensus_port,
+        Some(consensus_keys.clone()),
+        None,
+    )?;
     general_config.consensus_config = Some(consensus_config);
     general_config.save_with_base_path(shell, &chain_config.configs)?;
 

zk_toolbox/crates/zk_inception/src/commands/external_node/prepare_configs.rs

@@ -6,26 +6,27 @@ use config::{
     external_node::ENConfig,
     set_rocks_db_config,
     traits::{FileConfigWithDefaultName, SaveConfigWithBasePath},
-    ChainConfig, EcosystemConfig, GeneralConfig, SecretsConfig,
+    ChainConfig, EcosystemConfig, GeneralConfig, SecretsConfig, DEFAULT_CONSENSUS_PORT,
 };
 use xshell::Shell;
 use zksync_basic_types::url::SensitiveUrl;
 use zksync_config::configs::{
-    consensus::{ConsensusConfig, ConsensusSecrets, NodeSecretKey, Secret},
+    consensus::{ConsensusSecrets, NodeSecretKey, Secret},
     DatabaseSecrets, L1Secrets,
 };
 use zksync_consensus_crypto::TextFmt;
 use zksync_consensus_roles as roles;
 
 use crate::{
     commands::external_node::args::prepare_configs::{PrepareConfigArgs, PrepareConfigFinal},
+    defaults::PORT_RANGE_END,
     messages::{
         msg_preparing_en_config_is_done, MSG_CHAIN_NOT_INITIALIZED,
         MSG_CONSENSUS_CONFIG_MISSING_ERR, MSG_CONSENSUS_SECRETS_MISSING_ERR,
         MSG_CONSENSUS_SECRETS_NODE_KEY_MISSING_ERR, MSG_PREPARING_EN_CONFIGS,
     },
     utils::{
-        consensus::node_public_key,
+        consensus::{get_consensus_config, node_public_key},
         ports::EcosystemPortsScanner,
         rocks_db::{recreate_rocksdb_dirs, RocksDBDirOption},
     },
@@ -78,12 +79,19 @@ fn prepare_configs(
         bridge_addresses_refresh_interval_sec: None,
     };
     let mut general_en = general.clone();
-    general_en.consensus_config = None;
 
     let main_node_consensus_config = general
         .consensus_config
         .context(MSG_CONSENSUS_CONFIG_MISSING_ERR)?;
-    let mut en_consensus_config = main_node_consensus_config.clone();
+
+    // TODO: This is a temporary solution. We should allocate consensus port using `EcosystemPorts::allocate_ports_in_yaml`
+    ports.add_port_info(
+        main_node_consensus_config.server_addr.port(),
+        "Main node consensus".to_string(),
+    );
+    let offset = ((config.id - 1) * 100) as u16;
+    let consensus_port_range = DEFAULT_CONSENSUS_PORT + offset..PORT_RANGE_END;
+    let consensus_port = ports.allocate_port(consensus_port_range, "Consensus".to_string())?;
 
     let mut gossip_static_outbound = BTreeMap::new();
     let main_node_public_key = node_public_key(
@@ -93,8 +101,13 @@ fn prepare_configs(
             .context(MSG_CONSENSUS_SECRETS_MISSING_ERR)?,
     )?
     .context(MSG_CONSENSUS_SECRETS_NODE_KEY_MISSING_ERR)?;
+
     gossip_static_outbound.insert(main_node_public_key, main_node_consensus_config.public_addr);
-    en_consensus_config.gossip_static_outbound = gossip_static_outbound;
+
+    let en_consensus_config =
+        get_consensus_config(config, consensus_port, None, Some(gossip_static_outbound))?;
+    general_en.consensus_config = Some(en_consensus_config.clone());
+    en_consensus_config.save_with_base_path(shell, en_configs_path)?;
 
     // Set secrets config
     let node_key = roles::node::SecretKey::generate().encode();
@@ -115,25 +128,16 @@ fn prepare_configs(
         }),
         data_availability: None,
     };
-
+    secrets.save_with_base_path(shell, en_configs_path)?;
     let dirs = recreate_rocksdb_dirs(shell, &config.rocks_db_path, RocksDBDirOption::ExternalNode)?;
     set_rocks_db_config(&mut general_en, dirs)?;
-
     general_en.save_with_base_path(shell, en_configs_path)?;
     en_config.save_with_base_path(shell, en_configs_path)?;
-    en_consensus_config.save_with_base_path(shell, en_configs_path)?;
-    secrets.save_with_base_path(shell, en_configs_path)?;
 
-    let offset = 0; // This is zero because general_en ports already have a chain offset
     ports.allocate_ports_in_yaml(
         shell,
         &GeneralConfig::get_path_with_base_path(en_configs_path),
-        offset,
-    )?;
-    ports.allocate_ports_in_yaml(
-        shell,
-        &ConsensusConfig::get_path_with_base_path(en_configs_path),
-        offset,
+        0, // This is zero because general_en ports already have a chain offset
     )?;
 
     Ok(())

zk_toolbox/crates/zk_inception/src/consts.rs

@@ -1,3 +1,5 @@
+use std::net::{IpAddr, Ipv4Addr};
+
 pub const AMOUNT_FOR_DISTRIBUTION_TO_WALLETS: u128 = 1000000000000000000000;
 
 pub const MINIMUM_BALANCE_FOR_WALLET: u128 = 5000000000000000000;
@@ -10,6 +12,27 @@ pub const DEFAULT_UNSIGNED_TRANSACTIONS_DIR: &str = "transactions";
 pub const BELLMAN_CUDA_DIR: &str = "era-bellman-cuda";
 pub const L2_BASE_TOKEN_ADDRESS: &str = "0x000000000000000000000000000000000000800A";
 
+#[allow(non_upper_case_globals)]
+const kB: usize = 1024;
+
+/// Max payload size for consensus in bytes
+pub const MAX_PAYLOAD_SIZE: usize = 2_500_000;
+/// Max batch size for consensus in bytes
+/// Compute a default batch size, so operators are not caught out by the missing setting
+/// while we're still working on batch syncing. The batch interval is ~1 minute,
+/// so there will be ~60 blocks, and an Ethereum Merkle proof is ~1kB, but under high
+/// traffic there can be thousands of huge transactions that quickly fill up blocks
+/// and there could be more blocks in a batch then expected. We chose a generous
+/// limit so as not to prevent any legitimate batch from being transmitted.
+pub const MAX_BATCH_SIZE: usize = MAX_PAYLOAD_SIZE * 5000 + kB;
+/// Gossip dynamic inbound limit for consensus
+pub const GOSSIP_DYNAMIC_INBOUND_LIMIT: usize = 100;
+
+/// Public address for consensus
+pub const CONSENSUS_PUBLIC_ADDRESS_HOST: IpAddr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
+/// Server address for consensus
+pub const CONSENSUS_SERVER_ADDRESS_HOST: IpAddr = IpAddr::V4(Ipv4Addr::LOCALHOST);
+
 /// Path to the JS runtime config for the block-explorer-app docker container to be mounted to
 pub const EXPLORER_APP_DOCKER_CONFIG_PATH: &str = "/usr/src/app/packages/app/dist/config.js";
 pub const EXPLORER_APP_DOCKER_IMAGE: &str = "matterlabs/block-explorer-app";

zk_toolbox/crates/zk_inception/src/utils/consensus.rs

@@ -1,14 +1,24 @@
+use std::{
+    collections::{BTreeMap, BTreeSet},
+    net::SocketAddr,
+};
+
 use anyhow::Context as _;
 use config::ChainConfig;
 use secrecy::{ExposeSecret, Secret};
 use zksync_config::configs::consensus::{
-    AttesterPublicKey, AttesterSecretKey, ConsensusSecrets, GenesisSpec, NodePublicKey,
-    NodeSecretKey, ProtocolVersion, ValidatorPublicKey, ValidatorSecretKey, WeightedAttester,
-    WeightedValidator,
+    AttesterPublicKey, AttesterSecretKey, ConsensusConfig, ConsensusSecrets, GenesisSpec, Host,
+    NodePublicKey, NodeSecretKey, ProtocolVersion, ValidatorPublicKey, ValidatorSecretKey,
+    WeightedAttester, WeightedValidator,
 };
 use zksync_consensus_crypto::{Text, TextFmt};
 use zksync_consensus_roles::{attester, node, validator};
 
+use crate::consts::{
+    CONSENSUS_PUBLIC_ADDRESS_HOST, CONSENSUS_SERVER_ADDRESS_HOST, GOSSIP_DYNAMIC_INBOUND_LIMIT,
+    MAX_BATCH_SIZE, MAX_PAYLOAD_SIZE,
+};
+
 pub(crate) fn parse_attester_committee(
     attesters: &[WeightedAttester],
 ) -> anyhow::Result<attester::Committee> {
@@ -38,6 +48,32 @@ pub struct ConsensusPublicKeys {
     attester_key: attester::PublicKey,
 }
 
+pub fn get_consensus_config(
+    chain_config: &ChainConfig,
+    consensus_port: u16,
+    consensus_keys: Option<ConsensusSecretKeys>,
+    gossip_static_outbound: Option<BTreeMap<NodePublicKey, Host>>,
+) -> anyhow::Result<ConsensusConfig> {
+    let genesis_spec =
+        consensus_keys.map(|consensus_keys| get_genesis_specs(chain_config, &consensus_keys));
+
+    let public_addr = SocketAddr::new(CONSENSUS_PUBLIC_ADDRESS_HOST, consensus_port);
+    let server_addr = SocketAddr::new(CONSENSUS_SERVER_ADDRESS_HOST, consensus_port);
+
+    Ok(ConsensusConfig {
+        server_addr,
+        public_addr: Host(public_addr.encode()),
+        genesis_spec,
+        max_payload_size: MAX_PAYLOAD_SIZE,
+        gossip_dynamic_inbound_limit: GOSSIP_DYNAMIC_INBOUND_LIMIT,
+        max_batch_size: MAX_BATCH_SIZE,
+        gossip_static_inbound: BTreeSet::new(),
+        gossip_static_outbound: gossip_static_outbound.unwrap_or_default(),
+        rpc: None,
+        debug_page_addr: None,
+    })
+}
+
 pub fn generate_consensus_keys() -> ConsensusSecretKeys {
     ConsensusSecretKeys {
         validator_key: validator::SecretKey::generate(),

zk_toolbox/crates/zk_inception/src/utils/ports.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fmt, net::SocketAddr, ops::Range, path::Path};
+use std::{collections::HashMap, fmt, ops::Range, path::Path};
 
 use anyhow::{bail, Context, Result};
 use config::{
@@ -109,12 +109,6 @@ impl EcosystemPorts {
                                 }
                             }
                         }
-                    } else if key.as_str().map(|s| s.ends_with("addr")).unwrap_or(false) {
-                        let socket_addr = val.as_str().unwrap().parse::<SocketAddr>()?;
-                        if let Some(new_port) = updated_ports.get(&socket_addr.port()) {
-                            let new_socket_addr = SocketAddr::new(socket_addr.ip(), *new_port);
-                            *val = Value::String(new_socket_addr.to_string());
-                        }
                     }
                 }
                 // Continue traversing