Method start

etc/systems/src/l2/in_process_consensus.rs:98–232

Starts an in-process consensus node with the given configuration.

(config: InProcessConsensusConfig)

impl InProcessConsensus {
    /// Starts an in-process consensus node with the given configuration.
    pub async fn start(config: InProcessConsensusConfig) -> Result<Self> {
        let rollup_config = config.rollup_config;
        let l1_chain_config = config.l1_chain_config;

        let rpc_port = config.rpc_port.unwrap_or_else(get_available_port);
        let p2p_tcp_port = config.p2p_tcp_port.unwrap_or_else(get_available_port);
        let p2p_udp_port = config.p2p_udp_port.unwrap_or_else(get_available_port);
        let listen_ip = IpAddr::V4(Ipv4Addr::LOCALHOST);

        // Build keypair from P2P key or generate a random one.
        let keypair = if let Some(mut p2p_key) = config.p2p_key {
            SecretKeyLoader::parse(&mut p2p_key.0).wrap_err("Failed to parse P2P key")?
        } else {
            libp2p::identity::Keypair::generate_secp256k1()
        };

        let peer_id = keypair.public().to_peer_id().to_string();

        // Build the signing key for discv5 from the same P2P key material.
        let signing_key = extract_signing_key(&keypair)?;

        let local_node = LocalNode::new(signing_key, listen_ip, p2p_tcp_port, p2p_udp_port);

        let gossip_address: libp2p::Multiaddr = format!("/ip4/{listen_ip}/tcp/{p2p_tcp_port}")
            .parse()
            .wrap_err("Failed to parse gossip multiaddr")?;

        let mut net_config = NetworkConfig::new(
            rollup_config.clone(),
            local_node,
            gossip_address,
            config.unsafe_block_signer,
        );
        net_config.scoring = PeerScoreLevel::Off;
        net_config.keypair = keypair;
        // Use flood_publish since the mesh may not fully form with only two peers.
        net_config.gossip_config = base_consensus_gossip::default_config_builder()
            .flood_publish(true)
            .build()
            .expect("valid gossip config");

        // For sequencer mode, attach a gossip signer.
        if config.mode == NodeMode::Sequencer {
            let seq_key = config
                .sequencer_key
                .ok_or_else(|| eyre::eyre!("sequencer_key is required for Sequencer mode"))?;
            let signer = PrivateKeySigner::from_bytes(&seq_key)
                .wrap_err("Failed to create sequencer signer")?;
            net_config.gossip_signer = Some(BlockSigner::Local(signer));
        }

        let l1_config = L1ConfigBuilder {
            chain_config: l1_chain_config,
            trust_rpc: true,
            beacon: config.l1_beacon_url,
            rpc_url: config.l1_rpc_url.clone(),
            slot_duration_override: config.l1_slot_duration_override,
            verifier_l1_confs: config.verifier_l1_confs,