subspace_rpc_primitives/
lib.rs1use parity_scale_codec::{Decode, Encode, EncodeLike, Input, Output};
4use serde::{Deserialize, Serialize};
5use std::time::Duration;
6use subspace_core_primitives::hashes::Blake3Hash;
7use subspace_core_primitives::objects::GlobalObjectMapping;
8use subspace_core_primitives::solutions::{RewardSignature, Solution, SolutionRange};
9use subspace_core_primitives::{BlockNumber, PublicKey, SlotNumber};
10use subspace_farmer_components::FarmerProtocolInfo;
11use subspace_networking::libp2p::Multiaddr;
12
13pub const MAX_SEGMENT_HEADERS_PER_REQUEST: usize = 1000;
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(rename_all = "camelCase")]
19pub struct FarmerAppInfo {
20 #[serde(with = "hex")]
22 pub genesis_hash: [u8; 32],
23 pub dsn_bootstrap_nodes: Vec<Multiaddr>,
25 pub syncing: bool,
27 pub farming_timeout: Duration,
29 pub protocol_info: FarmerProtocolInfo,
31}
32
33impl Encode for FarmerAppInfo {
34 fn size_hint(&self) -> usize {
35 0_usize
36 .saturating_add(Encode::size_hint(&self.genesis_hash))
37 .saturating_add(Encode::size_hint(
38 &self
39 .dsn_bootstrap_nodes
40 .iter()
41 .map(|addr| addr.as_ref())
42 .collect::<Vec<_>>(),
43 ))
44 .saturating_add(Encode::size_hint(&self.syncing))
45 .saturating_add(Encode::size_hint(&self.farming_timeout))
46 .saturating_add(Encode::size_hint(&self.protocol_info))
47 }
48
49 fn encode_to<O: Output + ?Sized>(&self, output: &mut O) {
50 Encode::encode_to(&self.genesis_hash, output);
51 Encode::encode_to(
52 &self
53 .dsn_bootstrap_nodes
54 .iter()
55 .map(|addr| addr.as_ref())
56 .collect::<Vec<_>>(),
57 output,
58 );
59 Encode::encode_to(&self.syncing, output);
60 Encode::encode_to(&self.farming_timeout, output);
61 Encode::encode_to(&self.protocol_info, output);
62 }
63}
64
65impl EncodeLike for FarmerAppInfo {}
66
67impl Decode for FarmerAppInfo {
68 fn decode<I: Input>(input: &mut I) -> Result<Self, parity_scale_codec::Error> {
69 Ok(FarmerAppInfo {
70 genesis_hash: <[u8; 32]>::decode(input)
71 .map_err(|error| error.chain("Could not decode `FarmerAppInfo::genesis_hash`"))?,
72 dsn_bootstrap_nodes: Vec::<Vec<u8>>::decode(input)
73 .map_err(|error| {
74 error.chain("Could not decode `FarmerAppInfo::dsn_bootstrap_nodes`")
75 })?
76 .into_iter()
77 .map(Multiaddr::try_from)
78 .collect::<Result<Vec<_>, _>>()
79 .map_err(|error| {
80 parity_scale_codec::Error::from("Failed to decode bytes as Multiaddr")
81 .chain(error.to_string())
82 .chain("Could not decode `FarmerAppInfo::dsn_bootstrap_nodes`")
83 })?,
84 syncing: bool::decode(input)
85 .map_err(|error| error.chain("Could not decode `FarmerAppInfo::syncing`"))?,
86 farming_timeout: Duration::decode(input).map_err(|error| {
87 error.chain("Could not decode `FarmerAppInfo::farming_timeout`")
88 })?,
89 protocol_info: FarmerProtocolInfo::decode(input)
90 .map_err(|error| error.chain("Could not decode `FarmerAppInfo::protocol_info`"))?,
91 })
92 }
93}
94
95#[derive(Debug, Copy, Clone, Eq, PartialEq, Encode, Decode, Serialize, Deserialize)]
97#[serde(rename_all = "camelCase")]
98pub struct SlotInfo {
99 pub slot_number: SlotNumber,
101 pub global_challenge: Blake3Hash,
103 pub solution_range: SolutionRange,
105 pub voting_solution_range: SolutionRange,
107}
108
109#[derive(Clone, Debug, Encode, Decode, Serialize, Deserialize)]
112#[serde(rename_all = "camelCase")]
113pub struct SolutionResponse {
114 pub slot_number: SlotNumber,
116 pub solution: Solution<PublicKey>,
120}
121
122#[derive(Clone, Copy, Debug, Encode, Decode, Serialize, Deserialize)]
124#[serde(rename_all = "camelCase")]
125pub struct RewardSigningInfo {
126 #[serde(with = "hex")]
128 pub hash: [u8; 32],
129 pub public_key: PublicKey,
131}
132
133#[derive(Clone, Copy, Debug, Encode, Decode, Serialize, Deserialize)]
135#[serde(rename_all = "camelCase")]
136pub struct RewardSignatureResponse {
137 #[serde(with = "hex")]
139 pub hash: [u8; 32],
140 pub signature: Option<RewardSignature>,
142}
143
144#[derive(Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Serialize, Deserialize)]
147#[serde(rename_all = "camelCase")]
148pub struct ObjectMappingResponse {
149 pub block_number: BlockNumber,
151
152 #[serde(flatten)]
154 pub objects: GlobalObjectMapping,
155}