/// Request message for method Handshake.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HandshakeRequest {
    /// Nonce for the server to authenticate its node ID with.
    #[prost(bytes = "vec", tag = "1")]
    pub nonce: ::prost::alloc::vec::Vec<u8>,
}
/// Response message for method Handshake.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct HandshakeResponse {
    /// Version of the protocol implemented by the server.
    #[prost(uint32, tag = "1")]
    pub version: u32,
    /// The identifier of the genesis block. This can be used by the client
    /// to determine if the server node runs the expected blockchain.
    #[prost(bytes = "vec", tag = "2")]
    pub block0: ::prost::alloc::vec::Vec<u8>,
    /// Node ID of the server, the public key of a key pair.
    #[prost(bytes = "vec", tag = "3")]
    pub node_id: ::prost::alloc::vec::Vec<u8>,
    /// Signature of the client's nonce using the private key in the server's
    /// key pair.
    #[prost(bytes = "vec", tag = "4")]
    pub signature: ::prost::alloc::vec::Vec<u8>,
    /// Nonce for the client to authenticate its node ID with.
    #[prost(bytes = "vec", tag = "5")]
    pub nonce: ::prost::alloc::vec::Vec<u8>,
}
/// Request message for method ClientAuth.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClientAuthRequest {
    /// Node ID of the client, the public key of a key pair.
    #[prost(bytes = "vec", tag = "1")]
    pub node_id: ::prost::alloc::vec::Vec<u8>,
    /// Signature of the server's nonce sent in HandshakeResponse,
    /// using the private key in the client's key pair.
    #[prost(bytes = "vec", tag = "2")]
    pub signature: ::prost::alloc::vec::Vec<u8>,
}
/// Response message for method ClientAuth.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ClientAuthResponse {}
/// Request message for method Tip.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TipRequest {}
/// Response message for method Tip.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TipResponse {
    /// Serialized content of the tip block header.
    #[prost(bytes = "vec", tag = "1")]
    pub block_header: ::prost::alloc::vec::Vec<u8>,
}
/// Request for peers
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PeersRequest {
    #[prost(uint32, tag = "1")]
    pub limit: u32,
}
/// Responses as a bunch of peers, similar to Gossip
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PeersResponse {
    #[prost(bytes = "vec", repeated, tag = "2")]
    pub peers: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
}
/// Request message for method PullHeaders.
/// This message can also be send by the service as a BlockEvent variant.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PullHeadersRequest {
    /// The identifiers of blocks to consider as the
    /// starting point, in order of appearance.
    #[prost(bytes = "vec", repeated, tag = "1")]
    pub from: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
    /// The identifier of the end block.
    #[prost(bytes = "vec", tag = "2")]
    pub to: ::prost::alloc::vec::Vec<u8>,
}
/// Request message for method PullBlocksToTip.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PullBlocksToTipRequest {
    /// The identifiers of blocks to consider as the
    /// starting point, in order of appearance.
    #[prost(bytes = "vec", repeated, tag = "1")]
    pub from: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
}
/// Request message for method PullBlocks
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PullBlocksRequest {
    /// The identifiers of blocks to consider as the starting point in order of
    /// appearance.
    #[prost(bytes = "vec", repeated, tag = "1")]
    pub from: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
    /// The identifier of the end block
    #[prost(bytes = "vec", tag = "2")]
    pub to: ::prost::alloc::vec::Vec<u8>,
}
/// Response message for method PushHeaders.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PushHeadersResponse {}
/// Response message for method UploadBlocks.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UploadBlocksResponse {}
/// Gossip message with information on nodes in the network.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Gossip {
    /// Serialized descriptions of nodes.
    #[prost(bytes = "vec", repeated, tag = "2")]
    pub nodes: ::prost::alloc::vec::Vec<::prost::alloc::vec::Vec<u8>>,
}
/// Element of the subscription stream returned by BlockSubscription.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BlockEvent {
    #[prost(oneof = "block_event::Item", tags = "1, 2, 3")]
    pub item: ::core::option::Option<block_event::Item>,
}
/// Nested message and enum types in `BlockEvent`.
pub mod block_event {
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Item {
        /// Announcement of a new block, carrying the block's header.
        #[prost(message, tag = "1")]
        Announce(super::super::types::Header),
        /// Solicitation to upload identified blocks with an UploadBlocks
        /// method call.
        #[prost(message, tag = "2")]
        Solicit(super::super::types::BlockIds),
        /// Solicitation to push the chain of block headers with a PushHeaders
        /// method call.
        #[prost(message, tag = "3")]
        Missing(super::PullHeadersRequest),
    }
}
#[doc = r" Generated client implementations."]
pub mod node_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    #[derive(Debug, Clone)]
    pub struct NodeClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl NodeClient<tonic::transport::Channel> {
        #[doc = r" Attempt to create a new client by connecting to a given endpoint."]
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: std::convert::TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> NodeClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::ResponseBody: Body + Send + 'static,
        T::Error: Into<StdError>,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_interceptor<F>(inner: T, interceptor: F) -> NodeClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
                Into<StdError> + Send + Sync,
        {
            NodeClient::new(InterceptedService::new(inner, interceptor))
        }
        #[doc = r" Compress requests with `gzip`."]
        #[doc = r""]
        #[doc = r" This requires the server to support it otherwise it might respond with an"]
        #[doc = r" error."]
        pub fn send_gzip(mut self) -> Self {
            self.inner = self.inner.send_gzip();
            self
        }
        #[doc = r" Enable decompressing responses with `gzip`."]
        pub fn accept_gzip(mut self) -> Self {
            self.inner = self.inner.accept_gzip();
            self
        }
        #[doc = " Initial handshake and authentication of the server node."]
        pub async fn handshake(
            &mut self,
            request: impl tonic::IntoRequest<super::HandshakeRequest>,
        ) -> Result<tonic::Response<super::HandshakeResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/Handshake");
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Optional authentication of the client node."]
        #[doc = " Called after Handshake."]
        pub async fn client_auth(
            &mut self,
            request: impl tonic::IntoRequest<super::ClientAuthRequest>,
        ) -> Result<tonic::Response<super::ClientAuthResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/ClientAuth");
            self.inner.unary(request.into_request(), path, codec).await
        }
        pub async fn tip(
            &mut self,
            request: impl tonic::IntoRequest<super::TipRequest>,
        ) -> Result<tonic::Response<super::TipResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/Tip");
            self.inner.unary(request.into_request(), path, codec).await
        }
        #[doc = " Requests for some peers"]
        pub async fn peers(
            &mut self,
            request: impl tonic::IntoRequest<super::PeersRequest>,
        ) -> Result<tonic::Response<super::PeersResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/Peers");
            self.inner.unary(request.into_request(), path, codec).await
        }
        pub async fn get_blocks(
            &mut self,
            request: impl tonic::IntoRequest<super::super::types::BlockIds>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::super::types::Block>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/GetBlocks");
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        pub async fn get_headers(
            &mut self,
            request: impl tonic::IntoRequest<super::super::types::BlockIds>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::super::types::Header>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/GetHeaders");
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        pub async fn get_fragments(
            &mut self,
            request: impl tonic::IntoRequest<super::super::types::FragmentIds>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::super::types::Fragment>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/GetFragments");
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Requests headers of blocks in the chain in the chronological order,"]
        #[doc = " given a selection of possible starting blocks known by the requester,"]
        #[doc = " and the identifier of the end block to be included in the returned"]
        #[doc = " sequence."]
        pub async fn pull_headers(
            &mut self,
            request: impl tonic::IntoRequest<super::PullHeadersRequest>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::super::types::Header>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/PullHeaders");
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Requests blocks in the chain in the chronological order, given a selection"]
        #[doc = " of possible starting blocks known by the requester, and the identifier of"]
        #[doc = " the end block to be included in the returned sequence."]
        pub async fn pull_blocks(
            &mut self,
            request: impl tonic::IntoRequest<super::PullBlocksRequest>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::super::types::Block>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/PullBlocks");
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        pub async fn pull_blocks_to_tip(
            &mut self,
            request: impl tonic::IntoRequest<super::PullBlocksToTipRequest>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::super::types::Block>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/PullBlocksToTip");
            self.inner
                .server_streaming(request.into_request(), path, codec)
                .await
        }
        #[doc = " Sends headers of blocks to the service in response to a `missing`"]
        #[doc = " item received from the BlockSubscription response stream."]
        #[doc = " The headers are streamed the in chronological order of the chain."]
        pub async fn push_headers(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::super::types::Header>,
        ) -> Result<tonic::Response<super::PushHeadersResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/PushHeaders");
            self.inner
                .client_streaming(request.into_streaming_request(), path, codec)
                .await
        }
        #[doc = " Uploads blocks to the service in response to a `solicit` item"]
        #[doc = " received from the BlockSubscription response stream."]
        pub async fn upload_blocks(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::super::types::Block>,
        ) -> Result<tonic::Response<super::UploadBlocksResponse>, tonic::Status> {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/UploadBlocks");
            self.inner
                .client_streaming(request.into_streaming_request(), path, codec)
                .await
        }
        #[doc = " Establishes a bidirectional stream to exchange information on new"]
        #[doc = " blocks created or accepted by the peers."]
        pub async fn block_subscription(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::super::types::Header>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::BlockEvent>>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/BlockSubscription");
            self.inner
                .streaming(request.into_streaming_request(), path, codec)
                .await
        }
        #[doc = " Establishes a bidirectional stream to exchange information on new"]
        #[doc = " block fragments created or accepted by the peers."]
        pub async fn fragment_subscription(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::super::types::Fragment>,
        ) -> Result<
            tonic::Response<tonic::codec::Streaming<super::super::types::Fragment>>,
            tonic::Status,
        > {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/FragmentSubscription");
            self.inner
                .streaming(request.into_streaming_request(), path, codec)
                .await
        }
        #[doc = " Establishes a bidirectional stream to exchange information on new"]
        #[doc = " network peers."]
        pub async fn gossip_subscription(
            &mut self,
            request: impl tonic::IntoStreamingRequest<Message = super::Gossip>,
        ) -> Result<tonic::Response<tonic::codec::Streaming<super::Gossip>>, tonic::Status>
        {
            self.inner.ready().await.map_err(|e| {
                tonic::Status::new(
                    tonic::Code::Unknown,
                    format!("Service was not ready: {}", e.into()),
                )
            })?;
            let codec = tonic::codec::ProstCodec::default();
            let path =
                http::uri::PathAndQuery::from_static("/iohk.chain.node.Node/GossipSubscription");
            self.inner
                .streaming(request.into_streaming_request(), path, codec)
                .await
        }
    }
}
#[doc = r" Generated server implementations."]
pub mod node_server {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    #[doc = "Generated trait containing gRPC methods that should be implemented for use with NodeServer."]
    #[async_trait]
    pub trait Node: Send + Sync + 'static {
        #[doc = " Initial handshake and authentication of the server node."]
        async fn handshake(
            &self,
            request: tonic::Request<super::HandshakeRequest>,
        ) -> Result<tonic::Response<super::HandshakeResponse>, tonic::Status>;
        #[doc = " Optional authentication of the client node."]
        #[doc = " Called after Handshake."]
        async fn client_auth(
            &self,
            request: tonic::Request<super::ClientAuthRequest>,
        ) -> Result<tonic::Response<super::ClientAuthResponse>, tonic::Status>;
        async fn tip(
            &self,
            request: tonic::Request<super::TipRequest>,
        ) -> Result<tonic::Response<super::TipResponse>, tonic::Status>;
        #[doc = " Requests for some peers"]
        async fn peers(
            &self,
            request: tonic::Request<super::PeersRequest>,
        ) -> Result<tonic::Response<super::PeersResponse>, tonic::Status>;
        #[doc = "Server streaming response type for the GetBlocks method."]
        type GetBlocksStream: futures_core::Stream<Item = Result<super::super::types::Block, tonic::Status>>
            + Send
            + 'static;
        async fn get_blocks(
            &self,
            request: tonic::Request<super::super::types::BlockIds>,
        ) -> Result<tonic::Response<Self::GetBlocksStream>, tonic::Status>;
        #[doc = "Server streaming response type for the GetHeaders method."]
        type GetHeadersStream: futures_core::Stream<Item = Result<super::super::types::Header, tonic::Status>>
            + Send
            + 'static;
        async fn get_headers(
            &self,
            request: tonic::Request<super::super::types::BlockIds>,
        ) -> Result<tonic::Response<Self::GetHeadersStream>, tonic::Status>;
        #[doc = "Server streaming response type for the GetFragments method."]
        type GetFragmentsStream: futures_core::Stream<Item = Result<super::super::types::Fragment, tonic::Status>>
            + Send
            + 'static;
        async fn get_fragments(
            &self,
            request: tonic::Request<super::super::types::FragmentIds>,
        ) -> Result<tonic::Response<Self::GetFragmentsStream>, tonic::Status>;
        #[doc = "Server streaming response type for the PullHeaders method."]
        type PullHeadersStream: futures_core::Stream<Item = Result<super::super::types::Header, tonic::Status>>
            + Send
            + 'static;
        #[doc = " Requests headers of blocks in the chain in the chronological order,"]
        #[doc = " given a selection of possible starting blocks known by the requester,"]
        #[doc = " and the identifier of the end block to be included in the returned"]
        #[doc = " sequence."]
        async fn pull_headers(
            &self,
            request: tonic::Request<super::PullHeadersRequest>,
        ) -> Result<tonic::Response<Self::PullHeadersStream>, tonic::Status>;
        #[doc = "Server streaming response type for the PullBlocks method."]
        type PullBlocksStream: futures_core::Stream<Item = Result<super::super::types::Block, tonic::Status>>
            + Send
            + 'static;
        #[doc = " Requests blocks in the chain in the chronological order, given a selection"]
        #[doc = " of possible starting blocks known by the requester, and the identifier of"]
        #[doc = " the end block to be included in the returned sequence."]
        async fn pull_blocks(
            &self,
            request: tonic::Request<super::PullBlocksRequest>,
        ) -> Result<tonic::Response<Self::PullBlocksStream>, tonic::Status>;
        #[doc = "Server streaming response type for the PullBlocksToTip method."]
        type PullBlocksToTipStream: futures_core::Stream<Item = Result<super::super::types::Block, tonic::Status>>
            + Send
            + 'static;
        async fn pull_blocks_to_tip(
            &self,
            request: tonic::Request<super::PullBlocksToTipRequest>,
        ) -> Result<tonic::Response<Self::PullBlocksToTipStream>, tonic::Status>;
        #[doc = " Sends headers of blocks to the service in response to a `missing`"]
        #[doc = " item received from the BlockSubscription response stream."]
        #[doc = " The headers are streamed the in chronological order of the chain."]
        async fn push_headers(
            &self,
            request: tonic::Request<tonic::Streaming<super::super::types::Header>>,
        ) -> Result<tonic::Response<super::PushHeadersResponse>, tonic::Status>;
        #[doc = " Uploads blocks to the service in response to a `solicit` item"]
        #[doc = " received from the BlockSubscription response stream."]
        async fn upload_blocks(
            &self,
            request: tonic::Request<tonic::Streaming<super::super::types::Block>>,
        ) -> Result<tonic::Response<super::UploadBlocksResponse>, tonic::Status>;
        #[doc = "Server streaming response type for the BlockSubscription method."]
        type BlockSubscriptionStream: futures_core::Stream<Item = Result<super::BlockEvent, tonic::Status>>
            + Send
            + 'static;
        #[doc = " Establishes a bidirectional stream to exchange information on new"]
        #[doc = " blocks created or accepted by the peers."]
        async fn block_subscription(
            &self,
            request: tonic::Request<tonic::Streaming<super::super::types::Header>>,
        ) -> Result<tonic::Response<Self::BlockSubscriptionStream>, tonic::Status>;
        #[doc = "Server streaming response type for the FragmentSubscription method."]
        type FragmentSubscriptionStream: futures_core::Stream<Item = Result<super::super::types::Fragment, tonic::Status>>
            + Send
            + 'static;
        #[doc = " Establishes a bidirectional stream to exchange information on new"]
        #[doc = " block fragments created or accepted by the peers."]
        async fn fragment_subscription(
            &self,
            request: tonic::Request<tonic::Streaming<super::super::types::Fragment>>,
        ) -> Result<tonic::Response<Self::FragmentSubscriptionStream>, tonic::Status>;
        #[doc = "Server streaming response type for the GossipSubscription method."]
        type GossipSubscriptionStream: futures_core::Stream<Item = Result<super::Gossip, tonic::Status>>
            + Send
            + 'static;
        #[doc = " Establishes a bidirectional stream to exchange information on new"]
        #[doc = " network peers."]
        async fn gossip_subscription(
            &self,
            request: tonic::Request<tonic::Streaming<super::Gossip>>,
        ) -> Result<tonic::Response<Self::GossipSubscriptionStream>, tonic::Status>;
    }
    #[derive(Debug)]
    pub struct NodeServer<T: Node> {
        inner: _Inner<T>,
        accept_compression_encodings: (),
        send_compression_encodings: (),
    }
    struct _Inner<T>(Arc<T>);
    impl<T: Node> NodeServer<T> {
        pub fn new(inner: T) -> Self {
            let inner = Arc::new(inner);
            let inner = _Inner(inner);
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
            }
        }
        pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for NodeServer<T>
    where
        T: Node,
        B: Body + Send + 'static,
        B::Error: Into<StdError> + Send + 'static,
    {
        type Response = http::Response<tonic::body::BoxBody>;
        type Error = Never;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            let inner = self.inner.clone();
            match req.uri().path() {
                "/iohk.chain.node.Node/Handshake" => {
                    #[allow(non_camel_case_types)]
                    struct HandshakeSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::UnaryService<super::HandshakeRequest> for HandshakeSvc<T> {
                        type Response = super::HandshakeResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::HandshakeRequest>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).handshake(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = HandshakeSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/ClientAuth" => {
                    #[allow(non_camel_case_types)]
                    struct ClientAuthSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::UnaryService<super::ClientAuthRequest> for ClientAuthSvc<T> {
                        type Response = super::ClientAuthResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ClientAuthRequest>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).client_auth(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = ClientAuthSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/Tip" => {
                    #[allow(non_camel_case_types)]
                    struct TipSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::UnaryService<super::TipRequest> for TipSvc<T> {
                        type Response = super::TipResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::TipRequest>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).tip(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = TipSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/Peers" => {
                    #[allow(non_camel_case_types)]
                    struct PeersSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::UnaryService<super::PeersRequest> for PeersSvc<T> {
                        type Response = super::PeersResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PeersRequest>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).peers(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = PeersSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/GetBlocks" => {
                    #[allow(non_camel_case_types)]
                    struct GetBlocksSvc<T: Node>(pub Arc<T>);
                    impl<T: Node>
                        tonic::server::ServerStreamingService<super::super::types::BlockIds>
                        for GetBlocksSvc<T>
                    {
                        type Response = super::super::types::Block;
                        type ResponseStream = T::GetBlocksStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::super::types::BlockIds>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).get_blocks(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = GetBlocksSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/GetHeaders" => {
                    #[allow(non_camel_case_types)]
                    struct GetHeadersSvc<T: Node>(pub Arc<T>);
                    impl<T: Node>
                        tonic::server::ServerStreamingService<super::super::types::BlockIds>
                        for GetHeadersSvc<T>
                    {
                        type Response = super::super::types::Header;
                        type ResponseStream = T::GetHeadersStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::super::types::BlockIds>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).get_headers(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = GetHeadersSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/GetFragments" => {
                    #[allow(non_camel_case_types)]
                    struct GetFragmentsSvc<T: Node>(pub Arc<T>);
                    impl<T: Node>
                        tonic::server::ServerStreamingService<super::super::types::FragmentIds>
                        for GetFragmentsSvc<T>
                    {
                        type Response = super::super::types::Fragment;
                        type ResponseStream = T::GetFragmentsStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::super::types::FragmentIds>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).get_fragments(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = GetFragmentsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/PullHeaders" => {
                    #[allow(non_camel_case_types)]
                    struct PullHeadersSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::ServerStreamingService<super::PullHeadersRequest>
                        for PullHeadersSvc<T>
                    {
                        type Response = super::super::types::Header;
                        type ResponseStream = T::PullHeadersStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PullHeadersRequest>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).pull_headers(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = PullHeadersSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/PullBlocks" => {
                    #[allow(non_camel_case_types)]
                    struct PullBlocksSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::ServerStreamingService<super::PullBlocksRequest> for PullBlocksSvc<T> {
                        type Response = super::super::types::Block;
                        type ResponseStream = T::PullBlocksStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PullBlocksRequest>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).pull_blocks(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = PullBlocksSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/PullBlocksToTip" => {
                    #[allow(non_camel_case_types)]
                    struct PullBlocksToTipSvc<T: Node>(pub Arc<T>);
                    impl<T: Node>
                        tonic::server::ServerStreamingService<super::PullBlocksToTipRequest>
                        for PullBlocksToTipSvc<T>
                    {
                        type Response = super::super::types::Block;
                        type ResponseStream = T::PullBlocksToTipStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::PullBlocksToTipRequest>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).pull_blocks_to_tip(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = PullBlocksToTipSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/PushHeaders" => {
                    #[allow(non_camel_case_types)]
                    struct PushHeadersSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::ClientStreamingService<super::super::types::Header>
                        for PushHeadersSvc<T>
                    {
                        type Response = super::PushHeadersResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<tonic::Streaming<super::super::types::Header>>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).push_headers(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = PushHeadersSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.client_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/UploadBlocks" => {
                    #[allow(non_camel_case_types)]
                    struct UploadBlocksSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::ClientStreamingService<super::super::types::Block>
                        for UploadBlocksSvc<T>
                    {
                        type Response = super::UploadBlocksResponse;
                        type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<tonic::Streaming<super::super::types::Block>>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).upload_blocks(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = UploadBlocksSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.client_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/BlockSubscription" => {
                    #[allow(non_camel_case_types)]
                    struct BlockSubscriptionSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::StreamingService<super::super::types::Header>
                        for BlockSubscriptionSvc<T>
                    {
                        type Response = super::BlockEvent;
                        type ResponseStream = T::BlockSubscriptionStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<tonic::Streaming<super::super::types::Header>>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).block_subscription(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = BlockSubscriptionSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/FragmentSubscription" => {
                    #[allow(non_camel_case_types)]
                    struct FragmentSubscriptionSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::StreamingService<super::super::types::Fragment>
                        for FragmentSubscriptionSvc<T>
                    {
                        type Response = super::super::types::Fragment;
                        type ResponseStream = T::FragmentSubscriptionStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                tonic::Streaming<super::super::types::Fragment>,
                            >,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).fragment_subscription(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = FragmentSubscriptionSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/iohk.chain.node.Node/GossipSubscription" => {
                    #[allow(non_camel_case_types)]
                    struct GossipSubscriptionSvc<T: Node>(pub Arc<T>);
                    impl<T: Node> tonic::server::StreamingService<super::Gossip> for GossipSubscriptionSvc<T> {
                        type Response = super::Gossip;
                        type ResponseStream = T::GossipSubscriptionStream;
                        type Future =
                            BoxFuture<tonic::Response<Self::ResponseStream>, tonic::Status>;
                        fn call(
                            &mut self,
                            request: tonic::Request<tonic::Streaming<super::Gossip>>,
                        ) -> Self::Future {
                            let inner = self.0.clone();
                            let fut = async move { (*inner).gossip_subscription(request).await };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let inner = inner.0;
                        let method = GossipSubscriptionSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec).apply_compression_config(
                            accept_compression_encodings,
                            send_compression_encodings,
                        );
                        let res = grpc.streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => Box::pin(async move {
                    Ok(http::Response::builder()
                        .status(200)
                        .header("grpc-status", "12")
                        .header("content-type", "application/grpc")
                        .body(empty_body())
                        .unwrap())
                }),
            }
        }
    }
    impl<T: Node> Clone for NodeServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
            }
        }
    }
    impl<T: Node> Clone for _Inner<T> {
        fn clone(&self) -> Self {
            Self(self.0.clone())
        }
    }
    impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            write!(f, "{:?}", self.0)
        }
    }
    impl<T: Node> tonic::transport::NamedService for NodeServer<T> {
        const NAME: &'static str = "iohk.chain.node.Node";
    }
}