fabric-sdk 0.4.0

// This file is @generated by prost-build.
/// SignedRequest contains a serialized Request in the payload field
/// and a signature.
/// The identity that is used to verify the signature
/// can be extracted from the authentication field of type AuthInfo
/// in the Request itself after deserializing it.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SignedRequest {
    #[prost(bytes = "vec", tag = "1")]
    pub payload: ::prost::alloc::vec::Vec<u8>,
    #[prost(bytes = "vec", tag = "2")]
    pub signature: ::prost::alloc::vec::Vec<u8>,
}
/// Request contains authentication info about the client that sent the request
/// and the queries it wishes to query the service
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Request {
    /// authentication contains information that the service uses to check
    /// the client's eligibility for the queries.
    #[prost(message, optional, tag = "1")]
    pub authentication: ::core::option::Option<AuthInfo>,
    /// queries
    #[prost(message, repeated, tag = "2")]
    pub queries: ::prost::alloc::vec::Vec<Query>,
}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Response {
    /// The results are returned in the same order of the queries
    #[prost(message, repeated, tag = "1")]
    pub results: ::prost::alloc::vec::Vec<QueryResult>,
}
/// AuthInfo aggregates authentication information that the server uses
/// to authenticate the client
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct AuthInfo {
    /// This is the identity of the client that is used to verify the signature
    /// on the SignedRequest's payload.
    /// It is a msp.SerializedIdentity in bytes form
    #[prost(bytes = "vec", tag = "1")]
    pub client_identity: ::prost::alloc::vec::Vec<u8>,
    /// This is the hash of the client's TLS cert.
    /// When the network is running with TLS, clients that don't include a certificate
    /// will be denied access to the service.
    /// Since the Request is encapsulated with a SignedRequest (which is signed),
    /// this binds the TLS session to the enrollement identity of the client and
    /// therefore both authenticates the client to the server,
    /// and also prevents the server from relaying the request message to another server.
    #[prost(bytes = "vec", tag = "2")]
    pub client_tls_cert_hash: ::prost::alloc::vec::Vec<u8>,
}
/// Query asks for information in the context of a specific channel
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Query {
    #[prost(string, tag = "1")]
    pub channel: ::prost::alloc::string::String,
    #[prost(oneof = "query::Query", tags = "2, 3, 4, 5")]
    pub query: ::core::option::Option<query::Query>,
}
/// Nested message and enum types in `Query`.
pub mod query {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Query {
        /// ConfigQuery is used to query for the configuration of the channel,
        /// such as FabricMSPConfig, and rorderer endpoints.
        /// The client has to query a peer it trusts as it doesn't have means to self-verify
        /// the authenticity of the returned result.
        /// The result is returned in the form of ConfigResult.
        #[prost(message, tag = "2")]
        ConfigQuery(super::ConfigQuery),
        /// PeerMembershipQuery queries for peers in a channel context,
        /// and returns PeerMembershipResult
        #[prost(message, tag = "3")]
        PeerQuery(super::PeerMembershipQuery),
        /// ChaincodeQuery queries for chaincodes by their name and version.
        /// An empty version means any version can by returned.
        #[prost(message, tag = "4")]
        CcQuery(super::ChaincodeQuery),
        /// LocalPeerQuery queries for peers in a non channel context,
        /// and returns PeerMembershipResult
        #[prost(message, tag = "5")]
        LocalPeers(super::LocalPeerQuery),
    }
}
/// QueryResult contains a result for a given Query.
/// The corresponding Query can be inferred by the index of the QueryResult from
/// its enclosing Response message.
/// QueryResults are ordered in the same order as the Queries are ordered in their enclosing Request.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryResult {
    #[prost(oneof = "query_result::Result", tags = "1, 2, 3, 4")]
    pub result: ::core::option::Option<query_result::Result>,
}
/// Nested message and enum types in `QueryResult`.
pub mod query_result {
    #[derive(serde::Serialize, serde::Deserialize)]
    #[derive(Clone, PartialEq, ::prost::Oneof)]
    pub enum Result {
        /// Error indicates failure or refusal to process the query
        #[prost(message, tag = "1")]
        Error(super::Error),
        /// ConfigResult contains the configuration of the channel,
        /// such as FabricMSPConfig and orderer endpoints
        #[prost(message, tag = "2")]
        ConfigResult(super::ConfigResult),
        /// ChaincodeQueryResult contains information about chaincodes,
        /// and their corresponding endorsers
        #[prost(message, tag = "3")]
        CcQueryRes(super::ChaincodeQueryResult),
        /// PeerMembershipResult contains information about peers,
        /// such as their identity, endpoints, and channel related state.
        #[prost(message, tag = "4")]
        Members(super::PeerMembershipResult),
    }
}
/// ConfigQuery requests a ConfigResult
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ConfigQuery {}
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ConfigResult {
    /// msps is a map from MSP_ID to FabricMSPConfig
    #[prost(map = "string, message", tag = "1")]
    pub msps: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        super::msp::FabricMspConfig,
    >,
    /// orderers is a map from MSP_ID to endpoint lists of orderers
    #[prost(map = "string, message", tag = "2")]
    pub orderers: ::std::collections::HashMap<::prost::alloc::string::String, Endpoints>,
}
/// PeerMembershipQuery requests PeerMembershipResult.
/// The filter field may be optionally populated in order
/// for the peer membership to be filtered according to
/// chaincodes that are installed on peers and collection
/// access control policies.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PeerMembershipQuery {
    #[prost(message, optional, tag = "1")]
    pub filter: ::core::option::Option<super::protos::ChaincodeInterest>,
}
/// PeerMembershipResult contains peers mapped by their organizations (MSP_ID)
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PeerMembershipResult {
    #[prost(map = "string, message", tag = "1")]
    pub peers_by_org: ::std::collections::HashMap<::prost::alloc::string::String, Peers>,
}
/// ChaincodeQuery requests ChaincodeQueryResults for a given
/// list of chaincode invocations.
/// Each invocation is a separate one, and the endorsement policy
/// is evaluated independantly for each given interest.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ChaincodeQuery {
    #[prost(message, repeated, tag = "1")]
    pub interests: ::prost::alloc::vec::Vec<super::protos::ChaincodeInterest>,
}
/// ChaincodeQueryResult contains EndorsementDescriptors for
/// chaincodes
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ChaincodeQueryResult {
    #[prost(message, repeated, tag = "1")]
    pub content: ::prost::alloc::vec::Vec<EndorsementDescriptor>,
}
/// LocalPeerQuery queries for peers in a non channel context
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct LocalPeerQuery {}
/// EndorsementDescriptor contains information about which peers can be used
/// to request endorsement from, such that the endorsement policy would be fulfilled.
/// Here is how to compute a set of peers to ask an endorsement from, given an EndorsementDescriptor:
/// Let e: G --> P be the endorsers_by_groups field that maps a group to a set of peers.
/// Note that applying e on a group g yields a set of peers.
/// 1) Select a layout l: G --> N out of the layouts given.
///     l is the quantities_by_group field of a Layout, and it maps a group to an integer.
/// 2) R = {}  (an empty set of peers)
/// 3) For each group g in the layout l, compute n = l(g)
///     3.1) Denote P_g as a set of n random peers {p0, p1, ... p_n} selected from e(g)
///     3.2) R = R U P_g  (add P_g to R)
/// 4) The set of peers R is the peers the client needs to request endorsements from
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EndorsementDescriptor {
    #[prost(string, tag = "1")]
    pub chaincode: ::prost::alloc::string::String,
    /// Specifies the endorsers, separated to groups.
    #[prost(map = "string, message", tag = "2")]
    pub endorsers_by_groups: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        Peers,
    >,
    /// Specifies options of fulfulling the endorsement policy.
    /// Each option lists the group names, and the amount of signatures needed
    /// from each group.
    #[prost(message, repeated, tag = "3")]
    pub layouts: ::prost::alloc::vec::Vec<Layout>,
}
/// Layout contains a mapping from a group name to number of peers
/// that are needed for fulfilling an endorsement policy
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Layout {
    /// Specifies how many non repeated signatures of each group
    /// are needed for endorsement
    #[prost(map = "string, uint32", tag = "1")]
    pub quantities_by_group: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        u32,
    >,
}
/// Peers contains a list of Peer(s)
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Peers {
    #[prost(message, repeated, tag = "1")]
    pub peers: ::prost::alloc::vec::Vec<Peer>,
}
/// Peer contains information about the peer such as its channel specific
/// state, and membership information.
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Peer {
    /// This is an Envelope of a GossipMessage with a gossip.StateInfo message
    #[prost(message, optional, tag = "1")]
    pub state_info: ::core::option::Option<super::gossip::Envelope>,
    /// This is an Envelope of a GossipMessage with a gossip.AliveMessage message
    #[prost(message, optional, tag = "2")]
    pub membership_info: ::core::option::Option<super::gossip::Envelope>,
    /// This is the msp.SerializedIdentity of the peer, represented in bytes.
    #[prost(bytes = "vec", tag = "3")]
    pub identity: ::prost::alloc::vec::Vec<u8>,
}
/// Error denotes that something went wrong and contains the error message
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Error {
    #[prost(string, tag = "1")]
    pub content: ::prost::alloc::string::String,
}
/// Endpoints is a list of Endpoint(s)
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Endpoints {
    #[prost(message, repeated, tag = "1")]
    pub endpoint: ::prost::alloc::vec::Vec<Endpoint>,
}
/// Endpoint is a combination of a host and a port
#[derive(serde::Serialize, serde::Deserialize)]
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Endpoint {
    #[prost(string, tag = "1")]
    pub host: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub port: u32,
}
/// Generated client implementations.
pub mod discovery_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Discovery defines a service that serves information about the fabric network
    /// like which peers, orderers, chaincodes, etc.
    #[derive(Debug, Clone)]
    pub struct DiscoveryClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl<T> DiscoveryClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> DiscoveryClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            DiscoveryClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// Discover receives a signed request, and returns a response.
        pub async fn discover(
            &mut self,
            request: impl tonic::IntoRequest<super::SignedRequest>,
        ) -> std::result::Result<tonic::Response<super::Response>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/discovery.Discovery/Discover",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("discovery.Discovery", "Discover"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod discovery_server {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with DiscoveryServer.
    #[async_trait]
    pub trait Discovery: std::marker::Send + std::marker::Sync + 'static {
        /// Discover receives a signed request, and returns a response.
        async fn discover(
            &self,
            request: tonic::Request<super::SignedRequest>,
        ) -> std::result::Result<tonic::Response<super::Response>, tonic::Status>;
    }
    /// Discovery defines a service that serves information about the fabric network
    /// like which peers, orderers, chaincodes, etc.
    #[derive(Debug)]
    pub struct DiscoveryServer<T> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T> DiscoveryServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.max_decoding_message_size = Some(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for DiscoveryServer<T>
    where
        T: Discovery,
        B: Body + std::marker::Send + 'static,
        B::Error: Into<StdError> + std::marker::Send + 'static,
    {
        type Response = http::Response<tonic::body::Body>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/discovery.Discovery/Discover" => {
                    #[allow(non_camel_case_types)]
                    struct DiscoverSvc<T: Discovery>(pub Arc<T>);
                    impl<T: Discovery> tonic::server::UnaryService<super::SignedRequest>
                    for DiscoverSvc<T> {
                        type Response = super::Response;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SignedRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as Discovery>::discover(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = DiscoverSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        let mut response = http::Response::new(
                            tonic::body::Body::default(),
                        );
                        let headers = response.headers_mut();
                        headers
                            .insert(
                                tonic::Status::GRPC_STATUS,
                                (tonic::Code::Unimplemented as i32).into(),
                            );
                        headers
                            .insert(
                                http::header::CONTENT_TYPE,
                                tonic::metadata::GRPC_CONTENT_TYPE,
                            );
                        Ok(response)
                    })
                }
            }
        }
    }
    impl<T> Clone for DiscoveryServer<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,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    /// Generated gRPC service name
    pub const SERVICE_NAME: &str = "discovery.Discovery";
    impl<T> tonic::server::NamedService for DiscoveryServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}