1use bytes::Bytes;
2use cid::Cid;
3use derive_more::{From, TryInto};
4use libp2p::{Multiaddr, PeerId};
5use quic_rpc::{
6 message::{Msg, RpcMsg, ServerStreaming},
7 Service,
8};
9use serde::{Deserialize, Serialize};
10use std::collections::BTreeMap;
11
12use crate::{RpcResult, VersionRequest, VersionResponse, WatchRequest, WatchResponse};
13
14pub type P2pAddr = super::addr::Addr<P2pService>;
15
16#[derive(Serialize, Deserialize, Debug)]
17pub struct Key(pub Bytes);
18
19#[derive(Serialize, Deserialize, Debug)]
20pub struct LocalPeerIdRequest;
21
22#[derive(Serialize, Deserialize, Debug)]
23pub struct LocalPeerIdResponse {
24 pub peer_id: PeerId,
25}
26
27#[derive(Serialize, Deserialize, Debug)]
28pub struct ExternalAddrsRequest;
29
30#[derive(Serialize, Deserialize, Debug)]
31pub struct ExternalAddrsResponse {
32 pub addrs: Vec<Multiaddr>,
33}
34
35#[derive(Serialize, Deserialize, Debug)]
36pub struct ListenersRequest;
37
38#[derive(Serialize, Deserialize, Debug)]
39pub struct ListenersResponse {
40 pub addrs: Vec<Multiaddr>,
41}
42
43#[derive(Serialize, Deserialize, Debug)]
44pub struct BitswapRequest {
45 pub cid: Cid,
46 pub providers: Vec<PeerId>,
47 pub ctx: u64,
48}
49
50#[derive(Serialize, Deserialize, Debug)]
51pub struct BitswapResponse {
52 pub data: Bytes,
53 pub ctx: u64,
54}
55
56#[derive(Serialize, Deserialize, Debug)]
57pub struct FetchProvidersDhtRequest {
58 pub key: Key,
59}
60
61#[derive(Serialize, Deserialize, Debug)]
62pub struct FetchProvidersDhtResponse {
63 pub providers: Vec<PeerId>,
64}
65
66#[derive(Serialize, Deserialize, Debug)]
67pub struct NotifyNewBlocksBitswapRequest {
68 pub blocks: Vec<BitswapBlock>,
69}
70
71#[derive(Serialize, Deserialize, Debug)]
72pub struct BitswapBlock {
73 pub cid: Cid,
74 pub data: Bytes,
75}
76
77#[derive(Serialize, Deserialize, Debug)]
78pub struct StopSessionBitswapRequest {
79 pub ctx: u64,
80}
81
82#[derive(Serialize, Deserialize, Debug)]
83pub struct StartProvidingRequest {
84 pub key: Key,
85}
86
87#[derive(Serialize, Deserialize, Debug)]
88pub struct StopProvidingRequest {
89 pub key: Key,
90}
91
92#[derive(Serialize, Deserialize, Debug)]
93pub struct GetListeningAddrsRequest;
94
95#[derive(Serialize, Deserialize, Debug)]
96pub struct GetListeningAddrsResponse {
97 pub peer_id: PeerId,
98 pub addrs: Vec<Multiaddr>,
99}
100
101#[derive(Serialize, Deserialize, Debug)]
102pub struct GetPeersRequest;
103
104#[derive(Serialize, Deserialize, Debug)]
105pub struct GetPeersResponse {
106 pub peers: BTreeMap<PeerId, Vec<Multiaddr>>,
107}
108
109#[derive(Serialize, Deserialize, Debug)]
110pub struct ConnectRequest {
111 pub peer_id: PeerId,
112 pub addrs: Vec<Multiaddr>,
113}
114
115#[derive(Serialize, Deserialize, Debug)]
116pub struct ConnectByPeerIdRequest {
117 pub peer_id: PeerId,
118}
119
120#[derive(Serialize, Deserialize, Debug)]
121pub struct DisconnectRequest {
122 pub peer_id: PeerId,
123}
124
125#[derive(Serialize, Deserialize, Debug)]
126pub struct ShutdownRequest;
127
128#[derive(Serialize, Deserialize, Debug)]
129pub struct LookupRequest {
130 pub peer_id: PeerId,
131 pub addr: Option<Multiaddr>,
132}
133
134#[derive(Serialize, Deserialize, Debug)]
135pub struct LookupLocalRequest;
136
137#[derive(Serialize, Deserialize, Debug)]
138pub struct LookupResponse {
139 pub peer_id: PeerId,
140 pub protocol_version: String,
141 pub agent_version: String,
142 pub listen_addrs: Vec<Multiaddr>,
143 pub protocols: Vec<String>,
144 pub observed_addrs: Vec<Multiaddr>,
145}
146
147#[derive(Serialize, Deserialize, Debug)]
148pub struct GossipsubAddExplicitPeerRequest {
149 pub peer_id: PeerId,
150}
151
152#[derive(Serialize, Deserialize, Debug)]
153pub struct GossipsubAllMeshPeersRequest;
154
155#[derive(Serialize, Deserialize, Debug)]
156pub struct GossipsubPeersResponse {
157 pub peers: Vec<PeerId>,
158}
159
160#[derive(Serialize, Deserialize, Debug)]
161pub struct GossipsubAllPeersRequest;
162
163#[derive(Serialize, Deserialize, Debug)]
164pub struct GossipsubAllPeersResponse {
165 pub all: Vec<(PeerId, Vec<String>)>,
166}
167
168#[derive(Serialize, Deserialize, Debug)]
169pub struct GossipsubMeshPeersRequest {
170 pub topic_hash: String,
171}
172
173#[derive(Serialize, Deserialize, Debug)]
174pub struct GossipsubPublishRequest {
175 pub topic_hash: String,
176 pub data: Bytes,
177}
178
179#[derive(Serialize, Deserialize, Debug)]
180pub struct GossipsubPublishResponse {
181 pub message_id: Bytes,
182}
183
184#[derive(Serialize, Deserialize, Debug)]
185pub struct GossipsubRemoveExplicitPeerRequest {
186 pub peer_id: PeerId,
187}
188
189#[derive(Serialize, Deserialize, Debug)]
190pub struct GossipsubSubscribeRequest {
191 pub topic_hash: String,
192}
193
194#[derive(Serialize, Deserialize, Debug)]
195pub struct GossipsubSubscribeResponse {
196 pub was_subscribed: bool,
197}
198
199#[derive(Serialize, Deserialize, Debug)]
200pub struct GossipsubTopicsRequest;
201
202#[derive(Serialize, Deserialize, Debug)]
203pub struct GossipsubTopicsResponse {
204 pub topics: Vec<String>,
205}
206
207#[derive(Serialize, Deserialize, Debug)]
208pub struct GossipsubUnsubscribeRequest {
209 pub topic_hash: String,
210}
211
212#[derive(Serialize, Deserialize, Debug)]
213pub struct GossipsubUnsubscribeResponse {
214 pub was_subscribed: bool,
215}
216
217#[derive(Serialize, Deserialize, Debug, From, TryInto)]
218pub enum P2pRequest {
219 Watch(WatchRequest),
220 Version(VersionRequest),
221 Shutdown(ShutdownRequest),
222 FetchBitswap(BitswapRequest),
223 FetchProviderDht(FetchProvidersDhtRequest),
224 StopSessionBitswap(StopSessionBitswapRequest),
225 NotifyNewBlocksBitswap(NotifyNewBlocksBitswapRequest),
226 GetListeningAddrs(GetListeningAddrsRequest),
227 GetPeers(GetPeersRequest),
228 PeerConnect(ConnectRequest),
229 PeerConnectByPeerId(ConnectByPeerIdRequest),
230 PeerDisconnect(DisconnectRequest),
231 Lookup(LookupRequest),
232 LookupLocal(LookupLocalRequest),
233 GossipsubAddExplicitPeer(GossipsubAddExplicitPeerRequest),
234 GossipsubAllMeshPeers(GossipsubAllMeshPeersRequest),
235 GossipsubAllPeers(GossipsubAllPeersRequest),
236 GossipsubMeshPeers(GossipsubMeshPeersRequest),
237 GossipsubPublish(GossipsubPublishRequest),
238 GossipsubRemoveExplicitPeer(GossipsubRemoveExplicitPeerRequest),
239 GossipsubSubscribe(GossipsubSubscribeRequest),
240 GossipsubTopics(GossipsubTopicsRequest),
241 GossipsubUnsubscribe(GossipsubUnsubscribeRequest),
242 StartProviding(StartProvidingRequest),
243 StopProviding(StopProvidingRequest),
244 LocalPeerId(LocalPeerIdRequest),
245 ExternalAddrs(ExternalAddrsRequest),
246 Listeners(ListenersRequest),
247}
248
249#[derive(Serialize, Deserialize, Debug, From, TryInto)]
250pub enum P2pResponse {
251 Watch(WatchResponse),
252 Version(VersionResponse),
253 FetchBitswap(RpcResult<BitswapResponse>),
254 FetchProviderDht(RpcResult<FetchProvidersDhtResponse>),
255 GetListeningAddrs(RpcResult<GetListeningAddrsResponse>),
256 GetPeers(RpcResult<GetPeersResponse>),
257 Lookup(RpcResult<LookupResponse>),
258 GossipsubPeers(RpcResult<GossipsubPeersResponse>),
259 GossipsubAllPeers(RpcResult<GossipsubAllPeersResponse>),
260 GossipsubPublish(RpcResult<GossipsubPublishResponse>),
261 GossipsubSubscribe(RpcResult<GossipsubSubscribeResponse>),
262 GossipsubTopics(RpcResult<GossipsubTopicsResponse>),
263 GossipsubUnsubscribe(RpcResult<GossipsubUnsubscribeResponse>),
264 LocalPeerId(RpcResult<LocalPeerIdResponse>),
265 ExternalAddrs(RpcResult<ExternalAddrsResponse>),
266 Listeners(RpcResult<ListenersResponse>),
267 UnitResult(RpcResult<()>),
268}
269
270#[derive(Debug, Clone)]
271pub struct P2pService;
272
273impl Service for P2pService {
274 type Req = P2pRequest;
275 type Res = P2pResponse;
276}
277
278impl Msg<P2pService> for WatchRequest {
279 type Response = WatchResponse;
280
281 type Update = Self;
282
283 type Pattern = ServerStreaming;
284}
285
286impl RpcMsg<P2pService> for VersionRequest {
287 type Response = VersionResponse;
288}
289
290impl RpcMsg<P2pService> for ShutdownRequest {
291 type Response = RpcResult<()>;
292}
293
294impl RpcMsg<P2pService> for BitswapRequest {
295 type Response = RpcResult<BitswapResponse>;
296}
297
298impl Msg<P2pService> for FetchProvidersDhtRequest {
299 type Response = RpcResult<FetchProvidersDhtResponse>;
300
301 type Update = Self;
302
303 type Pattern = ServerStreaming;
304}
305
306impl RpcMsg<P2pService> for StopSessionBitswapRequest {
307 type Response = RpcResult<()>;
308}
309
310impl RpcMsg<P2pService> for NotifyNewBlocksBitswapRequest {
311 type Response = RpcResult<()>;
312}
313
314impl RpcMsg<P2pService> for GetListeningAddrsRequest {
315 type Response = RpcResult<GetListeningAddrsResponse>;
316}
317
318impl RpcMsg<P2pService> for GetPeersRequest {
319 type Response = RpcResult<GetPeersResponse>;
320}
321
322impl RpcMsg<P2pService> for ConnectRequest {
323 type Response = RpcResult<()>;
324}
325
326impl RpcMsg<P2pService> for ConnectByPeerIdRequest {
327 type Response = RpcResult<()>;
328}
329
330impl RpcMsg<P2pService> for DisconnectRequest {
331 type Response = RpcResult<()>;
332}
333
334impl RpcMsg<P2pService> for LookupRequest {
335 type Response = RpcResult<LookupResponse>;
336}
337
338impl RpcMsg<P2pService> for LookupLocalRequest {
339 type Response = RpcResult<LookupResponse>;
340}
341
342impl RpcMsg<P2pService> for GossipsubAddExplicitPeerRequest {
343 type Response = RpcResult<()>;
344}
345
346impl RpcMsg<P2pService> for GossipsubAllMeshPeersRequest {
347 type Response = RpcResult<GossipsubPeersResponse>;
348}
349
350impl RpcMsg<P2pService> for GossipsubMeshPeersRequest {
351 type Response = RpcResult<GossipsubPeersResponse>;
352}
353
354impl RpcMsg<P2pService> for GossipsubAllPeersRequest {
355 type Response = RpcResult<GossipsubAllPeersResponse>;
356}
357
358impl RpcMsg<P2pService> for GossipsubPublishRequest {
359 type Response = RpcResult<GossipsubPublishResponse>;
360}
361
362impl RpcMsg<P2pService> for GossipsubTopicsRequest {
363 type Response = RpcResult<GossipsubTopicsResponse>;
364}
365
366impl RpcMsg<P2pService> for GossipsubSubscribeRequest {
367 type Response = RpcResult<GossipsubSubscribeResponse>;
368}
369
370impl RpcMsg<P2pService> for GossipsubUnsubscribeRequest {
371 type Response = RpcResult<GossipsubUnsubscribeResponse>;
372}
373
374impl RpcMsg<P2pService> for GossipsubRemoveExplicitPeerRequest {
375 type Response = RpcResult<()>;
376}
377
378impl RpcMsg<P2pService> for StartProvidingRequest {
379 type Response = RpcResult<()>;
380}
381
382impl RpcMsg<P2pService> for StopProvidingRequest {
383 type Response = RpcResult<()>;
384}
385
386impl RpcMsg<P2pService> for LocalPeerIdRequest {
387 type Response = RpcResult<LocalPeerIdResponse>;
388}
389
390impl RpcMsg<P2pService> for ExternalAddrsRequest {
391 type Response = RpcResult<ExternalAddrsResponse>;
392}
393
394impl RpcMsg<P2pService> for ListenersRequest {
395 type Response = RpcResult<ListenersResponse>;
396}