From ac35a80ac4cb88106549cd91fbf2d94e2f59a2d0 Mon Sep 17 00:00:00 2001
From: hu55a1n1 <sufialhussaini@gmail.com>
Date: Thu, 29 Feb 2024 03:30:25 -0800
Subject: [PATCH] MTCS proto init
---
Cargo.lock | 1 +
enclaves/quartz/Cargo.toml | 3 +
enclaves/quartz/build.rs | 6 +
enclaves/quartz/proto/mtcs.proto | 15 ++
enclaves/quartz/src/main.rs | 1 +
enclaves/quartz/src/prost/mtcs.rs | 302 ++++++++++++++++++++++++++++++
enclaves/quartz/src/proto.rs | 3 +
7 files changed, 331 insertions(+)
create mode 100644 enclaves/quartz/build.rs
create mode 100644 enclaves/quartz/proto/mtcs.proto
create mode 100644 enclaves/quartz/src/prost/mtcs.rs
create mode 100644 enclaves/quartz/src/proto.rs
diff --git a/Cargo.lock b/Cargo.lock
index 8c6c2ba..30a0e6b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2389,6 +2389,7 @@ dependencies = [
"tendermint-light-client",
"tokio",
"tonic 0.11.0",
+ "tonic-build",
]
[[package]]
diff --git a/enclaves/quartz/Cargo.toml b/enclaves/quartz/Cargo.toml
index 8fafd73..7ad6a09 100644
--- a/enclaves/quartz/Cargo.toml
+++ b/enclaves/quartz/Cargo.toml
@@ -21,3 +21,6 @@ quartz-cw = { git = "ssh://git@github.com/informalsystems/bisenzone-cw-mvp.git",
quartz-proto = { path = "../../utils/quartz-proto" }
quartz-relayer = { path = "../../utils/quartz-relayer" }
quartz-tee-ra = { git = "ssh://git@github.com/informalsystems/bisenzone-cw-mvp.git", branch = "hu55a1n1/11-use-quartz" }
+
+[build-dependencies]
+tonic-build = "0.11"
diff --git a/enclaves/quartz/build.rs b/enclaves/quartz/build.rs
new file mode 100644
index 0000000..4f9ea1b
--- /dev/null
+++ b/enclaves/quartz/build.rs
@@ -0,0 +1,6 @@
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+ tonic_build::configure()
+ .out_dir("src/prost")
+ .compile(&["proto/mtcs.proto"], &["proto"])?;
+ Ok(())
+}
diff --git a/enclaves/quartz/proto/mtcs.proto b/enclaves/quartz/proto/mtcs.proto
new file mode 100644
index 0000000..99345a6
--- /dev/null
+++ b/enclaves/quartz/proto/mtcs.proto
@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package mtcs;
+
+service Clearing {
+ rpc Run (RunClearingRequest) returns (RunClearingResponse) {}
+}
+
+message RunClearingRequest {
+ string message = 1;
+}
+
+message RunClearingResponse {
+ string message = 1;
+}
diff --git a/enclaves/quartz/src/main.rs b/enclaves/quartz/src/main.rs
index 90a15c8..b8aa4c2 100644
--- a/enclaves/quartz/src/main.rs
+++ b/enclaves/quartz/src/main.rs
@@ -15,6 +15,7 @@
mod attestor;
mod cli;
+mod proto;
mod server;
use std::time::Duration;
diff --git a/enclaves/quartz/src/prost/mtcs.rs b/enclaves/quartz/src/prost/mtcs.rs
new file mode 100644
index 0000000..17d679f
--- /dev/null
+++ b/enclaves/quartz/src/prost/mtcs.rs
@@ -0,0 +1,302 @@
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RunClearingRequest {
+ #[prost(string, tag = "1")]
+ pub message: ::prost::alloc::string::String,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RunClearingResponse {
+ #[prost(string, tag = "1")]
+ pub message: ::prost::alloc::string::String,
+}
+/// Generated client implementations.
+pub mod clearing_client {
+ #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+ use tonic::codegen::*;
+ use tonic::codegen::http::Uri;
+ #[derive(Debug, Clone)]
+ pub struct ClearingClient<T> {
+ inner: tonic::client::Grpc<T>,
+ }
+ impl ClearingClient<tonic::transport::Channel> {
+ /// 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: TryInto<tonic::transport::Endpoint>,
+ D::Error: Into<StdError>,
+ {
+ let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+ Ok(Self::new(conn))
+ }
+ }
+ impl<T> ClearingClient<T>
+ where
+ T: tonic::client::GrpcService<tonic::body::BoxBody>,
+ T::Error: Into<StdError>,
+ T::ResponseBody: Body<Data = Bytes> + Send + 'static,
+ <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_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,
+ ) -> ClearingClient<InterceptedService<T, F>>
+ where
+ F: tonic::service::Interceptor,
+ T::ResponseBody: Default,
+ 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,
+ {
+ ClearingClient::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
+ }
+ pub async fn run(
+ &mut self,
+ request: impl tonic::IntoRequest<super::RunClearingRequest>,
+ ) -> std::result::Result<
+ tonic::Response<super::RunClearingResponse>,
+ 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("/mtcs.Clearing/Run");
+ let mut req = request.into_request();
+ req.extensions_mut().insert(GrpcMethod::new("mtcs.Clearing", "Run"));
+ self.inner.unary(req, path, codec).await
+ }
+ }
+}
+/// Generated server implementations.
+pub mod clearing_server {
+ #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
+ use tonic::codegen::*;
+ /// Generated trait containing gRPC methods that should be implemented for use with ClearingServer.
+ #[async_trait]
+ pub trait Clearing: Send + Sync + 'static {
+ async fn run(
+ &self,
+ request: tonic::Request<super::RunClearingRequest>,
+ ) -> std::result::Result<
+ tonic::Response<super::RunClearingResponse>,
+ tonic::Status,
+ >;
+ }
+ #[derive(Debug)]
+ pub struct ClearingServer<T: Clearing> {
+ inner: _Inner<T>,
+ accept_compression_encodings: EnabledCompressionEncodings,
+ send_compression_encodings: EnabledCompressionEncodings,
+ max_decoding_message_size: Option<usize>,
+ max_encoding_message_size: Option<usize>,
+ }
+ struct _Inner<T>(Arc<T>);
+ impl<T: Clearing> ClearingServer<T> {
+ pub fn new(inner: T) -> Self {
+ Self::from_arc(Arc::new(inner))
+ }
+ pub fn from_arc(inner: Arc<T>) -> Self {
+ let inner = _Inner(inner);
+ 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 ClearingServer<T>
+ where
+ T: Clearing,
+ B: Body + Send + 'static,
+ B::Error: Into<StdError> + Send + 'static,
+ {
+ type Response = http::Response<tonic::body::BoxBody>;
+ 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 {
+ let inner = self.inner.clone();
+ match req.uri().path() {
+ "/mtcs.Clearing/Run" => {
+ #[allow(non_camel_case_types)]
+ struct RunSvc<T: Clearing>(pub Arc<T>);
+ impl<
+ T: Clearing,
+ > tonic::server::UnaryService<super::RunClearingRequest>
+ for RunSvc<T> {
+ type Response = super::RunClearingResponse;
+ type Future = BoxFuture<
+ tonic::Response<Self::Response>,
+ tonic::Status,
+ >;
+ fn call(
+ &mut self,
+ request: tonic::Request<super::RunClearingRequest>,
+ ) -> Self::Future {
+ let inner = Arc::clone(&self.0);
+ let fut = async move {
+ <T as Clearing>::run(&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 inner = inner.0;
+ let method = RunSvc(inner);
+ let codec = tonic::codec::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 {
+ Ok(
+ http::Response::builder()
+ .status(200)
+ .header("grpc-status", "12")
+ .header("content-type", "application/grpc")
+ .body(empty_body())
+ .unwrap(),
+ )
+ })
+ }
+ }
+ }
+ }
+ impl<T: Clearing> Clone for ClearingServer<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,
+ }
+ }
+ }
+ impl<T: Clearing> Clone for _Inner<T> {
+ fn clone(&self) -> Self {
+ Self(Arc::clone(&self.0))
+ }
+ }
+ 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: Clearing> tonic::server::NamedService for ClearingServer<T> {
+ const NAME: &'static str = "mtcs.Clearing";
+ }
+}
diff --git a/enclaves/quartz/src/proto.rs b/enclaves/quartz/src/proto.rs
new file mode 100644
index 0000000..99cb67e
--- /dev/null
+++ b/enclaves/quartz/src/proto.rs
@@ -0,0 +1,3 @@
+#![allow(clippy::unwrap_used, unused_qualifications)]
+
+include!(concat!("prost/", "mtcs.rs"));