zksync_consensus_network 0.13.0

ZKsync consensus network component
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use std::collections::HashMap;

use anyhow::Context as _;
use zksync_protobuf::{kB, required};

use super::CapabilityId;
use crate::proto::mux as proto;

/// Max size of a handshkake frame.
pub(super) const MAX_FRAME: usize = 10 * kB;

pub(super) struct Handshake {
    /// Maximal supported number of the accept streams per capability.
    pub(super) accept_max_streams: HashMap<CapabilityId, u32>,
    /// Maximal supported number of the connect streams per capability.
    pub(super) connect_max_streams: HashMap<CapabilityId, u32>,
}

fn read_max_streams(
    capabilities: &Vec<proto::handshake::Capability>,
) -> anyhow::Result<HashMap<CapabilityId, u32>> {
    let mut ms = HashMap::new();
    for r in capabilities {
        let id = *required(&r.id).context("id")?;
        let max_streams = *required(&r.max_streams).context("max_streams")?;
        if ms.insert(id, max_streams).is_some() {
            anyhow::bail!("duplicate entry for id {id}");
        }
    }
    Ok(ms)
}

fn build_capabilities(
    max_streams: &HashMap<CapabilityId, u32>,
) -> Vec<proto::handshake::Capability> {
    max_streams
        .iter()
        .map(|(id, max_streams)| proto::handshake::Capability {
            id: Some(*id),
            max_streams: Some(*max_streams),
        })
        .collect()
}

impl zksync_protobuf::ProtoFmt for Handshake {
    type Proto = proto::Handshake;

    fn read(r: &Self::Proto) -> anyhow::Result<Self> {
        Ok(Self {
            accept_max_streams: read_max_streams(&r.accept).context("accept")?,
            connect_max_streams: read_max_streams(&r.connect).context("connect")?,
        })
    }

    fn build(&self) -> Self::Proto {
        Self::Proto {
            accept: build_capabilities(&self.accept_max_streams),
            connect: build_capabilities(&self.connect_max_streams),
        }
    }
}