sp1_cuda/proto/
api.rs

1// This file is @generated by prost-build.
2#[derive(serde::Serialize, serde::Deserialize)]
3#[derive(Clone, Copy, PartialEq, ::prost::Message)]
4pub struct ReadyRequest {}
5#[derive(serde::Serialize, serde::Deserialize)]
6#[derive(Clone, Copy, PartialEq, ::prost::Message)]
7pub struct ReadyResponse {
8    #[prost(bool, tag = "1")]
9    pub ready: bool,
10}
11#[derive(serde::Serialize, serde::Deserialize)]
12#[derive(Clone, PartialEq, ::prost::Message)]
13pub struct SetupRequest {
14    #[prost(bytes = "vec", tag = "1")]
15    pub data: ::prost::alloc::vec::Vec<u8>,
16}
17#[derive(serde::Serialize, serde::Deserialize)]
18#[derive(Clone, PartialEq, ::prost::Message)]
19pub struct SetupResponse {
20    #[prost(bytes = "vec", tag = "1")]
21    pub result: ::prost::alloc::vec::Vec<u8>,
22}
23#[derive(serde::Serialize, serde::Deserialize)]
24#[derive(Clone, PartialEq, ::prost::Message)]
25pub struct ProveCoreRequest {
26    #[prost(bytes = "vec", tag = "1")]
27    pub data: ::prost::alloc::vec::Vec<u8>,
28}
29#[derive(serde::Serialize, serde::Deserialize)]
30#[derive(Clone, PartialEq, ::prost::Message)]
31pub struct ProveCoreResponse {
32    #[prost(bytes = "vec", tag = "1")]
33    pub result: ::prost::alloc::vec::Vec<u8>,
34}
35#[derive(serde::Serialize, serde::Deserialize)]
36#[derive(Clone, PartialEq, ::prost::Message)]
37pub struct CompressRequest {
38    #[prost(bytes = "vec", tag = "1")]
39    pub data: ::prost::alloc::vec::Vec<u8>,
40}
41#[derive(serde::Serialize, serde::Deserialize)]
42#[derive(Clone, PartialEq, ::prost::Message)]
43pub struct CompressResponse {
44    #[prost(bytes = "vec", tag = "1")]
45    pub result: ::prost::alloc::vec::Vec<u8>,
46}
47#[derive(serde::Serialize, serde::Deserialize)]
48#[derive(Clone, PartialEq, ::prost::Message)]
49pub struct ShrinkRequest {
50    #[prost(bytes = "vec", tag = "1")]
51    pub data: ::prost::alloc::vec::Vec<u8>,
52}
53#[derive(serde::Serialize, serde::Deserialize)]
54#[derive(Clone, PartialEq, ::prost::Message)]
55pub struct ShrinkResponse {
56    #[prost(bytes = "vec", tag = "1")]
57    pub result: ::prost::alloc::vec::Vec<u8>,
58}
59#[derive(serde::Serialize, serde::Deserialize)]
60#[derive(Clone, PartialEq, ::prost::Message)]
61pub struct WrapRequest {
62    #[prost(bytes = "vec", tag = "1")]
63    pub data: ::prost::alloc::vec::Vec<u8>,
64}
65#[derive(serde::Serialize, serde::Deserialize)]
66#[derive(Clone, PartialEq, ::prost::Message)]
67pub struct WrapResponse {
68    #[prost(bytes = "vec", tag = "1")]
69    pub result: ::prost::alloc::vec::Vec<u8>,
70}
71pub use twirp;
72pub const SERVICE_FQN: &str = "/api.ProverService";
73#[twirp::async_trait::async_trait]
74pub trait ProverService {
75    async fn setup(
76        &self,
77        ctx: twirp::Context,
78        req: SetupRequest,
79    ) -> Result<SetupResponse, twirp::TwirpErrorResponse>;
80    async fn ready(
81        &self,
82        ctx: twirp::Context,
83        req: ReadyRequest,
84    ) -> Result<ReadyResponse, twirp::TwirpErrorResponse>;
85    async fn prove_core(
86        &self,
87        ctx: twirp::Context,
88        req: ProveCoreRequest,
89    ) -> Result<ProveCoreResponse, twirp::TwirpErrorResponse>;
90    async fn prove_core_stateless(
91        &self,
92        ctx: twirp::Context,
93        req: ProveCoreRequest,
94    ) -> Result<ProveCoreResponse, twirp::TwirpErrorResponse>;
95    async fn compress(
96        &self,
97        ctx: twirp::Context,
98        req: CompressRequest,
99    ) -> Result<CompressResponse, twirp::TwirpErrorResponse>;
100    async fn shrink(
101        &self,
102        ctx: twirp::Context,
103        req: ShrinkRequest,
104    ) -> Result<ShrinkResponse, twirp::TwirpErrorResponse>;
105    async fn wrap(
106        &self,
107        ctx: twirp::Context,
108        req: WrapRequest,
109    ) -> Result<WrapResponse, twirp::TwirpErrorResponse>;
110}
111#[twirp::async_trait::async_trait]
112impl<T> ProverService for std::sync::Arc<T>
113where
114    T: ProverService + Sync + Send,
115{
116    async fn setup(
117        &self,
118        ctx: twirp::Context,
119        req: SetupRequest,
120    ) -> Result<SetupResponse, twirp::TwirpErrorResponse> {
121        T::setup(&*self, ctx, req).await
122    }
123    async fn ready(
124        &self,
125        ctx: twirp::Context,
126        req: ReadyRequest,
127    ) -> Result<ReadyResponse, twirp::TwirpErrorResponse> {
128        T::ready(&*self, ctx, req).await
129    }
130    async fn prove_core(
131        &self,
132        ctx: twirp::Context,
133        req: ProveCoreRequest,
134    ) -> Result<ProveCoreResponse, twirp::TwirpErrorResponse> {
135        T::prove_core(&*self, ctx, req).await
136    }
137    async fn prove_core_stateless(
138        &self,
139        ctx: twirp::Context,
140        req: ProveCoreRequest,
141    ) -> Result<ProveCoreResponse, twirp::TwirpErrorResponse> {
142        T::prove_core_stateless(&*self, ctx, req).await
143    }
144    async fn compress(
145        &self,
146        ctx: twirp::Context,
147        req: CompressRequest,
148    ) -> Result<CompressResponse, twirp::TwirpErrorResponse> {
149        T::compress(&*self, ctx, req).await
150    }
151    async fn shrink(
152        &self,
153        ctx: twirp::Context,
154        req: ShrinkRequest,
155    ) -> Result<ShrinkResponse, twirp::TwirpErrorResponse> {
156        T::shrink(&*self, ctx, req).await
157    }
158    async fn wrap(
159        &self,
160        ctx: twirp::Context,
161        req: WrapRequest,
162    ) -> Result<WrapResponse, twirp::TwirpErrorResponse> {
163        T::wrap(&*self, ctx, req).await
164    }
165}
166pub fn router<T>(api: T) -> twirp::Router
167where
168    T: ProverService + Clone + Send + Sync + 'static,
169{
170    twirp::details::TwirpRouterBuilder::new(api)
171        .route(
172            "/Setup",
173            |api: T, ctx: twirp::Context, req: SetupRequest| async move {
174                api.setup(ctx, req).await
175            },
176        )
177        .route(
178            "/Ready",
179            |api: T, ctx: twirp::Context, req: ReadyRequest| async move {
180                api.ready(ctx, req).await
181            },
182        )
183        .route(
184            "/ProveCore",
185            |api: T, ctx: twirp::Context, req: ProveCoreRequest| async move {
186                api.prove_core(ctx, req).await
187            },
188        )
189        .route(
190            "/ProveCoreStateless",
191            |api: T, ctx: twirp::Context, req: ProveCoreRequest| async move {
192                api.prove_core_stateless(ctx, req).await
193            },
194        )
195        .route(
196            "/Compress",
197            |api: T, ctx: twirp::Context, req: CompressRequest| async move {
198                api.compress(ctx, req).await
199            },
200        )
201        .route(
202            "/Shrink",
203            |api: T, ctx: twirp::Context, req: ShrinkRequest| async move {
204                api.shrink(ctx, req).await
205            },
206        )
207        .route(
208            "/Wrap",
209            |api: T, ctx: twirp::Context, req: WrapRequest| async move {
210                api.wrap(ctx, req).await
211            },
212        )
213        .build()
214}
215#[twirp::async_trait::async_trait]
216pub trait ProverServiceClient: Send + Sync + std::fmt::Debug {
217    async fn setup(
218        &self,
219        req: SetupRequest,
220    ) -> Result<SetupResponse, twirp::ClientError>;
221    async fn ready(
222        &self,
223        req: ReadyRequest,
224    ) -> Result<ReadyResponse, twirp::ClientError>;
225    async fn prove_core(
226        &self,
227        req: ProveCoreRequest,
228    ) -> Result<ProveCoreResponse, twirp::ClientError>;
229    async fn prove_core_stateless(
230        &self,
231        req: ProveCoreRequest,
232    ) -> Result<ProveCoreResponse, twirp::ClientError>;
233    async fn compress(
234        &self,
235        req: CompressRequest,
236    ) -> Result<CompressResponse, twirp::ClientError>;
237    async fn shrink(
238        &self,
239        req: ShrinkRequest,
240    ) -> Result<ShrinkResponse, twirp::ClientError>;
241    async fn wrap(&self, req: WrapRequest) -> Result<WrapResponse, twirp::ClientError>;
242}
243#[twirp::async_trait::async_trait]
244impl ProverServiceClient for twirp::client::Client {
245    async fn setup(
246        &self,
247        req: SetupRequest,
248    ) -> Result<SetupResponse, twirp::ClientError> {
249        self.request("api.ProverService/Setup", req).await
250    }
251    async fn ready(
252        &self,
253        req: ReadyRequest,
254    ) -> Result<ReadyResponse, twirp::ClientError> {
255        self.request("api.ProverService/Ready", req).await
256    }
257    async fn prove_core(
258        &self,
259        req: ProveCoreRequest,
260    ) -> Result<ProveCoreResponse, twirp::ClientError> {
261        self.request("api.ProverService/ProveCore", req).await
262    }
263    async fn prove_core_stateless(
264        &self,
265        req: ProveCoreRequest,
266    ) -> Result<ProveCoreResponse, twirp::ClientError> {
267        self.request("api.ProverService/ProveCoreStateless", req).await
268    }
269    async fn compress(
270        &self,
271        req: CompressRequest,
272    ) -> Result<CompressResponse, twirp::ClientError> {
273        self.request("api.ProverService/Compress", req).await
274    }
275    async fn shrink(
276        &self,
277        req: ShrinkRequest,
278    ) -> Result<ShrinkResponse, twirp::ClientError> {
279        self.request("api.ProverService/Shrink", req).await
280    }
281    async fn wrap(&self, req: WrapRequest) -> Result<WrapResponse, twirp::ClientError> {
282        self.request("api.ProverService/Wrap", req).await
283    }
284}
sp1_cuda/proto/api.rs

sp1_cuda/proto/
api.rs
