1use alloc::vec::Vec;
19use codec::{Decode, Encode};
20use polkadot_primitives::{
21 ApprovedPeerId, ClaimQueueOffset, CoreSelector, Header as RelayChainHeader, Slot, UMPSignal,
22 UMP_SEPARATOR,
23};
24use sp_runtime::traits::{BlakeTwo256, Hash as HashT};
25
26#[derive(Clone, Encode, Decode, Debug, PartialEq, Eq)]
31pub struct SchedulingInfoPayload {
32 pub core_selector: CoreSelector,
34 pub claim_queue_offset: u8,
36 pub peer_id: ApprovedPeerId,
38 pub internal_scheduling_parent: polkadot_primitives::Hash,
41}
42
43#[derive(Clone, Encode, Decode, Debug, PartialEq, Eq)]
49pub struct SignedSchedulingInfo {
50 pub payload: SchedulingInfoPayload,
52 pub signature: [u8; 64],
56}
57
58impl SchedulingInfoPayload {
59 pub fn new(
61 core_selector: CoreSelector,
62 claim_queue_offset: u8,
63 peer_id: ApprovedPeerId,
64 internal_scheduling_parent: polkadot_primitives::Hash,
65 ) -> Self {
66 Self { core_selector, claim_queue_offset, peer_id, internal_scheduling_parent }
67 }
68}
69
70#[derive(Debug, Default, PartialEq, Eq)]
78pub struct SchedulingSignals {
79 select_core: Option<(CoreSelector, ClaimQueueOffset)>,
80 approved_peer: Option<ApprovedPeerId>,
81}
82
83impl SchedulingSignals {
84 pub fn from_block_signals(raw: &[Vec<u8>]) -> Self {
89 let mut signals = Self::default();
90 for bytes in raw {
91 match UMPSignal::decode(&mut &bytes[..]).expect("Failed to decode `UMPSignal`") {
94 UMPSignal::SelectCore(selector, offset) => {
95 if signals.select_core.replace((selector, offset)).is_some() {
96 panic!("Parachain emitted more than one `SelectCore` UMP signal");
97 }
98 },
99 UMPSignal::ApprovedPeer(peer_id) => {
100 if signals.approved_peer.replace(peer_id).is_some() {
101 panic!("Parachain emitted more than one `ApprovedPeer` UMP signal");
102 }
103 },
104 UMPSignal::Provides(_) | UMPSignal::Requires(_) => panic!(
105 "Parachain emitted a speculative-messaging UMP signal, which `validate_block` does not yet forward"
106 ),
107 }
108 }
109 signals
110 }
111
112 pub fn from_scheduling_info(signed_info: &SignedSchedulingInfo) -> Self {
116 let payload = &signed_info.payload;
117 Self {
118 select_core: Some((
119 payload.core_selector,
120 ClaimQueueOffset(payload.claim_queue_offset),
121 )),
122 approved_peer: Some(payload.peer_id.clone()),
123 }
124 }
125
126 fn is_empty(&self) -> bool {
127 self.select_core.is_none() && self.approved_peer.is_none()
128 }
129
130 pub fn into_ump_messages(self) -> Vec<Vec<u8>> {
135 if self.is_empty() {
136 return Vec::new();
137 }
138 let mut messages = Vec::with_capacity(3);
139 messages.push(UMP_SEPARATOR);
140 if let Some((selector, offset)) = self.select_core {
141 messages.push(UMPSignal::SelectCore(selector, offset).encode());
142 }
143 if let Some(peer_id) = self.approved_peer {
144 messages.push(UMPSignal::ApprovedPeer(peer_id).encode());
145 }
146 messages
147 }
148}
149
150#[derive(Clone, Encode, Decode, Debug, PartialEq, Eq)]
155pub struct SchedulingProof {
156 pub header_chain: Vec<RelayChainHeader>,
161 pub internal_scheduling_parent_header: RelayChainHeader,
165 pub signed_scheduling_info: Option<SignedSchedulingInfo>,
175}
176
177impl SchedulingProof {
178 pub fn new(
180 header_chain: Vec<RelayChainHeader>,
181 internal_scheduling_parent_header: RelayChainHeader,
182 signed_scheduling_info: Option<SignedSchedulingInfo>,
183 ) -> Self {
184 Self { header_chain, internal_scheduling_parent_header, signed_scheduling_info }
185 }
186
187 pub fn scheduling_parent(&self) -> polkadot_primitives::Hash {
191 self.header_chain
192 .first()
193 .map(BlakeTwo256::hash_of)
194 .unwrap_or_else(|| self.internal_scheduling_parent_header.hash())
195 }
196}
197
198pub trait VerifySchedulingSignature {
201 const V3_SCHEDULING_ENABLED: bool;
203
204 fn verify(signed_info: &SignedSchedulingInfo, relay_slot: Slot) -> bool;
207}
208
209impl VerifySchedulingSignature for () {
212 const V3_SCHEDULING_ENABLED: bool = false;
213
214 fn verify(_signed_info: &SignedSchedulingInfo, _relay_slot: Slot) -> bool {
215 true
216 }
217}
218
219#[cfg(test)]
220mod tests {
221 use super::{SchedulingInfoPayload, SchedulingSignals, SignedSchedulingInfo};
222 use alloc::vec;
223 use codec::Encode;
224 use polkadot_primitives::{
225 ApprovedPeerId, ClaimQueueOffset, CoreSelector, UMPSignal, UMP_SEPARATOR,
226 };
227
228 fn peer(byte: u8) -> ApprovedPeerId {
229 ApprovedPeerId::try_from(vec![byte; 4]).expect("4 bytes fits the bound; qed")
230 }
231
232 fn signed_with(
233 core_selector: CoreSelector,
234 claim_queue_offset: u8,
235 peer_id: ApprovedPeerId,
236 ) -> SignedSchedulingInfo {
237 SignedSchedulingInfo {
238 payload: SchedulingInfoPayload::new(
239 core_selector,
240 claim_queue_offset,
241 peer_id,
242 Default::default(),
243 ),
244 signature: [0u8; 64],
245 }
246 }
247
248 #[test]
249 fn from_block_signals_roundtrips_select_core_and_approved_peer() {
250 let raw = vec![
253 UMPSignal::SelectCore(CoreSelector(7), ClaimQueueOffset(1)).encode(),
254 UMPSignal::ApprovedPeer(peer(0xAA)).encode(),
255 ];
256 assert_eq!(
257 SchedulingSignals::from_block_signals(&raw).into_ump_messages(),
258 vec![
259 UMP_SEPARATOR,
260 UMPSignal::SelectCore(CoreSelector(7), ClaimQueueOffset(1)).encode(),
261 UMPSignal::ApprovedPeer(peer(0xAA)).encode(),
262 ]
263 );
264 }
265
266 #[test]
267 fn from_block_signals_select_core_only() {
268 let raw = vec![UMPSignal::SelectCore(CoreSelector(3), ClaimQueueOffset(0)).encode()];
270 assert_eq!(
271 SchedulingSignals::from_block_signals(&raw).into_ump_messages(),
272 vec![
273 UMP_SEPARATOR,
274 UMPSignal::SelectCore(CoreSelector(3), ClaimQueueOffset(0)).encode()
275 ]
276 );
277 }
278
279 #[test]
280 #[should_panic(expected = "more than one `SelectCore`")]
281 fn from_block_signals_panics_on_duplicate_select_core_same_value() {
282 let raw = vec![
285 UMPSignal::SelectCore(CoreSelector(1), ClaimQueueOffset(0)).encode(),
286 UMPSignal::SelectCore(CoreSelector(1), ClaimQueueOffset(0)).encode(),
287 ];
288 let _ = SchedulingSignals::from_block_signals(&raw);
289 }
290
291 #[test]
292 #[should_panic(expected = "more than one `SelectCore`")]
293 fn from_block_signals_panics_on_duplicate_select_core_different_value() {
294 let raw = vec![
295 UMPSignal::SelectCore(CoreSelector(1), ClaimQueueOffset(0)).encode(),
296 UMPSignal::SelectCore(CoreSelector(2), ClaimQueueOffset(0)).encode(),
297 ];
298 let _ = SchedulingSignals::from_block_signals(&raw);
299 }
300
301 #[test]
302 #[should_panic(expected = "more than one `ApprovedPeer`")]
303 fn from_block_signals_panics_on_duplicate_approved_peer() {
304 let raw = vec![
305 UMPSignal::ApprovedPeer(peer(0xAA)).encode(),
306 UMPSignal::ApprovedPeer(peer(0xBB)).encode(),
307 ];
308 let _ = SchedulingSignals::from_block_signals(&raw);
309 }
310
311 #[test]
312 fn from_block_signals_empty_emits_nothing() {
313 assert!(SchedulingSignals::from_block_signals(&[]).into_ump_messages().is_empty());
315 }
316
317 #[test]
318 fn from_scheduling_info_sources_all_fields() {
319 let signed = signed_with(CoreSelector(7), 3, peer(0xAA));
323 assert_eq!(
324 SchedulingSignals::from_scheduling_info(&signed).into_ump_messages(),
325 vec![
326 UMP_SEPARATOR,
327 UMPSignal::SelectCore(CoreSelector(7), ClaimQueueOffset(3)).encode(),
328 UMPSignal::ApprovedPeer(peer(0xAA)).encode(),
329 ]
330 );
331 }
332
333 #[test]
334 fn from_scheduling_info_emits_peer_verbatim_even_if_empty() {
335 let signed = signed_with(CoreSelector(5), 1, ApprovedPeerId::default());
338 assert_eq!(
339 SchedulingSignals::from_scheduling_info(&signed).into_ump_messages(),
340 vec![
341 UMP_SEPARATOR,
342 UMPSignal::SelectCore(CoreSelector(5), ClaimQueueOffset(1)).encode(),
343 UMPSignal::ApprovedPeer(ApprovedPeerId::default()).encode(),
344 ]
345 );
346 }
347
348 #[test]
349 fn override_matches_block_signals_when_values_agree() {
350 let selector = CoreSelector(7);
355 let offset = ClaimQueueOffset(3);
356 let peer_id = peer(0xAA);
357
358 let from_block = SchedulingSignals::from_block_signals(&[
359 UMPSignal::SelectCore(selector, offset).encode(),
360 UMPSignal::ApprovedPeer(peer_id.clone()).encode(),
361 ])
362 .into_ump_messages();
363
364 let from_signed =
365 SchedulingSignals::from_scheduling_info(&signed_with(selector, offset.0, peer_id))
366 .into_ump_messages();
367
368 assert_eq!(from_block, from_signed);
369 }
370
371 #[test]
372 fn from_scheduling_info_emits_even_when_block_emitted_nothing() {
373 let signed = signed_with(CoreSelector(0), 0, peer(0xCC));
376 assert!(!SchedulingSignals::from_scheduling_info(&signed).into_ump_messages().is_empty());
377 }
378
379 #[test]
382 fn every_ump_signal_is_classified() {
383 fn classify(signal: UMPSignal) {
384 match signal {
385 UMPSignal::SelectCore(..) | UMPSignal::ApprovedPeer(..) => {},
386 UMPSignal::Provides(..) | UMPSignal::Requires(..) => {},
387 }
388 }
389 let _ = classify;
390 }
391}