1use alloc::vec::Vec;
30use polkadot_core_primitives::Hash;
31use polkadot_parachain_primitives::primitives::Id as ParaId;
32use sp_core::ConstU32;
33use sp_runtime::BoundedVec;
34
35pub const MAX_COMMITMENT_ENTRIES: u32 = 256;
39
40#[derive(
47 Clone,
48 Copy,
49 codec::Encode,
50 codec::Decode,
51 codec::DecodeWithMemTracking,
52 codec::MaxEncodedLen,
53 Debug,
54 Default,
55 Eq,
56 PartialEq,
57 scale_info::TypeInfo,
58)]
59#[cfg_attr(feature = "std", derive(Hash))]
60pub struct StreamsRoot(pub Hash);
61
62#[derive(
66 Clone, codec::Encode, codec::MaxEncodedLen, Debug, Eq, PartialEq, scale_info::TypeInfo,
67)]
68#[cfg_attr(feature = "std", derive(Hash))]
69pub struct RequiresSet(BoundedVec<(ParaId, StreamsRoot), ConstU32<MAX_COMMITMENT_ENTRIES>>);
70
71impl codec::Decode for RequiresSet {
75 fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
76 let inner =
77 BoundedVec::<(ParaId, StreamsRoot), ConstU32<MAX_COMMITMENT_ENTRIES>>::decode(input)?;
78
79 if inner.is_empty() {
80 return Err(codec::Error::from("RequiresSet must not be empty"));
81 }
82 for pair in inner.windows(2) {
83 if pair[0].0 >= pair[1].0 {
84 return Err(codec::Error::from(
85 "RequiresSet entries must be sorted by increasing ParaId",
86 ));
87 }
88 }
89
90 Ok(Self(inner))
91 }
92}
93
94impl codec::DecodeWithMemTracking for RequiresSet {}
96
97impl RequiresSet {
98 pub fn get(&self, source: ParaId) -> Option<&StreamsRoot> {
100 self.0
101 .binary_search_by_key(&source, |(id, _)| *id)
102 .ok()
103 .map(|idx| &self.0[idx].1)
104 }
105
106 pub fn len(&self) -> usize {
108 self.0.len()
109 }
110
111 pub fn is_empty(&self) -> bool {
113 self.0.is_empty()
114 }
115
116 pub fn iter(&self) -> impl Iterator<Item = &(ParaId, StreamsRoot)> {
118 self.0.iter()
119 }
120
121 pub fn try_from_iter(
123 it: impl IntoIterator<Item = (ParaId, StreamsRoot)>,
124 ) -> Result<Self, CommitmentError> {
125 let mut entries: Vec<(ParaId, StreamsRoot)> = it.into_iter().collect();
126 entries.sort_by_key(|(source, _)| *source);
127
128 if entries.is_empty() {
129 return Err(CommitmentError::Empty);
130 }
131 if entries.windows(2).any(|w| w[0].0 == w[1].0) {
132 return Err(CommitmentError::DuplicateParaId);
133 }
134
135 let inner = BoundedVec::try_from(entries).map_err(|_| CommitmentError::TooManyEntries)?;
136
137 Ok(Self(inner))
138 }
139}
140
141impl<'a> IntoIterator for &'a RequiresSet {
142 type Item = &'a (ParaId, StreamsRoot);
143 type IntoIter = core::slice::Iter<'a, (ParaId, StreamsRoot)>;
144
145 fn into_iter(self) -> Self::IntoIter {
146 self.0.iter()
147 }
148}
149
150#[derive(Debug, PartialEq, Eq)]
152pub enum CommitmentError {
153 Empty,
155 DuplicateParaId,
157 TooManyEntries,
159}
160
161#[cfg(test)]
162mod tests {
163 use super::*;
164 use codec::{Decode, Encode};
165
166 fn sr(byte: u8) -> StreamsRoot {
167 StreamsRoot(Hash::repeat_byte(byte))
168 }
169
170 fn many(n: u32) -> Vec<(ParaId, StreamsRoot)> {
172 (0..n).map(|i| (ParaId::from(i), sr(i as u8))).collect()
173 }
174
175 #[test]
176 fn try_from_iter_sorts_entries() {
177 let set = RequiresSet::try_from_iter([
178 (ParaId::from(3), sr(3)),
179 (ParaId::from(1), sr(1)),
180 (ParaId::from(2), sr(2)),
181 ])
182 .unwrap();
183
184 let ids: Vec<ParaId> = set.iter().map(|(id, _)| *id).collect();
185 assert_eq!(ids, vec![ParaId::from(1), ParaId::from(2), ParaId::from(3)]);
186 }
187
188 #[test]
189 fn try_from_iter_rejects_duplicate_para_id() {
190 let result =
191 RequiresSet::try_from_iter([(ParaId::from(1), sr(1)), (ParaId::from(1), sr(2))]);
192 assert_eq!(result, Err(CommitmentError::DuplicateParaId));
193 }
194
195 #[test]
196 fn try_from_iter_rejects_too_many_entries() {
197 let result = RequiresSet::try_from_iter(many(MAX_COMMITMENT_ENTRIES + 1));
198 assert_eq!(result, Err(CommitmentError::TooManyEntries));
199 }
200
201 #[test]
202 fn encode_decode_round_trip_works() {
203 let set = RequiresSet::try_from_iter([(ParaId::from(1), sr(1)), (ParaId::from(2), sr(2))])
204 .unwrap();
205
206 let encoded = set.encode();
207 let decoded = RequiresSet::decode(&mut &encoded[..]).unwrap();
208
209 assert_eq!(set, decoded);
210 }
211
212 #[test]
213 fn decode_rejects_out_of_order_para_ids() {
214 let bad: Vec<(ParaId, StreamsRoot)> =
215 vec![(ParaId::from(2), sr(2)), (ParaId::from(1), sr(1))];
216 let encoded = bad.encode();
217
218 assert!(RequiresSet::decode(&mut &encoded[..]).is_err());
219 }
220
221 #[test]
222 fn decode_rejects_duplicate_para_ids() {
223 let bad: Vec<(ParaId, StreamsRoot)> =
224 vec![(ParaId::from(1), sr(1)), (ParaId::from(1), sr(2))];
225 let encoded = bad.encode();
226
227 assert!(RequiresSet::decode(&mut &encoded[..]).is_err());
228 }
229
230 #[test]
231 fn decode_rejects_too_many_entries() {
232 let encoded = many(MAX_COMMITMENT_ENTRIES + 1).encode();
233 assert!(RequiresSet::decode(&mut &encoded[..]).is_err());
234 }
235
236 #[test]
237 fn get_finds_existing_and_missing_entries() {
238 let set = RequiresSet::try_from_iter([(ParaId::from(1), sr(1)), (ParaId::from(3), sr(3))])
239 .unwrap();
240
241 assert_eq!(set.get(ParaId::from(1)), Some(&sr(1)));
242 assert_eq!(set.get(ParaId::from(3)), Some(&sr(3)));
243 assert_eq!(set.get(ParaId::from(2)), None);
244 }
245
246 #[test]
247 fn len_and_is_empty() {
248 let set = RequiresSet::try_from_iter([(ParaId::from(1), sr(1))]).unwrap();
249 assert!(!set.is_empty());
250 assert_eq!(set.len(), 1);
251 }
252
253 #[test]
254 fn empty_set_is_not_constructible_or_decodable() {
255 assert_eq!(RequiresSet::try_from_iter([]), Err(CommitmentError::Empty));
257 let encoded = Vec::<(ParaId, StreamsRoot)>::new().encode();
258 assert!(RequiresSet::decode(&mut &encoded[..]).is_err());
259 }
260
261 #[test]
262 fn into_iter_yields_sorted_entries() {
263 let set = RequiresSet::try_from_iter([(ParaId::from(2), sr(2)), (ParaId::from(1), sr(1))])
264 .unwrap();
265
266 let collected: Vec<_> = (&set).into_iter().collect();
267 assert_eq!(collected, vec![&(ParaId::from(1), sr(1)), &(ParaId::from(2), sr(2))]);
268 }
269}