From 581e94f14b89387c8e7c435de9404d535711bf31 Mon Sep 17 00:00:00 2001 From: kostekIV <27210860+kostekIV@users.noreply.github.com> Date: Mon, 28 Oct 2024 10:03:59 +0100 Subject: [PATCH] Revert "L1-9: Rm V3" (#1845) Reverts Cardinal-Cryptography/aleph-node#1842 since we did it too early. --- finality-aleph/src/sync/data.rs | 141 ++++++++++++++++++++++++++++++++ 1 file changed, 141 insertions(+) diff --git a/finality-aleph/src/sync/data.rs b/finality-aleph/src/sync/data.rs index 1eb7824a86..40b82c54e2 100644 --- a/finality-aleph/src/sync/data.rs +++ b/finality-aleph/src/sync/data.rs @@ -65,6 +65,22 @@ pub enum BranchKnowledge { TopImported(BlockId), } +// Only needed for backwards compatible decoding. +// TODO(A0-4270): Remove this when removing v3 data. +#[derive(Clone, Debug, Encode, Decode)] +enum MaybeHeader { + Header(UH), + Id(BlockId), +} + +/// Request content, version 2. +#[derive(Clone, Debug, Encode, Decode)] +pub struct RequestV2 { + target: MaybeHeader>, + branch_knowledge: BranchKnowledge, + state: State, +} + /// Request content, current version. #[derive(Clone, Debug, Encode, Decode)] pub struct Request { @@ -73,6 +89,42 @@ pub struct Request { state: State, } +impl TryFrom> for Request { + type Error = (); + + fn try_from(other: RequestV2) -> Result { + let RequestV2 { + target, + branch_knowledge, + state, + } = other; + let target = match target { + MaybeHeader::Header(header) => header, + MaybeHeader::Id(_) => return Err(()), + }; + Ok(Request { + target, + branch_knowledge, + state, + }) + } +} + +impl From> for RequestV2 { + fn from(other: Request) -> Self { + let Request { + target, + branch_knowledge, + state, + } = other; + RequestV2 { + target: MaybeHeader::Header(target), + branch_knowledge, + state, + } + } +} + impl Request { pub fn new( target: UnverifiedHeaderFor, @@ -130,6 +182,28 @@ impl PreRequest { } } +/// Data to be sent over the network, version 3. +#[derive(Clone, Debug, Encode, Decode)] +pub enum NetworkDataV3 +where + J: Justification, + B: Block>, +{ + /// A periodic state broadcast, so that neighbouring nodes can request what they are missing, + /// send what we are missing, and sometimes just use the justifications to update their own + /// state. + StateBroadcast(State), + /// Response to a state broadcast. Contains at most two justifications that the peer will + /// understand. + StateBroadcastResponse(J::Unverified, Option), + /// An explicit request for data, potentially a lot of it. + Request(RequestV2), + /// Response to the request for data. + RequestResponse(ResponseItems), + /// A request for a chain extension. + ChainExtensionRequest(State), +} + /// Data to be sent over the network, current version. #[derive(Clone, Debug, Encode, Decode)] pub enum NetworkData @@ -152,6 +226,52 @@ where ChainExtensionRequest(State), } +impl TryFrom> for NetworkData +where + J: Justification, + B: Block>, +{ + type Error = (); + + fn try_from(data: NetworkDataV3) -> Result { + Ok(match data { + NetworkDataV3::StateBroadcast(state) => NetworkData::StateBroadcast(state), + NetworkDataV3::StateBroadcastResponse(justification, maybe_justification) => { + NetworkData::StateBroadcastResponse(justification, maybe_justification) + } + NetworkDataV3::Request(request) => NetworkData::Request(request.try_into()?), + NetworkDataV3::RequestResponse(response_items) => { + NetworkData::RequestResponse(response_items) + } + NetworkDataV3::ChainExtensionRequest(state) => { + NetworkData::ChainExtensionRequest(state) + } + }) + } +} + +impl From> for NetworkDataV3 +where + J: Justification, + B: Block>, +{ + fn from(data: NetworkData) -> Self { + match data { + NetworkData::StateBroadcast(state) => NetworkDataV3::StateBroadcast(state), + NetworkData::StateBroadcastResponse(justification, maybe_justification) => { + NetworkDataV3::StateBroadcastResponse(justification, maybe_justification) + } + NetworkData::Request(request) => NetworkDataV3::Request(request.into()), + NetworkData::RequestResponse(response_items) => { + NetworkDataV3::RequestResponse(response_items) + } + NetworkData::ChainExtensionRequest(state) => { + NetworkDataV3::ChainExtensionRequest(state) + } + } + } +} + /// Version wrapper around the network data. #[derive(Clone, Debug)] pub enum VersionedNetworkData @@ -161,6 +281,7 @@ where { // Most likely from the future. Other(Version, Vec), + V3(NetworkDataV3), V4(NetworkData), } @@ -211,6 +332,7 @@ where + byte_count_size + match self { Other(_, payload) => payload.len(), + V3(data) => data.size_hint(), V4(data) => data.size_hint(), } } @@ -219,6 +341,7 @@ where use VersionedNetworkData::*; match self { Other(version, payload) => encode_with_version(*version, payload), + V3(data) => encode_with_version(Version(3), &data.encode()), V4(data) => encode_with_version(Version(4), &data.encode()), } } @@ -234,6 +357,7 @@ where let version = Version::decode(input)?; let num_bytes = ByteCount::decode(input)?; match version { + Version(3) => Ok(V3(NetworkDataV3::decode(input)?)), Version(4) => Ok(V4(NetworkData::decode(input)?)), _ => { if num_bytes > MAX_SYNC_MESSAGE_SIZE { @@ -288,6 +412,10 @@ where data: NetworkData, peer_id: Self::PeerId, ) -> Result<(), Self::Error> { + self.inner.send_to( + VersionedNetworkData::V3(data.clone().into()), + peer_id.clone(), + )?; self.inner.send_to(VersionedNetworkData::V4(data), peer_id) } @@ -296,11 +424,17 @@ where data: NetworkData, peer_ids: HashSet, ) -> Result<(), Self::Error> { + self.inner.send_to_random( + VersionedNetworkData::V3(data.clone().into()), + peer_ids.clone(), + )?; self.inner .send_to_random(VersionedNetworkData::V4(data), peer_ids) } fn broadcast(&mut self, data: NetworkData) -> Result<(), Self::Error> { + self.inner + .broadcast(VersionedNetworkData::V3(data.clone().into()))?; self.inner.broadcast(VersionedNetworkData::V4(data)) } @@ -318,6 +452,13 @@ where "Received sync data of unsupported version {:?}.", version ) } + (VersionedNetworkData::V3(data), peer_id) => match data.try_into() { + Ok(data) => return Ok((data, peer_id)), + Err(()) => warn!( + target: LOG_TARGET, + "Received request with no header in target, this should never happen.", + ), + }, (VersionedNetworkData::V4(data), peer_id) => return Ok((data, peer_id)), } }